head 1.1; branch 1.1.1; access; symbols netbsd-11-0-RC4:1.1.1.11 netbsd-11-0-RC3:1.1.1.11 netbsd-11-0-RC2:1.1.1.11 netbsd-11-0-RC1:1.1.1.11 perseant-exfatfs-base-20250801:1.1.1.11 netbsd-11:1.1.1.11.0.10 netbsd-11-base:1.1.1.11 netbsd-10-1-RELEASE:1.1.1.11 perseant-exfatfs-base-20240630:1.1.1.11 perseant-exfatfs:1.1.1.11.0.8 perseant-exfatfs-base:1.1.1.11 netbsd-8-3-RELEASE:1.1.1.8 netbsd-9-4-RELEASE:1.1.1.10 netbsd-10-0-RELEASE:1.1.1.11 netbsd-10-0-RC6:1.1.1.11 netbsd-10-0-RC5:1.1.1.11 netbsd-10-0-RC4:1.1.1.11 netbsd-10-0-RC3:1.1.1.11 netbsd-10-0-RC2:1.1.1.11 netbsd-10-0-RC1:1.1.1.11 netbsd-10:1.1.1.11.0.6 netbsd-10-base:1.1.1.11 netbsd-9-3-RELEASE:1.1.1.10 cjep_sun2x:1.1.1.11.0.4 cjep_sun2x-base:1.1.1.11 cjep_staticlib_x-base1:1.1.1.11 netbsd-9-2-RELEASE:1.1.1.10 cjep_staticlib_x:1.1.1.11.0.2 cjep_staticlib_x-base:1.1.1.11 netbsd-9-1-RELEASE:1.1.1.10 phil-wifi-20200421:1.1.1.11 phil-wifi-20200411:1.1.1.11 phil-wifi-20200406:1.1.1.11 netbsd-8-2-RELEASE:1.1.1.8 netbsd-9-0-RELEASE:1.1.1.10 netbsd-9-0-RC2:1.1.1.10 netbsd-9-0-RC1:1.1.1.10 netbsd-9:1.1.1.10.0.2 netbsd-9-base:1.1.1.10 phil-wifi-20190609:1.1.1.10 netbsd-8-1-RELEASE:1.1.1.8 netbsd-8-1-RC1:1.1.1.8 pgoyette-compat-merge-20190127:1.1.1.9.2.1 pgoyette-compat-20190127:1.1.1.10 pgoyette-compat-20190118:1.1.1.10 pgoyette-compat-1226:1.1.1.10 pgoyette-compat-1126:1.1.1.10 pgoyette-compat-1020:1.1.1.10 pgoyette-compat-0930:1.1.1.10 pgoyette-compat-0906:1.1.1.10 netbsd-7-2-RELEASE:1.1.1.4.2.1 pgoyette-compat-0728:1.1.1.10 clang-337282:1.1.1.10 netbsd-8-0-RELEASE:1.1.1.8 phil-wifi:1.1.1.9.0.4 phil-wifi-base:1.1.1.9 pgoyette-compat-0625:1.1.1.9 netbsd-8-0-RC2:1.1.1.8 pgoyette-compat-0521:1.1.1.9 pgoyette-compat-0502:1.1.1.9 pgoyette-compat-0422:1.1.1.9 netbsd-8-0-RC1:1.1.1.8 pgoyette-compat-0415:1.1.1.9 pgoyette-compat-0407:1.1.1.9 pgoyette-compat-0330:1.1.1.9 pgoyette-compat-0322:1.1.1.9 pgoyette-compat-0315:1.1.1.9 netbsd-7-1-2-RELEASE:1.1.1.4.2.1 pgoyette-compat:1.1.1.9.0.2 pgoyette-compat-base:1.1.1.9 netbsd-7-1-1-RELEASE:1.1.1.4.2.1 clang-319952:1.1.1.9 matt-nb8-mediatek:1.1.1.8.0.8 matt-nb8-mediatek-base:1.1.1.8 clang-309604:1.1.1.9 perseant-stdc-iso10646:1.1.1.8.0.6 perseant-stdc-iso10646-base:1.1.1.8 netbsd-8:1.1.1.8.0.4 netbsd-8-base:1.1.1.8 prg-localcount2-base3:1.1.1.8 prg-localcount2-base2:1.1.1.8 prg-localcount2-base1:1.1.1.8 prg-localcount2:1.1.1.8.0.2 prg-localcount2-base:1.1.1.8 pgoyette-localcount-20170426:1.1.1.8 bouyer-socketcan-base1:1.1.1.8 pgoyette-localcount-20170320:1.1.1.8 netbsd-7-1:1.1.1.4.2.1.0.6 netbsd-7-1-RELEASE:1.1.1.4.2.1 netbsd-7-1-RC2:1.1.1.4.2.1 clang-294123:1.1.1.8 netbsd-7-nhusb-base-20170116:1.1.1.4.2.1 bouyer-socketcan:1.1.1.7.0.2 bouyer-socketcan-base:1.1.1.7 clang-291444:1.1.1.7 pgoyette-localcount-20170107:1.1.1.6 netbsd-7-1-RC1:1.1.1.4.2.1 pgoyette-localcount-20161104:1.1.1.6 netbsd-7-0-2-RELEASE:1.1.1.4.2.1 localcount-20160914:1.1.1.6 netbsd-7-nhusb:1.1.1.4.2.1.0.4 netbsd-7-nhusb-base:1.1.1.4.2.1 clang-280599:1.1.1.6 pgoyette-localcount-20160806:1.1.1.6 pgoyette-localcount-20160726:1.1.1.6 pgoyette-localcount:1.1.1.6.0.2 pgoyette-localcount-base:1.1.1.6 netbsd-7-0-1-RELEASE:1.1.1.4.2.1 clang-261930:1.1.1.6 netbsd-7-0:1.1.1.4.2.1.0.2 netbsd-7-0-RELEASE:1.1.1.4.2.1 netbsd-7-0-RC3:1.1.1.4.2.1 netbsd-7-0-RC2:1.1.1.4.2.1 netbsd-7-0-RC1:1.1.1.4.2.1 clang-237755:1.1.1.5 clang-232565:1.1.1.5 clang-227398:1.1.1.5 tls-maxphys-base:1.1.1.4 tls-maxphys:1.1.1.4.0.4 netbsd-7:1.1.1.4.0.2 netbsd-7-base:1.1.1.4 clang-215315:1.1.1.4 clang-209886:1.1.1.3 yamt-pagecache:1.1.1.2.0.4 yamt-pagecache-base9:1.1.1.2 tls-earlyentropy:1.1.1.2.0.2 tls-earlyentropy-base:1.1.1.3 riastradh-xf86-video-intel-2-7-1-pre-2-21-15:1.1.1.2 riastradh-drm2-base3:1.1.1.2 clang-202566:1.1.1.2 clang-201163:1.1.1.2 clang-199312:1.1.1.2 clang-198450:1.1.1.2 clang-196603:1.1.1.1 clang-195771:1.1.1.1 LLVM:1.1.1; locks; strict; comment @// @; 1.1 date 2013.11.28.14.14.53; author joerg; state Exp; branches 1.1.1.1; next ; commitid ow8OybrawrB1f3fx; 1.1.1.1 date 2013.11.28.14.14.53; author joerg; state Exp; branches; next 1.1.1.2; commitid ow8OybrawrB1f3fx; 1.1.1.2 date 2014.01.05.15.39.37; author joerg; state Exp; branches 1.1.1.2.2.1 1.1.1.2.4.1; next 1.1.1.3; commitid wh3aCSIWykURqWjx; 1.1.1.3 date 2014.05.30.18.14.44; author joerg; state Exp; branches; next 1.1.1.4; commitid 8q0kdlBlCn09GACx; 1.1.1.4 date 2014.08.10.17.08.35; author joerg; state Exp; branches 1.1.1.4.2.1 1.1.1.4.4.1; next 1.1.1.5; commitid N85tXAN6Ex9VZPLx; 1.1.1.5 date 2015.01.29.19.57.30; author joerg; state Exp; branches; next 1.1.1.6; commitid mlISSizlPKvepX7y; 1.1.1.6 date 2016.02.27.22.12.06; author joerg; state Exp; branches 1.1.1.6.2.1; next 1.1.1.7; commitid tIimz3oDlh1NpBWy; 1.1.1.7 date 2017.01.11.10.35.37; author joerg; state Exp; branches 1.1.1.7.2.1; next 1.1.1.8; commitid CNnUNfII1jgNmxBz; 1.1.1.8 date 2017.02.09.17.38.31; author joerg; state Exp; branches; next 1.1.1.9; commitid UxB8JMFWM7xyMiFz; 1.1.1.9 date 2017.08.01.19.35.15; author joerg; state Exp; branches 1.1.1.9.2.1 1.1.1.9.4.1; next 1.1.1.10; commitid pMuDy65V0VicSx1A; 1.1.1.10 date 2018.07.17.18.31.06; author joerg; state Exp; branches; next 1.1.1.11; commitid wDzL46ALjrCZgwKA; 1.1.1.11 date 2019.11.13.22.19.29; author joerg; state dead; branches; next ; commitid QD8YATxuNG34YJKB; 1.1.1.2.2.1 date 2014.08.10.07.08.10; author tls; state Exp; branches; next ; commitid t01A1TLTYxkpGMLx; 1.1.1.2.4.1 date 2014.01.05.15.39.37; author yamt; state dead; branches; next 1.1.1.2.4.2; commitid WSrDtL5nYAUyiyBx; 1.1.1.2.4.2 date 2014.05.22.16.18.31; author yamt; state Exp; branches; next ; commitid WSrDtL5nYAUyiyBx; 1.1.1.4.2.1 date 2015.06.04.20.04.30; author snj; state Exp; branches; next ; commitid yRnjq9fueSo6n9oy; 1.1.1.4.4.1 date 2014.08.10.17.08.35; author tls; state dead; branches; next 1.1.1.4.4.2; commitid jTnpym9Qu0o4R1Nx; 1.1.1.4.4.2 date 2014.08.19.23.47.32; author tls; state Exp; branches; next ; commitid jTnpym9Qu0o4R1Nx; 1.1.1.6.2.1 date 2017.03.20.06.52.42; author pgoyette; state Exp; branches; next ; commitid jjw7cAwgyKq7RfKz; 1.1.1.7.2.1 date 2017.04.21.16.51.40; author bouyer; state Exp; branches; next ; commitid dUG7nkTKALCadqOz; 1.1.1.9.2.1 date 2018.07.28.04.33.24; author pgoyette; state Exp; branches; next ; commitid 1UP1xAIUxv1ZgRLA; 1.1.1.9.4.1 date 2019.06.10.21.45.29; author christos; state Exp; branches; next 1.1.1.9.4.2; commitid jtc8rnCzWiEEHGqB; 1.1.1.9.4.2 date 2020.04.13.07.46.39; author martin; state dead; branches; next ; commitid X01YhRUPVUDaec4C; desc @@ 1.1 log @Initial revision @ text @//== MemRegion.cpp - Abstract memory regions for static analysis --*- C++ -*--// // // The LLVM Compiler Infrastructure // // This file is distributed under the University of Illinois Open Source // License. See LICENSE.TXT for details. // //===----------------------------------------------------------------------===// // // This file defines MemRegion and its subclasses. MemRegion defines a // partially-typed abstraction of memory useful for path-sensitive dataflow // analyses. // //===----------------------------------------------------------------------===// #include "clang/StaticAnalyzer/Core/PathSensitive/MemRegion.h" #include "clang/AST/Attr.h" #include "clang/AST/CharUnits.h" #include "clang/AST/DeclObjC.h" #include "clang/AST/RecordLayout.h" #include "clang/Analysis/AnalysisContext.h" #include "clang/Analysis/Support/BumpVector.h" #include "clang/Basic/SourceManager.h" #include "clang/StaticAnalyzer/Core/PathSensitive/SValBuilder.h" #include "llvm/Support/raw_ostream.h" using namespace clang; using namespace ento; //===----------------------------------------------------------------------===// // MemRegion Construction. //===----------------------------------------------------------------------===// template struct MemRegionManagerTrait; template RegionTy* MemRegionManager::getRegion(const A1 a1) { const typename MemRegionManagerTrait::SuperRegionTy *superRegion = MemRegionManagerTrait::getSuperRegion(*this, a1); llvm::FoldingSetNodeID ID; RegionTy::ProfileRegion(ID, a1, superRegion); void *InsertPos; RegionTy* R = cast_or_null(Regions.FindNodeOrInsertPos(ID, InsertPos)); if (!R) { R = (RegionTy*) A.Allocate(); new (R) RegionTy(a1, superRegion); Regions.InsertNode(R, InsertPos); } return R; } template RegionTy* MemRegionManager::getSubRegion(const A1 a1, const MemRegion *superRegion) { llvm::FoldingSetNodeID ID; RegionTy::ProfileRegion(ID, a1, superRegion); void *InsertPos; RegionTy* R = cast_or_null(Regions.FindNodeOrInsertPos(ID, InsertPos)); if (!R) { R = (RegionTy*) A.Allocate(); new (R) RegionTy(a1, superRegion); Regions.InsertNode(R, InsertPos); } return R; } template RegionTy* MemRegionManager::getRegion(const A1 a1, const A2 a2) { const typename MemRegionManagerTrait::SuperRegionTy *superRegion = MemRegionManagerTrait::getSuperRegion(*this, a1, a2); llvm::FoldingSetNodeID ID; RegionTy::ProfileRegion(ID, a1, a2, superRegion); void *InsertPos; RegionTy* R = cast_or_null(Regions.FindNodeOrInsertPos(ID, InsertPos)); if (!R) { R = (RegionTy*) A.Allocate(); new (R) RegionTy(a1, a2, superRegion); Regions.InsertNode(R, InsertPos); } return R; } template RegionTy* MemRegionManager::getSubRegion(const A1 a1, const A2 a2, const MemRegion *superRegion) { llvm::FoldingSetNodeID ID; RegionTy::ProfileRegion(ID, a1, a2, superRegion); void *InsertPos; RegionTy* R = cast_or_null(Regions.FindNodeOrInsertPos(ID, InsertPos)); if (!R) { R = (RegionTy*) A.Allocate(); new (R) RegionTy(a1, a2, superRegion); Regions.InsertNode(R, InsertPos); } return R; } template RegionTy* MemRegionManager::getSubRegion(const A1 a1, const A2 a2, const A3 a3, const MemRegion *superRegion) { llvm::FoldingSetNodeID ID; RegionTy::ProfileRegion(ID, a1, a2, a3, superRegion); void *InsertPos; RegionTy* R = cast_or_null(Regions.FindNodeOrInsertPos(ID, InsertPos)); if (!R) { R = (RegionTy*) A.Allocate(); new (R) RegionTy(a1, a2, a3, superRegion); Regions.InsertNode(R, InsertPos); } return R; } //===----------------------------------------------------------------------===// // Object destruction. //===----------------------------------------------------------------------===// MemRegion::~MemRegion() {} MemRegionManager::~MemRegionManager() { // All regions and their data are BumpPtrAllocated. No need to call // their destructors. } //===----------------------------------------------------------------------===// // Basic methods. //===----------------------------------------------------------------------===// bool SubRegion::isSubRegionOf(const MemRegion* R) const { const MemRegion* r = getSuperRegion(); while (r != 0) { if (r == R) return true; if (const SubRegion* sr = dyn_cast(r)) r = sr->getSuperRegion(); else break; } return false; } MemRegionManager* SubRegion::getMemRegionManager() const { const SubRegion* r = this; do { const MemRegion *superRegion = r->getSuperRegion(); if (const SubRegion *sr = dyn_cast(superRegion)) { r = sr; continue; } return superRegion->getMemRegionManager(); } while (1); } const StackFrameContext *VarRegion::getStackFrame() const { const StackSpaceRegion *SSR = dyn_cast(getMemorySpace()); return SSR ? SSR->getStackFrame() : NULL; } //===----------------------------------------------------------------------===// // Region extents. //===----------------------------------------------------------------------===// DefinedOrUnknownSVal TypedValueRegion::getExtent(SValBuilder &svalBuilder) const { ASTContext &Ctx = svalBuilder.getContext(); QualType T = getDesugaredValueType(Ctx); if (isa(T)) return nonloc::SymbolVal(svalBuilder.getSymbolManager().getExtentSymbol(this)); if (T->isIncompleteType()) return UnknownVal(); CharUnits size = Ctx.getTypeSizeInChars(T); QualType sizeTy = svalBuilder.getArrayIndexType(); return svalBuilder.makeIntVal(size.getQuantity(), sizeTy); } DefinedOrUnknownSVal FieldRegion::getExtent(SValBuilder &svalBuilder) const { // Force callers to deal with bitfields explicitly. if (getDecl()->isBitField()) return UnknownVal(); DefinedOrUnknownSVal Extent = DeclRegion::getExtent(svalBuilder); // A zero-length array at the end of a struct often stands for dynamically- // allocated extra memory. if (Extent.isZeroConstant()) { QualType T = getDesugaredValueType(svalBuilder.getContext()); if (isa(T)) return UnknownVal(); } return Extent; } DefinedOrUnknownSVal AllocaRegion::getExtent(SValBuilder &svalBuilder) const { return nonloc::SymbolVal(svalBuilder.getSymbolManager().getExtentSymbol(this)); } DefinedOrUnknownSVal SymbolicRegion::getExtent(SValBuilder &svalBuilder) const { return nonloc::SymbolVal(svalBuilder.getSymbolManager().getExtentSymbol(this)); } DefinedOrUnknownSVal StringRegion::getExtent(SValBuilder &svalBuilder) const { return svalBuilder.makeIntVal(getStringLiteral()->getByteLength()+1, svalBuilder.getArrayIndexType()); } ObjCIvarRegion::ObjCIvarRegion(const ObjCIvarDecl *ivd, const MemRegion* sReg) : DeclRegion(ivd, sReg, ObjCIvarRegionKind) {} const ObjCIvarDecl *ObjCIvarRegion::getDecl() const { return cast(D); } QualType ObjCIvarRegion::getValueType() const { return getDecl()->getType(); } QualType CXXBaseObjectRegion::getValueType() const { return QualType(getDecl()->getTypeForDecl(), 0); } //===----------------------------------------------------------------------===// // FoldingSet profiling. //===----------------------------------------------------------------------===// void MemSpaceRegion::Profile(llvm::FoldingSetNodeID& ID) const { ID.AddInteger((unsigned)getKind()); } void StackSpaceRegion::Profile(llvm::FoldingSetNodeID &ID) const { ID.AddInteger((unsigned)getKind()); ID.AddPointer(getStackFrame()); } void StaticGlobalSpaceRegion::Profile(llvm::FoldingSetNodeID &ID) const { ID.AddInteger((unsigned)getKind()); ID.AddPointer(getCodeRegion()); } void StringRegion::ProfileRegion(llvm::FoldingSetNodeID& ID, const StringLiteral* Str, const MemRegion* superRegion) { ID.AddInteger((unsigned) StringRegionKind); ID.AddPointer(Str); ID.AddPointer(superRegion); } void ObjCStringRegion::ProfileRegion(llvm::FoldingSetNodeID& ID, const ObjCStringLiteral* Str, const MemRegion* superRegion) { ID.AddInteger((unsigned) ObjCStringRegionKind); ID.AddPointer(Str); ID.AddPointer(superRegion); } void AllocaRegion::ProfileRegion(llvm::FoldingSetNodeID& ID, const Expr *Ex, unsigned cnt, const MemRegion *superRegion) { ID.AddInteger((unsigned) AllocaRegionKind); ID.AddPointer(Ex); ID.AddInteger(cnt); ID.AddPointer(superRegion); } void AllocaRegion::Profile(llvm::FoldingSetNodeID& ID) const { ProfileRegion(ID, Ex, Cnt, superRegion); } void CompoundLiteralRegion::Profile(llvm::FoldingSetNodeID& ID) const { CompoundLiteralRegion::ProfileRegion(ID, CL, superRegion); } void CompoundLiteralRegion::ProfileRegion(llvm::FoldingSetNodeID& ID, const CompoundLiteralExpr *CL, const MemRegion* superRegion) { ID.AddInteger((unsigned) CompoundLiteralRegionKind); ID.AddPointer(CL); ID.AddPointer(superRegion); } void CXXThisRegion::ProfileRegion(llvm::FoldingSetNodeID &ID, const PointerType *PT, const MemRegion *sRegion) { ID.AddInteger((unsigned) CXXThisRegionKind); ID.AddPointer(PT); ID.AddPointer(sRegion); } void CXXThisRegion::Profile(llvm::FoldingSetNodeID &ID) const { CXXThisRegion::ProfileRegion(ID, ThisPointerTy, superRegion); } void ObjCIvarRegion::ProfileRegion(llvm::FoldingSetNodeID& ID, const ObjCIvarDecl *ivd, const MemRegion* superRegion) { DeclRegion::ProfileRegion(ID, ivd, superRegion, ObjCIvarRegionKind); } void DeclRegion::ProfileRegion(llvm::FoldingSetNodeID& ID, const Decl *D, const MemRegion* superRegion, Kind k) { ID.AddInteger((unsigned) k); ID.AddPointer(D); ID.AddPointer(superRegion); } void DeclRegion::Profile(llvm::FoldingSetNodeID& ID) const { DeclRegion::ProfileRegion(ID, D, superRegion, getKind()); } void VarRegion::Profile(llvm::FoldingSetNodeID &ID) const { VarRegion::ProfileRegion(ID, getDecl(), superRegion); } void SymbolicRegion::ProfileRegion(llvm::FoldingSetNodeID& ID, SymbolRef sym, const MemRegion *sreg) { ID.AddInteger((unsigned) MemRegion::SymbolicRegionKind); ID.Add(sym); ID.AddPointer(sreg); } void SymbolicRegion::Profile(llvm::FoldingSetNodeID& ID) const { SymbolicRegion::ProfileRegion(ID, sym, getSuperRegion()); } void ElementRegion::ProfileRegion(llvm::FoldingSetNodeID& ID, QualType ElementType, SVal Idx, const MemRegion* superRegion) { ID.AddInteger(MemRegion::ElementRegionKind); ID.Add(ElementType); ID.AddPointer(superRegion); Idx.Profile(ID); } void ElementRegion::Profile(llvm::FoldingSetNodeID& ID) const { ElementRegion::ProfileRegion(ID, ElementType, Index, superRegion); } void FunctionTextRegion::ProfileRegion(llvm::FoldingSetNodeID& ID, const NamedDecl *FD, const MemRegion*) { ID.AddInteger(MemRegion::FunctionTextRegionKind); ID.AddPointer(FD); } void FunctionTextRegion::Profile(llvm::FoldingSetNodeID& ID) const { FunctionTextRegion::ProfileRegion(ID, FD, superRegion); } void BlockTextRegion::ProfileRegion(llvm::FoldingSetNodeID& ID, const BlockDecl *BD, CanQualType, const AnalysisDeclContext *AC, const MemRegion*) { ID.AddInteger(MemRegion::BlockTextRegionKind); ID.AddPointer(BD); } void BlockTextRegion::Profile(llvm::FoldingSetNodeID& ID) const { BlockTextRegion::ProfileRegion(ID, BD, locTy, AC, superRegion); } void BlockDataRegion::ProfileRegion(llvm::FoldingSetNodeID& ID, const BlockTextRegion *BC, const LocationContext *LC, unsigned BlkCount, const MemRegion *sReg) { ID.AddInteger(MemRegion::BlockDataRegionKind); ID.AddPointer(BC); ID.AddPointer(LC); ID.AddInteger(BlkCount); ID.AddPointer(sReg); } void BlockDataRegion::Profile(llvm::FoldingSetNodeID& ID) const { BlockDataRegion::ProfileRegion(ID, BC, LC, BlockCount, getSuperRegion()); } void CXXTempObjectRegion::ProfileRegion(llvm::FoldingSetNodeID &ID, Expr const *Ex, const MemRegion *sReg) { ID.AddPointer(Ex); ID.AddPointer(sReg); } void CXXTempObjectRegion::Profile(llvm::FoldingSetNodeID &ID) const { ProfileRegion(ID, Ex, getSuperRegion()); } void CXXBaseObjectRegion::ProfileRegion(llvm::FoldingSetNodeID &ID, const CXXRecordDecl *RD, bool IsVirtual, const MemRegion *SReg) { ID.AddPointer(RD); ID.AddBoolean(IsVirtual); ID.AddPointer(SReg); } void CXXBaseObjectRegion::Profile(llvm::FoldingSetNodeID &ID) const { ProfileRegion(ID, getDecl(), isVirtual(), superRegion); } //===----------------------------------------------------------------------===// // Region anchors. //===----------------------------------------------------------------------===// void GlobalsSpaceRegion::anchor() { } void HeapSpaceRegion::anchor() { } void UnknownSpaceRegion::anchor() { } void StackLocalsSpaceRegion::anchor() { } void StackArgumentsSpaceRegion::anchor() { } void TypedRegion::anchor() { } void TypedValueRegion::anchor() { } void CodeTextRegion::anchor() { } void SubRegion::anchor() { } //===----------------------------------------------------------------------===// // Region pretty-printing. //===----------------------------------------------------------------------===// void MemRegion::dump() const { dumpToStream(llvm::errs()); } std::string MemRegion::getString() const { std::string s; llvm::raw_string_ostream os(s); dumpToStream(os); return os.str(); } void MemRegion::dumpToStream(raw_ostream &os) const { os << ""; } void AllocaRegion::dumpToStream(raw_ostream &os) const { os << "alloca{" << (const void*) Ex << ',' << Cnt << '}'; } void FunctionTextRegion::dumpToStream(raw_ostream &os) const { os << "code{" << getDecl()->getDeclName().getAsString() << '}'; } void BlockTextRegion::dumpToStream(raw_ostream &os) const { os << "block_code{" << (const void*) this << '}'; } void BlockDataRegion::dumpToStream(raw_ostream &os) const { os << "block_data{" << BC; os << "; "; for (BlockDataRegion::referenced_vars_iterator I = referenced_vars_begin(), E = referenced_vars_end(); I != E; ++I) os << "(" << I.getCapturedRegion() << "," << I.getOriginalRegion() << ") "; os << '}'; } void CompoundLiteralRegion::dumpToStream(raw_ostream &os) const { // FIXME: More elaborate pretty-printing. os << "{ " << (const void*) CL << " }"; } void CXXTempObjectRegion::dumpToStream(raw_ostream &os) const { os << "temp_object{" << getValueType().getAsString() << ',' << (const void*) Ex << '}'; } void CXXBaseObjectRegion::dumpToStream(raw_ostream &os) const { os << "base{" << superRegion << ',' << getDecl()->getName() << '}'; } void CXXThisRegion::dumpToStream(raw_ostream &os) const { os << "this"; } void ElementRegion::dumpToStream(raw_ostream &os) const { os << "element{" << superRegion << ',' << Index << ',' << getElementType().getAsString() << '}'; } void FieldRegion::dumpToStream(raw_ostream &os) const { os << superRegion << "->" << *getDecl(); } void ObjCIvarRegion::dumpToStream(raw_ostream &os) const { os << "ivar{" << superRegion << ',' << *getDecl() << '}'; } void StringRegion::dumpToStream(raw_ostream &os) const { Str->printPretty(os, 0, PrintingPolicy(getContext().getLangOpts())); } void ObjCStringRegion::dumpToStream(raw_ostream &os) const { Str->printPretty(os, 0, PrintingPolicy(getContext().getLangOpts())); } void SymbolicRegion::dumpToStream(raw_ostream &os) const { os << "SymRegion{" << sym << '}'; } void VarRegion::dumpToStream(raw_ostream &os) const { os << *cast(D); } void RegionRawOffset::dump() const { dumpToStream(llvm::errs()); } void RegionRawOffset::dumpToStream(raw_ostream &os) const { os << "raw_offset{" << getRegion() << ',' << getOffset().getQuantity() << '}'; } void StaticGlobalSpaceRegion::dumpToStream(raw_ostream &os) const { os << "StaticGlobalsMemSpace{" << CR << '}'; } void GlobalInternalSpaceRegion::dumpToStream(raw_ostream &os) const { os << "GlobalInternalSpaceRegion"; } void GlobalSystemSpaceRegion::dumpToStream(raw_ostream &os) const { os << "GlobalSystemSpaceRegion"; } void GlobalImmutableSpaceRegion::dumpToStream(raw_ostream &os) const { os << "GlobalImmutableSpaceRegion"; } void HeapSpaceRegion::dumpToStream(raw_ostream &os) const { os << "HeapSpaceRegion"; } void UnknownSpaceRegion::dumpToStream(raw_ostream &os) const { os << "UnknownSpaceRegion"; } void StackArgumentsSpaceRegion::dumpToStream(raw_ostream &os) const { os << "StackArgumentsSpaceRegion"; } void StackLocalsSpaceRegion::dumpToStream(raw_ostream &os) const { os << "StackLocalsSpaceRegion"; } bool MemRegion::canPrintPretty() const { return canPrintPrettyAsExpr(); } bool MemRegion::canPrintPrettyAsExpr() const { return false; } void MemRegion::printPretty(raw_ostream &os) const { assert(canPrintPretty() && "This region cannot be printed pretty."); os << "'"; printPrettyAsExpr(os); os << "'"; return; } void MemRegion::printPrettyAsExpr(raw_ostream &os) const { llvm_unreachable("This region cannot be printed pretty."); return; } bool VarRegion::canPrintPrettyAsExpr() const { return true; } void VarRegion::printPrettyAsExpr(raw_ostream &os) const { os << getDecl()->getName(); } bool ObjCIvarRegion::canPrintPrettyAsExpr() const { return true; } void ObjCIvarRegion::printPrettyAsExpr(raw_ostream &os) const { os << getDecl()->getName(); } bool FieldRegion::canPrintPretty() const { return true; } bool FieldRegion::canPrintPrettyAsExpr() const { return superRegion->canPrintPrettyAsExpr(); } void FieldRegion::printPrettyAsExpr(raw_ostream &os) const { assert(canPrintPrettyAsExpr()); superRegion->printPrettyAsExpr(os); os << "." << getDecl()->getName(); } void FieldRegion::printPretty(raw_ostream &os) const { if (canPrintPrettyAsExpr()) { os << "\'"; printPrettyAsExpr(os); os << "'"; } else { os << "field " << "\'" << getDecl()->getName() << "'"; } return; } bool CXXBaseObjectRegion::canPrintPrettyAsExpr() const { return superRegion->canPrintPrettyAsExpr(); } void CXXBaseObjectRegion::printPrettyAsExpr(raw_ostream &os) const { superRegion->printPrettyAsExpr(os); } //===----------------------------------------------------------------------===// // MemRegionManager methods. //===----------------------------------------------------------------------===// template const REG *MemRegionManager::LazyAllocate(REG*& region) { if (!region) { region = (REG*) A.Allocate(); new (region) REG(this); } return region; } template const REG *MemRegionManager::LazyAllocate(REG*& region, ARG a) { if (!region) { region = (REG*) A.Allocate(); new (region) REG(this, a); } return region; } const StackLocalsSpaceRegion* MemRegionManager::getStackLocalsRegion(const StackFrameContext *STC) { assert(STC); StackLocalsSpaceRegion *&R = StackLocalsSpaceRegions[STC]; if (R) return R; R = A.Allocate(); new (R) StackLocalsSpaceRegion(this, STC); return R; } const StackArgumentsSpaceRegion * MemRegionManager::getStackArgumentsRegion(const StackFrameContext *STC) { assert(STC); StackArgumentsSpaceRegion *&R = StackArgumentsSpaceRegions[STC]; if (R) return R; R = A.Allocate(); new (R) StackArgumentsSpaceRegion(this, STC); return R; } const GlobalsSpaceRegion *MemRegionManager::getGlobalsRegion(MemRegion::Kind K, const CodeTextRegion *CR) { if (!CR) { if (K == MemRegion::GlobalSystemSpaceRegionKind) return LazyAllocate(SystemGlobals); if (K == MemRegion::GlobalImmutableSpaceRegionKind) return LazyAllocate(ImmutableGlobals); assert(K == MemRegion::GlobalInternalSpaceRegionKind); return LazyAllocate(InternalGlobals); } assert(K == MemRegion::StaticGlobalSpaceRegionKind); StaticGlobalSpaceRegion *&R = StaticsGlobalSpaceRegions[CR]; if (R) return R; R = A.Allocate(); new (R) StaticGlobalSpaceRegion(this, CR); return R; } const HeapSpaceRegion *MemRegionManager::getHeapRegion() { return LazyAllocate(heap); } const MemSpaceRegion *MemRegionManager::getUnknownRegion() { return LazyAllocate(unknown); } const MemSpaceRegion *MemRegionManager::getCodeRegion() { return LazyAllocate(code); } //===----------------------------------------------------------------------===// // Constructing regions. //===----------------------------------------------------------------------===// const StringRegion* MemRegionManager::getStringRegion(const StringLiteral* Str){ return getSubRegion(Str, getGlobalsRegion()); } const ObjCStringRegion * MemRegionManager::getObjCStringRegion(const ObjCStringLiteral* Str){ return getSubRegion(Str, getGlobalsRegion()); } /// Look through a chain of LocationContexts to either find the /// StackFrameContext that matches a DeclContext, or find a VarRegion /// for a variable captured by a block. static llvm::PointerUnion getStackOrCaptureRegionForDeclContext(const LocationContext *LC, const DeclContext *DC, const VarDecl *VD) { while (LC) { if (const StackFrameContext *SFC = dyn_cast(LC)) { if (cast(SFC->getDecl()) == DC) return SFC; } if (const BlockInvocationContext *BC = dyn_cast(LC)) { const BlockDataRegion *BR = static_cast(BC->getContextData()); // FIXME: This can be made more efficient. for (BlockDataRegion::referenced_vars_iterator I = BR->referenced_vars_begin(), E = BR->referenced_vars_end(); I != E; ++I) { if (const VarRegion *VR = dyn_cast(I.getOriginalRegion())) if (VR->getDecl() == VD) return cast(I.getCapturedRegion()); } } LC = LC->getParent(); } return (const StackFrameContext*)0; } const VarRegion* MemRegionManager::getVarRegion(const VarDecl *D, const LocationContext *LC) { const MemRegion *sReg = 0; if (D->hasGlobalStorage() && !D->isStaticLocal()) { // First handle the globals defined in system headers. if (C.getSourceManager().isInSystemHeader(D->getLocation())) { // Whitelist the system globals which often DO GET modified, assume the // rest are immutable. if (D->getName().find("errno") != StringRef::npos) sReg = getGlobalsRegion(MemRegion::GlobalSystemSpaceRegionKind); else sReg = getGlobalsRegion(MemRegion::GlobalImmutableSpaceRegionKind); // Treat other globals as GlobalInternal unless they are constants. } else { QualType GQT = D->getType(); const Type *GT = GQT.getTypePtrOrNull(); // TODO: We could walk the complex types here and see if everything is // constified. if (GT && GQT.isConstQualified() && GT->isArithmeticType()) sReg = getGlobalsRegion(MemRegion::GlobalImmutableSpaceRegionKind); else sReg = getGlobalsRegion(); } // Finally handle static locals. } else { // FIXME: Once we implement scope handling, we will need to properly lookup // 'D' to the proper LocationContext. const DeclContext *DC = D->getDeclContext(); llvm::PointerUnion V = getStackOrCaptureRegionForDeclContext(LC, DC, D); if (V.is()) return V.get(); const StackFrameContext *STC = V.get(); if (!STC) sReg = getUnknownRegion(); else { if (D->hasLocalStorage()) { sReg = isa(D) || isa(D) ? static_cast(getStackArgumentsRegion(STC)) : static_cast(getStackLocalsRegion(STC)); } else { assert(D->isStaticLocal()); const Decl *STCD = STC->getDecl(); if (isa(STCD) || isa(STCD)) sReg = getGlobalsRegion(MemRegion::StaticGlobalSpaceRegionKind, getFunctionTextRegion(cast(STCD))); else if (const BlockDecl *BD = dyn_cast(STCD)) { // FIXME: The fallback type here is totally bogus -- though it should // never be queried, it will prevent uniquing with the real // BlockTextRegion. Ideally we'd fix the AST so that we always had a // signature. QualType T; if (const TypeSourceInfo *TSI = BD->getSignatureAsWritten()) T = TSI->getType(); else T = getContext().getFunctionNoProtoType(getContext().VoidTy); const BlockTextRegion *BTR = getBlockTextRegion(BD, C.getCanonicalType(T), STC->getAnalysisDeclContext()); sReg = getGlobalsRegion(MemRegion::StaticGlobalSpaceRegionKind, BTR); } else { sReg = getGlobalsRegion(); } } } } return getSubRegion(D, sReg); } const VarRegion *MemRegionManager::getVarRegion(const VarDecl *D, const MemRegion *superR) { return getSubRegion(D, superR); } const BlockDataRegion * MemRegionManager::getBlockDataRegion(const BlockTextRegion *BC, const LocationContext *LC, unsigned blockCount) { const MemRegion *sReg = 0; const BlockDecl *BD = BC->getDecl(); if (!BD->hasCaptures()) { // This handles 'static' blocks. sReg = getGlobalsRegion(MemRegion::GlobalImmutableSpaceRegionKind); } else { if (LC) { // FIXME: Once we implement scope handling, we want the parent region // to be the scope. const StackFrameContext *STC = LC->getCurrentStackFrame(); assert(STC); sReg = getStackLocalsRegion(STC); } else { // We allow 'LC' to be NULL for cases where want BlockDataRegions // without context-sensitivity. sReg = getUnknownRegion(); } } return getSubRegion(BC, LC, blockCount, sReg); } const CXXTempObjectRegion * MemRegionManager::getCXXStaticTempObjectRegion(const Expr *Ex) { return getSubRegion( Ex, getGlobalsRegion(MemRegion::GlobalInternalSpaceRegionKind, NULL)); } const CompoundLiteralRegion* MemRegionManager::getCompoundLiteralRegion(const CompoundLiteralExpr *CL, const LocationContext *LC) { const MemRegion *sReg = 0; if (CL->isFileScope()) sReg = getGlobalsRegion(); else { const StackFrameContext *STC = LC->getCurrentStackFrame(); assert(STC); sReg = getStackLocalsRegion(STC); } return getSubRegion(CL, sReg); } const ElementRegion* MemRegionManager::getElementRegion(QualType elementType, NonLoc Idx, const MemRegion* superRegion, ASTContext &Ctx){ QualType T = Ctx.getCanonicalType(elementType).getUnqualifiedType(); llvm::FoldingSetNodeID ID; ElementRegion::ProfileRegion(ID, T, Idx, superRegion); void *InsertPos; MemRegion* data = Regions.FindNodeOrInsertPos(ID, InsertPos); ElementRegion* R = cast_or_null(data); if (!R) { R = (ElementRegion*) A.Allocate(); new (R) ElementRegion(T, Idx, superRegion); Regions.InsertNode(R, InsertPos); } return R; } const FunctionTextRegion * MemRegionManager::getFunctionTextRegion(const NamedDecl *FD) { return getSubRegion(FD, getCodeRegion()); } const BlockTextRegion * MemRegionManager::getBlockTextRegion(const BlockDecl *BD, CanQualType locTy, AnalysisDeclContext *AC) { return getSubRegion(BD, locTy, AC, getCodeRegion()); } /// getSymbolicRegion - Retrieve or create a "symbolic" memory region. const SymbolicRegion *MemRegionManager::getSymbolicRegion(SymbolRef sym) { return getSubRegion(sym, getUnknownRegion()); } const SymbolicRegion *MemRegionManager::getSymbolicHeapRegion(SymbolRef Sym) { return getSubRegion(Sym, getHeapRegion()); } const FieldRegion* MemRegionManager::getFieldRegion(const FieldDecl *d, const MemRegion* superRegion){ return getSubRegion(d, superRegion); } const ObjCIvarRegion* MemRegionManager::getObjCIvarRegion(const ObjCIvarDecl *d, const MemRegion* superRegion) { return getSubRegion(d, superRegion); } const CXXTempObjectRegion* MemRegionManager::getCXXTempObjectRegion(Expr const *E, LocationContext const *LC) { const StackFrameContext *SFC = LC->getCurrentStackFrame(); assert(SFC); return getSubRegion(E, getStackLocalsRegion(SFC)); } /// Checks whether \p BaseClass is a valid virtual or direct non-virtual base /// class of the type of \p Super. static bool isValidBaseClass(const CXXRecordDecl *BaseClass, const TypedValueRegion *Super, bool IsVirtual) { BaseClass = BaseClass->getCanonicalDecl(); const CXXRecordDecl *Class = Super->getValueType()->getAsCXXRecordDecl(); if (!Class) return true; if (IsVirtual) return Class->isVirtuallyDerivedFrom(BaseClass); for (CXXRecordDecl::base_class_const_iterator I = Class->bases_begin(), E = Class->bases_end(); I != E; ++I) { if (I->getType()->getAsCXXRecordDecl()->getCanonicalDecl() == BaseClass) return true; } return false; } const CXXBaseObjectRegion * MemRegionManager::getCXXBaseObjectRegion(const CXXRecordDecl *RD, const MemRegion *Super, bool IsVirtual) { if (isa(Super)) { assert(isValidBaseClass(RD, dyn_cast(Super), IsVirtual)); (void)&isValidBaseClass; if (IsVirtual) { // Virtual base regions should not be layered, since the layout rules // are different. while (const CXXBaseObjectRegion *Base = dyn_cast(Super)) { Super = Base->getSuperRegion(); } assert(Super && !isa(Super)); } } return getSubRegion(RD, IsVirtual, Super); } const CXXThisRegion* MemRegionManager::getCXXThisRegion(QualType thisPointerTy, const LocationContext *LC) { const StackFrameContext *STC = LC->getCurrentStackFrame(); assert(STC); const PointerType *PT = thisPointerTy->getAs(); assert(PT); return getSubRegion(PT, getStackArgumentsRegion(STC)); } const AllocaRegion* MemRegionManager::getAllocaRegion(const Expr *E, unsigned cnt, const LocationContext *LC) { const StackFrameContext *STC = LC->getCurrentStackFrame(); assert(STC); return getSubRegion(E, cnt, getStackLocalsRegion(STC)); } const MemSpaceRegion *MemRegion::getMemorySpace() const { const MemRegion *R = this; const SubRegion* SR = dyn_cast(this); while (SR) { R = SR->getSuperRegion(); SR = dyn_cast(R); } return dyn_cast(R); } bool MemRegion::hasStackStorage() const { return isa(getMemorySpace()); } bool MemRegion::hasStackNonParametersStorage() const { return isa(getMemorySpace()); } bool MemRegion::hasStackParametersStorage() const { return isa(getMemorySpace()); } bool MemRegion::hasGlobalsOrParametersStorage() const { const MemSpaceRegion *MS = getMemorySpace(); return isa(MS) || isa(MS); } // getBaseRegion strips away all elements and fields, and get the base region // of them. const MemRegion *MemRegion::getBaseRegion() const { const MemRegion *R = this; while (true) { switch (R->getKind()) { case MemRegion::ElementRegionKind: case MemRegion::FieldRegionKind: case MemRegion::ObjCIvarRegionKind: case MemRegion::CXXBaseObjectRegionKind: R = cast(R)->getSuperRegion(); continue; default: break; } break; } return R; } bool MemRegion::isSubRegionOf(const MemRegion *R) const { return false; } //===----------------------------------------------------------------------===// // View handling. //===----------------------------------------------------------------------===// const MemRegion *MemRegion::StripCasts(bool StripBaseCasts) const { const MemRegion *R = this; while (true) { switch (R->getKind()) { case ElementRegionKind: { const ElementRegion *ER = cast(R); if (!ER->getIndex().isZeroConstant()) return R; R = ER->getSuperRegion(); break; } case CXXBaseObjectRegionKind: if (!StripBaseCasts) return R; R = cast(R)->getSuperRegion(); break; default: return R; } } } const SymbolicRegion *MemRegion::getSymbolicBase() const { const SubRegion *SubR = dyn_cast(this); while (SubR) { if (const SymbolicRegion *SymR = dyn_cast(SubR)) return SymR; SubR = dyn_cast(SubR->getSuperRegion()); } return 0; } // FIXME: Merge with the implementation of the same method in Store.cpp static bool IsCompleteType(ASTContext &Ctx, QualType Ty) { if (const RecordType *RT = Ty->getAs()) { const RecordDecl *D = RT->getDecl(); if (!D->getDefinition()) return false; } return true; } RegionRawOffset ElementRegion::getAsArrayOffset() const { CharUnits offset = CharUnits::Zero(); const ElementRegion *ER = this; const MemRegion *superR = NULL; ASTContext &C = getContext(); // FIXME: Handle multi-dimensional arrays. while (ER) { superR = ER->getSuperRegion(); // FIXME: generalize to symbolic offsets. SVal index = ER->getIndex(); if (Optional CI = index.getAs()) { // Update the offset. int64_t i = CI->getValue().getSExtValue(); if (i != 0) { QualType elemType = ER->getElementType(); // If we are pointing to an incomplete type, go no further. if (!IsCompleteType(C, elemType)) { superR = ER; break; } CharUnits size = C.getTypeSizeInChars(elemType); offset += (i * size); } // Go to the next ElementRegion (if any). ER = dyn_cast(superR); continue; } return NULL; } assert(superR && "super region cannot be NULL"); return RegionRawOffset(superR, offset); } /// Returns true if \p Base is an immediate base class of \p Child static bool isImmediateBase(const CXXRecordDecl *Child, const CXXRecordDecl *Base) { // Note that we do NOT canonicalize the base class here, because // ASTRecordLayout doesn't either. If that leads us down the wrong path, // so be it; at least we won't crash. for (CXXRecordDecl::base_class_const_iterator I = Child->bases_begin(), E = Child->bases_end(); I != E; ++I) { if (I->getType()->getAsCXXRecordDecl() == Base) return true; } return false; } RegionOffset MemRegion::getAsOffset() const { const MemRegion *R = this; const MemRegion *SymbolicOffsetBase = 0; int64_t Offset = 0; while (1) { switch (R->getKind()) { case GenericMemSpaceRegionKind: case StackLocalsSpaceRegionKind: case StackArgumentsSpaceRegionKind: case HeapSpaceRegionKind: case UnknownSpaceRegionKind: case StaticGlobalSpaceRegionKind: case GlobalInternalSpaceRegionKind: case GlobalSystemSpaceRegionKind: case GlobalImmutableSpaceRegionKind: // Stores can bind directly to a region space to set a default value. assert(Offset == 0 && !SymbolicOffsetBase); goto Finish; case FunctionTextRegionKind: case BlockTextRegionKind: case BlockDataRegionKind: // These will never have bindings, but may end up having values requested // if the user does some strange casting. if (Offset != 0) SymbolicOffsetBase = R; goto Finish; case SymbolicRegionKind: case AllocaRegionKind: case CompoundLiteralRegionKind: case CXXThisRegionKind: case StringRegionKind: case ObjCStringRegionKind: case VarRegionKind: case CXXTempObjectRegionKind: // Usual base regions. goto Finish; case ObjCIvarRegionKind: // This is a little strange, but it's a compromise between // ObjCIvarRegions having unknown compile-time offsets (when using the // non-fragile runtime) and yet still being distinct, non-overlapping // regions. Thus we treat them as "like" base regions for the purposes // of computing offsets. goto Finish; case CXXBaseObjectRegionKind: { const CXXBaseObjectRegion *BOR = cast(R); R = BOR->getSuperRegion(); QualType Ty; bool RootIsSymbolic = false; if (const TypedValueRegion *TVR = dyn_cast(R)) { Ty = TVR->getDesugaredValueType(getContext()); } else if (const SymbolicRegion *SR = dyn_cast(R)) { // If our base region is symbolic, we don't know what type it really is. // Pretend the type of the symbol is the true dynamic type. // (This will at least be self-consistent for the life of the symbol.) Ty = SR->getSymbol()->getType()->getPointeeType(); RootIsSymbolic = true; } const CXXRecordDecl *Child = Ty->getAsCXXRecordDecl(); if (!Child) { // We cannot compute the offset of the base class. SymbolicOffsetBase = R; } if (RootIsSymbolic) { // Base layers on symbolic regions may not be type-correct. // Double-check the inheritance here, and revert to a symbolic offset // if it's invalid (e.g. due to a reinterpret_cast). if (BOR->isVirtual()) { if (!Child->isVirtuallyDerivedFrom(BOR->getDecl())) SymbolicOffsetBase = R; } else { if (!isImmediateBase(Child, BOR->getDecl())) SymbolicOffsetBase = R; } } // Don't bother calculating precise offsets if we already have a // symbolic offset somewhere in the chain. if (SymbolicOffsetBase) continue; CharUnits BaseOffset; const ASTRecordLayout &Layout = getContext().getASTRecordLayout(Child); if (BOR->isVirtual()) BaseOffset = Layout.getVBaseClassOffset(BOR->getDecl()); else BaseOffset = Layout.getBaseClassOffset(BOR->getDecl()); // The base offset is in chars, not in bits. Offset += BaseOffset.getQuantity() * getContext().getCharWidth(); break; } case ElementRegionKind: { const ElementRegion *ER = cast(R); R = ER->getSuperRegion(); QualType EleTy = ER->getValueType(); if (!IsCompleteType(getContext(), EleTy)) { // We cannot compute the offset of the base class. SymbolicOffsetBase = R; continue; } SVal Index = ER->getIndex(); if (Optional CI = Index.getAs()) { // Don't bother calculating precise offsets if we already have a // symbolic offset somewhere in the chain. if (SymbolicOffsetBase) continue; int64_t i = CI->getValue().getSExtValue(); // This type size is in bits. Offset += i * getContext().getTypeSize(EleTy); } else { // We cannot compute offset for non-concrete index. SymbolicOffsetBase = R; } break; } case FieldRegionKind: { const FieldRegion *FR = cast(R); R = FR->getSuperRegion(); const RecordDecl *RD = FR->getDecl()->getParent(); if (RD->isUnion() || !RD->isCompleteDefinition()) { // We cannot compute offset for incomplete type. // For unions, we could treat everything as offset 0, but we'd rather // treat each field as a symbolic offset so they aren't stored on top // of each other, since we depend on things in typed regions actually // matching their types. SymbolicOffsetBase = R; } // Don't bother calculating precise offsets if we already have a // symbolic offset somewhere in the chain. if (SymbolicOffsetBase) continue; // Get the field number. unsigned idx = 0; for (RecordDecl::field_iterator FI = RD->field_begin(), FE = RD->field_end(); FI != FE; ++FI, ++idx) if (FR->getDecl() == *FI) break; const ASTRecordLayout &Layout = getContext().getASTRecordLayout(RD); // This is offset in bits. Offset += Layout.getFieldOffset(idx); break; } } } Finish: if (SymbolicOffsetBase) return RegionOffset(SymbolicOffsetBase, RegionOffset::Symbolic); return RegionOffset(R, Offset); } //===----------------------------------------------------------------------===// // BlockDataRegion //===----------------------------------------------------------------------===// std::pair BlockDataRegion::getCaptureRegions(const VarDecl *VD) { MemRegionManager &MemMgr = *getMemRegionManager(); const VarRegion *VR = 0; const VarRegion *OriginalVR = 0; if (!VD->getAttr() && VD->hasLocalStorage()) { VR = MemMgr.getVarRegion(VD, this); OriginalVR = MemMgr.getVarRegion(VD, LC); } else { if (LC) { VR = MemMgr.getVarRegion(VD, LC); OriginalVR = VR; } else { VR = MemMgr.getVarRegion(VD, MemMgr.getUnknownRegion()); OriginalVR = MemMgr.getVarRegion(VD, LC); } } return std::make_pair(VR, OriginalVR); } void BlockDataRegion::LazyInitializeReferencedVars() { if (ReferencedVars) return; AnalysisDeclContext *AC = getCodeRegion()->getAnalysisDeclContext(); AnalysisDeclContext::referenced_decls_iterator I, E; llvm::tie(I, E) = AC->getReferencedBlockVars(BC->getDecl()); if (I == E) { ReferencedVars = (void*) 0x1; return; } MemRegionManager &MemMgr = *getMemRegionManager(); llvm::BumpPtrAllocator &A = MemMgr.getAllocator(); BumpVectorContext BC(A); typedef BumpVector VarVec; VarVec *BV = (VarVec*) A.Allocate(); new (BV) VarVec(BC, E - I); VarVec *BVOriginal = (VarVec*) A.Allocate(); new (BVOriginal) VarVec(BC, E - I); for ( ; I != E; ++I) { const VarRegion *VR = 0; const VarRegion *OriginalVR = 0; llvm::tie(VR, OriginalVR) = getCaptureRegions(*I); assert(VR); assert(OriginalVR); BV->push_back(VR, BC); BVOriginal->push_back(OriginalVR, BC); } ReferencedVars = BV; OriginalVars = BVOriginal; } BlockDataRegion::referenced_vars_iterator BlockDataRegion::referenced_vars_begin() const { const_cast(this)->LazyInitializeReferencedVars(); BumpVector *Vec = static_cast*>(ReferencedVars); if (Vec == (void*) 0x1) return BlockDataRegion::referenced_vars_iterator(0, 0); BumpVector *VecOriginal = static_cast*>(OriginalVars); return BlockDataRegion::referenced_vars_iterator(Vec->begin(), VecOriginal->begin()); } BlockDataRegion::referenced_vars_iterator BlockDataRegion::referenced_vars_end() const { const_cast(this)->LazyInitializeReferencedVars(); BumpVector *Vec = static_cast*>(ReferencedVars); if (Vec == (void*) 0x1) return BlockDataRegion::referenced_vars_iterator(0, 0); BumpVector *VecOriginal = static_cast*>(OriginalVars); return BlockDataRegion::referenced_vars_iterator(Vec->end(), VecOriginal->end()); } const VarRegion *BlockDataRegion::getOriginalRegion(const VarRegion *R) const { for (referenced_vars_iterator I = referenced_vars_begin(), E = referenced_vars_end(); I != E; ++I) { if (I.getCapturedRegion() == R) return I.getOriginalRegion(); } return 0; } //===----------------------------------------------------------------------===// // RegionAndSymbolInvalidationTraits //===----------------------------------------------------------------------===// void RegionAndSymbolInvalidationTraits::setTrait(SymbolRef Sym, InvalidationKinds IK) { SymTraitsMap[Sym] |= IK; } void RegionAndSymbolInvalidationTraits::setTrait(const MemRegion *MR, InvalidationKinds IK) { assert(MR); if (const SymbolicRegion *SR = dyn_cast(MR)) setTrait(SR->getSymbol(), IK); else MRTraitsMap[MR] |= IK; } bool RegionAndSymbolInvalidationTraits::hasTrait(SymbolRef Sym, InvalidationKinds IK) { const_symbol_iterator I = SymTraitsMap.find(Sym); if (I != SymTraitsMap.end()) return I->second & IK; return false; } bool RegionAndSymbolInvalidationTraits::hasTrait(const MemRegion *MR, InvalidationKinds IK) { if (!MR) return false; if (const SymbolicRegion *SR = dyn_cast(MR)) return hasTrait(SR->getSymbol(), IK); const_region_iterator I = MRTraitsMap.find(MR); if (I != MRTraitsMap.end()) return I->second & IK; return false; } @ 1.1.1.1 log @Import Clang 3.4rc1 r195771. @ text @@ 1.1.1.2 log @Import clang 3.5svn r198450. @ text @d1366 1 a1366 1 if (!VD->hasAttr() && VD->hasLocalStorage()) { @ 1.1.1.2.2.1 log @Rebase. @ text @d151 1 a151 1 while (r != nullptr) { d176 1 a176 1 return SSR ? SSR->getStackFrame() : nullptr; d511 1 a511 1 Str->printPretty(os, nullptr, PrintingPolicy(getContext().getLangOpts())); d515 1 a515 1 Str->printPretty(os, nullptr, PrintingPolicy(getContext().getLangOpts())); d760 1 a760 1 return (const StackFrameContext *)nullptr; d765 1 a765 1 const MemRegion *sReg = nullptr; d853 1 a853 1 const MemRegion *sReg = nullptr; d880 1 a880 1 Ex, getGlobalsRegion(MemRegion::GlobalInternalSpaceRegionKind, nullptr)); d887 1 a887 1 const MemRegion *sReg = nullptr; d978 4 a981 2 for (const auto &I : Class->bases()) { if (I.getType()->getAsCXXRecordDecl()->getCanonicalDecl() == BaseClass) d1116 1 a1116 1 return nullptr; d1133 1 a1133 1 const MemRegion *superR = nullptr; d1165 1 a1165 1 return nullptr; d1179 4 a1182 2 for (const auto &I : Child->bases()) { if (I.getType()->getAsCXXRecordDecl() == Base) d1191 1 a1191 1 const MemRegion *SymbolicOffsetBase = nullptr; d1363 2 a1364 2 const VarRegion *VR = nullptr; const VarRegion *OriginalVR = nullptr; d1389 1 a1389 1 std::tie(I, E) = AC->getReferencedBlockVars(BC->getDecl()); d1407 3 a1409 3 const VarRegion *VR = nullptr; const VarRegion *OriginalVR = nullptr; std::tie(VR, OriginalVR) = getCaptureRegions(*I); d1428 2 a1429 2 return BlockDataRegion::referenced_vars_iterator(nullptr, nullptr); d1445 2 a1446 2 return BlockDataRegion::referenced_vars_iterator(nullptr, nullptr); d1461 1 a1461 1 return nullptr; @ 1.1.1.3 log @Import Clang 3.5svn r209886. @ text @d151 1 a151 1 while (r != nullptr) { d176 1 a176 1 return SSR ? SSR->getStackFrame() : nullptr; d511 1 a511 1 Str->printPretty(os, nullptr, PrintingPolicy(getContext().getLangOpts())); d515 1 a515 1 Str->printPretty(os, nullptr, PrintingPolicy(getContext().getLangOpts())); d760 1 a760 1 return (const StackFrameContext *)nullptr; d765 1 a765 1 const MemRegion *sReg = nullptr; d853 1 a853 1 const MemRegion *sReg = nullptr; d880 1 a880 1 Ex, getGlobalsRegion(MemRegion::GlobalInternalSpaceRegionKind, nullptr)); d887 1 a887 1 const MemRegion *sReg = nullptr; d978 4 a981 2 for (const auto &I : Class->bases()) { if (I.getType()->getAsCXXRecordDecl()->getCanonicalDecl() == BaseClass) d1116 1 a1116 1 return nullptr; d1133 1 a1133 1 const MemRegion *superR = nullptr; d1165 1 a1165 1 return nullptr; d1179 4 a1182 2 for (const auto &I : Child->bases()) { if (I.getType()->getAsCXXRecordDecl() == Base) d1191 1 a1191 1 const MemRegion *SymbolicOffsetBase = nullptr; d1363 2 a1364 2 const VarRegion *VR = nullptr; const VarRegion *OriginalVR = nullptr; d1389 1 a1389 1 std::tie(I, E) = AC->getReferencedBlockVars(BC->getDecl()); d1407 3 a1409 3 const VarRegion *VR = nullptr; const VarRegion *OriginalVR = nullptr; std::tie(VR, OriginalVR) = getCaptureRegions(*I); d1428 2 a1429 2 return BlockDataRegion::referenced_vars_iterator(nullptr, nullptr); d1445 2 a1446 2 return BlockDataRegion::referenced_vars_iterator(nullptr, nullptr); d1461 1 a1461 1 return nullptr; @ 1.1.1.4 log @Import clang 3.6svn r215315. @ text @a510 1 assert(Str != nullptr && "Expecting non-null StringLiteral"); a514 1 assert(Str != nullptr && "Expecting non-null ObjCStringLiteral"); @ 1.1.1.4.2.1 log @Update LLVM to 3.6.1, requested by joerg in ticket 824. @ text @d1119 11 d1151 1 a1151 1 if (elemType->isIncompleteType()) { d1291 1 a1291 1 if (EleTy->isIncompleteType()) { @ 1.1.1.5 log @Import Clang 3.6RC1 r227398. @ text @d1119 11 d1151 1 a1151 1 if (elemType->isIncompleteType()) { d1291 1 a1291 1 if (EleTy->isIncompleteType()) { @ 1.1.1.6 log @Import Clang 3.8.0rc3 r261930. @ text @d248 1 a248 1 void MemSpaceRegion::Profile(llvm::FoldingSetNodeID &ID) const { d360 1 a360 1 void FunctionCodeRegion::ProfileRegion(llvm::FoldingSetNodeID& ID, d363 1 a363 1 ID.AddInteger(MemRegion::FunctionCodeRegionKind); d367 2 a368 2 void FunctionCodeRegion::Profile(llvm::FoldingSetNodeID& ID) const { FunctionCodeRegion::ProfileRegion(ID, FD, superRegion); d371 1 a371 1 void BlockCodeRegion::ProfileRegion(llvm::FoldingSetNodeID& ID, d375 1 a375 1 ID.AddInteger(MemRegion::BlockCodeRegionKind); d379 2 a380 2 void BlockCodeRegion::Profile(llvm::FoldingSetNodeID& ID) const { BlockCodeRegion::ProfileRegion(ID, BD, locTy, AC, superRegion); d384 1 a384 1 const BlockCodeRegion *BC, d460 1 a460 1 void FunctionCodeRegion::dumpToStream(raw_ostream &os) const { d464 1 a464 1 void BlockCodeRegion::dumpToStream(raw_ostream &os) const { a535 4 void CodeSpaceRegion::dumpToStream(raw_ostream &os) const { os << "CodeSpaceRegion"; } d714 1 a714 1 const UnknownSpaceRegion *MemRegionManager::getUnknownRegion() { d718 1 a718 1 const CodeSpaceRegion *MemRegionManager::getCodeRegion() { d759 1 a759 1 d791 2 a792 2 // Finally handle static locals. d799 1 a799 1 d802 1 a802 1 d818 1 a818 1 getFunctionCodeRegion(cast(STCD))); d822 1 a822 1 // BlockCodeRegion. Ideally we'd fix the AST so that we always had a d827 5 a831 8 if (T.isNull()) T = getContext().VoidTy; if (!T->getAs()) T = getContext().getFunctionNoProtoType(T); T = getContext().getBlockPointerType(T); const BlockCodeRegion *BTR = getBlockCodeRegion(BD, C.getCanonicalType(T), d852 1 a852 1 MemRegionManager::getBlockDataRegion(const BlockCodeRegion *BC, d925 3 a927 3 const FunctionCodeRegion * MemRegionManager::getFunctionCodeRegion(const NamedDecl *FD) { return getSubRegion(FD, getCodeRegion()); d930 2 a931 2 const BlockCodeRegion * MemRegionManager::getBlockCodeRegion(const BlockDecl *BD, CanQualType locTy, d933 1 a933 1 return getSubRegion(BD, locTy, AC, getCodeRegion()); d1013 2 a1016 14 // Inside the body of the operator() of a lambda a this expr might refer to an // object in one of the parent location contexts. const auto *D = dyn_cast(LC->getDecl()); // FIXME: when operator() of lambda is analyzed as a top level function and // 'this' refers to a this to the enclosing scope, there is no right region to // return. while (!LC->inTopFrame() && (!D || D->isStatic() || PT != D->getThisType(getContext())->getAs())) { LC = LC->getParent(); D = dyn_cast(LC->getDecl()); } const StackFrameContext *STC = LC->getCurrentStackFrame(); assert(STC); a1164 1 assert(Child && "Child must not be null"); d1183 1 a1183 1 case CodeSpaceRegionKind: d1196 2 a1197 2 case FunctionCodeRegionKind: case BlockCodeRegionKind: d1239 1 a1239 1 d1244 12 a1255 12 } else { if (RootIsSymbolic) { // Base layers on symbolic regions may not be type-correct. // Double-check the inheritance here, and revert to a symbolic offset // if it's invalid (e.g. due to a reinterpret_cast). if (BOR->isVirtual()) { if (!Child->isVirtuallyDerivedFrom(BOR->getDecl())) SymbolicOffsetBase = R; } else { if (!isImmediateBase(Child, BOR->getDecl())) SymbolicOffsetBase = R; } d1290 1 a1290 1 // symbolic offset somewhere in the chain. d1324 1 a1324 1 for (RecordDecl::field_iterator FI = RD->field_begin(), d1375 2 a1376 3 const auto &ReferencedBlockVars = AC->getReferencedBlockVars(BC->getDecl()); auto NumBlockVars = std::distance(ReferencedBlockVars.begin(), ReferencedBlockVars.end()); d1378 1 a1378 1 if (NumBlockVars == 0) { d1389 1 a1389 1 new (BV) VarVec(BC, NumBlockVars); d1391 1 a1391 1 new (BVOriginal) VarVec(BC, NumBlockVars); d1393 1 a1393 1 for (const VarDecl *VD : ReferencedBlockVars) { d1396 1 a1396 1 std::tie(VR, OriginalVR) = getCaptureRegions(VD); d1419 1 a1419 1 d1455 1 a1455 1 void RegionAndSymbolInvalidationTraits::setTrait(SymbolRef Sym, d1460 1 a1460 1 void RegionAndSymbolInvalidationTraits::setTrait(const MemRegion *MR, d1469 1 a1469 1 bool RegionAndSymbolInvalidationTraits::hasTrait(SymbolRef Sym, d1475 1 a1475 1 return false; @ 1.1.1.6.2.1 log @Sync with HEAD @ text @d34 23 d67 1 a67 1 R = A.Allocate(); d76 21 d99 1 d107 1 a107 1 R = A.Allocate(); d118 1 d126 1 a126 1 R = A.Allocate(); d249 1 a249 1 ID.AddInteger(static_cast(getKind())); d253 1 a253 1 ID.AddInteger(static_cast(getKind())); d258 1 a258 1 ID.AddInteger(static_cast(getKind())); d265 1 a265 1 ID.AddInteger(static_cast(StringRegionKind)); d273 1 a273 1 ID.AddInteger(static_cast(ObjCStringRegionKind)); d281 1 a281 1 ID.AddInteger(static_cast(AllocaRegionKind)); d298 1 a298 1 ID.AddInteger(static_cast(CompoundLiteralRegionKind)); d306 1 a306 1 ID.AddInteger(static_cast(CXXThisRegionKind)); d323 1 a323 1 ID.AddInteger(static_cast(k)); d338 1 a338 1 ID.AddInteger(static_cast(MemRegion::SymbolicRegionKind)); d441 1 a441 1 LLVM_DUMP_METHOD void MemRegion::dump() const { d457 1 a457 1 os << "alloca{" << static_cast(Ex) << ',' << Cnt << '}'; d465 1 a465 1 os << "block_code{" << static_cast(this) << '}'; d481 1 a481 1 os << "{ " << static_cast(CL) << " }"; d486 1 a486 1 << static_cast(Ex) << '}'; d528 1 a528 1 LLVM_DUMP_METHOD void RegionRawOffset::dump() const { d585 1 d590 1 d631 1 a641 59 std::string MemRegion::getDescriptiveName(bool UseQuotes) const { std::string VariableName; std::string ArrayIndices; const MemRegion *R = this; SmallString<50> buf; llvm::raw_svector_ostream os(buf); // Obtain array indices to add them to the variable name. const ElementRegion *ER = nullptr; while ((ER = R->getAs())) { // Index is a ConcreteInt. if (auto CI = ER->getIndex().getAs()) { llvm::SmallString<2> Idx; CI->getValue().toString(Idx); ArrayIndices = (llvm::Twine("[") + Idx.str() + "]" + ArrayIndices).str(); } // If not a ConcreteInt, try to obtain the variable // name by calling 'getDescriptiveName' recursively. else { std::string Idx = ER->getDescriptiveName(false); if (!Idx.empty()) { ArrayIndices = (llvm::Twine("[") + Idx + "]" + ArrayIndices).str(); } } R = ER->getSuperRegion(); } // Get variable name. if (R && R->canPrintPrettyAsExpr()) { R->printPrettyAsExpr(os); if (UseQuotes) { return (llvm::Twine("'") + os.str() + ArrayIndices + "'").str(); } else { return (llvm::Twine(os.str()) + ArrayIndices).str(); } } return VariableName; } SourceRange MemRegion::sourceRange() const { const VarRegion *const VR = dyn_cast(this->getBaseRegion()); const FieldRegion *const FR = dyn_cast(this); // Check for more specific regions first. // FieldRegion if (FR) { return FR->getDecl()->getSourceRange(); } // VarRegion else if (VR) { return VR->getDecl()->getSourceRange(); } // Return invalid source range (can be checked by client). else { return SourceRange{}; } } d649 1 a649 1 region = A.Allocate(); d659 1 a659 1 region = A.Allocate(); d809 1 a809 3 if (!STC) { // FIXME: Assign a more sensible memory space to static locals // we see from within blocks that we analyze as top-level declarations. d811 1 a811 1 } else { d895 1 d913 1 d924 1 a924 1 R = A.Allocate(); d1345 1 a1345 1 FE = RD->field_end(); FI != FE; ++FI, ++idx) { d1348 1 a1348 1 } d1409 1 a1409 1 VarVec *BV = A.Allocate(); d1411 1 a1411 1 VarVec *BVOriginal = A.Allocate(); d1491 1 a1491 1 InvalidationKinds IK) const { d1500 1 a1500 1 InvalidationKinds IK) const { @ 1.1.1.7 log @Import Clang pre-4.0.0 r291444. @ text @d34 23 d67 1 a67 1 R = A.Allocate(); d76 21 d99 1 d107 1 a107 1 R = A.Allocate(); d118 1 d126 1 a126 1 R = A.Allocate(); d249 1 a249 1 ID.AddInteger(static_cast(getKind())); d253 1 a253 1 ID.AddInteger(static_cast(getKind())); d258 1 a258 1 ID.AddInteger(static_cast(getKind())); d265 1 a265 1 ID.AddInteger(static_cast(StringRegionKind)); d273 1 a273 1 ID.AddInteger(static_cast(ObjCStringRegionKind)); d281 1 a281 1 ID.AddInteger(static_cast(AllocaRegionKind)); d298 1 a298 1 ID.AddInteger(static_cast(CompoundLiteralRegionKind)); d306 1 a306 1 ID.AddInteger(static_cast(CXXThisRegionKind)); d323 1 a323 1 ID.AddInteger(static_cast(k)); d338 1 a338 1 ID.AddInteger(static_cast(MemRegion::SymbolicRegionKind)); d441 1 a441 1 LLVM_DUMP_METHOD void MemRegion::dump() const { d457 1 a457 1 os << "alloca{" << static_cast(Ex) << ',' << Cnt << '}'; d465 1 a465 1 os << "block_code{" << static_cast(this) << '}'; d481 1 a481 1 os << "{ " << static_cast(CL) << " }"; d486 1 a486 1 << static_cast(Ex) << '}'; d528 1 a528 1 LLVM_DUMP_METHOD void RegionRawOffset::dump() const { d585 1 d590 1 d631 1 a641 59 std::string MemRegion::getDescriptiveName(bool UseQuotes) const { std::string VariableName; std::string ArrayIndices; const MemRegion *R = this; SmallString<50> buf; llvm::raw_svector_ostream os(buf); // Obtain array indices to add them to the variable name. const ElementRegion *ER = nullptr; while ((ER = R->getAs())) { // Index is a ConcreteInt. if (auto CI = ER->getIndex().getAs()) { llvm::SmallString<2> Idx; CI->getValue().toString(Idx); ArrayIndices = (llvm::Twine("[") + Idx.str() + "]" + ArrayIndices).str(); } // If not a ConcreteInt, try to obtain the variable // name by calling 'getDescriptiveName' recursively. else { std::string Idx = ER->getDescriptiveName(false); if (!Idx.empty()) { ArrayIndices = (llvm::Twine("[") + Idx + "]" + ArrayIndices).str(); } } R = ER->getSuperRegion(); } // Get variable name. if (R && R->canPrintPrettyAsExpr()) { R->printPrettyAsExpr(os); if (UseQuotes) { return (llvm::Twine("'") + os.str() + ArrayIndices + "'").str(); } else { return (llvm::Twine(os.str()) + ArrayIndices).str(); } } return VariableName; } SourceRange MemRegion::sourceRange() const { const VarRegion *const VR = dyn_cast(this->getBaseRegion()); const FieldRegion *const FR = dyn_cast(this); // Check for more specific regions first. // FieldRegion if (FR) { return FR->getDecl()->getSourceRange(); } // VarRegion else if (VR) { return VR->getDecl()->getSourceRange(); } // Return invalid source range (can be checked by client). else { return SourceRange{}; } } d649 1 a649 1 region = A.Allocate(); d659 1 a659 1 region = A.Allocate(); d895 1 d913 1 d924 1 a924 1 R = A.Allocate(); d1345 1 a1345 1 FE = RD->field_end(); FI != FE; ++FI, ++idx) { d1348 1 a1348 1 } d1409 1 a1409 1 VarVec *BV = A.Allocate(); d1411 1 a1411 1 VarVec *BVOriginal = A.Allocate(); d1491 1 a1491 1 InvalidationKinds IK) const { d1500 1 a1500 1 InvalidationKinds IK) const { @ 1.1.1.7.2.1 log @Sync with HEAD @ text @d819 1 a819 3 if (!STC) { // FIXME: Assign a more sensible memory space to static locals // we see from within blocks that we analyze as top-level declarations. d821 1 a821 1 } else { @ 1.1.1.8 log @Import Clang 4.0RC1 r294123. @ text @d819 1 a819 3 if (!STC) { // FIXME: Assign a more sensible memory space to static locals // we see from within blocks that we analyze as top-level declarations. d821 1 a821 1 } else { @ 1.1.1.9 log @Import clang r309604 from branches/release_50 @ text @d34 3 a36 3 template RegionTy* MemRegionManager::getSubRegion(const Arg1Ty arg1, const SuperTy *superRegion) { d38 1 a38 1 RegionTy::ProfileRegion(ID, arg1, superRegion); d45 1 a45 1 new (R) RegionTy(arg1, superRegion); d52 3 a54 3 template RegionTy* MemRegionManager::getSubRegion(const Arg1Ty arg1, const Arg2Ty arg2, const SuperTy *superRegion) { d56 1 a56 1 RegionTy::ProfileRegion(ID, arg1, arg2, superRegion); d63 1 a63 1 new (R) RegionTy(arg1, arg2, superRegion); d70 3 a72 5 template RegionTy* MemRegionManager::getSubRegion(const Arg1Ty arg1, const Arg2Ty arg2, const Arg3Ty arg3, const SuperTy *superRegion) { d74 1 a74 1 RegionTy::ProfileRegion(ID, arg1, arg2, arg3, superRegion); d81 1 a81 1 new (R) RegionTy(arg1, arg2, arg3, superRegion); d183 2 a184 2 ObjCIvarRegion::ObjCIvarRegion(const ObjCIvarDecl *ivd, const SubRegion *sReg) : DeclRegion(ivd, sReg, ObjCIvarRegionKind) {} d382 4 a385 2 void NonStaticGlobalSpaceRegion::anchor() { } void StackSpaceRegion::anchor() { } d740 1 a740 2 return getSubRegion( Str, cast(getGlobalsRegion())); d745 1 a745 2 return getSubRegion( Str, cast(getGlobalsRegion())); d874 1 a874 1 const MemSpaceRegion *sReg = nullptr; d907 1 a907 1 const MemSpaceRegion *sReg = nullptr; d922 1 a922 1 const SubRegion* superRegion, d965 1 a965 1 const SubRegion* superRegion){ d971 1 a971 1 const SubRegion* superRegion) { d1007 1 a1007 1 const SubRegion *Super, d1018 1 a1018 1 Super = cast(Base->getSuperRegion()); @ 1.1.1.9.4.1 log @Sync with HEAD @ text @d1 1 a1 1 //===- MemRegion.cpp - Abstract memory regions for static analysis --------===// a16 1 #include "clang/AST/ASTContext.h" a18 2 #include "clang/AST/Decl.h" #include "clang/AST/DeclCXX.h" a19 2 #include "clang/AST/Expr.h" #include "clang/AST/PrettyPrinter.h" d21 1 a21 2 #include "clang/AST/Type.h" #include "clang/Analysis/AnalysisDeclContext.h" a22 2 #include "clang/Basic/IdentifierTable.h" #include "clang/Basic/LLVM.h" a24 15 #include "clang/StaticAnalyzer/Core/PathSensitive/SVals.h" #include "clang/StaticAnalyzer/Core/PathSensitive/SymbolManager.h" #include "llvm/ADT/APInt.h" #include "llvm/ADT/FoldingSet.h" #include "llvm/ADT/Optional.h" #include "llvm/ADT/PointerUnion.h" #include "llvm/ADT/SmallString.h" #include "llvm/ADT/StringRef.h" #include "llvm/ADT/Twine.h" #include "llvm/Support/Allocator.h" #include "llvm/Support/Casting.h" #include "llvm/Support/CheckedArithmetic.h" #include "llvm/Support/Compiler.h" #include "llvm/Support/Debug.h" #include "llvm/Support/ErrorHandling.h" a25 7 #include #include #include #include #include #include #include a29 2 #define DEBUG_TYPE "MemRegion" d40 2 a41 1 auto *R = cast_or_null(Regions.FindNodeOrInsertPos(ID, InsertPos)); d58 2 a59 1 auto *R = cast_or_null(Regions.FindNodeOrInsertPos(ID, InsertPos)); d78 2 a79 1 auto *R = cast_or_null(Regions.FindNodeOrInsertPos(ID, InsertPos)); d94 1 a94 1 MemRegion::~MemRegion() = default; d96 4 a99 3 // All regions and their data are BumpPtrAllocated. No need to call their // destructors. MemRegionManager::~MemRegionManager() = default; d106 2 a107 2 const MemRegion* r = this; do { d110 1 a110 1 if (const auto *sr = dyn_cast(r)) d114 1 a114 1 } while (r != nullptr); d122 1 a122 1 if (const auto *sr = dyn_cast(superRegion)) { d127 1 a127 1 } while (true); d131 1 a131 1 const auto *SSR = dyn_cast(getMemorySpace()); d218 3 a220 3 void StringRegion::ProfileRegion(llvm::FoldingSetNodeID &ID, const StringLiteral *Str, const MemRegion *superRegion) { d226 3 a228 3 void ObjCStringRegion::ProfileRegion(llvm::FoldingSetNodeID &ID, const ObjCStringLiteral *Str, const MemRegion *superRegion) { d383 7 a389 13 void GlobalsSpaceRegion::anchor() {} void NonStaticGlobalSpaceRegion::anchor() {} void StackSpaceRegion::anchor() {} void TypedRegion::anchor() {} void TypedValueRegion::anchor() {} void CodeTextRegion::anchor() {} void SubRegion::anchor() {} d411 1 a411 1 os << "alloca{" << static_cast(Ex) << ',' << Cnt << '}'; d419 1 a419 1 os << "block_code{" << static_cast(this) << '}'; d428 1 a428 1 os << "(" << I.getCapturedRegion() << "<-" << d435 1 a435 1 os << "{ " << static_cast(CL) << " }"; d440 1 a440 1 << static_cast(Ex) << '}'; a474 2 if (isa(getSuperRegion())) os << "Heap"; d479 1 a479 5 const auto *VD = cast(D); if (const IdentifierInfo *ID = VD->getIdentifier()) os << ID->getName(); else os << "VarRegion{" << static_cast(this) << '}'; d623 1 a623 1 if (UseQuotes) d625 1 a625 1 else d627 1 d634 2 a635 2 const auto *const VR = dyn_cast(this->getBaseRegion()); const auto *const FR = dyn_cast(this); d647 3 a649 2 else return {}; d739 1 a739 2 const StringRegion *MemRegionManager::getStringRegion(const StringLiteral *Str){ d745 1 a745 1 MemRegionManager::getObjCStringRegion(const ObjCStringLiteral *Str){ d758 1 a758 1 if (const auto *SFC = dyn_cast(LC)) { d762 4 a765 3 if (const auto *BC = dyn_cast(LC)) { const auto *BR = static_cast(BC->getContextData()); d770 3 a772 3 const VarRegion *VR = I.getOriginalRegion(); if (VR->getDecl() == VD) return cast(I.getCapturedRegion()); d819 1 a819 1 const auto *STC = V.get(); d837 1 a837 1 else if (const auto *BD = dyn_cast(STCD)) { d886 1 a886 1 const StackFrameContext *STC = LC->getStackFrame(); d914 1 a914 1 const StackFrameContext *STC = LC->getStackFrame(); d933 1 a933 1 auto *R = cast_or_null(data); d955 1 d980 1 a980 1 const StackFrameContext *SFC = LC->getStackFrame(); d1018 2 a1019 1 while (const auto *Base = dyn_cast(Super)) d1021 1 d1032 1 a1032 1 const auto *PT = thisPointerTy->getAs(); d1046 1 a1046 1 const StackFrameContext *STC = LC->getStackFrame(); d1054 1 a1054 1 const StackFrameContext *STC = LC->getStackFrame(); d1061 1 a1061 1 const auto *SR = dyn_cast(this); d1122 1 a1122 1 const auto *ER = cast(R); d1140 1 a1140 1 const auto *SubR = dyn_cast(this); d1143 1 a1143 1 if (const auto *SymR = dyn_cast(SubR)) d1151 1 a1151 1 int64_t offset = 0; d1163 1 a1163 1 if (auto CI = index.getAs()) { d1176 2 a1177 9 int64_t size = C.getTypeSizeInChars(elemType).getQuantity(); if (auto NewOffset = llvm::checkedMulAdd(i, size, offset)) { offset = *NewOffset; } else { LLVM_DEBUG(llvm::dbgs() << "MemRegion::getAsArrayOffset: " << "offset overflowing, returning unknown\n"); return nullptr; } d1189 1 a1189 1 return RegionRawOffset(superR, CharUnits::fromQuantity(offset)); d1192 1 d1208 2 a1209 1 static RegionOffset calculateOffset(const MemRegion *R) { d1213 1 a1213 1 while (true) { d1215 9 a1223 9 case MemRegion::CodeSpaceRegionKind: case MemRegion::StackLocalsSpaceRegionKind: case MemRegion::StackArgumentsSpaceRegionKind: case MemRegion::HeapSpaceRegionKind: case MemRegion::UnknownSpaceRegionKind: case MemRegion::StaticGlobalSpaceRegionKind: case MemRegion::GlobalInternalSpaceRegionKind: case MemRegion::GlobalSystemSpaceRegionKind: case MemRegion::GlobalImmutableSpaceRegionKind: d1228 3 a1230 3 case MemRegion::FunctionCodeRegionKind: case MemRegion::BlockCodeRegionKind: case MemRegion::BlockDataRegionKind: d1237 8 a1244 8 case MemRegion::SymbolicRegionKind: case MemRegion::AllocaRegionKind: case MemRegion::CompoundLiteralRegionKind: case MemRegion::CXXThisRegionKind: case MemRegion::StringRegionKind: case MemRegion::ObjCStringRegionKind: case MemRegion::VarRegionKind: case MemRegion::CXXTempObjectRegionKind: d1248 1 a1248 1 case MemRegion::ObjCIvarRegionKind: d1256 2 a1257 2 case MemRegion::CXXBaseObjectRegionKind: { const auto *BOR = cast(R); d1262 3 a1264 3 if (const auto *TVR = dyn_cast(R)) { Ty = TVR->getDesugaredValueType(R->getContext()); } else if (const auto *SR = dyn_cast(R)) { d1297 1 a1297 1 const ASTRecordLayout &Layout = R->getContext().getASTRecordLayout(Child); d1304 1 a1304 1 Offset += BaseOffset.getQuantity() * R->getContext().getCharWidth(); d1307 2 a1308 2 case MemRegion::ElementRegionKind: { const auto *ER = cast(R); d1328 1 a1328 1 Offset += i * R->getContext().getTypeSize(EleTy); d1335 2 a1336 2 case MemRegion::FieldRegionKind: { const auto *FR = cast(R); d1361 1 a1361 1 const ASTRecordLayout &Layout = R->getContext().getASTRecordLayout(RD); a1374 6 RegionOffset MemRegion::getAsOffset() const { if (!cachedOffset) cachedOffset = calculateOffset(this); return *cachedOffset; } d1420 2 a1421 3 using VarVec = BumpVector; auto *BV = A.Allocate(); d1423 1 a1423 1 auto *BVOriginal = A.Allocate(); d1426 1 a1426 1 for (const auto *VD : ReferencedBlockVars) { d1444 2 a1445 1 auto *Vec = static_cast *>(ReferencedVars); d1450 2 a1451 2 auto *VecOriginal = static_cast *>(OriginalVars); d1461 2 a1462 1 auto *Vec = static_cast *>(ReferencedVars); d1467 2 a1468 2 auto *VecOriginal = static_cast *>(OriginalVars); d1496 1 a1496 1 if (const auto *SR = dyn_cast(MR)) d1516 1 a1516 1 if (const auto *SR = dyn_cast(MR)) @ 1.1.1.9.4.2 log @Mostly merge changes from HEAD upto 20200411 @ text @@ 1.1.1.9.2.1 log @Sync with HEAD @ text @d1 1 a1 1 //===- MemRegion.cpp - Abstract memory regions for static analysis --------===// a16 1 #include "clang/AST/ASTContext.h" a18 2 #include "clang/AST/Decl.h" #include "clang/AST/DeclCXX.h" a19 2 #include "clang/AST/Expr.h" #include "clang/AST/PrettyPrinter.h" d21 1 a21 2 #include "clang/AST/Type.h" #include "clang/Analysis/AnalysisDeclContext.h" a22 2 #include "clang/Basic/IdentifierTable.h" #include "clang/Basic/LLVM.h" a24 15 #include "clang/StaticAnalyzer/Core/PathSensitive/SVals.h" #include "clang/StaticAnalyzer/Core/PathSensitive/SymbolManager.h" #include "llvm/ADT/APInt.h" #include "llvm/ADT/FoldingSet.h" #include "llvm/ADT/Optional.h" #include "llvm/ADT/PointerUnion.h" #include "llvm/ADT/SmallString.h" #include "llvm/ADT/StringRef.h" #include "llvm/ADT/Twine.h" #include "llvm/Support/Allocator.h" #include "llvm/Support/Casting.h" #include "llvm/Support/CheckedArithmetic.h" #include "llvm/Support/Compiler.h" #include "llvm/Support/Debug.h" #include "llvm/Support/ErrorHandling.h" a25 7 #include #include #include #include #include #include #include a29 2 #define DEBUG_TYPE "MemRegion" d40 2 a41 1 auto *R = cast_or_null(Regions.FindNodeOrInsertPos(ID, InsertPos)); d58 2 a59 1 auto *R = cast_or_null(Regions.FindNodeOrInsertPos(ID, InsertPos)); d78 2 a79 1 auto *R = cast_or_null(Regions.FindNodeOrInsertPos(ID, InsertPos)); d94 1 a94 1 MemRegion::~MemRegion() = default; d96 4 a99 3 // All regions and their data are BumpPtrAllocated. No need to call their // destructors. MemRegionManager::~MemRegionManager() = default; d106 2 a107 2 const MemRegion* r = this; do { d110 1 a110 1 if (const auto *sr = dyn_cast(r)) d114 1 a114 1 } while (r != nullptr); d122 1 a122 1 if (const auto *sr = dyn_cast(superRegion)) { d127 1 a127 1 } while (true); d131 1 a131 1 const auto *SSR = dyn_cast(getMemorySpace()); d218 3 a220 3 void StringRegion::ProfileRegion(llvm::FoldingSetNodeID &ID, const StringLiteral *Str, const MemRegion *superRegion) { d226 3 a228 3 void ObjCStringRegion::ProfileRegion(llvm::FoldingSetNodeID &ID, const ObjCStringLiteral *Str, const MemRegion *superRegion) { d383 7 a389 13 void GlobalsSpaceRegion::anchor() {} void NonStaticGlobalSpaceRegion::anchor() {} void StackSpaceRegion::anchor() {} void TypedRegion::anchor() {} void TypedValueRegion::anchor() {} void CodeTextRegion::anchor() {} void SubRegion::anchor() {} d411 1 a411 1 os << "alloca{" << static_cast(Ex) << ',' << Cnt << '}'; d419 1 a419 1 os << "block_code{" << static_cast(this) << '}'; d428 1 a428 1 os << "(" << I.getCapturedRegion() << "<-" << d435 1 a435 1 os << "{ " << static_cast(CL) << " }"; d440 1 a440 1 << static_cast(Ex) << '}'; a474 2 if (isa(getSuperRegion())) os << "Heap"; d479 1 a479 5 const auto *VD = cast(D); if (const IdentifierInfo *ID = VD->getIdentifier()) os << ID->getName(); else os << "VarRegion{" << static_cast(this) << '}'; d623 1 a623 1 if (UseQuotes) d625 1 a625 1 else d627 1 d634 2 a635 2 const auto *const VR = dyn_cast(this->getBaseRegion()); const auto *const FR = dyn_cast(this); d647 3 a649 2 else return {}; d739 1 a739 2 const StringRegion *MemRegionManager::getStringRegion(const StringLiteral *Str){ d745 1 a745 1 MemRegionManager::getObjCStringRegion(const ObjCStringLiteral *Str){ d758 1 a758 1 if (const auto *SFC = dyn_cast(LC)) { d762 4 a765 3 if (const auto *BC = dyn_cast(LC)) { const auto *BR = static_cast(BC->getContextData()); d770 3 a772 3 const VarRegion *VR = I.getOriginalRegion(); if (VR->getDecl() == VD) return cast(I.getCapturedRegion()); d819 1 a819 1 const auto *STC = V.get(); d837 1 a837 1 else if (const auto *BD = dyn_cast(STCD)) { d886 1 a886 1 const StackFrameContext *STC = LC->getStackFrame(); d914 1 a914 1 const StackFrameContext *STC = LC->getStackFrame(); d933 1 a933 1 auto *R = cast_or_null(data); d955 1 d980 1 a980 1 const StackFrameContext *SFC = LC->getStackFrame(); d1018 2 a1019 1 while (const auto *Base = dyn_cast(Super)) d1021 1 d1032 1 a1032 1 const auto *PT = thisPointerTy->getAs(); d1046 1 a1046 1 const StackFrameContext *STC = LC->getStackFrame(); d1054 1 a1054 1 const StackFrameContext *STC = LC->getStackFrame(); d1061 1 a1061 1 const auto *SR = dyn_cast(this); d1122 1 a1122 1 const auto *ER = cast(R); d1140 1 a1140 1 const auto *SubR = dyn_cast(this); d1143 1 a1143 1 if (const auto *SymR = dyn_cast(SubR)) d1151 1 a1151 1 int64_t offset = 0; d1163 1 a1163 1 if (auto CI = index.getAs()) { d1176 2 a1177 9 int64_t size = C.getTypeSizeInChars(elemType).getQuantity(); if (auto NewOffset = llvm::checkedMulAdd(i, size, offset)) { offset = *NewOffset; } else { LLVM_DEBUG(llvm::dbgs() << "MemRegion::getAsArrayOffset: " << "offset overflowing, returning unknown\n"); return nullptr; } d1189 1 a1189 1 return RegionRawOffset(superR, CharUnits::fromQuantity(offset)); d1192 1 d1208 2 a1209 1 static RegionOffset calculateOffset(const MemRegion *R) { d1213 1 a1213 1 while (true) { d1215 9 a1223 9 case MemRegion::CodeSpaceRegionKind: case MemRegion::StackLocalsSpaceRegionKind: case MemRegion::StackArgumentsSpaceRegionKind: case MemRegion::HeapSpaceRegionKind: case MemRegion::UnknownSpaceRegionKind: case MemRegion::StaticGlobalSpaceRegionKind: case MemRegion::GlobalInternalSpaceRegionKind: case MemRegion::GlobalSystemSpaceRegionKind: case MemRegion::GlobalImmutableSpaceRegionKind: d1228 3 a1230 3 case MemRegion::FunctionCodeRegionKind: case MemRegion::BlockCodeRegionKind: case MemRegion::BlockDataRegionKind: d1237 8 a1244 8 case MemRegion::SymbolicRegionKind: case MemRegion::AllocaRegionKind: case MemRegion::CompoundLiteralRegionKind: case MemRegion::CXXThisRegionKind: case MemRegion::StringRegionKind: case MemRegion::ObjCStringRegionKind: case MemRegion::VarRegionKind: case MemRegion::CXXTempObjectRegionKind: d1248 1 a1248 1 case MemRegion::ObjCIvarRegionKind: d1256 2 a1257 2 case MemRegion::CXXBaseObjectRegionKind: { const auto *BOR = cast(R); d1262 3 a1264 3 if (const auto *TVR = dyn_cast(R)) { Ty = TVR->getDesugaredValueType(R->getContext()); } else if (const auto *SR = dyn_cast(R)) { d1297 1 a1297 1 const ASTRecordLayout &Layout = R->getContext().getASTRecordLayout(Child); d1304 1 a1304 1 Offset += BaseOffset.getQuantity() * R->getContext().getCharWidth(); d1307 2 a1308 2 case MemRegion::ElementRegionKind: { const auto *ER = cast(R); d1328 1 a1328 1 Offset += i * R->getContext().getTypeSize(EleTy); d1335 2 a1336 2 case MemRegion::FieldRegionKind: { const auto *FR = cast(R); d1361 1 a1361 1 const ASTRecordLayout &Layout = R->getContext().getASTRecordLayout(RD); a1374 6 RegionOffset MemRegion::getAsOffset() const { if (!cachedOffset) cachedOffset = calculateOffset(this); return *cachedOffset; } d1420 2 a1421 3 using VarVec = BumpVector; auto *BV = A.Allocate(); d1423 1 a1423 1 auto *BVOriginal = A.Allocate(); d1426 1 a1426 1 for (const auto *VD : ReferencedBlockVars) { d1444 2 a1445 1 auto *Vec = static_cast *>(ReferencedVars); d1450 2 a1451 2 auto *VecOriginal = static_cast *>(OriginalVars); d1461 2 a1462 1 auto *Vec = static_cast *>(ReferencedVars); d1467 2 a1468 2 auto *VecOriginal = static_cast *>(OriginalVars); d1496 1 a1496 1 if (const auto *SR = dyn_cast(MR)) d1516 1 a1516 1 if (const auto *SR = dyn_cast(MR)) @ 1.1.1.10 log @Import clang r337282 from trunk @ text @d1 1 a1 1 //===- MemRegion.cpp - Abstract memory regions for static analysis --------===// a16 1 #include "clang/AST/ASTContext.h" a18 2 #include "clang/AST/Decl.h" #include "clang/AST/DeclCXX.h" a19 2 #include "clang/AST/Expr.h" #include "clang/AST/PrettyPrinter.h" d21 1 a21 2 #include "clang/AST/Type.h" #include "clang/Analysis/AnalysisDeclContext.h" a22 2 #include "clang/Basic/IdentifierTable.h" #include "clang/Basic/LLVM.h" a24 15 #include "clang/StaticAnalyzer/Core/PathSensitive/SVals.h" #include "clang/StaticAnalyzer/Core/PathSensitive/SymbolManager.h" #include "llvm/ADT/APInt.h" #include "llvm/ADT/FoldingSet.h" #include "llvm/ADT/Optional.h" #include "llvm/ADT/PointerUnion.h" #include "llvm/ADT/SmallString.h" #include "llvm/ADT/StringRef.h" #include "llvm/ADT/Twine.h" #include "llvm/Support/Allocator.h" #include "llvm/Support/Casting.h" #include "llvm/Support/CheckedArithmetic.h" #include "llvm/Support/Compiler.h" #include "llvm/Support/Debug.h" #include "llvm/Support/ErrorHandling.h" a25 7 #include #include #include #include #include #include #include a29 2 #define DEBUG_TYPE "MemRegion" d40 2 a41 1 auto *R = cast_or_null(Regions.FindNodeOrInsertPos(ID, InsertPos)); d58 2 a59 1 auto *R = cast_or_null(Regions.FindNodeOrInsertPos(ID, InsertPos)); d78 2 a79 1 auto *R = cast_or_null(Regions.FindNodeOrInsertPos(ID, InsertPos)); d94 1 a94 1 MemRegion::~MemRegion() = default; d96 4 a99 3 // All regions and their data are BumpPtrAllocated. No need to call their // destructors. MemRegionManager::~MemRegionManager() = default; d106 2 a107 2 const MemRegion* r = this; do { d110 1 a110 1 if (const auto *sr = dyn_cast(r)) d114 1 a114 1 } while (r != nullptr); d122 1 a122 1 if (const auto *sr = dyn_cast(superRegion)) { d127 1 a127 1 } while (true); d131 1 a131 1 const auto *SSR = dyn_cast(getMemorySpace()); d218 3 a220 3 void StringRegion::ProfileRegion(llvm::FoldingSetNodeID &ID, const StringLiteral *Str, const MemRegion *superRegion) { d226 3 a228 3 void ObjCStringRegion::ProfileRegion(llvm::FoldingSetNodeID &ID, const ObjCStringLiteral *Str, const MemRegion *superRegion) { d383 7 a389 13 void GlobalsSpaceRegion::anchor() {} void NonStaticGlobalSpaceRegion::anchor() {} void StackSpaceRegion::anchor() {} void TypedRegion::anchor() {} void TypedValueRegion::anchor() {} void CodeTextRegion::anchor() {} void SubRegion::anchor() {} d411 1 a411 1 os << "alloca{" << static_cast(Ex) << ',' << Cnt << '}'; d419 1 a419 1 os << "block_code{" << static_cast(this) << '}'; d428 1 a428 1 os << "(" << I.getCapturedRegion() << "<-" << d435 1 a435 1 os << "{ " << static_cast(CL) << " }"; d440 1 a440 1 << static_cast(Ex) << '}'; a474 2 if (isa(getSuperRegion())) os << "Heap"; d479 1 a479 5 const auto *VD = cast(D); if (const IdentifierInfo *ID = VD->getIdentifier()) os << ID->getName(); else os << "VarRegion{" << static_cast(this) << '}'; d623 1 a623 1 if (UseQuotes) d625 1 a625 1 else d627 1 d634 2 a635 2 const auto *const VR = dyn_cast(this->getBaseRegion()); const auto *const FR = dyn_cast(this); d647 3 a649 2 else return {}; d739 1 a739 2 const StringRegion *MemRegionManager::getStringRegion(const StringLiteral *Str){ d745 1 a745 1 MemRegionManager::getObjCStringRegion(const ObjCStringLiteral *Str){ d758 1 a758 1 if (const auto *SFC = dyn_cast(LC)) { d762 4 a765 3 if (const auto *BC = dyn_cast(LC)) { const auto *BR = static_cast(BC->getContextData()); d770 3 a772 3 const VarRegion *VR = I.getOriginalRegion(); if (VR->getDecl() == VD) return cast(I.getCapturedRegion()); d819 1 a819 1 const auto *STC = V.get(); d837 1 a837 1 else if (const auto *BD = dyn_cast(STCD)) { d886 1 a886 1 const StackFrameContext *STC = LC->getStackFrame(); d914 1 a914 1 const StackFrameContext *STC = LC->getStackFrame(); d933 1 a933 1 auto *R = cast_or_null(data); d955 1 d980 1 a980 1 const StackFrameContext *SFC = LC->getStackFrame(); d1018 2 a1019 1 while (const auto *Base = dyn_cast(Super)) d1021 1 d1032 1 a1032 1 const auto *PT = thisPointerTy->getAs(); d1046 1 a1046 1 const StackFrameContext *STC = LC->getStackFrame(); d1054 1 a1054 1 const StackFrameContext *STC = LC->getStackFrame(); d1061 1 a1061 1 const auto *SR = dyn_cast(this); d1122 1 a1122 1 const auto *ER = cast(R); d1140 1 a1140 1 const auto *SubR = dyn_cast(this); d1143 1 a1143 1 if (const auto *SymR = dyn_cast(SubR)) d1151 1 a1151 1 int64_t offset = 0; d1163 1 a1163 1 if (auto CI = index.getAs()) { d1176 2 a1177 9 int64_t size = C.getTypeSizeInChars(elemType).getQuantity(); if (auto NewOffset = llvm::checkedMulAdd(i, size, offset)) { offset = *NewOffset; } else { LLVM_DEBUG(llvm::dbgs() << "MemRegion::getAsArrayOffset: " << "offset overflowing, returning unknown\n"); return nullptr; } d1189 1 a1189 1 return RegionRawOffset(superR, CharUnits::fromQuantity(offset)); d1192 1 d1208 2 a1209 1 static RegionOffset calculateOffset(const MemRegion *R) { d1213 1 a1213 1 while (true) { d1215 9 a1223 9 case MemRegion::CodeSpaceRegionKind: case MemRegion::StackLocalsSpaceRegionKind: case MemRegion::StackArgumentsSpaceRegionKind: case MemRegion::HeapSpaceRegionKind: case MemRegion::UnknownSpaceRegionKind: case MemRegion::StaticGlobalSpaceRegionKind: case MemRegion::GlobalInternalSpaceRegionKind: case MemRegion::GlobalSystemSpaceRegionKind: case MemRegion::GlobalImmutableSpaceRegionKind: d1228 3 a1230 3 case MemRegion::FunctionCodeRegionKind: case MemRegion::BlockCodeRegionKind: case MemRegion::BlockDataRegionKind: d1237 8 a1244 8 case MemRegion::SymbolicRegionKind: case MemRegion::AllocaRegionKind: case MemRegion::CompoundLiteralRegionKind: case MemRegion::CXXThisRegionKind: case MemRegion::StringRegionKind: case MemRegion::ObjCStringRegionKind: case MemRegion::VarRegionKind: case MemRegion::CXXTempObjectRegionKind: d1248 1 a1248 1 case MemRegion::ObjCIvarRegionKind: d1256 2 a1257 2 case MemRegion::CXXBaseObjectRegionKind: { const auto *BOR = cast(R); d1262 3 a1264 3 if (const auto *TVR = dyn_cast(R)) { Ty = TVR->getDesugaredValueType(R->getContext()); } else if (const auto *SR = dyn_cast(R)) { d1297 1 a1297 1 const ASTRecordLayout &Layout = R->getContext().getASTRecordLayout(Child); d1304 1 a1304 1 Offset += BaseOffset.getQuantity() * R->getContext().getCharWidth(); d1307 2 a1308 2 case MemRegion::ElementRegionKind: { const auto *ER = cast(R); d1328 1 a1328 1 Offset += i * R->getContext().getTypeSize(EleTy); d1335 2 a1336 2 case MemRegion::FieldRegionKind: { const auto *FR = cast(R); d1361 1 a1361 1 const ASTRecordLayout &Layout = R->getContext().getASTRecordLayout(RD); a1374 6 RegionOffset MemRegion::getAsOffset() const { if (!cachedOffset) cachedOffset = calculateOffset(this); return *cachedOffset; } d1420 2 a1421 3 using VarVec = BumpVector; auto *BV = A.Allocate(); d1423 1 a1423 1 auto *BVOriginal = A.Allocate(); d1426 1 a1426 1 for (const auto *VD : ReferencedBlockVars) { d1444 2 a1445 1 auto *Vec = static_cast *>(ReferencedVars); d1450 2 a1451 2 auto *VecOriginal = static_cast *>(OriginalVars); d1461 2 a1462 1 auto *Vec = static_cast *>(ReferencedVars); d1467 2 a1468 2 auto *VecOriginal = static_cast *>(OriginalVars); d1496 1 a1496 1 if (const auto *SR = dyn_cast(MR)) d1516 1 a1516 1 if (const auto *SR = dyn_cast(MR)) @ 1.1.1.11 log @Mark old LLVM instance as dead. @ text @@ 1.1.1.4.4.1 log @file MemRegion.cpp was added on branch tls-maxphys on 2014-08-19 23:47:32 +0000 @ text @d1 1502 @ 1.1.1.4.4.2 log @Rebase to HEAD as of a few days ago. @ text @a0 1502 //== MemRegion.cpp - Abstract memory regions for static analysis --*- C++ -*--// // // The LLVM Compiler Infrastructure // // This file is distributed under the University of Illinois Open Source // License. See LICENSE.TXT for details. // //===----------------------------------------------------------------------===// // // This file defines MemRegion and its subclasses. MemRegion defines a // partially-typed abstraction of memory useful for path-sensitive dataflow // analyses. // //===----------------------------------------------------------------------===// #include "clang/StaticAnalyzer/Core/PathSensitive/MemRegion.h" #include "clang/AST/Attr.h" #include "clang/AST/CharUnits.h" #include "clang/AST/DeclObjC.h" #include "clang/AST/RecordLayout.h" #include "clang/Analysis/AnalysisContext.h" #include "clang/Analysis/Support/BumpVector.h" #include "clang/Basic/SourceManager.h" #include "clang/StaticAnalyzer/Core/PathSensitive/SValBuilder.h" #include "llvm/Support/raw_ostream.h" using namespace clang; using namespace ento; //===----------------------------------------------------------------------===// // MemRegion Construction. //===----------------------------------------------------------------------===// template struct MemRegionManagerTrait; template RegionTy* MemRegionManager::getRegion(const A1 a1) { const typename MemRegionManagerTrait::SuperRegionTy *superRegion = MemRegionManagerTrait::getSuperRegion(*this, a1); llvm::FoldingSetNodeID ID; RegionTy::ProfileRegion(ID, a1, superRegion); void *InsertPos; RegionTy* R = cast_or_null(Regions.FindNodeOrInsertPos(ID, InsertPos)); if (!R) { R = (RegionTy*) A.Allocate(); new (R) RegionTy(a1, superRegion); Regions.InsertNode(R, InsertPos); } return R; } template RegionTy* MemRegionManager::getSubRegion(const A1 a1, const MemRegion *superRegion) { llvm::FoldingSetNodeID ID; RegionTy::ProfileRegion(ID, a1, superRegion); void *InsertPos; RegionTy* R = cast_or_null(Regions.FindNodeOrInsertPos(ID, InsertPos)); if (!R) { R = (RegionTy*) A.Allocate(); new (R) RegionTy(a1, superRegion); Regions.InsertNode(R, InsertPos); } return R; } template RegionTy* MemRegionManager::getRegion(const A1 a1, const A2 a2) { const typename MemRegionManagerTrait::SuperRegionTy *superRegion = MemRegionManagerTrait::getSuperRegion(*this, a1, a2); llvm::FoldingSetNodeID ID; RegionTy::ProfileRegion(ID, a1, a2, superRegion); void *InsertPos; RegionTy* R = cast_or_null(Regions.FindNodeOrInsertPos(ID, InsertPos)); if (!R) { R = (RegionTy*) A.Allocate(); new (R) RegionTy(a1, a2, superRegion); Regions.InsertNode(R, InsertPos); } return R; } template RegionTy* MemRegionManager::getSubRegion(const A1 a1, const A2 a2, const MemRegion *superRegion) { llvm::FoldingSetNodeID ID; RegionTy::ProfileRegion(ID, a1, a2, superRegion); void *InsertPos; RegionTy* R = cast_or_null(Regions.FindNodeOrInsertPos(ID, InsertPos)); if (!R) { R = (RegionTy*) A.Allocate(); new (R) RegionTy(a1, a2, superRegion); Regions.InsertNode(R, InsertPos); } return R; } template RegionTy* MemRegionManager::getSubRegion(const A1 a1, const A2 a2, const A3 a3, const MemRegion *superRegion) { llvm::FoldingSetNodeID ID; RegionTy::ProfileRegion(ID, a1, a2, a3, superRegion); void *InsertPos; RegionTy* R = cast_or_null(Regions.FindNodeOrInsertPos(ID, InsertPos)); if (!R) { R = (RegionTy*) A.Allocate(); new (R) RegionTy(a1, a2, a3, superRegion); Regions.InsertNode(R, InsertPos); } return R; } //===----------------------------------------------------------------------===// // Object destruction. //===----------------------------------------------------------------------===// MemRegion::~MemRegion() {} MemRegionManager::~MemRegionManager() { // All regions and their data are BumpPtrAllocated. No need to call // their destructors. } //===----------------------------------------------------------------------===// // Basic methods. //===----------------------------------------------------------------------===// bool SubRegion::isSubRegionOf(const MemRegion* R) const { const MemRegion* r = getSuperRegion(); while (r != nullptr) { if (r == R) return true; if (const SubRegion* sr = dyn_cast(r)) r = sr->getSuperRegion(); else break; } return false; } MemRegionManager* SubRegion::getMemRegionManager() const { const SubRegion* r = this; do { const MemRegion *superRegion = r->getSuperRegion(); if (const SubRegion *sr = dyn_cast(superRegion)) { r = sr; continue; } return superRegion->getMemRegionManager(); } while (1); } const StackFrameContext *VarRegion::getStackFrame() const { const StackSpaceRegion *SSR = dyn_cast(getMemorySpace()); return SSR ? SSR->getStackFrame() : nullptr; } //===----------------------------------------------------------------------===// // Region extents. //===----------------------------------------------------------------------===// DefinedOrUnknownSVal TypedValueRegion::getExtent(SValBuilder &svalBuilder) const { ASTContext &Ctx = svalBuilder.getContext(); QualType T = getDesugaredValueType(Ctx); if (isa(T)) return nonloc::SymbolVal(svalBuilder.getSymbolManager().getExtentSymbol(this)); if (T->isIncompleteType()) return UnknownVal(); CharUnits size = Ctx.getTypeSizeInChars(T); QualType sizeTy = svalBuilder.getArrayIndexType(); return svalBuilder.makeIntVal(size.getQuantity(), sizeTy); } DefinedOrUnknownSVal FieldRegion::getExtent(SValBuilder &svalBuilder) const { // Force callers to deal with bitfields explicitly. if (getDecl()->isBitField()) return UnknownVal(); DefinedOrUnknownSVal Extent = DeclRegion::getExtent(svalBuilder); // A zero-length array at the end of a struct often stands for dynamically- // allocated extra memory. if (Extent.isZeroConstant()) { QualType T = getDesugaredValueType(svalBuilder.getContext()); if (isa(T)) return UnknownVal(); } return Extent; } DefinedOrUnknownSVal AllocaRegion::getExtent(SValBuilder &svalBuilder) const { return nonloc::SymbolVal(svalBuilder.getSymbolManager().getExtentSymbol(this)); } DefinedOrUnknownSVal SymbolicRegion::getExtent(SValBuilder &svalBuilder) const { return nonloc::SymbolVal(svalBuilder.getSymbolManager().getExtentSymbol(this)); } DefinedOrUnknownSVal StringRegion::getExtent(SValBuilder &svalBuilder) const { return svalBuilder.makeIntVal(getStringLiteral()->getByteLength()+1, svalBuilder.getArrayIndexType()); } ObjCIvarRegion::ObjCIvarRegion(const ObjCIvarDecl *ivd, const MemRegion* sReg) : DeclRegion(ivd, sReg, ObjCIvarRegionKind) {} const ObjCIvarDecl *ObjCIvarRegion::getDecl() const { return cast(D); } QualType ObjCIvarRegion::getValueType() const { return getDecl()->getType(); } QualType CXXBaseObjectRegion::getValueType() const { return QualType(getDecl()->getTypeForDecl(), 0); } //===----------------------------------------------------------------------===// // FoldingSet profiling. //===----------------------------------------------------------------------===// void MemSpaceRegion::Profile(llvm::FoldingSetNodeID& ID) const { ID.AddInteger((unsigned)getKind()); } void StackSpaceRegion::Profile(llvm::FoldingSetNodeID &ID) const { ID.AddInteger((unsigned)getKind()); ID.AddPointer(getStackFrame()); } void StaticGlobalSpaceRegion::Profile(llvm::FoldingSetNodeID &ID) const { ID.AddInteger((unsigned)getKind()); ID.AddPointer(getCodeRegion()); } void StringRegion::ProfileRegion(llvm::FoldingSetNodeID& ID, const StringLiteral* Str, const MemRegion* superRegion) { ID.AddInteger((unsigned) StringRegionKind); ID.AddPointer(Str); ID.AddPointer(superRegion); } void ObjCStringRegion::ProfileRegion(llvm::FoldingSetNodeID& ID, const ObjCStringLiteral* Str, const MemRegion* superRegion) { ID.AddInteger((unsigned) ObjCStringRegionKind); ID.AddPointer(Str); ID.AddPointer(superRegion); } void AllocaRegion::ProfileRegion(llvm::FoldingSetNodeID& ID, const Expr *Ex, unsigned cnt, const MemRegion *superRegion) { ID.AddInteger((unsigned) AllocaRegionKind); ID.AddPointer(Ex); ID.AddInteger(cnt); ID.AddPointer(superRegion); } void AllocaRegion::Profile(llvm::FoldingSetNodeID& ID) const { ProfileRegion(ID, Ex, Cnt, superRegion); } void CompoundLiteralRegion::Profile(llvm::FoldingSetNodeID& ID) const { CompoundLiteralRegion::ProfileRegion(ID, CL, superRegion); } void CompoundLiteralRegion::ProfileRegion(llvm::FoldingSetNodeID& ID, const CompoundLiteralExpr *CL, const MemRegion* superRegion) { ID.AddInteger((unsigned) CompoundLiteralRegionKind); ID.AddPointer(CL); ID.AddPointer(superRegion); } void CXXThisRegion::ProfileRegion(llvm::FoldingSetNodeID &ID, const PointerType *PT, const MemRegion *sRegion) { ID.AddInteger((unsigned) CXXThisRegionKind); ID.AddPointer(PT); ID.AddPointer(sRegion); } void CXXThisRegion::Profile(llvm::FoldingSetNodeID &ID) const { CXXThisRegion::ProfileRegion(ID, ThisPointerTy, superRegion); } void ObjCIvarRegion::ProfileRegion(llvm::FoldingSetNodeID& ID, const ObjCIvarDecl *ivd, const MemRegion* superRegion) { DeclRegion::ProfileRegion(ID, ivd, superRegion, ObjCIvarRegionKind); } void DeclRegion::ProfileRegion(llvm::FoldingSetNodeID& ID, const Decl *D, const MemRegion* superRegion, Kind k) { ID.AddInteger((unsigned) k); ID.AddPointer(D); ID.AddPointer(superRegion); } void DeclRegion::Profile(llvm::FoldingSetNodeID& ID) const { DeclRegion::ProfileRegion(ID, D, superRegion, getKind()); } void VarRegion::Profile(llvm::FoldingSetNodeID &ID) const { VarRegion::ProfileRegion(ID, getDecl(), superRegion); } void SymbolicRegion::ProfileRegion(llvm::FoldingSetNodeID& ID, SymbolRef sym, const MemRegion *sreg) { ID.AddInteger((unsigned) MemRegion::SymbolicRegionKind); ID.Add(sym); ID.AddPointer(sreg); } void SymbolicRegion::Profile(llvm::FoldingSetNodeID& ID) const { SymbolicRegion::ProfileRegion(ID, sym, getSuperRegion()); } void ElementRegion::ProfileRegion(llvm::FoldingSetNodeID& ID, QualType ElementType, SVal Idx, const MemRegion* superRegion) { ID.AddInteger(MemRegion::ElementRegionKind); ID.Add(ElementType); ID.AddPointer(superRegion); Idx.Profile(ID); } void ElementRegion::Profile(llvm::FoldingSetNodeID& ID) const { ElementRegion::ProfileRegion(ID, ElementType, Index, superRegion); } void FunctionTextRegion::ProfileRegion(llvm::FoldingSetNodeID& ID, const NamedDecl *FD, const MemRegion*) { ID.AddInteger(MemRegion::FunctionTextRegionKind); ID.AddPointer(FD); } void FunctionTextRegion::Profile(llvm::FoldingSetNodeID& ID) const { FunctionTextRegion::ProfileRegion(ID, FD, superRegion); } void BlockTextRegion::ProfileRegion(llvm::FoldingSetNodeID& ID, const BlockDecl *BD, CanQualType, const AnalysisDeclContext *AC, const MemRegion*) { ID.AddInteger(MemRegion::BlockTextRegionKind); ID.AddPointer(BD); } void BlockTextRegion::Profile(llvm::FoldingSetNodeID& ID) const { BlockTextRegion::ProfileRegion(ID, BD, locTy, AC, superRegion); } void BlockDataRegion::ProfileRegion(llvm::FoldingSetNodeID& ID, const BlockTextRegion *BC, const LocationContext *LC, unsigned BlkCount, const MemRegion *sReg) { ID.AddInteger(MemRegion::BlockDataRegionKind); ID.AddPointer(BC); ID.AddPointer(LC); ID.AddInteger(BlkCount); ID.AddPointer(sReg); } void BlockDataRegion::Profile(llvm::FoldingSetNodeID& ID) const { BlockDataRegion::ProfileRegion(ID, BC, LC, BlockCount, getSuperRegion()); } void CXXTempObjectRegion::ProfileRegion(llvm::FoldingSetNodeID &ID, Expr const *Ex, const MemRegion *sReg) { ID.AddPointer(Ex); ID.AddPointer(sReg); } void CXXTempObjectRegion::Profile(llvm::FoldingSetNodeID &ID) const { ProfileRegion(ID, Ex, getSuperRegion()); } void CXXBaseObjectRegion::ProfileRegion(llvm::FoldingSetNodeID &ID, const CXXRecordDecl *RD, bool IsVirtual, const MemRegion *SReg) { ID.AddPointer(RD); ID.AddBoolean(IsVirtual); ID.AddPointer(SReg); } void CXXBaseObjectRegion::Profile(llvm::FoldingSetNodeID &ID) const { ProfileRegion(ID, getDecl(), isVirtual(), superRegion); } //===----------------------------------------------------------------------===// // Region anchors. //===----------------------------------------------------------------------===// void GlobalsSpaceRegion::anchor() { } void HeapSpaceRegion::anchor() { } void UnknownSpaceRegion::anchor() { } void StackLocalsSpaceRegion::anchor() { } void StackArgumentsSpaceRegion::anchor() { } void TypedRegion::anchor() { } void TypedValueRegion::anchor() { } void CodeTextRegion::anchor() { } void SubRegion::anchor() { } //===----------------------------------------------------------------------===// // Region pretty-printing. //===----------------------------------------------------------------------===// void MemRegion::dump() const { dumpToStream(llvm::errs()); } std::string MemRegion::getString() const { std::string s; llvm::raw_string_ostream os(s); dumpToStream(os); return os.str(); } void MemRegion::dumpToStream(raw_ostream &os) const { os << ""; } void AllocaRegion::dumpToStream(raw_ostream &os) const { os << "alloca{" << (const void*) Ex << ',' << Cnt << '}'; } void FunctionTextRegion::dumpToStream(raw_ostream &os) const { os << "code{" << getDecl()->getDeclName().getAsString() << '}'; } void BlockTextRegion::dumpToStream(raw_ostream &os) const { os << "block_code{" << (const void*) this << '}'; } void BlockDataRegion::dumpToStream(raw_ostream &os) const { os << "block_data{" << BC; os << "; "; for (BlockDataRegion::referenced_vars_iterator I = referenced_vars_begin(), E = referenced_vars_end(); I != E; ++I) os << "(" << I.getCapturedRegion() << "," << I.getOriginalRegion() << ") "; os << '}'; } void CompoundLiteralRegion::dumpToStream(raw_ostream &os) const { // FIXME: More elaborate pretty-printing. os << "{ " << (const void*) CL << " }"; } void CXXTempObjectRegion::dumpToStream(raw_ostream &os) const { os << "temp_object{" << getValueType().getAsString() << ',' << (const void*) Ex << '}'; } void CXXBaseObjectRegion::dumpToStream(raw_ostream &os) const { os << "base{" << superRegion << ',' << getDecl()->getName() << '}'; } void CXXThisRegion::dumpToStream(raw_ostream &os) const { os << "this"; } void ElementRegion::dumpToStream(raw_ostream &os) const { os << "element{" << superRegion << ',' << Index << ',' << getElementType().getAsString() << '}'; } void FieldRegion::dumpToStream(raw_ostream &os) const { os << superRegion << "->" << *getDecl(); } void ObjCIvarRegion::dumpToStream(raw_ostream &os) const { os << "ivar{" << superRegion << ',' << *getDecl() << '}'; } void StringRegion::dumpToStream(raw_ostream &os) const { assert(Str != nullptr && "Expecting non-null StringLiteral"); Str->printPretty(os, nullptr, PrintingPolicy(getContext().getLangOpts())); } void ObjCStringRegion::dumpToStream(raw_ostream &os) const { assert(Str != nullptr && "Expecting non-null ObjCStringLiteral"); Str->printPretty(os, nullptr, PrintingPolicy(getContext().getLangOpts())); } void SymbolicRegion::dumpToStream(raw_ostream &os) const { os << "SymRegion{" << sym << '}'; } void VarRegion::dumpToStream(raw_ostream &os) const { os << *cast(D); } void RegionRawOffset::dump() const { dumpToStream(llvm::errs()); } void RegionRawOffset::dumpToStream(raw_ostream &os) const { os << "raw_offset{" << getRegion() << ',' << getOffset().getQuantity() << '}'; } void StaticGlobalSpaceRegion::dumpToStream(raw_ostream &os) const { os << "StaticGlobalsMemSpace{" << CR << '}'; } void GlobalInternalSpaceRegion::dumpToStream(raw_ostream &os) const { os << "GlobalInternalSpaceRegion"; } void GlobalSystemSpaceRegion::dumpToStream(raw_ostream &os) const { os << "GlobalSystemSpaceRegion"; } void GlobalImmutableSpaceRegion::dumpToStream(raw_ostream &os) const { os << "GlobalImmutableSpaceRegion"; } void HeapSpaceRegion::dumpToStream(raw_ostream &os) const { os << "HeapSpaceRegion"; } void UnknownSpaceRegion::dumpToStream(raw_ostream &os) const { os << "UnknownSpaceRegion"; } void StackArgumentsSpaceRegion::dumpToStream(raw_ostream &os) const { os << "StackArgumentsSpaceRegion"; } void StackLocalsSpaceRegion::dumpToStream(raw_ostream &os) const { os << "StackLocalsSpaceRegion"; } bool MemRegion::canPrintPretty() const { return canPrintPrettyAsExpr(); } bool MemRegion::canPrintPrettyAsExpr() const { return false; } void MemRegion::printPretty(raw_ostream &os) const { assert(canPrintPretty() && "This region cannot be printed pretty."); os << "'"; printPrettyAsExpr(os); os << "'"; return; } void MemRegion::printPrettyAsExpr(raw_ostream &os) const { llvm_unreachable("This region cannot be printed pretty."); return; } bool VarRegion::canPrintPrettyAsExpr() const { return true; } void VarRegion::printPrettyAsExpr(raw_ostream &os) const { os << getDecl()->getName(); } bool ObjCIvarRegion::canPrintPrettyAsExpr() const { return true; } void ObjCIvarRegion::printPrettyAsExpr(raw_ostream &os) const { os << getDecl()->getName(); } bool FieldRegion::canPrintPretty() const { return true; } bool FieldRegion::canPrintPrettyAsExpr() const { return superRegion->canPrintPrettyAsExpr(); } void FieldRegion::printPrettyAsExpr(raw_ostream &os) const { assert(canPrintPrettyAsExpr()); superRegion->printPrettyAsExpr(os); os << "." << getDecl()->getName(); } void FieldRegion::printPretty(raw_ostream &os) const { if (canPrintPrettyAsExpr()) { os << "\'"; printPrettyAsExpr(os); os << "'"; } else { os << "field " << "\'" << getDecl()->getName() << "'"; } return; } bool CXXBaseObjectRegion::canPrintPrettyAsExpr() const { return superRegion->canPrintPrettyAsExpr(); } void CXXBaseObjectRegion::printPrettyAsExpr(raw_ostream &os) const { superRegion->printPrettyAsExpr(os); } //===----------------------------------------------------------------------===// // MemRegionManager methods. //===----------------------------------------------------------------------===// template const REG *MemRegionManager::LazyAllocate(REG*& region) { if (!region) { region = (REG*) A.Allocate(); new (region) REG(this); } return region; } template const REG *MemRegionManager::LazyAllocate(REG*& region, ARG a) { if (!region) { region = (REG*) A.Allocate(); new (region) REG(this, a); } return region; } const StackLocalsSpaceRegion* MemRegionManager::getStackLocalsRegion(const StackFrameContext *STC) { assert(STC); StackLocalsSpaceRegion *&R = StackLocalsSpaceRegions[STC]; if (R) return R; R = A.Allocate(); new (R) StackLocalsSpaceRegion(this, STC); return R; } const StackArgumentsSpaceRegion * MemRegionManager::getStackArgumentsRegion(const StackFrameContext *STC) { assert(STC); StackArgumentsSpaceRegion *&R = StackArgumentsSpaceRegions[STC]; if (R) return R; R = A.Allocate(); new (R) StackArgumentsSpaceRegion(this, STC); return R; } const GlobalsSpaceRegion *MemRegionManager::getGlobalsRegion(MemRegion::Kind K, const CodeTextRegion *CR) { if (!CR) { if (K == MemRegion::GlobalSystemSpaceRegionKind) return LazyAllocate(SystemGlobals); if (K == MemRegion::GlobalImmutableSpaceRegionKind) return LazyAllocate(ImmutableGlobals); assert(K == MemRegion::GlobalInternalSpaceRegionKind); return LazyAllocate(InternalGlobals); } assert(K == MemRegion::StaticGlobalSpaceRegionKind); StaticGlobalSpaceRegion *&R = StaticsGlobalSpaceRegions[CR]; if (R) return R; R = A.Allocate(); new (R) StaticGlobalSpaceRegion(this, CR); return R; } const HeapSpaceRegion *MemRegionManager::getHeapRegion() { return LazyAllocate(heap); } const MemSpaceRegion *MemRegionManager::getUnknownRegion() { return LazyAllocate(unknown); } const MemSpaceRegion *MemRegionManager::getCodeRegion() { return LazyAllocate(code); } //===----------------------------------------------------------------------===// // Constructing regions. //===----------------------------------------------------------------------===// const StringRegion* MemRegionManager::getStringRegion(const StringLiteral* Str){ return getSubRegion(Str, getGlobalsRegion()); } const ObjCStringRegion * MemRegionManager::getObjCStringRegion(const ObjCStringLiteral* Str){ return getSubRegion(Str, getGlobalsRegion()); } /// Look through a chain of LocationContexts to either find the /// StackFrameContext that matches a DeclContext, or find a VarRegion /// for a variable captured by a block. static llvm::PointerUnion getStackOrCaptureRegionForDeclContext(const LocationContext *LC, const DeclContext *DC, const VarDecl *VD) { while (LC) { if (const StackFrameContext *SFC = dyn_cast(LC)) { if (cast(SFC->getDecl()) == DC) return SFC; } if (const BlockInvocationContext *BC = dyn_cast(LC)) { const BlockDataRegion *BR = static_cast(BC->getContextData()); // FIXME: This can be made more efficient. for (BlockDataRegion::referenced_vars_iterator I = BR->referenced_vars_begin(), E = BR->referenced_vars_end(); I != E; ++I) { if (const VarRegion *VR = dyn_cast(I.getOriginalRegion())) if (VR->getDecl() == VD) return cast(I.getCapturedRegion()); } } LC = LC->getParent(); } return (const StackFrameContext *)nullptr; } const VarRegion* MemRegionManager::getVarRegion(const VarDecl *D, const LocationContext *LC) { const MemRegion *sReg = nullptr; if (D->hasGlobalStorage() && !D->isStaticLocal()) { // First handle the globals defined in system headers. if (C.getSourceManager().isInSystemHeader(D->getLocation())) { // Whitelist the system globals which often DO GET modified, assume the // rest are immutable. if (D->getName().find("errno") != StringRef::npos) sReg = getGlobalsRegion(MemRegion::GlobalSystemSpaceRegionKind); else sReg = getGlobalsRegion(MemRegion::GlobalImmutableSpaceRegionKind); // Treat other globals as GlobalInternal unless they are constants. } else { QualType GQT = D->getType(); const Type *GT = GQT.getTypePtrOrNull(); // TODO: We could walk the complex types here and see if everything is // constified. if (GT && GQT.isConstQualified() && GT->isArithmeticType()) sReg = getGlobalsRegion(MemRegion::GlobalImmutableSpaceRegionKind); else sReg = getGlobalsRegion(); } // Finally handle static locals. } else { // FIXME: Once we implement scope handling, we will need to properly lookup // 'D' to the proper LocationContext. const DeclContext *DC = D->getDeclContext(); llvm::PointerUnion V = getStackOrCaptureRegionForDeclContext(LC, DC, D); if (V.is()) return V.get(); const StackFrameContext *STC = V.get(); if (!STC) sReg = getUnknownRegion(); else { if (D->hasLocalStorage()) { sReg = isa(D) || isa(D) ? static_cast(getStackArgumentsRegion(STC)) : static_cast(getStackLocalsRegion(STC)); } else { assert(D->isStaticLocal()); const Decl *STCD = STC->getDecl(); if (isa(STCD) || isa(STCD)) sReg = getGlobalsRegion(MemRegion::StaticGlobalSpaceRegionKind, getFunctionTextRegion(cast(STCD))); else if (const BlockDecl *BD = dyn_cast(STCD)) { // FIXME: The fallback type here is totally bogus -- though it should // never be queried, it will prevent uniquing with the real // BlockTextRegion. Ideally we'd fix the AST so that we always had a // signature. QualType T; if (const TypeSourceInfo *TSI = BD->getSignatureAsWritten()) T = TSI->getType(); else T = getContext().getFunctionNoProtoType(getContext().VoidTy); const BlockTextRegion *BTR = getBlockTextRegion(BD, C.getCanonicalType(T), STC->getAnalysisDeclContext()); sReg = getGlobalsRegion(MemRegion::StaticGlobalSpaceRegionKind, BTR); } else { sReg = getGlobalsRegion(); } } } } return getSubRegion(D, sReg); } const VarRegion *MemRegionManager::getVarRegion(const VarDecl *D, const MemRegion *superR) { return getSubRegion(D, superR); } const BlockDataRegion * MemRegionManager::getBlockDataRegion(const BlockTextRegion *BC, const LocationContext *LC, unsigned blockCount) { const MemRegion *sReg = nullptr; const BlockDecl *BD = BC->getDecl(); if (!BD->hasCaptures()) { // This handles 'static' blocks. sReg = getGlobalsRegion(MemRegion::GlobalImmutableSpaceRegionKind); } else { if (LC) { // FIXME: Once we implement scope handling, we want the parent region // to be the scope. const StackFrameContext *STC = LC->getCurrentStackFrame(); assert(STC); sReg = getStackLocalsRegion(STC); } else { // We allow 'LC' to be NULL for cases where want BlockDataRegions // without context-sensitivity. sReg = getUnknownRegion(); } } return getSubRegion(BC, LC, blockCount, sReg); } const CXXTempObjectRegion * MemRegionManager::getCXXStaticTempObjectRegion(const Expr *Ex) { return getSubRegion( Ex, getGlobalsRegion(MemRegion::GlobalInternalSpaceRegionKind, nullptr)); } const CompoundLiteralRegion* MemRegionManager::getCompoundLiteralRegion(const CompoundLiteralExpr *CL, const LocationContext *LC) { const MemRegion *sReg = nullptr; if (CL->isFileScope()) sReg = getGlobalsRegion(); else { const StackFrameContext *STC = LC->getCurrentStackFrame(); assert(STC); sReg = getStackLocalsRegion(STC); } return getSubRegion(CL, sReg); } const ElementRegion* MemRegionManager::getElementRegion(QualType elementType, NonLoc Idx, const MemRegion* superRegion, ASTContext &Ctx){ QualType T = Ctx.getCanonicalType(elementType).getUnqualifiedType(); llvm::FoldingSetNodeID ID; ElementRegion::ProfileRegion(ID, T, Idx, superRegion); void *InsertPos; MemRegion* data = Regions.FindNodeOrInsertPos(ID, InsertPos); ElementRegion* R = cast_or_null(data); if (!R) { R = (ElementRegion*) A.Allocate(); new (R) ElementRegion(T, Idx, superRegion); Regions.InsertNode(R, InsertPos); } return R; } const FunctionTextRegion * MemRegionManager::getFunctionTextRegion(const NamedDecl *FD) { return getSubRegion(FD, getCodeRegion()); } const BlockTextRegion * MemRegionManager::getBlockTextRegion(const BlockDecl *BD, CanQualType locTy, AnalysisDeclContext *AC) { return getSubRegion(BD, locTy, AC, getCodeRegion()); } /// getSymbolicRegion - Retrieve or create a "symbolic" memory region. const SymbolicRegion *MemRegionManager::getSymbolicRegion(SymbolRef sym) { return getSubRegion(sym, getUnknownRegion()); } const SymbolicRegion *MemRegionManager::getSymbolicHeapRegion(SymbolRef Sym) { return getSubRegion(Sym, getHeapRegion()); } const FieldRegion* MemRegionManager::getFieldRegion(const FieldDecl *d, const MemRegion* superRegion){ return getSubRegion(d, superRegion); } const ObjCIvarRegion* MemRegionManager::getObjCIvarRegion(const ObjCIvarDecl *d, const MemRegion* superRegion) { return getSubRegion(d, superRegion); } const CXXTempObjectRegion* MemRegionManager::getCXXTempObjectRegion(Expr const *E, LocationContext const *LC) { const StackFrameContext *SFC = LC->getCurrentStackFrame(); assert(SFC); return getSubRegion(E, getStackLocalsRegion(SFC)); } /// Checks whether \p BaseClass is a valid virtual or direct non-virtual base /// class of the type of \p Super. static bool isValidBaseClass(const CXXRecordDecl *BaseClass, const TypedValueRegion *Super, bool IsVirtual) { BaseClass = BaseClass->getCanonicalDecl(); const CXXRecordDecl *Class = Super->getValueType()->getAsCXXRecordDecl(); if (!Class) return true; if (IsVirtual) return Class->isVirtuallyDerivedFrom(BaseClass); for (const auto &I : Class->bases()) { if (I.getType()->getAsCXXRecordDecl()->getCanonicalDecl() == BaseClass) return true; } return false; } const CXXBaseObjectRegion * MemRegionManager::getCXXBaseObjectRegion(const CXXRecordDecl *RD, const MemRegion *Super, bool IsVirtual) { if (isa(Super)) { assert(isValidBaseClass(RD, dyn_cast(Super), IsVirtual)); (void)&isValidBaseClass; if (IsVirtual) { // Virtual base regions should not be layered, since the layout rules // are different. while (const CXXBaseObjectRegion *Base = dyn_cast(Super)) { Super = Base->getSuperRegion(); } assert(Super && !isa(Super)); } } return getSubRegion(RD, IsVirtual, Super); } const CXXThisRegion* MemRegionManager::getCXXThisRegion(QualType thisPointerTy, const LocationContext *LC) { const StackFrameContext *STC = LC->getCurrentStackFrame(); assert(STC); const PointerType *PT = thisPointerTy->getAs(); assert(PT); return getSubRegion(PT, getStackArgumentsRegion(STC)); } const AllocaRegion* MemRegionManager::getAllocaRegion(const Expr *E, unsigned cnt, const LocationContext *LC) { const StackFrameContext *STC = LC->getCurrentStackFrame(); assert(STC); return getSubRegion(E, cnt, getStackLocalsRegion(STC)); } const MemSpaceRegion *MemRegion::getMemorySpace() const { const MemRegion *R = this; const SubRegion* SR = dyn_cast(this); while (SR) { R = SR->getSuperRegion(); SR = dyn_cast(R); } return dyn_cast(R); } bool MemRegion::hasStackStorage() const { return isa(getMemorySpace()); } bool MemRegion::hasStackNonParametersStorage() const { return isa(getMemorySpace()); } bool MemRegion::hasStackParametersStorage() const { return isa(getMemorySpace()); } bool MemRegion::hasGlobalsOrParametersStorage() const { const MemSpaceRegion *MS = getMemorySpace(); return isa(MS) || isa(MS); } // getBaseRegion strips away all elements and fields, and get the base region // of them. const MemRegion *MemRegion::getBaseRegion() const { const MemRegion *R = this; while (true) { switch (R->getKind()) { case MemRegion::ElementRegionKind: case MemRegion::FieldRegionKind: case MemRegion::ObjCIvarRegionKind: case MemRegion::CXXBaseObjectRegionKind: R = cast(R)->getSuperRegion(); continue; default: break; } break; } return R; } bool MemRegion::isSubRegionOf(const MemRegion *R) const { return false; } //===----------------------------------------------------------------------===// // View handling. //===----------------------------------------------------------------------===// const MemRegion *MemRegion::StripCasts(bool StripBaseCasts) const { const MemRegion *R = this; while (true) { switch (R->getKind()) { case ElementRegionKind: { const ElementRegion *ER = cast(R); if (!ER->getIndex().isZeroConstant()) return R; R = ER->getSuperRegion(); break; } case CXXBaseObjectRegionKind: if (!StripBaseCasts) return R; R = cast(R)->getSuperRegion(); break; default: return R; } } } const SymbolicRegion *MemRegion::getSymbolicBase() const { const SubRegion *SubR = dyn_cast(this); while (SubR) { if (const SymbolicRegion *SymR = dyn_cast(SubR)) return SymR; SubR = dyn_cast(SubR->getSuperRegion()); } return nullptr; } // FIXME: Merge with the implementation of the same method in Store.cpp static bool IsCompleteType(ASTContext &Ctx, QualType Ty) { if (const RecordType *RT = Ty->getAs()) { const RecordDecl *D = RT->getDecl(); if (!D->getDefinition()) return false; } return true; } RegionRawOffset ElementRegion::getAsArrayOffset() const { CharUnits offset = CharUnits::Zero(); const ElementRegion *ER = this; const MemRegion *superR = nullptr; ASTContext &C = getContext(); // FIXME: Handle multi-dimensional arrays. while (ER) { superR = ER->getSuperRegion(); // FIXME: generalize to symbolic offsets. SVal index = ER->getIndex(); if (Optional CI = index.getAs()) { // Update the offset. int64_t i = CI->getValue().getSExtValue(); if (i != 0) { QualType elemType = ER->getElementType(); // If we are pointing to an incomplete type, go no further. if (!IsCompleteType(C, elemType)) { superR = ER; break; } CharUnits size = C.getTypeSizeInChars(elemType); offset += (i * size); } // Go to the next ElementRegion (if any). ER = dyn_cast(superR); continue; } return nullptr; } assert(superR && "super region cannot be NULL"); return RegionRawOffset(superR, offset); } /// Returns true if \p Base is an immediate base class of \p Child static bool isImmediateBase(const CXXRecordDecl *Child, const CXXRecordDecl *Base) { // Note that we do NOT canonicalize the base class here, because // ASTRecordLayout doesn't either. If that leads us down the wrong path, // so be it; at least we won't crash. for (const auto &I : Child->bases()) { if (I.getType()->getAsCXXRecordDecl() == Base) return true; } return false; } RegionOffset MemRegion::getAsOffset() const { const MemRegion *R = this; const MemRegion *SymbolicOffsetBase = nullptr; int64_t Offset = 0; while (1) { switch (R->getKind()) { case GenericMemSpaceRegionKind: case StackLocalsSpaceRegionKind: case StackArgumentsSpaceRegionKind: case HeapSpaceRegionKind: case UnknownSpaceRegionKind: case StaticGlobalSpaceRegionKind: case GlobalInternalSpaceRegionKind: case GlobalSystemSpaceRegionKind: case GlobalImmutableSpaceRegionKind: // Stores can bind directly to a region space to set a default value. assert(Offset == 0 && !SymbolicOffsetBase); goto Finish; case FunctionTextRegionKind: case BlockTextRegionKind: case BlockDataRegionKind: // These will never have bindings, but may end up having values requested // if the user does some strange casting. if (Offset != 0) SymbolicOffsetBase = R; goto Finish; case SymbolicRegionKind: case AllocaRegionKind: case CompoundLiteralRegionKind: case CXXThisRegionKind: case StringRegionKind: case ObjCStringRegionKind: case VarRegionKind: case CXXTempObjectRegionKind: // Usual base regions. goto Finish; case ObjCIvarRegionKind: // This is a little strange, but it's a compromise between // ObjCIvarRegions having unknown compile-time offsets (when using the // non-fragile runtime) and yet still being distinct, non-overlapping // regions. Thus we treat them as "like" base regions for the purposes // of computing offsets. goto Finish; case CXXBaseObjectRegionKind: { const CXXBaseObjectRegion *BOR = cast(R); R = BOR->getSuperRegion(); QualType Ty; bool RootIsSymbolic = false; if (const TypedValueRegion *TVR = dyn_cast(R)) { Ty = TVR->getDesugaredValueType(getContext()); } else if (const SymbolicRegion *SR = dyn_cast(R)) { // If our base region is symbolic, we don't know what type it really is. // Pretend the type of the symbol is the true dynamic type. // (This will at least be self-consistent for the life of the symbol.) Ty = SR->getSymbol()->getType()->getPointeeType(); RootIsSymbolic = true; } const CXXRecordDecl *Child = Ty->getAsCXXRecordDecl(); if (!Child) { // We cannot compute the offset of the base class. SymbolicOffsetBase = R; } if (RootIsSymbolic) { // Base layers on symbolic regions may not be type-correct. // Double-check the inheritance here, and revert to a symbolic offset // if it's invalid (e.g. due to a reinterpret_cast). if (BOR->isVirtual()) { if (!Child->isVirtuallyDerivedFrom(BOR->getDecl())) SymbolicOffsetBase = R; } else { if (!isImmediateBase(Child, BOR->getDecl())) SymbolicOffsetBase = R; } } // Don't bother calculating precise offsets if we already have a // symbolic offset somewhere in the chain. if (SymbolicOffsetBase) continue; CharUnits BaseOffset; const ASTRecordLayout &Layout = getContext().getASTRecordLayout(Child); if (BOR->isVirtual()) BaseOffset = Layout.getVBaseClassOffset(BOR->getDecl()); else BaseOffset = Layout.getBaseClassOffset(BOR->getDecl()); // The base offset is in chars, not in bits. Offset += BaseOffset.getQuantity() * getContext().getCharWidth(); break; } case ElementRegionKind: { const ElementRegion *ER = cast(R); R = ER->getSuperRegion(); QualType EleTy = ER->getValueType(); if (!IsCompleteType(getContext(), EleTy)) { // We cannot compute the offset of the base class. SymbolicOffsetBase = R; continue; } SVal Index = ER->getIndex(); if (Optional CI = Index.getAs()) { // Don't bother calculating precise offsets if we already have a // symbolic offset somewhere in the chain. if (SymbolicOffsetBase) continue; int64_t i = CI->getValue().getSExtValue(); // This type size is in bits. Offset += i * getContext().getTypeSize(EleTy); } else { // We cannot compute offset for non-concrete index. SymbolicOffsetBase = R; } break; } case FieldRegionKind: { const FieldRegion *FR = cast(R); R = FR->getSuperRegion(); const RecordDecl *RD = FR->getDecl()->getParent(); if (RD->isUnion() || !RD->isCompleteDefinition()) { // We cannot compute offset for incomplete type. // For unions, we could treat everything as offset 0, but we'd rather // treat each field as a symbolic offset so they aren't stored on top // of each other, since we depend on things in typed regions actually // matching their types. SymbolicOffsetBase = R; } // Don't bother calculating precise offsets if we already have a // symbolic offset somewhere in the chain. if (SymbolicOffsetBase) continue; // Get the field number. unsigned idx = 0; for (RecordDecl::field_iterator FI = RD->field_begin(), FE = RD->field_end(); FI != FE; ++FI, ++idx) if (FR->getDecl() == *FI) break; const ASTRecordLayout &Layout = getContext().getASTRecordLayout(RD); // This is offset in bits. Offset += Layout.getFieldOffset(idx); break; } } } Finish: if (SymbolicOffsetBase) return RegionOffset(SymbolicOffsetBase, RegionOffset::Symbolic); return RegionOffset(R, Offset); } //===----------------------------------------------------------------------===// // BlockDataRegion //===----------------------------------------------------------------------===// std::pair BlockDataRegion::getCaptureRegions(const VarDecl *VD) { MemRegionManager &MemMgr = *getMemRegionManager(); const VarRegion *VR = nullptr; const VarRegion *OriginalVR = nullptr; if (!VD->hasAttr() && VD->hasLocalStorage()) { VR = MemMgr.getVarRegion(VD, this); OriginalVR = MemMgr.getVarRegion(VD, LC); } else { if (LC) { VR = MemMgr.getVarRegion(VD, LC); OriginalVR = VR; } else { VR = MemMgr.getVarRegion(VD, MemMgr.getUnknownRegion()); OriginalVR = MemMgr.getVarRegion(VD, LC); } } return std::make_pair(VR, OriginalVR); } void BlockDataRegion::LazyInitializeReferencedVars() { if (ReferencedVars) return; AnalysisDeclContext *AC = getCodeRegion()->getAnalysisDeclContext(); AnalysisDeclContext::referenced_decls_iterator I, E; std::tie(I, E) = AC->getReferencedBlockVars(BC->getDecl()); if (I == E) { ReferencedVars = (void*) 0x1; return; } MemRegionManager &MemMgr = *getMemRegionManager(); llvm::BumpPtrAllocator &A = MemMgr.getAllocator(); BumpVectorContext BC(A); typedef BumpVector VarVec; VarVec *BV = (VarVec*) A.Allocate(); new (BV) VarVec(BC, E - I); VarVec *BVOriginal = (VarVec*) A.Allocate(); new (BVOriginal) VarVec(BC, E - I); for ( ; I != E; ++I) { const VarRegion *VR = nullptr; const VarRegion *OriginalVR = nullptr; std::tie(VR, OriginalVR) = getCaptureRegions(*I); assert(VR); assert(OriginalVR); BV->push_back(VR, BC); BVOriginal->push_back(OriginalVR, BC); } ReferencedVars = BV; OriginalVars = BVOriginal; } BlockDataRegion::referenced_vars_iterator BlockDataRegion::referenced_vars_begin() const { const_cast(this)->LazyInitializeReferencedVars(); BumpVector *Vec = static_cast*>(ReferencedVars); if (Vec == (void*) 0x1) return BlockDataRegion::referenced_vars_iterator(nullptr, nullptr); BumpVector *VecOriginal = static_cast*>(OriginalVars); return BlockDataRegion::referenced_vars_iterator(Vec->begin(), VecOriginal->begin()); } BlockDataRegion::referenced_vars_iterator BlockDataRegion::referenced_vars_end() const { const_cast(this)->LazyInitializeReferencedVars(); BumpVector *Vec = static_cast*>(ReferencedVars); if (Vec == (void*) 0x1) return BlockDataRegion::referenced_vars_iterator(nullptr, nullptr); BumpVector *VecOriginal = static_cast*>(OriginalVars); return BlockDataRegion::referenced_vars_iterator(Vec->end(), VecOriginal->end()); } const VarRegion *BlockDataRegion::getOriginalRegion(const VarRegion *R) const { for (referenced_vars_iterator I = referenced_vars_begin(), E = referenced_vars_end(); I != E; ++I) { if (I.getCapturedRegion() == R) return I.getOriginalRegion(); } return nullptr; } //===----------------------------------------------------------------------===// // RegionAndSymbolInvalidationTraits //===----------------------------------------------------------------------===// void RegionAndSymbolInvalidationTraits::setTrait(SymbolRef Sym, InvalidationKinds IK) { SymTraitsMap[Sym] |= IK; } void RegionAndSymbolInvalidationTraits::setTrait(const MemRegion *MR, InvalidationKinds IK) { assert(MR); if (const SymbolicRegion *SR = dyn_cast(MR)) setTrait(SR->getSymbol(), IK); else MRTraitsMap[MR] |= IK; } bool RegionAndSymbolInvalidationTraits::hasTrait(SymbolRef Sym, InvalidationKinds IK) { const_symbol_iterator I = SymTraitsMap.find(Sym); if (I != SymTraitsMap.end()) return I->second & IK; return false; } bool RegionAndSymbolInvalidationTraits::hasTrait(const MemRegion *MR, InvalidationKinds IK) { if (!MR) return false; if (const SymbolicRegion *SR = dyn_cast(MR)) return hasTrait(SR->getSymbol(), IK); const_region_iterator I = MRTraitsMap.find(MR); if (I != MRTraitsMap.end()) return I->second & IK; return false; } @ 1.1.1.2.4.1 log @file MemRegion.cpp was added on branch yamt-pagecache on 2014-05-22 16:18:31 +0000 @ text @d1 1504 @ 1.1.1.2.4.2 log @sync with head. for a reference, the tree before this commit was tagged as yamt-pagecache-tag8. this commit was splitted into small chunks to avoid a limitation of cvs. ("Protocol error: too many arguments") @ text @a0 1504 //== MemRegion.cpp - Abstract memory regions for static analysis --*- C++ -*--// // // The LLVM Compiler Infrastructure // // This file is distributed under the University of Illinois Open Source // License. See LICENSE.TXT for details. // //===----------------------------------------------------------------------===// // // This file defines MemRegion and its subclasses. MemRegion defines a // partially-typed abstraction of memory useful for path-sensitive dataflow // analyses. // //===----------------------------------------------------------------------===// #include "clang/StaticAnalyzer/Core/PathSensitive/MemRegion.h" #include "clang/AST/Attr.h" #include "clang/AST/CharUnits.h" #include "clang/AST/DeclObjC.h" #include "clang/AST/RecordLayout.h" #include "clang/Analysis/AnalysisContext.h" #include "clang/Analysis/Support/BumpVector.h" #include "clang/Basic/SourceManager.h" #include "clang/StaticAnalyzer/Core/PathSensitive/SValBuilder.h" #include "llvm/Support/raw_ostream.h" using namespace clang; using namespace ento; //===----------------------------------------------------------------------===// // MemRegion Construction. //===----------------------------------------------------------------------===// template struct MemRegionManagerTrait; template RegionTy* MemRegionManager::getRegion(const A1 a1) { const typename MemRegionManagerTrait::SuperRegionTy *superRegion = MemRegionManagerTrait::getSuperRegion(*this, a1); llvm::FoldingSetNodeID ID; RegionTy::ProfileRegion(ID, a1, superRegion); void *InsertPos; RegionTy* R = cast_or_null(Regions.FindNodeOrInsertPos(ID, InsertPos)); if (!R) { R = (RegionTy*) A.Allocate(); new (R) RegionTy(a1, superRegion); Regions.InsertNode(R, InsertPos); } return R; } template RegionTy* MemRegionManager::getSubRegion(const A1 a1, const MemRegion *superRegion) { llvm::FoldingSetNodeID ID; RegionTy::ProfileRegion(ID, a1, superRegion); void *InsertPos; RegionTy* R = cast_or_null(Regions.FindNodeOrInsertPos(ID, InsertPos)); if (!R) { R = (RegionTy*) A.Allocate(); new (R) RegionTy(a1, superRegion); Regions.InsertNode(R, InsertPos); } return R; } template RegionTy* MemRegionManager::getRegion(const A1 a1, const A2 a2) { const typename MemRegionManagerTrait::SuperRegionTy *superRegion = MemRegionManagerTrait::getSuperRegion(*this, a1, a2); llvm::FoldingSetNodeID ID; RegionTy::ProfileRegion(ID, a1, a2, superRegion); void *InsertPos; RegionTy* R = cast_or_null(Regions.FindNodeOrInsertPos(ID, InsertPos)); if (!R) { R = (RegionTy*) A.Allocate(); new (R) RegionTy(a1, a2, superRegion); Regions.InsertNode(R, InsertPos); } return R; } template RegionTy* MemRegionManager::getSubRegion(const A1 a1, const A2 a2, const MemRegion *superRegion) { llvm::FoldingSetNodeID ID; RegionTy::ProfileRegion(ID, a1, a2, superRegion); void *InsertPos; RegionTy* R = cast_or_null(Regions.FindNodeOrInsertPos(ID, InsertPos)); if (!R) { R = (RegionTy*) A.Allocate(); new (R) RegionTy(a1, a2, superRegion); Regions.InsertNode(R, InsertPos); } return R; } template RegionTy* MemRegionManager::getSubRegion(const A1 a1, const A2 a2, const A3 a3, const MemRegion *superRegion) { llvm::FoldingSetNodeID ID; RegionTy::ProfileRegion(ID, a1, a2, a3, superRegion); void *InsertPos; RegionTy* R = cast_or_null(Regions.FindNodeOrInsertPos(ID, InsertPos)); if (!R) { R = (RegionTy*) A.Allocate(); new (R) RegionTy(a1, a2, a3, superRegion); Regions.InsertNode(R, InsertPos); } return R; } //===----------------------------------------------------------------------===// // Object destruction. //===----------------------------------------------------------------------===// MemRegion::~MemRegion() {} MemRegionManager::~MemRegionManager() { // All regions and their data are BumpPtrAllocated. No need to call // their destructors. } //===----------------------------------------------------------------------===// // Basic methods. //===----------------------------------------------------------------------===// bool SubRegion::isSubRegionOf(const MemRegion* R) const { const MemRegion* r = getSuperRegion(); while (r != 0) { if (r == R) return true; if (const SubRegion* sr = dyn_cast(r)) r = sr->getSuperRegion(); else break; } return false; } MemRegionManager* SubRegion::getMemRegionManager() const { const SubRegion* r = this; do { const MemRegion *superRegion = r->getSuperRegion(); if (const SubRegion *sr = dyn_cast(superRegion)) { r = sr; continue; } return superRegion->getMemRegionManager(); } while (1); } const StackFrameContext *VarRegion::getStackFrame() const { const StackSpaceRegion *SSR = dyn_cast(getMemorySpace()); return SSR ? SSR->getStackFrame() : NULL; } //===----------------------------------------------------------------------===// // Region extents. //===----------------------------------------------------------------------===// DefinedOrUnknownSVal TypedValueRegion::getExtent(SValBuilder &svalBuilder) const { ASTContext &Ctx = svalBuilder.getContext(); QualType T = getDesugaredValueType(Ctx); if (isa(T)) return nonloc::SymbolVal(svalBuilder.getSymbolManager().getExtentSymbol(this)); if (T->isIncompleteType()) return UnknownVal(); CharUnits size = Ctx.getTypeSizeInChars(T); QualType sizeTy = svalBuilder.getArrayIndexType(); return svalBuilder.makeIntVal(size.getQuantity(), sizeTy); } DefinedOrUnknownSVal FieldRegion::getExtent(SValBuilder &svalBuilder) const { // Force callers to deal with bitfields explicitly. if (getDecl()->isBitField()) return UnknownVal(); DefinedOrUnknownSVal Extent = DeclRegion::getExtent(svalBuilder); // A zero-length array at the end of a struct often stands for dynamically- // allocated extra memory. if (Extent.isZeroConstant()) { QualType T = getDesugaredValueType(svalBuilder.getContext()); if (isa(T)) return UnknownVal(); } return Extent; } DefinedOrUnknownSVal AllocaRegion::getExtent(SValBuilder &svalBuilder) const { return nonloc::SymbolVal(svalBuilder.getSymbolManager().getExtentSymbol(this)); } DefinedOrUnknownSVal SymbolicRegion::getExtent(SValBuilder &svalBuilder) const { return nonloc::SymbolVal(svalBuilder.getSymbolManager().getExtentSymbol(this)); } DefinedOrUnknownSVal StringRegion::getExtent(SValBuilder &svalBuilder) const { return svalBuilder.makeIntVal(getStringLiteral()->getByteLength()+1, svalBuilder.getArrayIndexType()); } ObjCIvarRegion::ObjCIvarRegion(const ObjCIvarDecl *ivd, const MemRegion* sReg) : DeclRegion(ivd, sReg, ObjCIvarRegionKind) {} const ObjCIvarDecl *ObjCIvarRegion::getDecl() const { return cast(D); } QualType ObjCIvarRegion::getValueType() const { return getDecl()->getType(); } QualType CXXBaseObjectRegion::getValueType() const { return QualType(getDecl()->getTypeForDecl(), 0); } //===----------------------------------------------------------------------===// // FoldingSet profiling. //===----------------------------------------------------------------------===// void MemSpaceRegion::Profile(llvm::FoldingSetNodeID& ID) const { ID.AddInteger((unsigned)getKind()); } void StackSpaceRegion::Profile(llvm::FoldingSetNodeID &ID) const { ID.AddInteger((unsigned)getKind()); ID.AddPointer(getStackFrame()); } void StaticGlobalSpaceRegion::Profile(llvm::FoldingSetNodeID &ID) const { ID.AddInteger((unsigned)getKind()); ID.AddPointer(getCodeRegion()); } void StringRegion::ProfileRegion(llvm::FoldingSetNodeID& ID, const StringLiteral* Str, const MemRegion* superRegion) { ID.AddInteger((unsigned) StringRegionKind); ID.AddPointer(Str); ID.AddPointer(superRegion); } void ObjCStringRegion::ProfileRegion(llvm::FoldingSetNodeID& ID, const ObjCStringLiteral* Str, const MemRegion* superRegion) { ID.AddInteger((unsigned) ObjCStringRegionKind); ID.AddPointer(Str); ID.AddPointer(superRegion); } void AllocaRegion::ProfileRegion(llvm::FoldingSetNodeID& ID, const Expr *Ex, unsigned cnt, const MemRegion *superRegion) { ID.AddInteger((unsigned) AllocaRegionKind); ID.AddPointer(Ex); ID.AddInteger(cnt); ID.AddPointer(superRegion); } void AllocaRegion::Profile(llvm::FoldingSetNodeID& ID) const { ProfileRegion(ID, Ex, Cnt, superRegion); } void CompoundLiteralRegion::Profile(llvm::FoldingSetNodeID& ID) const { CompoundLiteralRegion::ProfileRegion(ID, CL, superRegion); } void CompoundLiteralRegion::ProfileRegion(llvm::FoldingSetNodeID& ID, const CompoundLiteralExpr *CL, const MemRegion* superRegion) { ID.AddInteger((unsigned) CompoundLiteralRegionKind); ID.AddPointer(CL); ID.AddPointer(superRegion); } void CXXThisRegion::ProfileRegion(llvm::FoldingSetNodeID &ID, const PointerType *PT, const MemRegion *sRegion) { ID.AddInteger((unsigned) CXXThisRegionKind); ID.AddPointer(PT); ID.AddPointer(sRegion); } void CXXThisRegion::Profile(llvm::FoldingSetNodeID &ID) const { CXXThisRegion::ProfileRegion(ID, ThisPointerTy, superRegion); } void ObjCIvarRegion::ProfileRegion(llvm::FoldingSetNodeID& ID, const ObjCIvarDecl *ivd, const MemRegion* superRegion) { DeclRegion::ProfileRegion(ID, ivd, superRegion, ObjCIvarRegionKind); } void DeclRegion::ProfileRegion(llvm::FoldingSetNodeID& ID, const Decl *D, const MemRegion* superRegion, Kind k) { ID.AddInteger((unsigned) k); ID.AddPointer(D); ID.AddPointer(superRegion); } void DeclRegion::Profile(llvm::FoldingSetNodeID& ID) const { DeclRegion::ProfileRegion(ID, D, superRegion, getKind()); } void VarRegion::Profile(llvm::FoldingSetNodeID &ID) const { VarRegion::ProfileRegion(ID, getDecl(), superRegion); } void SymbolicRegion::ProfileRegion(llvm::FoldingSetNodeID& ID, SymbolRef sym, const MemRegion *sreg) { ID.AddInteger((unsigned) MemRegion::SymbolicRegionKind); ID.Add(sym); ID.AddPointer(sreg); } void SymbolicRegion::Profile(llvm::FoldingSetNodeID& ID) const { SymbolicRegion::ProfileRegion(ID, sym, getSuperRegion()); } void ElementRegion::ProfileRegion(llvm::FoldingSetNodeID& ID, QualType ElementType, SVal Idx, const MemRegion* superRegion) { ID.AddInteger(MemRegion::ElementRegionKind); ID.Add(ElementType); ID.AddPointer(superRegion); Idx.Profile(ID); } void ElementRegion::Profile(llvm::FoldingSetNodeID& ID) const { ElementRegion::ProfileRegion(ID, ElementType, Index, superRegion); } void FunctionTextRegion::ProfileRegion(llvm::FoldingSetNodeID& ID, const NamedDecl *FD, const MemRegion*) { ID.AddInteger(MemRegion::FunctionTextRegionKind); ID.AddPointer(FD); } void FunctionTextRegion::Profile(llvm::FoldingSetNodeID& ID) const { FunctionTextRegion::ProfileRegion(ID, FD, superRegion); } void BlockTextRegion::ProfileRegion(llvm::FoldingSetNodeID& ID, const BlockDecl *BD, CanQualType, const AnalysisDeclContext *AC, const MemRegion*) { ID.AddInteger(MemRegion::BlockTextRegionKind); ID.AddPointer(BD); } void BlockTextRegion::Profile(llvm::FoldingSetNodeID& ID) const { BlockTextRegion::ProfileRegion(ID, BD, locTy, AC, superRegion); } void BlockDataRegion::ProfileRegion(llvm::FoldingSetNodeID& ID, const BlockTextRegion *BC, const LocationContext *LC, unsigned BlkCount, const MemRegion *sReg) { ID.AddInteger(MemRegion::BlockDataRegionKind); ID.AddPointer(BC); ID.AddPointer(LC); ID.AddInteger(BlkCount); ID.AddPointer(sReg); } void BlockDataRegion::Profile(llvm::FoldingSetNodeID& ID) const { BlockDataRegion::ProfileRegion(ID, BC, LC, BlockCount, getSuperRegion()); } void CXXTempObjectRegion::ProfileRegion(llvm::FoldingSetNodeID &ID, Expr const *Ex, const MemRegion *sReg) { ID.AddPointer(Ex); ID.AddPointer(sReg); } void CXXTempObjectRegion::Profile(llvm::FoldingSetNodeID &ID) const { ProfileRegion(ID, Ex, getSuperRegion()); } void CXXBaseObjectRegion::ProfileRegion(llvm::FoldingSetNodeID &ID, const CXXRecordDecl *RD, bool IsVirtual, const MemRegion *SReg) { ID.AddPointer(RD); ID.AddBoolean(IsVirtual); ID.AddPointer(SReg); } void CXXBaseObjectRegion::Profile(llvm::FoldingSetNodeID &ID) const { ProfileRegion(ID, getDecl(), isVirtual(), superRegion); } //===----------------------------------------------------------------------===// // Region anchors. //===----------------------------------------------------------------------===// void GlobalsSpaceRegion::anchor() { } void HeapSpaceRegion::anchor() { } void UnknownSpaceRegion::anchor() { } void StackLocalsSpaceRegion::anchor() { } void StackArgumentsSpaceRegion::anchor() { } void TypedRegion::anchor() { } void TypedValueRegion::anchor() { } void CodeTextRegion::anchor() { } void SubRegion::anchor() { } //===----------------------------------------------------------------------===// // Region pretty-printing. //===----------------------------------------------------------------------===// void MemRegion::dump() const { dumpToStream(llvm::errs()); } std::string MemRegion::getString() const { std::string s; llvm::raw_string_ostream os(s); dumpToStream(os); return os.str(); } void MemRegion::dumpToStream(raw_ostream &os) const { os << ""; } void AllocaRegion::dumpToStream(raw_ostream &os) const { os << "alloca{" << (const void*) Ex << ',' << Cnt << '}'; } void FunctionTextRegion::dumpToStream(raw_ostream &os) const { os << "code{" << getDecl()->getDeclName().getAsString() << '}'; } void BlockTextRegion::dumpToStream(raw_ostream &os) const { os << "block_code{" << (const void*) this << '}'; } void BlockDataRegion::dumpToStream(raw_ostream &os) const { os << "block_data{" << BC; os << "; "; for (BlockDataRegion::referenced_vars_iterator I = referenced_vars_begin(), E = referenced_vars_end(); I != E; ++I) os << "(" << I.getCapturedRegion() << "," << I.getOriginalRegion() << ") "; os << '}'; } void CompoundLiteralRegion::dumpToStream(raw_ostream &os) const { // FIXME: More elaborate pretty-printing. os << "{ " << (const void*) CL << " }"; } void CXXTempObjectRegion::dumpToStream(raw_ostream &os) const { os << "temp_object{" << getValueType().getAsString() << ',' << (const void*) Ex << '}'; } void CXXBaseObjectRegion::dumpToStream(raw_ostream &os) const { os << "base{" << superRegion << ',' << getDecl()->getName() << '}'; } void CXXThisRegion::dumpToStream(raw_ostream &os) const { os << "this"; } void ElementRegion::dumpToStream(raw_ostream &os) const { os << "element{" << superRegion << ',' << Index << ',' << getElementType().getAsString() << '}'; } void FieldRegion::dumpToStream(raw_ostream &os) const { os << superRegion << "->" << *getDecl(); } void ObjCIvarRegion::dumpToStream(raw_ostream &os) const { os << "ivar{" << superRegion << ',' << *getDecl() << '}'; } void StringRegion::dumpToStream(raw_ostream &os) const { Str->printPretty(os, 0, PrintingPolicy(getContext().getLangOpts())); } void ObjCStringRegion::dumpToStream(raw_ostream &os) const { Str->printPretty(os, 0, PrintingPolicy(getContext().getLangOpts())); } void SymbolicRegion::dumpToStream(raw_ostream &os) const { os << "SymRegion{" << sym << '}'; } void VarRegion::dumpToStream(raw_ostream &os) const { os << *cast(D); } void RegionRawOffset::dump() const { dumpToStream(llvm::errs()); } void RegionRawOffset::dumpToStream(raw_ostream &os) const { os << "raw_offset{" << getRegion() << ',' << getOffset().getQuantity() << '}'; } void StaticGlobalSpaceRegion::dumpToStream(raw_ostream &os) const { os << "StaticGlobalsMemSpace{" << CR << '}'; } void GlobalInternalSpaceRegion::dumpToStream(raw_ostream &os) const { os << "GlobalInternalSpaceRegion"; } void GlobalSystemSpaceRegion::dumpToStream(raw_ostream &os) const { os << "GlobalSystemSpaceRegion"; } void GlobalImmutableSpaceRegion::dumpToStream(raw_ostream &os) const { os << "GlobalImmutableSpaceRegion"; } void HeapSpaceRegion::dumpToStream(raw_ostream &os) const { os << "HeapSpaceRegion"; } void UnknownSpaceRegion::dumpToStream(raw_ostream &os) const { os << "UnknownSpaceRegion"; } void StackArgumentsSpaceRegion::dumpToStream(raw_ostream &os) const { os << "StackArgumentsSpaceRegion"; } void StackLocalsSpaceRegion::dumpToStream(raw_ostream &os) const { os << "StackLocalsSpaceRegion"; } bool MemRegion::canPrintPretty() const { return canPrintPrettyAsExpr(); } bool MemRegion::canPrintPrettyAsExpr() const { return false; } void MemRegion::printPretty(raw_ostream &os) const { assert(canPrintPretty() && "This region cannot be printed pretty."); os << "'"; printPrettyAsExpr(os); os << "'"; return; } void MemRegion::printPrettyAsExpr(raw_ostream &os) const { llvm_unreachable("This region cannot be printed pretty."); return; } bool VarRegion::canPrintPrettyAsExpr() const { return true; } void VarRegion::printPrettyAsExpr(raw_ostream &os) const { os << getDecl()->getName(); } bool ObjCIvarRegion::canPrintPrettyAsExpr() const { return true; } void ObjCIvarRegion::printPrettyAsExpr(raw_ostream &os) const { os << getDecl()->getName(); } bool FieldRegion::canPrintPretty() const { return true; } bool FieldRegion::canPrintPrettyAsExpr() const { return superRegion->canPrintPrettyAsExpr(); } void FieldRegion::printPrettyAsExpr(raw_ostream &os) const { assert(canPrintPrettyAsExpr()); superRegion->printPrettyAsExpr(os); os << "." << getDecl()->getName(); } void FieldRegion::printPretty(raw_ostream &os) const { if (canPrintPrettyAsExpr()) { os << "\'"; printPrettyAsExpr(os); os << "'"; } else { os << "field " << "\'" << getDecl()->getName() << "'"; } return; } bool CXXBaseObjectRegion::canPrintPrettyAsExpr() const { return superRegion->canPrintPrettyAsExpr(); } void CXXBaseObjectRegion::printPrettyAsExpr(raw_ostream &os) const { superRegion->printPrettyAsExpr(os); } //===----------------------------------------------------------------------===// // MemRegionManager methods. //===----------------------------------------------------------------------===// template const REG *MemRegionManager::LazyAllocate(REG*& region) { if (!region) { region = (REG*) A.Allocate(); new (region) REG(this); } return region; } template const REG *MemRegionManager::LazyAllocate(REG*& region, ARG a) { if (!region) { region = (REG*) A.Allocate(); new (region) REG(this, a); } return region; } const StackLocalsSpaceRegion* MemRegionManager::getStackLocalsRegion(const StackFrameContext *STC) { assert(STC); StackLocalsSpaceRegion *&R = StackLocalsSpaceRegions[STC]; if (R) return R; R = A.Allocate(); new (R) StackLocalsSpaceRegion(this, STC); return R; } const StackArgumentsSpaceRegion * MemRegionManager::getStackArgumentsRegion(const StackFrameContext *STC) { assert(STC); StackArgumentsSpaceRegion *&R = StackArgumentsSpaceRegions[STC]; if (R) return R; R = A.Allocate(); new (R) StackArgumentsSpaceRegion(this, STC); return R; } const GlobalsSpaceRegion *MemRegionManager::getGlobalsRegion(MemRegion::Kind K, const CodeTextRegion *CR) { if (!CR) { if (K == MemRegion::GlobalSystemSpaceRegionKind) return LazyAllocate(SystemGlobals); if (K == MemRegion::GlobalImmutableSpaceRegionKind) return LazyAllocate(ImmutableGlobals); assert(K == MemRegion::GlobalInternalSpaceRegionKind); return LazyAllocate(InternalGlobals); } assert(K == MemRegion::StaticGlobalSpaceRegionKind); StaticGlobalSpaceRegion *&R = StaticsGlobalSpaceRegions[CR]; if (R) return R; R = A.Allocate(); new (R) StaticGlobalSpaceRegion(this, CR); return R; } const HeapSpaceRegion *MemRegionManager::getHeapRegion() { return LazyAllocate(heap); } const MemSpaceRegion *MemRegionManager::getUnknownRegion() { return LazyAllocate(unknown); } const MemSpaceRegion *MemRegionManager::getCodeRegion() { return LazyAllocate(code); } //===----------------------------------------------------------------------===// // Constructing regions. //===----------------------------------------------------------------------===// const StringRegion* MemRegionManager::getStringRegion(const StringLiteral* Str){ return getSubRegion(Str, getGlobalsRegion()); } const ObjCStringRegion * MemRegionManager::getObjCStringRegion(const ObjCStringLiteral* Str){ return getSubRegion(Str, getGlobalsRegion()); } /// Look through a chain of LocationContexts to either find the /// StackFrameContext that matches a DeclContext, or find a VarRegion /// for a variable captured by a block. static llvm::PointerUnion getStackOrCaptureRegionForDeclContext(const LocationContext *LC, const DeclContext *DC, const VarDecl *VD) { while (LC) { if (const StackFrameContext *SFC = dyn_cast(LC)) { if (cast(SFC->getDecl()) == DC) return SFC; } if (const BlockInvocationContext *BC = dyn_cast(LC)) { const BlockDataRegion *BR = static_cast(BC->getContextData()); // FIXME: This can be made more efficient. for (BlockDataRegion::referenced_vars_iterator I = BR->referenced_vars_begin(), E = BR->referenced_vars_end(); I != E; ++I) { if (const VarRegion *VR = dyn_cast(I.getOriginalRegion())) if (VR->getDecl() == VD) return cast(I.getCapturedRegion()); } } LC = LC->getParent(); } return (const StackFrameContext*)0; } const VarRegion* MemRegionManager::getVarRegion(const VarDecl *D, const LocationContext *LC) { const MemRegion *sReg = 0; if (D->hasGlobalStorage() && !D->isStaticLocal()) { // First handle the globals defined in system headers. if (C.getSourceManager().isInSystemHeader(D->getLocation())) { // Whitelist the system globals which often DO GET modified, assume the // rest are immutable. if (D->getName().find("errno") != StringRef::npos) sReg = getGlobalsRegion(MemRegion::GlobalSystemSpaceRegionKind); else sReg = getGlobalsRegion(MemRegion::GlobalImmutableSpaceRegionKind); // Treat other globals as GlobalInternal unless they are constants. } else { QualType GQT = D->getType(); const Type *GT = GQT.getTypePtrOrNull(); // TODO: We could walk the complex types here and see if everything is // constified. if (GT && GQT.isConstQualified() && GT->isArithmeticType()) sReg = getGlobalsRegion(MemRegion::GlobalImmutableSpaceRegionKind); else sReg = getGlobalsRegion(); } // Finally handle static locals. } else { // FIXME: Once we implement scope handling, we will need to properly lookup // 'D' to the proper LocationContext. const DeclContext *DC = D->getDeclContext(); llvm::PointerUnion V = getStackOrCaptureRegionForDeclContext(LC, DC, D); if (V.is()) return V.get(); const StackFrameContext *STC = V.get(); if (!STC) sReg = getUnknownRegion(); else { if (D->hasLocalStorage()) { sReg = isa(D) || isa(D) ? static_cast(getStackArgumentsRegion(STC)) : static_cast(getStackLocalsRegion(STC)); } else { assert(D->isStaticLocal()); const Decl *STCD = STC->getDecl(); if (isa(STCD) || isa(STCD)) sReg = getGlobalsRegion(MemRegion::StaticGlobalSpaceRegionKind, getFunctionTextRegion(cast(STCD))); else if (const BlockDecl *BD = dyn_cast(STCD)) { // FIXME: The fallback type here is totally bogus -- though it should // never be queried, it will prevent uniquing with the real // BlockTextRegion. Ideally we'd fix the AST so that we always had a // signature. QualType T; if (const TypeSourceInfo *TSI = BD->getSignatureAsWritten()) T = TSI->getType(); else T = getContext().getFunctionNoProtoType(getContext().VoidTy); const BlockTextRegion *BTR = getBlockTextRegion(BD, C.getCanonicalType(T), STC->getAnalysisDeclContext()); sReg = getGlobalsRegion(MemRegion::StaticGlobalSpaceRegionKind, BTR); } else { sReg = getGlobalsRegion(); } } } } return getSubRegion(D, sReg); } const VarRegion *MemRegionManager::getVarRegion(const VarDecl *D, const MemRegion *superR) { return getSubRegion(D, superR); } const BlockDataRegion * MemRegionManager::getBlockDataRegion(const BlockTextRegion *BC, const LocationContext *LC, unsigned blockCount) { const MemRegion *sReg = 0; const BlockDecl *BD = BC->getDecl(); if (!BD->hasCaptures()) { // This handles 'static' blocks. sReg = getGlobalsRegion(MemRegion::GlobalImmutableSpaceRegionKind); } else { if (LC) { // FIXME: Once we implement scope handling, we want the parent region // to be the scope. const StackFrameContext *STC = LC->getCurrentStackFrame(); assert(STC); sReg = getStackLocalsRegion(STC); } else { // We allow 'LC' to be NULL for cases where want BlockDataRegions // without context-sensitivity. sReg = getUnknownRegion(); } } return getSubRegion(BC, LC, blockCount, sReg); } const CXXTempObjectRegion * MemRegionManager::getCXXStaticTempObjectRegion(const Expr *Ex) { return getSubRegion( Ex, getGlobalsRegion(MemRegion::GlobalInternalSpaceRegionKind, NULL)); } const CompoundLiteralRegion* MemRegionManager::getCompoundLiteralRegion(const CompoundLiteralExpr *CL, const LocationContext *LC) { const MemRegion *sReg = 0; if (CL->isFileScope()) sReg = getGlobalsRegion(); else { const StackFrameContext *STC = LC->getCurrentStackFrame(); assert(STC); sReg = getStackLocalsRegion(STC); } return getSubRegion(CL, sReg); } const ElementRegion* MemRegionManager::getElementRegion(QualType elementType, NonLoc Idx, const MemRegion* superRegion, ASTContext &Ctx){ QualType T = Ctx.getCanonicalType(elementType).getUnqualifiedType(); llvm::FoldingSetNodeID ID; ElementRegion::ProfileRegion(ID, T, Idx, superRegion); void *InsertPos; MemRegion* data = Regions.FindNodeOrInsertPos(ID, InsertPos); ElementRegion* R = cast_or_null(data); if (!R) { R = (ElementRegion*) A.Allocate(); new (R) ElementRegion(T, Idx, superRegion); Regions.InsertNode(R, InsertPos); } return R; } const FunctionTextRegion * MemRegionManager::getFunctionTextRegion(const NamedDecl *FD) { return getSubRegion(FD, getCodeRegion()); } const BlockTextRegion * MemRegionManager::getBlockTextRegion(const BlockDecl *BD, CanQualType locTy, AnalysisDeclContext *AC) { return getSubRegion(BD, locTy, AC, getCodeRegion()); } /// getSymbolicRegion - Retrieve or create a "symbolic" memory region. const SymbolicRegion *MemRegionManager::getSymbolicRegion(SymbolRef sym) { return getSubRegion(sym, getUnknownRegion()); } const SymbolicRegion *MemRegionManager::getSymbolicHeapRegion(SymbolRef Sym) { return getSubRegion(Sym, getHeapRegion()); } const FieldRegion* MemRegionManager::getFieldRegion(const FieldDecl *d, const MemRegion* superRegion){ return getSubRegion(d, superRegion); } const ObjCIvarRegion* MemRegionManager::getObjCIvarRegion(const ObjCIvarDecl *d, const MemRegion* superRegion) { return getSubRegion(d, superRegion); } const CXXTempObjectRegion* MemRegionManager::getCXXTempObjectRegion(Expr const *E, LocationContext const *LC) { const StackFrameContext *SFC = LC->getCurrentStackFrame(); assert(SFC); return getSubRegion(E, getStackLocalsRegion(SFC)); } /// Checks whether \p BaseClass is a valid virtual or direct non-virtual base /// class of the type of \p Super. static bool isValidBaseClass(const CXXRecordDecl *BaseClass, const TypedValueRegion *Super, bool IsVirtual) { BaseClass = BaseClass->getCanonicalDecl(); const CXXRecordDecl *Class = Super->getValueType()->getAsCXXRecordDecl(); if (!Class) return true; if (IsVirtual) return Class->isVirtuallyDerivedFrom(BaseClass); for (CXXRecordDecl::base_class_const_iterator I = Class->bases_begin(), E = Class->bases_end(); I != E; ++I) { if (I->getType()->getAsCXXRecordDecl()->getCanonicalDecl() == BaseClass) return true; } return false; } const CXXBaseObjectRegion * MemRegionManager::getCXXBaseObjectRegion(const CXXRecordDecl *RD, const MemRegion *Super, bool IsVirtual) { if (isa(Super)) { assert(isValidBaseClass(RD, dyn_cast(Super), IsVirtual)); (void)&isValidBaseClass; if (IsVirtual) { // Virtual base regions should not be layered, since the layout rules // are different. while (const CXXBaseObjectRegion *Base = dyn_cast(Super)) { Super = Base->getSuperRegion(); } assert(Super && !isa(Super)); } } return getSubRegion(RD, IsVirtual, Super); } const CXXThisRegion* MemRegionManager::getCXXThisRegion(QualType thisPointerTy, const LocationContext *LC) { const StackFrameContext *STC = LC->getCurrentStackFrame(); assert(STC); const PointerType *PT = thisPointerTy->getAs(); assert(PT); return getSubRegion(PT, getStackArgumentsRegion(STC)); } const AllocaRegion* MemRegionManager::getAllocaRegion(const Expr *E, unsigned cnt, const LocationContext *LC) { const StackFrameContext *STC = LC->getCurrentStackFrame(); assert(STC); return getSubRegion(E, cnt, getStackLocalsRegion(STC)); } const MemSpaceRegion *MemRegion::getMemorySpace() const { const MemRegion *R = this; const SubRegion* SR = dyn_cast(this); while (SR) { R = SR->getSuperRegion(); SR = dyn_cast(R); } return dyn_cast(R); } bool MemRegion::hasStackStorage() const { return isa(getMemorySpace()); } bool MemRegion::hasStackNonParametersStorage() const { return isa(getMemorySpace()); } bool MemRegion::hasStackParametersStorage() const { return isa(getMemorySpace()); } bool MemRegion::hasGlobalsOrParametersStorage() const { const MemSpaceRegion *MS = getMemorySpace(); return isa(MS) || isa(MS); } // getBaseRegion strips away all elements and fields, and get the base region // of them. const MemRegion *MemRegion::getBaseRegion() const { const MemRegion *R = this; while (true) { switch (R->getKind()) { case MemRegion::ElementRegionKind: case MemRegion::FieldRegionKind: case MemRegion::ObjCIvarRegionKind: case MemRegion::CXXBaseObjectRegionKind: R = cast(R)->getSuperRegion(); continue; default: break; } break; } return R; } bool MemRegion::isSubRegionOf(const MemRegion *R) const { return false; } //===----------------------------------------------------------------------===// // View handling. //===----------------------------------------------------------------------===// const MemRegion *MemRegion::StripCasts(bool StripBaseCasts) const { const MemRegion *R = this; while (true) { switch (R->getKind()) { case ElementRegionKind: { const ElementRegion *ER = cast(R); if (!ER->getIndex().isZeroConstant()) return R; R = ER->getSuperRegion(); break; } case CXXBaseObjectRegionKind: if (!StripBaseCasts) return R; R = cast(R)->getSuperRegion(); break; default: return R; } } } const SymbolicRegion *MemRegion::getSymbolicBase() const { const SubRegion *SubR = dyn_cast(this); while (SubR) { if (const SymbolicRegion *SymR = dyn_cast(SubR)) return SymR; SubR = dyn_cast(SubR->getSuperRegion()); } return 0; } // FIXME: Merge with the implementation of the same method in Store.cpp static bool IsCompleteType(ASTContext &Ctx, QualType Ty) { if (const RecordType *RT = Ty->getAs()) { const RecordDecl *D = RT->getDecl(); if (!D->getDefinition()) return false; } return true; } RegionRawOffset ElementRegion::getAsArrayOffset() const { CharUnits offset = CharUnits::Zero(); const ElementRegion *ER = this; const MemRegion *superR = NULL; ASTContext &C = getContext(); // FIXME: Handle multi-dimensional arrays. while (ER) { superR = ER->getSuperRegion(); // FIXME: generalize to symbolic offsets. SVal index = ER->getIndex(); if (Optional CI = index.getAs()) { // Update the offset. int64_t i = CI->getValue().getSExtValue(); if (i != 0) { QualType elemType = ER->getElementType(); // If we are pointing to an incomplete type, go no further. if (!IsCompleteType(C, elemType)) { superR = ER; break; } CharUnits size = C.getTypeSizeInChars(elemType); offset += (i * size); } // Go to the next ElementRegion (if any). ER = dyn_cast(superR); continue; } return NULL; } assert(superR && "super region cannot be NULL"); return RegionRawOffset(superR, offset); } /// Returns true if \p Base is an immediate base class of \p Child static bool isImmediateBase(const CXXRecordDecl *Child, const CXXRecordDecl *Base) { // Note that we do NOT canonicalize the base class here, because // ASTRecordLayout doesn't either. If that leads us down the wrong path, // so be it; at least we won't crash. for (CXXRecordDecl::base_class_const_iterator I = Child->bases_begin(), E = Child->bases_end(); I != E; ++I) { if (I->getType()->getAsCXXRecordDecl() == Base) return true; } return false; } RegionOffset MemRegion::getAsOffset() const { const MemRegion *R = this; const MemRegion *SymbolicOffsetBase = 0; int64_t Offset = 0; while (1) { switch (R->getKind()) { case GenericMemSpaceRegionKind: case StackLocalsSpaceRegionKind: case StackArgumentsSpaceRegionKind: case HeapSpaceRegionKind: case UnknownSpaceRegionKind: case StaticGlobalSpaceRegionKind: case GlobalInternalSpaceRegionKind: case GlobalSystemSpaceRegionKind: case GlobalImmutableSpaceRegionKind: // Stores can bind directly to a region space to set a default value. assert(Offset == 0 && !SymbolicOffsetBase); goto Finish; case FunctionTextRegionKind: case BlockTextRegionKind: case BlockDataRegionKind: // These will never have bindings, but may end up having values requested // if the user does some strange casting. if (Offset != 0) SymbolicOffsetBase = R; goto Finish; case SymbolicRegionKind: case AllocaRegionKind: case CompoundLiteralRegionKind: case CXXThisRegionKind: case StringRegionKind: case ObjCStringRegionKind: case VarRegionKind: case CXXTempObjectRegionKind: // Usual base regions. goto Finish; case ObjCIvarRegionKind: // This is a little strange, but it's a compromise between // ObjCIvarRegions having unknown compile-time offsets (when using the // non-fragile runtime) and yet still being distinct, non-overlapping // regions. Thus we treat them as "like" base regions for the purposes // of computing offsets. goto Finish; case CXXBaseObjectRegionKind: { const CXXBaseObjectRegion *BOR = cast(R); R = BOR->getSuperRegion(); QualType Ty; bool RootIsSymbolic = false; if (const TypedValueRegion *TVR = dyn_cast(R)) { Ty = TVR->getDesugaredValueType(getContext()); } else if (const SymbolicRegion *SR = dyn_cast(R)) { // If our base region is symbolic, we don't know what type it really is. // Pretend the type of the symbol is the true dynamic type. // (This will at least be self-consistent for the life of the symbol.) Ty = SR->getSymbol()->getType()->getPointeeType(); RootIsSymbolic = true; } const CXXRecordDecl *Child = Ty->getAsCXXRecordDecl(); if (!Child) { // We cannot compute the offset of the base class. SymbolicOffsetBase = R; } if (RootIsSymbolic) { // Base layers on symbolic regions may not be type-correct. // Double-check the inheritance here, and revert to a symbolic offset // if it's invalid (e.g. due to a reinterpret_cast). if (BOR->isVirtual()) { if (!Child->isVirtuallyDerivedFrom(BOR->getDecl())) SymbolicOffsetBase = R; } else { if (!isImmediateBase(Child, BOR->getDecl())) SymbolicOffsetBase = R; } } // Don't bother calculating precise offsets if we already have a // symbolic offset somewhere in the chain. if (SymbolicOffsetBase) continue; CharUnits BaseOffset; const ASTRecordLayout &Layout = getContext().getASTRecordLayout(Child); if (BOR->isVirtual()) BaseOffset = Layout.getVBaseClassOffset(BOR->getDecl()); else BaseOffset = Layout.getBaseClassOffset(BOR->getDecl()); // The base offset is in chars, not in bits. Offset += BaseOffset.getQuantity() * getContext().getCharWidth(); break; } case ElementRegionKind: { const ElementRegion *ER = cast(R); R = ER->getSuperRegion(); QualType EleTy = ER->getValueType(); if (!IsCompleteType(getContext(), EleTy)) { // We cannot compute the offset of the base class. SymbolicOffsetBase = R; continue; } SVal Index = ER->getIndex(); if (Optional CI = Index.getAs()) { // Don't bother calculating precise offsets if we already have a // symbolic offset somewhere in the chain. if (SymbolicOffsetBase) continue; int64_t i = CI->getValue().getSExtValue(); // This type size is in bits. Offset += i * getContext().getTypeSize(EleTy); } else { // We cannot compute offset for non-concrete index. SymbolicOffsetBase = R; } break; } case FieldRegionKind: { const FieldRegion *FR = cast(R); R = FR->getSuperRegion(); const RecordDecl *RD = FR->getDecl()->getParent(); if (RD->isUnion() || !RD->isCompleteDefinition()) { // We cannot compute offset for incomplete type. // For unions, we could treat everything as offset 0, but we'd rather // treat each field as a symbolic offset so they aren't stored on top // of each other, since we depend on things in typed regions actually // matching their types. SymbolicOffsetBase = R; } // Don't bother calculating precise offsets if we already have a // symbolic offset somewhere in the chain. if (SymbolicOffsetBase) continue; // Get the field number. unsigned idx = 0; for (RecordDecl::field_iterator FI = RD->field_begin(), FE = RD->field_end(); FI != FE; ++FI, ++idx) if (FR->getDecl() == *FI) break; const ASTRecordLayout &Layout = getContext().getASTRecordLayout(RD); // This is offset in bits. Offset += Layout.getFieldOffset(idx); break; } } } Finish: if (SymbolicOffsetBase) return RegionOffset(SymbolicOffsetBase, RegionOffset::Symbolic); return RegionOffset(R, Offset); } //===----------------------------------------------------------------------===// // BlockDataRegion //===----------------------------------------------------------------------===// std::pair BlockDataRegion::getCaptureRegions(const VarDecl *VD) { MemRegionManager &MemMgr = *getMemRegionManager(); const VarRegion *VR = 0; const VarRegion *OriginalVR = 0; if (!VD->hasAttr() && VD->hasLocalStorage()) { VR = MemMgr.getVarRegion(VD, this); OriginalVR = MemMgr.getVarRegion(VD, LC); } else { if (LC) { VR = MemMgr.getVarRegion(VD, LC); OriginalVR = VR; } else { VR = MemMgr.getVarRegion(VD, MemMgr.getUnknownRegion()); OriginalVR = MemMgr.getVarRegion(VD, LC); } } return std::make_pair(VR, OriginalVR); } void BlockDataRegion::LazyInitializeReferencedVars() { if (ReferencedVars) return; AnalysisDeclContext *AC = getCodeRegion()->getAnalysisDeclContext(); AnalysisDeclContext::referenced_decls_iterator I, E; llvm::tie(I, E) = AC->getReferencedBlockVars(BC->getDecl()); if (I == E) { ReferencedVars = (void*) 0x1; return; } MemRegionManager &MemMgr = *getMemRegionManager(); llvm::BumpPtrAllocator &A = MemMgr.getAllocator(); BumpVectorContext BC(A); typedef BumpVector VarVec; VarVec *BV = (VarVec*) A.Allocate(); new (BV) VarVec(BC, E - I); VarVec *BVOriginal = (VarVec*) A.Allocate(); new (BVOriginal) VarVec(BC, E - I); for ( ; I != E; ++I) { const VarRegion *VR = 0; const VarRegion *OriginalVR = 0; llvm::tie(VR, OriginalVR) = getCaptureRegions(*I); assert(VR); assert(OriginalVR); BV->push_back(VR, BC); BVOriginal->push_back(OriginalVR, BC); } ReferencedVars = BV; OriginalVars = BVOriginal; } BlockDataRegion::referenced_vars_iterator BlockDataRegion::referenced_vars_begin() const { const_cast(this)->LazyInitializeReferencedVars(); BumpVector *Vec = static_cast*>(ReferencedVars); if (Vec == (void*) 0x1) return BlockDataRegion::referenced_vars_iterator(0, 0); BumpVector *VecOriginal = static_cast*>(OriginalVars); return BlockDataRegion::referenced_vars_iterator(Vec->begin(), VecOriginal->begin()); } BlockDataRegion::referenced_vars_iterator BlockDataRegion::referenced_vars_end() const { const_cast(this)->LazyInitializeReferencedVars(); BumpVector *Vec = static_cast*>(ReferencedVars); if (Vec == (void*) 0x1) return BlockDataRegion::referenced_vars_iterator(0, 0); BumpVector *VecOriginal = static_cast*>(OriginalVars); return BlockDataRegion::referenced_vars_iterator(Vec->end(), VecOriginal->end()); } const VarRegion *BlockDataRegion::getOriginalRegion(const VarRegion *R) const { for (referenced_vars_iterator I = referenced_vars_begin(), E = referenced_vars_end(); I != E; ++I) { if (I.getCapturedRegion() == R) return I.getOriginalRegion(); } return 0; } //===----------------------------------------------------------------------===// // RegionAndSymbolInvalidationTraits //===----------------------------------------------------------------------===// void RegionAndSymbolInvalidationTraits::setTrait(SymbolRef Sym, InvalidationKinds IK) { SymTraitsMap[Sym] |= IK; } void RegionAndSymbolInvalidationTraits::setTrait(const MemRegion *MR, InvalidationKinds IK) { assert(MR); if (const SymbolicRegion *SR = dyn_cast(MR)) setTrait(SR->getSymbol(), IK); else MRTraitsMap[MR] |= IK; } bool RegionAndSymbolInvalidationTraits::hasTrait(SymbolRef Sym, InvalidationKinds IK) { const_symbol_iterator I = SymTraitsMap.find(Sym); if (I != SymTraitsMap.end()) return I->second & IK; return false; } bool RegionAndSymbolInvalidationTraits::hasTrait(const MemRegion *MR, InvalidationKinds IK) { if (!MR) return false; if (const SymbolicRegion *SR = dyn_cast(MR)) return hasTrait(SR->getSymbol(), IK); const_region_iterator I = MRTraitsMap.find(MR); if (I != MRTraitsMap.end()) return I->second & IK; return false; } @