MemRegion.cpp revision 8ef064d53fb33b5a8f8743bcbb0a2fd5c3e97be1
1//== MemRegion.cpp - Abstract memory regions for static analysis --*- C++ -*--// 2// 3// The LLVM Compiler Infrastructure 4// 5// This file is distributed under the University of Illinois Open Source 6// License. See LICENSE.TXT for details. 7// 8//===----------------------------------------------------------------------===// 9// 10// This file defines MemRegion and its subclasses. MemRegion defines a 11// partially-typed abstraction of memory useful for path-sensitive dataflow 12// analyses. 13// 14//===----------------------------------------------------------------------===// 15 16#include "clang/StaticAnalyzer/Core/PathSensitive/MemRegion.h" 17#include "clang/AST/Attr.h" 18#include "clang/AST/CharUnits.h" 19#include "clang/AST/DeclObjC.h" 20#include "clang/AST/RecordLayout.h" 21#include "clang/Analysis/AnalysisContext.h" 22#include "clang/Analysis/Support/BumpVector.h" 23#include "clang/Basic/SourceManager.h" 24#include "clang/StaticAnalyzer/Core/PathSensitive/SValBuilder.h" 25#include "llvm/Support/raw_ostream.h" 26 27using namespace clang; 28using namespace ento; 29 30//===----------------------------------------------------------------------===// 31// MemRegion Construction. 32//===----------------------------------------------------------------------===// 33 34template<typename RegionTy> struct MemRegionManagerTrait; 35 36template <typename RegionTy, typename A1> 37RegionTy* MemRegionManager::getRegion(const A1 a1) { 38 39 const typename MemRegionManagerTrait<RegionTy>::SuperRegionTy *superRegion = 40 MemRegionManagerTrait<RegionTy>::getSuperRegion(*this, a1); 41 42 llvm::FoldingSetNodeID ID; 43 RegionTy::ProfileRegion(ID, a1, superRegion); 44 void *InsertPos; 45 RegionTy* R = cast_or_null<RegionTy>(Regions.FindNodeOrInsertPos(ID, 46 InsertPos)); 47 48 if (!R) { 49 R = (RegionTy*) A.Allocate<RegionTy>(); 50 new (R) RegionTy(a1, superRegion); 51 Regions.InsertNode(R, InsertPos); 52 } 53 54 return R; 55} 56 57template <typename RegionTy, typename A1> 58RegionTy* MemRegionManager::getSubRegion(const A1 a1, 59 const MemRegion *superRegion) { 60 llvm::FoldingSetNodeID ID; 61 RegionTy::ProfileRegion(ID, a1, superRegion); 62 void *InsertPos; 63 RegionTy* R = cast_or_null<RegionTy>(Regions.FindNodeOrInsertPos(ID, 64 InsertPos)); 65 66 if (!R) { 67 R = (RegionTy*) A.Allocate<RegionTy>(); 68 new (R) RegionTy(a1, superRegion); 69 Regions.InsertNode(R, InsertPos); 70 } 71 72 return R; 73} 74 75template <typename RegionTy, typename A1, typename A2> 76RegionTy* MemRegionManager::getRegion(const A1 a1, const A2 a2) { 77 78 const typename MemRegionManagerTrait<RegionTy>::SuperRegionTy *superRegion = 79 MemRegionManagerTrait<RegionTy>::getSuperRegion(*this, a1, a2); 80 81 llvm::FoldingSetNodeID ID; 82 RegionTy::ProfileRegion(ID, a1, a2, superRegion); 83 void *InsertPos; 84 RegionTy* R = cast_or_null<RegionTy>(Regions.FindNodeOrInsertPos(ID, 85 InsertPos)); 86 87 if (!R) { 88 R = (RegionTy*) A.Allocate<RegionTy>(); 89 new (R) RegionTy(a1, a2, superRegion); 90 Regions.InsertNode(R, InsertPos); 91 } 92 93 return R; 94} 95 96template <typename RegionTy, typename A1, typename A2> 97RegionTy* MemRegionManager::getSubRegion(const A1 a1, const A2 a2, 98 const MemRegion *superRegion) { 99 100 llvm::FoldingSetNodeID ID; 101 RegionTy::ProfileRegion(ID, a1, a2, superRegion); 102 void *InsertPos; 103 RegionTy* R = cast_or_null<RegionTy>(Regions.FindNodeOrInsertPos(ID, 104 InsertPos)); 105 106 if (!R) { 107 R = (RegionTy*) A.Allocate<RegionTy>(); 108 new (R) RegionTy(a1, a2, superRegion); 109 Regions.InsertNode(R, InsertPos); 110 } 111 112 return R; 113} 114 115template <typename RegionTy, typename A1, typename A2, typename A3> 116RegionTy* MemRegionManager::getSubRegion(const A1 a1, const A2 a2, const A3 a3, 117 const MemRegion *superRegion) { 118 119 llvm::FoldingSetNodeID ID; 120 RegionTy::ProfileRegion(ID, a1, a2, a3, superRegion); 121 void *InsertPos; 122 RegionTy* R = cast_or_null<RegionTy>(Regions.FindNodeOrInsertPos(ID, 123 InsertPos)); 124 125 if (!R) { 126 R = (RegionTy*) A.Allocate<RegionTy>(); 127 new (R) RegionTy(a1, a2, a3, superRegion); 128 Regions.InsertNode(R, InsertPos); 129 } 130 131 return R; 132} 133 134//===----------------------------------------------------------------------===// 135// Object destruction. 136//===----------------------------------------------------------------------===// 137 138MemRegion::~MemRegion() {} 139 140MemRegionManager::~MemRegionManager() { 141 // All regions and their data are BumpPtrAllocated. No need to call 142 // their destructors. 143} 144 145//===----------------------------------------------------------------------===// 146// Basic methods. 147//===----------------------------------------------------------------------===// 148 149bool SubRegion::isSubRegionOf(const MemRegion* R) const { 150 const MemRegion* r = getSuperRegion(); 151 while (r != 0) { 152 if (r == R) 153 return true; 154 if (const SubRegion* sr = dyn_cast<SubRegion>(r)) 155 r = sr->getSuperRegion(); 156 else 157 break; 158 } 159 return false; 160} 161 162MemRegionManager* SubRegion::getMemRegionManager() const { 163 const SubRegion* r = this; 164 do { 165 const MemRegion *superRegion = r->getSuperRegion(); 166 if (const SubRegion *sr = dyn_cast<SubRegion>(superRegion)) { 167 r = sr; 168 continue; 169 } 170 return superRegion->getMemRegionManager(); 171 } while (1); 172} 173 174const StackFrameContext *VarRegion::getStackFrame() const { 175 const StackSpaceRegion *SSR = dyn_cast<StackSpaceRegion>(getMemorySpace()); 176 return SSR ? SSR->getStackFrame() : NULL; 177} 178 179//===----------------------------------------------------------------------===// 180// Region extents. 181//===----------------------------------------------------------------------===// 182 183DefinedOrUnknownSVal TypedValueRegion::getExtent(SValBuilder &svalBuilder) const { 184 ASTContext &Ctx = svalBuilder.getContext(); 185 QualType T = getDesugaredValueType(Ctx); 186 187 if (isa<VariableArrayType>(T)) 188 return nonloc::SymbolVal(svalBuilder.getSymbolManager().getExtentSymbol(this)); 189 if (isa<IncompleteArrayType>(T)) 190 return UnknownVal(); 191 192 CharUnits size = Ctx.getTypeSizeInChars(T); 193 QualType sizeTy = svalBuilder.getArrayIndexType(); 194 return svalBuilder.makeIntVal(size.getQuantity(), sizeTy); 195} 196 197DefinedOrUnknownSVal FieldRegion::getExtent(SValBuilder &svalBuilder) const { 198 // Force callers to deal with bitfields explicitly. 199 if (getDecl()->isBitField()) 200 return UnknownVal(); 201 202 DefinedOrUnknownSVal Extent = DeclRegion::getExtent(svalBuilder); 203 204 // A zero-length array at the end of a struct often stands for dynamically- 205 // allocated extra memory. 206 if (Extent.isZeroConstant()) { 207 QualType T = getDesugaredValueType(svalBuilder.getContext()); 208 209 if (isa<ConstantArrayType>(T)) 210 return UnknownVal(); 211 } 212 213 return Extent; 214} 215 216DefinedOrUnknownSVal AllocaRegion::getExtent(SValBuilder &svalBuilder) const { 217 return nonloc::SymbolVal(svalBuilder.getSymbolManager().getExtentSymbol(this)); 218} 219 220DefinedOrUnknownSVal SymbolicRegion::getExtent(SValBuilder &svalBuilder) const { 221 return nonloc::SymbolVal(svalBuilder.getSymbolManager().getExtentSymbol(this)); 222} 223 224DefinedOrUnknownSVal StringRegion::getExtent(SValBuilder &svalBuilder) const { 225 return svalBuilder.makeIntVal(getStringLiteral()->getByteLength()+1, 226 svalBuilder.getArrayIndexType()); 227} 228 229ObjCIvarRegion::ObjCIvarRegion(const ObjCIvarDecl *ivd, const MemRegion* sReg) 230 : DeclRegion(ivd, sReg, ObjCIvarRegionKind) {} 231 232const ObjCIvarDecl *ObjCIvarRegion::getDecl() const { 233 return cast<ObjCIvarDecl>(D); 234} 235 236QualType ObjCIvarRegion::getValueType() const { 237 return getDecl()->getType(); 238} 239 240QualType CXXBaseObjectRegion::getValueType() const { 241 return QualType(getDecl()->getTypeForDecl(), 0); 242} 243 244//===----------------------------------------------------------------------===// 245// FoldingSet profiling. 246//===----------------------------------------------------------------------===// 247 248void MemSpaceRegion::Profile(llvm::FoldingSetNodeID& ID) const { 249 ID.AddInteger((unsigned)getKind()); 250} 251 252void StackSpaceRegion::Profile(llvm::FoldingSetNodeID &ID) const { 253 ID.AddInteger((unsigned)getKind()); 254 ID.AddPointer(getStackFrame()); 255} 256 257void StaticGlobalSpaceRegion::Profile(llvm::FoldingSetNodeID &ID) const { 258 ID.AddInteger((unsigned)getKind()); 259 ID.AddPointer(getCodeRegion()); 260} 261 262void StringRegion::ProfileRegion(llvm::FoldingSetNodeID& ID, 263 const StringLiteral* Str, 264 const MemRegion* superRegion) { 265 ID.AddInteger((unsigned) StringRegionKind); 266 ID.AddPointer(Str); 267 ID.AddPointer(superRegion); 268} 269 270void ObjCStringRegion::ProfileRegion(llvm::FoldingSetNodeID& ID, 271 const ObjCStringLiteral* Str, 272 const MemRegion* superRegion) { 273 ID.AddInteger((unsigned) ObjCStringRegionKind); 274 ID.AddPointer(Str); 275 ID.AddPointer(superRegion); 276} 277 278void AllocaRegion::ProfileRegion(llvm::FoldingSetNodeID& ID, 279 const Expr *Ex, unsigned cnt, 280 const MemRegion *superRegion) { 281 ID.AddInteger((unsigned) AllocaRegionKind); 282 ID.AddPointer(Ex); 283 ID.AddInteger(cnt); 284 ID.AddPointer(superRegion); 285} 286 287void AllocaRegion::Profile(llvm::FoldingSetNodeID& ID) const { 288 ProfileRegion(ID, Ex, Cnt, superRegion); 289} 290 291void CompoundLiteralRegion::Profile(llvm::FoldingSetNodeID& ID) const { 292 CompoundLiteralRegion::ProfileRegion(ID, CL, superRegion); 293} 294 295void CompoundLiteralRegion::ProfileRegion(llvm::FoldingSetNodeID& ID, 296 const CompoundLiteralExpr *CL, 297 const MemRegion* superRegion) { 298 ID.AddInteger((unsigned) CompoundLiteralRegionKind); 299 ID.AddPointer(CL); 300 ID.AddPointer(superRegion); 301} 302 303void CXXThisRegion::ProfileRegion(llvm::FoldingSetNodeID &ID, 304 const PointerType *PT, 305 const MemRegion *sRegion) { 306 ID.AddInteger((unsigned) CXXThisRegionKind); 307 ID.AddPointer(PT); 308 ID.AddPointer(sRegion); 309} 310 311void CXXThisRegion::Profile(llvm::FoldingSetNodeID &ID) const { 312 CXXThisRegion::ProfileRegion(ID, ThisPointerTy, superRegion); 313} 314 315void ObjCIvarRegion::ProfileRegion(llvm::FoldingSetNodeID& ID, 316 const ObjCIvarDecl *ivd, 317 const MemRegion* superRegion) { 318 DeclRegion::ProfileRegion(ID, ivd, superRegion, ObjCIvarRegionKind); 319} 320 321void DeclRegion::ProfileRegion(llvm::FoldingSetNodeID& ID, const Decl *D, 322 const MemRegion* superRegion, Kind k) { 323 ID.AddInteger((unsigned) k); 324 ID.AddPointer(D); 325 ID.AddPointer(superRegion); 326} 327 328void DeclRegion::Profile(llvm::FoldingSetNodeID& ID) const { 329 DeclRegion::ProfileRegion(ID, D, superRegion, getKind()); 330} 331 332void VarRegion::Profile(llvm::FoldingSetNodeID &ID) const { 333 VarRegion::ProfileRegion(ID, getDecl(), superRegion); 334} 335 336void SymbolicRegion::ProfileRegion(llvm::FoldingSetNodeID& ID, SymbolRef sym, 337 const MemRegion *sreg) { 338 ID.AddInteger((unsigned) MemRegion::SymbolicRegionKind); 339 ID.Add(sym); 340 ID.AddPointer(sreg); 341} 342 343void SymbolicRegion::Profile(llvm::FoldingSetNodeID& ID) const { 344 SymbolicRegion::ProfileRegion(ID, sym, getSuperRegion()); 345} 346 347void ElementRegion::ProfileRegion(llvm::FoldingSetNodeID& ID, 348 QualType ElementType, SVal Idx, 349 const MemRegion* superRegion) { 350 ID.AddInteger(MemRegion::ElementRegionKind); 351 ID.Add(ElementType); 352 ID.AddPointer(superRegion); 353 Idx.Profile(ID); 354} 355 356void ElementRegion::Profile(llvm::FoldingSetNodeID& ID) const { 357 ElementRegion::ProfileRegion(ID, ElementType, Index, superRegion); 358} 359 360void FunctionTextRegion::ProfileRegion(llvm::FoldingSetNodeID& ID, 361 const NamedDecl *FD, 362 const MemRegion*) { 363 ID.AddInteger(MemRegion::FunctionTextRegionKind); 364 ID.AddPointer(FD); 365} 366 367void FunctionTextRegion::Profile(llvm::FoldingSetNodeID& ID) const { 368 FunctionTextRegion::ProfileRegion(ID, FD, superRegion); 369} 370 371void BlockTextRegion::ProfileRegion(llvm::FoldingSetNodeID& ID, 372 const BlockDecl *BD, CanQualType, 373 const AnalysisDeclContext *AC, 374 const MemRegion*) { 375 ID.AddInteger(MemRegion::BlockTextRegionKind); 376 ID.AddPointer(BD); 377} 378 379void BlockTextRegion::Profile(llvm::FoldingSetNodeID& ID) const { 380 BlockTextRegion::ProfileRegion(ID, BD, locTy, AC, superRegion); 381} 382 383void BlockDataRegion::ProfileRegion(llvm::FoldingSetNodeID& ID, 384 const BlockTextRegion *BC, 385 const LocationContext *LC, 386 const MemRegion *sReg) { 387 ID.AddInteger(MemRegion::BlockDataRegionKind); 388 ID.AddPointer(BC); 389 ID.AddPointer(LC); 390 ID.AddPointer(sReg); 391} 392 393void BlockDataRegion::Profile(llvm::FoldingSetNodeID& ID) const { 394 BlockDataRegion::ProfileRegion(ID, BC, LC, getSuperRegion()); 395} 396 397void CXXTempObjectRegion::ProfileRegion(llvm::FoldingSetNodeID &ID, 398 Expr const *Ex, 399 const MemRegion *sReg) { 400 ID.AddPointer(Ex); 401 ID.AddPointer(sReg); 402} 403 404void CXXTempObjectRegion::Profile(llvm::FoldingSetNodeID &ID) const { 405 ProfileRegion(ID, Ex, getSuperRegion()); 406} 407 408void CXXBaseObjectRegion::ProfileRegion(llvm::FoldingSetNodeID &ID, 409 const CXXRecordDecl *RD, 410 bool IsVirtual, 411 const MemRegion *SReg) { 412 ID.AddPointer(RD); 413 ID.AddBoolean(IsVirtual); 414 ID.AddPointer(SReg); 415} 416 417void CXXBaseObjectRegion::Profile(llvm::FoldingSetNodeID &ID) const { 418 ProfileRegion(ID, getDecl(), isVirtual(), superRegion); 419} 420 421//===----------------------------------------------------------------------===// 422// Region anchors. 423//===----------------------------------------------------------------------===// 424 425void GlobalsSpaceRegion::anchor() { } 426void HeapSpaceRegion::anchor() { } 427void UnknownSpaceRegion::anchor() { } 428void StackLocalsSpaceRegion::anchor() { } 429void StackArgumentsSpaceRegion::anchor() { } 430void TypedRegion::anchor() { } 431void TypedValueRegion::anchor() { } 432void CodeTextRegion::anchor() { } 433void SubRegion::anchor() { } 434 435//===----------------------------------------------------------------------===// 436// Region pretty-printing. 437//===----------------------------------------------------------------------===// 438 439void MemRegion::dump() const { 440 dumpToStream(llvm::errs()); 441} 442 443std::string MemRegion::getString() const { 444 std::string s; 445 llvm::raw_string_ostream os(s); 446 dumpToStream(os); 447 return os.str(); 448} 449 450void MemRegion::dumpToStream(raw_ostream &os) const { 451 os << "<Unknown Region>"; 452} 453 454void AllocaRegion::dumpToStream(raw_ostream &os) const { 455 os << "alloca{" << (const void*) Ex << ',' << Cnt << '}'; 456} 457 458void FunctionTextRegion::dumpToStream(raw_ostream &os) const { 459 os << "code{" << getDecl()->getDeclName().getAsString() << '}'; 460} 461 462void BlockTextRegion::dumpToStream(raw_ostream &os) const { 463 os << "block_code{" << (const void*) this << '}'; 464} 465 466void BlockDataRegion::dumpToStream(raw_ostream &os) const { 467 os << "block_data{" << BC << '}'; 468} 469 470void CompoundLiteralRegion::dumpToStream(raw_ostream &os) const { 471 // FIXME: More elaborate pretty-printing. 472 os << "{ " << (const void*) CL << " }"; 473} 474 475void CXXTempObjectRegion::dumpToStream(raw_ostream &os) const { 476 os << "temp_object{" << getValueType().getAsString() << ',' 477 << (const void*) Ex << '}'; 478} 479 480void CXXBaseObjectRegion::dumpToStream(raw_ostream &os) const { 481 os << "base{" << superRegion << ',' << getDecl()->getName() << '}'; 482} 483 484void CXXThisRegion::dumpToStream(raw_ostream &os) const { 485 os << "this"; 486} 487 488void ElementRegion::dumpToStream(raw_ostream &os) const { 489 os << "element{" << superRegion << ',' 490 << Index << ',' << getElementType().getAsString() << '}'; 491} 492 493void FieldRegion::dumpToStream(raw_ostream &os) const { 494 os << superRegion << "->" << *getDecl(); 495} 496 497void ObjCIvarRegion::dumpToStream(raw_ostream &os) const { 498 os << "ivar{" << superRegion << ',' << *getDecl() << '}'; 499} 500 501void StringRegion::dumpToStream(raw_ostream &os) const { 502 Str->printPretty(os, 0, PrintingPolicy(getContext().getLangOpts())); 503} 504 505void ObjCStringRegion::dumpToStream(raw_ostream &os) const { 506 Str->printPretty(os, 0, PrintingPolicy(getContext().getLangOpts())); 507} 508 509void SymbolicRegion::dumpToStream(raw_ostream &os) const { 510 os << "SymRegion{" << sym << '}'; 511} 512 513void VarRegion::dumpToStream(raw_ostream &os) const { 514 os << *cast<VarDecl>(D); 515} 516 517void RegionRawOffset::dump() const { 518 dumpToStream(llvm::errs()); 519} 520 521void RegionRawOffset::dumpToStream(raw_ostream &os) const { 522 os << "raw_offset{" << getRegion() << ',' << getOffset().getQuantity() << '}'; 523} 524 525void StaticGlobalSpaceRegion::dumpToStream(raw_ostream &os) const { 526 os << "StaticGlobalsMemSpace{" << CR << '}'; 527} 528 529void GlobalInternalSpaceRegion::dumpToStream(raw_ostream &os) const { 530 os << "GlobalInternalSpaceRegion"; 531} 532 533void GlobalSystemSpaceRegion::dumpToStream(raw_ostream &os) const { 534 os << "GlobalSystemSpaceRegion"; 535} 536 537void GlobalImmutableSpaceRegion::dumpToStream(raw_ostream &os) const { 538 os << "GlobalImmutableSpaceRegion"; 539} 540 541void HeapSpaceRegion::dumpToStream(raw_ostream &os) const { 542 os << "HeapSpaceRegion"; 543} 544 545void UnknownSpaceRegion::dumpToStream(raw_ostream &os) const { 546 os << "UnknownSpaceRegion"; 547} 548 549void StackArgumentsSpaceRegion::dumpToStream(raw_ostream &os) const { 550 os << "StackArgumentsSpaceRegion"; 551} 552 553void StackLocalsSpaceRegion::dumpToStream(raw_ostream &os) const { 554 os << "StackLocalsSpaceRegion"; 555} 556 557bool MemRegion::canPrintPretty() const { 558 return canPrintPrettyAsExpr(); 559} 560 561bool MemRegion::canPrintPrettyAsExpr() const { 562 return false; 563} 564 565void MemRegion::printPretty(raw_ostream &os) const { 566 assert(canPrintPretty() && "This region cannot be printed pretty."); 567 os << "'"; 568 printPrettyAsExpr(os); 569 os << "'"; 570 return; 571} 572 573void MemRegion::printPrettyAsExpr(raw_ostream &os) const { 574 llvm_unreachable("This region cannot be printed pretty."); 575 return; 576} 577 578bool VarRegion::canPrintPrettyAsExpr() const { 579 return true; 580} 581 582void VarRegion::printPrettyAsExpr(raw_ostream &os) const { 583 os << getDecl()->getName(); 584} 585 586bool ObjCIvarRegion::canPrintPrettyAsExpr() const { 587 return true; 588} 589 590void ObjCIvarRegion::printPrettyAsExpr(raw_ostream &os) const { 591 os << getDecl()->getName(); 592} 593 594bool FieldRegion::canPrintPretty() const { 595 return true; 596} 597 598bool FieldRegion::canPrintPrettyAsExpr() const { 599 return superRegion->canPrintPrettyAsExpr(); 600} 601 602void FieldRegion::printPrettyAsExpr(raw_ostream &os) const { 603 assert(canPrintPrettyAsExpr()); 604 superRegion->printPrettyAsExpr(os); 605 os << "." << getDecl()->getName(); 606} 607 608void FieldRegion::printPretty(raw_ostream &os) const { 609 if (canPrintPrettyAsExpr()) { 610 os << "\'"; 611 printPrettyAsExpr(os); 612 os << "'"; 613 } else { 614 os << "field " << "\'" << getDecl()->getName() << "'"; 615 } 616 return; 617} 618 619bool CXXBaseObjectRegion::canPrintPrettyAsExpr() const { 620 return superRegion->canPrintPrettyAsExpr(); 621} 622 623void CXXBaseObjectRegion::printPrettyAsExpr(raw_ostream &os) const { 624 superRegion->printPrettyAsExpr(os); 625} 626 627//===----------------------------------------------------------------------===// 628// MemRegionManager methods. 629//===----------------------------------------------------------------------===// 630 631template <typename REG> 632const REG *MemRegionManager::LazyAllocate(REG*& region) { 633 if (!region) { 634 region = (REG*) A.Allocate<REG>(); 635 new (region) REG(this); 636 } 637 638 return region; 639} 640 641template <typename REG, typename ARG> 642const REG *MemRegionManager::LazyAllocate(REG*& region, ARG a) { 643 if (!region) { 644 region = (REG*) A.Allocate<REG>(); 645 new (region) REG(this, a); 646 } 647 648 return region; 649} 650 651const StackLocalsSpaceRegion* 652MemRegionManager::getStackLocalsRegion(const StackFrameContext *STC) { 653 assert(STC); 654 StackLocalsSpaceRegion *&R = StackLocalsSpaceRegions[STC]; 655 656 if (R) 657 return R; 658 659 R = A.Allocate<StackLocalsSpaceRegion>(); 660 new (R) StackLocalsSpaceRegion(this, STC); 661 return R; 662} 663 664const StackArgumentsSpaceRegion * 665MemRegionManager::getStackArgumentsRegion(const StackFrameContext *STC) { 666 assert(STC); 667 StackArgumentsSpaceRegion *&R = StackArgumentsSpaceRegions[STC]; 668 669 if (R) 670 return R; 671 672 R = A.Allocate<StackArgumentsSpaceRegion>(); 673 new (R) StackArgumentsSpaceRegion(this, STC); 674 return R; 675} 676 677const GlobalsSpaceRegion 678*MemRegionManager::getGlobalsRegion(MemRegion::Kind K, 679 const CodeTextRegion *CR) { 680 if (!CR) { 681 if (K == MemRegion::GlobalSystemSpaceRegionKind) 682 return LazyAllocate(SystemGlobals); 683 if (K == MemRegion::GlobalImmutableSpaceRegionKind) 684 return LazyAllocate(ImmutableGlobals); 685 assert(K == MemRegion::GlobalInternalSpaceRegionKind); 686 return LazyAllocate(InternalGlobals); 687 } 688 689 assert(K == MemRegion::StaticGlobalSpaceRegionKind); 690 StaticGlobalSpaceRegion *&R = StaticsGlobalSpaceRegions[CR]; 691 if (R) 692 return R; 693 694 R = A.Allocate<StaticGlobalSpaceRegion>(); 695 new (R) StaticGlobalSpaceRegion(this, CR); 696 return R; 697} 698 699const HeapSpaceRegion *MemRegionManager::getHeapRegion() { 700 return LazyAllocate(heap); 701} 702 703const MemSpaceRegion *MemRegionManager::getUnknownRegion() { 704 return LazyAllocate(unknown); 705} 706 707const MemSpaceRegion *MemRegionManager::getCodeRegion() { 708 return LazyAllocate(code); 709} 710 711//===----------------------------------------------------------------------===// 712// Constructing regions. 713//===----------------------------------------------------------------------===// 714const StringRegion* MemRegionManager::getStringRegion(const StringLiteral* Str){ 715 return getSubRegion<StringRegion>(Str, getGlobalsRegion()); 716} 717 718const ObjCStringRegion * 719MemRegionManager::getObjCStringRegion(const ObjCStringLiteral* Str){ 720 return getSubRegion<ObjCStringRegion>(Str, getGlobalsRegion()); 721} 722 723/// Look through a chain of LocationContexts to either find the 724/// StackFrameContext that matches a DeclContext, or find a VarRegion 725/// for a variable captured by a block. 726static llvm::PointerUnion<const StackFrameContext *, const VarRegion *> 727getStackOrCaptureRegionForDeclContext(const LocationContext *LC, 728 const DeclContext *DC, 729 const VarDecl *VD) { 730 while (LC) { 731 if (const StackFrameContext *SFC = dyn_cast<StackFrameContext>(LC)) { 732 if (cast<DeclContext>(SFC->getDecl()) == DC) 733 return SFC; 734 } 735 if (const BlockInvocationContext *BC = 736 dyn_cast<BlockInvocationContext>(LC)) { 737 const BlockDataRegion *BR = 738 static_cast<const BlockDataRegion*>(BC->getContextData()); 739 // FIXME: This can be made more efficient. 740 for (BlockDataRegion::referenced_vars_iterator 741 I = BR->referenced_vars_begin(), 742 E = BR->referenced_vars_end(); I != E; ++I) { 743 if (const VarRegion *VR = dyn_cast<VarRegion>(I.getOriginalRegion())) 744 if (VR->getDecl() == VD) 745 return cast<VarRegion>(I.getCapturedRegion()); 746 } 747 } 748 749 LC = LC->getParent(); 750 } 751 return (const StackFrameContext*)0; 752} 753 754const VarRegion* MemRegionManager::getVarRegion(const VarDecl *D, 755 const LocationContext *LC) { 756 const MemRegion *sReg = 0; 757 758 if (D->hasGlobalStorage() && !D->isStaticLocal()) { 759 760 // First handle the globals defined in system headers. 761 if (C.getSourceManager().isInSystemHeader(D->getLocation())) { 762 // Whitelist the system globals which often DO GET modified, assume the 763 // rest are immutable. 764 if (D->getName().find("errno") != StringRef::npos) 765 sReg = getGlobalsRegion(MemRegion::GlobalSystemSpaceRegionKind); 766 else 767 sReg = getGlobalsRegion(MemRegion::GlobalImmutableSpaceRegionKind); 768 769 // Treat other globals as GlobalInternal unless they are constants. 770 } else { 771 QualType GQT = D->getType(); 772 const Type *GT = GQT.getTypePtrOrNull(); 773 // TODO: We could walk the complex types here and see if everything is 774 // constified. 775 if (GT && GQT.isConstQualified() && GT->isArithmeticType()) 776 sReg = getGlobalsRegion(MemRegion::GlobalImmutableSpaceRegionKind); 777 else 778 sReg = getGlobalsRegion(); 779 } 780 781 // Finally handle static locals. 782 } else { 783 // FIXME: Once we implement scope handling, we will need to properly lookup 784 // 'D' to the proper LocationContext. 785 const DeclContext *DC = D->getDeclContext(); 786 llvm::PointerUnion<const StackFrameContext *, const VarRegion *> V = 787 getStackOrCaptureRegionForDeclContext(LC, DC, D); 788 789 if (V.is<const VarRegion*>()) 790 return V.get<const VarRegion*>(); 791 792 const StackFrameContext *STC = V.get<const StackFrameContext*>(); 793 794 if (!STC) 795 sReg = getUnknownRegion(); 796 else { 797 if (D->hasLocalStorage()) { 798 sReg = isa<ParmVarDecl>(D) || isa<ImplicitParamDecl>(D) 799 ? static_cast<const MemRegion*>(getStackArgumentsRegion(STC)) 800 : static_cast<const MemRegion*>(getStackLocalsRegion(STC)); 801 } 802 else { 803 assert(D->isStaticLocal()); 804 const Decl *STCD = STC->getDecl(); 805 if (isa<FunctionDecl>(STCD) || isa<ObjCMethodDecl>(STCD)) 806 sReg = getGlobalsRegion(MemRegion::StaticGlobalSpaceRegionKind, 807 getFunctionTextRegion(cast<NamedDecl>(STCD))); 808 else if (const BlockDecl *BD = dyn_cast<BlockDecl>(STCD)) { 809 const BlockTextRegion *BTR = 810 getBlockTextRegion(BD, 811 C.getCanonicalType(BD->getSignatureAsWritten()->getType()), 812 STC->getAnalysisDeclContext()); 813 sReg = getGlobalsRegion(MemRegion::StaticGlobalSpaceRegionKind, 814 BTR); 815 } 816 else { 817 sReg = getGlobalsRegion(); 818 } 819 } 820 } 821 } 822 823 return getSubRegion<VarRegion>(D, sReg); 824} 825 826const VarRegion *MemRegionManager::getVarRegion(const VarDecl *D, 827 const MemRegion *superR) { 828 return getSubRegion<VarRegion>(D, superR); 829} 830 831const BlockDataRegion * 832MemRegionManager::getBlockDataRegion(const BlockTextRegion *BC, 833 const LocationContext *LC) { 834 const MemRegion *sReg = 0; 835 const BlockDecl *BD = BC->getDecl(); 836 if (!BD->hasCaptures()) { 837 // This handles 'static' blocks. 838 sReg = getGlobalsRegion(MemRegion::GlobalImmutableSpaceRegionKind); 839 } 840 else { 841 if (LC) { 842 // FIXME: Once we implement scope handling, we want the parent region 843 // to be the scope. 844 const StackFrameContext *STC = LC->getCurrentStackFrame(); 845 assert(STC); 846 sReg = getStackLocalsRegion(STC); 847 } 848 else { 849 // We allow 'LC' to be NULL for cases where want BlockDataRegions 850 // without context-sensitivity. 851 sReg = getUnknownRegion(); 852 } 853 } 854 855 return getSubRegion<BlockDataRegion>(BC, LC, sReg); 856} 857 858const CompoundLiteralRegion* 859MemRegionManager::getCompoundLiteralRegion(const CompoundLiteralExpr *CL, 860 const LocationContext *LC) { 861 862 const MemRegion *sReg = 0; 863 864 if (CL->isFileScope()) 865 sReg = getGlobalsRegion(); 866 else { 867 const StackFrameContext *STC = LC->getCurrentStackFrame(); 868 assert(STC); 869 sReg = getStackLocalsRegion(STC); 870 } 871 872 return getSubRegion<CompoundLiteralRegion>(CL, sReg); 873} 874 875const ElementRegion* 876MemRegionManager::getElementRegion(QualType elementType, NonLoc Idx, 877 const MemRegion* superRegion, 878 ASTContext &Ctx){ 879 880 QualType T = Ctx.getCanonicalType(elementType).getUnqualifiedType(); 881 882 llvm::FoldingSetNodeID ID; 883 ElementRegion::ProfileRegion(ID, T, Idx, superRegion); 884 885 void *InsertPos; 886 MemRegion* data = Regions.FindNodeOrInsertPos(ID, InsertPos); 887 ElementRegion* R = cast_or_null<ElementRegion>(data); 888 889 if (!R) { 890 R = (ElementRegion*) A.Allocate<ElementRegion>(); 891 new (R) ElementRegion(T, Idx, superRegion); 892 Regions.InsertNode(R, InsertPos); 893 } 894 895 return R; 896} 897 898const FunctionTextRegion * 899MemRegionManager::getFunctionTextRegion(const NamedDecl *FD) { 900 return getSubRegion<FunctionTextRegion>(FD, getCodeRegion()); 901} 902 903const BlockTextRegion * 904MemRegionManager::getBlockTextRegion(const BlockDecl *BD, CanQualType locTy, 905 AnalysisDeclContext *AC) { 906 return getSubRegion<BlockTextRegion>(BD, locTy, AC, getCodeRegion()); 907} 908 909 910/// getSymbolicRegion - Retrieve or create a "symbolic" memory region. 911const SymbolicRegion *MemRegionManager::getSymbolicRegion(SymbolRef sym) { 912 return getSubRegion<SymbolicRegion>(sym, getUnknownRegion()); 913} 914 915const SymbolicRegion *MemRegionManager::getSymbolicHeapRegion(SymbolRef Sym) { 916 return getSubRegion<SymbolicRegion>(Sym, getHeapRegion()); 917} 918 919const FieldRegion* 920MemRegionManager::getFieldRegion(const FieldDecl *d, 921 const MemRegion* superRegion){ 922 return getSubRegion<FieldRegion>(d, superRegion); 923} 924 925const ObjCIvarRegion* 926MemRegionManager::getObjCIvarRegion(const ObjCIvarDecl *d, 927 const MemRegion* superRegion) { 928 return getSubRegion<ObjCIvarRegion>(d, superRegion); 929} 930 931const CXXTempObjectRegion* 932MemRegionManager::getCXXTempObjectRegion(Expr const *E, 933 LocationContext const *LC) { 934 const StackFrameContext *SFC = LC->getCurrentStackFrame(); 935 assert(SFC); 936 return getSubRegion<CXXTempObjectRegion>(E, getStackLocalsRegion(SFC)); 937} 938 939/// Checks whether \p BaseClass is a valid virtual or direct non-virtual base 940/// class of the type of \p Super. 941static bool isValidBaseClass(const CXXRecordDecl *BaseClass, 942 const TypedValueRegion *Super, 943 bool IsVirtual) { 944 BaseClass = BaseClass->getCanonicalDecl(); 945 946 const CXXRecordDecl *Class = Super->getValueType()->getAsCXXRecordDecl(); 947 if (!Class) 948 return true; 949 950 if (IsVirtual) 951 return Class->isVirtuallyDerivedFrom(BaseClass); 952 953 for (CXXRecordDecl::base_class_const_iterator I = Class->bases_begin(), 954 E = Class->bases_end(); 955 I != E; ++I) { 956 if (I->getType()->getAsCXXRecordDecl()->getCanonicalDecl() == BaseClass) 957 return true; 958 } 959 960 return false; 961} 962 963const CXXBaseObjectRegion * 964MemRegionManager::getCXXBaseObjectRegion(const CXXRecordDecl *RD, 965 const MemRegion *Super, 966 bool IsVirtual) { 967 if (isa<TypedValueRegion>(Super)) { 968 assert(isValidBaseClass(RD, dyn_cast<TypedValueRegion>(Super), IsVirtual)); 969 (void)isValidBaseClass; 970 971 if (IsVirtual) { 972 // Virtual base regions should not be layered, since the layout rules 973 // are different. 974 while (const CXXBaseObjectRegion *Base = 975 dyn_cast<CXXBaseObjectRegion>(Super)) { 976 Super = Base->getSuperRegion(); 977 } 978 assert(Super && !isa<MemSpaceRegion>(Super)); 979 } 980 } 981 982 return getSubRegion<CXXBaseObjectRegion>(RD, IsVirtual, Super); 983} 984 985const CXXThisRegion* 986MemRegionManager::getCXXThisRegion(QualType thisPointerTy, 987 const LocationContext *LC) { 988 const StackFrameContext *STC = LC->getCurrentStackFrame(); 989 assert(STC); 990 const PointerType *PT = thisPointerTy->getAs<PointerType>(); 991 assert(PT); 992 return getSubRegion<CXXThisRegion>(PT, getStackArgumentsRegion(STC)); 993} 994 995const AllocaRegion* 996MemRegionManager::getAllocaRegion(const Expr *E, unsigned cnt, 997 const LocationContext *LC) { 998 const StackFrameContext *STC = LC->getCurrentStackFrame(); 999 assert(STC); 1000 return getSubRegion<AllocaRegion>(E, cnt, getStackLocalsRegion(STC)); 1001} 1002 1003const MemSpaceRegion *MemRegion::getMemorySpace() const { 1004 const MemRegion *R = this; 1005 const SubRegion* SR = dyn_cast<SubRegion>(this); 1006 1007 while (SR) { 1008 R = SR->getSuperRegion(); 1009 SR = dyn_cast<SubRegion>(R); 1010 } 1011 1012 return dyn_cast<MemSpaceRegion>(R); 1013} 1014 1015bool MemRegion::hasStackStorage() const { 1016 return isa<StackSpaceRegion>(getMemorySpace()); 1017} 1018 1019bool MemRegion::hasStackNonParametersStorage() const { 1020 return isa<StackLocalsSpaceRegion>(getMemorySpace()); 1021} 1022 1023bool MemRegion::hasStackParametersStorage() const { 1024 return isa<StackArgumentsSpaceRegion>(getMemorySpace()); 1025} 1026 1027bool MemRegion::hasGlobalsOrParametersStorage() const { 1028 const MemSpaceRegion *MS = getMemorySpace(); 1029 return isa<StackArgumentsSpaceRegion>(MS) || 1030 isa<GlobalsSpaceRegion>(MS); 1031} 1032 1033// getBaseRegion strips away all elements and fields, and get the base region 1034// of them. 1035const MemRegion *MemRegion::getBaseRegion() const { 1036 const MemRegion *R = this; 1037 while (true) { 1038 switch (R->getKind()) { 1039 case MemRegion::ElementRegionKind: 1040 case MemRegion::FieldRegionKind: 1041 case MemRegion::ObjCIvarRegionKind: 1042 case MemRegion::CXXBaseObjectRegionKind: 1043 R = cast<SubRegion>(R)->getSuperRegion(); 1044 continue; 1045 default: 1046 break; 1047 } 1048 break; 1049 } 1050 return R; 1051} 1052 1053bool MemRegion::isSubRegionOf(const MemRegion *R) const { 1054 return false; 1055} 1056 1057//===----------------------------------------------------------------------===// 1058// View handling. 1059//===----------------------------------------------------------------------===// 1060 1061const MemRegion *MemRegion::StripCasts(bool StripBaseCasts) const { 1062 const MemRegion *R = this; 1063 while (true) { 1064 switch (R->getKind()) { 1065 case ElementRegionKind: { 1066 const ElementRegion *ER = cast<ElementRegion>(R); 1067 if (!ER->getIndex().isZeroConstant()) 1068 return R; 1069 R = ER->getSuperRegion(); 1070 break; 1071 } 1072 case CXXBaseObjectRegionKind: 1073 if (!StripBaseCasts) 1074 return R; 1075 R = cast<CXXBaseObjectRegion>(R)->getSuperRegion(); 1076 break; 1077 default: 1078 return R; 1079 } 1080 } 1081} 1082 1083const SymbolicRegion *MemRegion::getSymbolicBase() const { 1084 const SubRegion *SubR = dyn_cast<SubRegion>(this); 1085 1086 while (SubR) { 1087 if (const SymbolicRegion *SymR = dyn_cast<SymbolicRegion>(SubR)) 1088 return SymR; 1089 SubR = dyn_cast<SubRegion>(SubR->getSuperRegion()); 1090 } 1091 return 0; 1092} 1093 1094// FIXME: Merge with the implementation of the same method in Store.cpp 1095static bool IsCompleteType(ASTContext &Ctx, QualType Ty) { 1096 if (const RecordType *RT = Ty->getAs<RecordType>()) { 1097 const RecordDecl *D = RT->getDecl(); 1098 if (!D->getDefinition()) 1099 return false; 1100 } 1101 1102 return true; 1103} 1104 1105RegionRawOffset ElementRegion::getAsArrayOffset() const { 1106 CharUnits offset = CharUnits::Zero(); 1107 const ElementRegion *ER = this; 1108 const MemRegion *superR = NULL; 1109 ASTContext &C = getContext(); 1110 1111 // FIXME: Handle multi-dimensional arrays. 1112 1113 while (ER) { 1114 superR = ER->getSuperRegion(); 1115 1116 // FIXME: generalize to symbolic offsets. 1117 SVal index = ER->getIndex(); 1118 if (Optional<nonloc::ConcreteInt> CI = index.getAs<nonloc::ConcreteInt>()) { 1119 // Update the offset. 1120 int64_t i = CI->getValue().getSExtValue(); 1121 1122 if (i != 0) { 1123 QualType elemType = ER->getElementType(); 1124 1125 // If we are pointing to an incomplete type, go no further. 1126 if (!IsCompleteType(C, elemType)) { 1127 superR = ER; 1128 break; 1129 } 1130 1131 CharUnits size = C.getTypeSizeInChars(elemType); 1132 offset += (i * size); 1133 } 1134 1135 // Go to the next ElementRegion (if any). 1136 ER = dyn_cast<ElementRegion>(superR); 1137 continue; 1138 } 1139 1140 return NULL; 1141 } 1142 1143 assert(superR && "super region cannot be NULL"); 1144 return RegionRawOffset(superR, offset); 1145} 1146 1147 1148/// Returns true if \p Base is an immediate base class of \p Child 1149static bool isImmediateBase(const CXXRecordDecl *Child, 1150 const CXXRecordDecl *Base) { 1151 // Note that we do NOT canonicalize the base class here, because 1152 // ASTRecordLayout doesn't either. If that leads us down the wrong path, 1153 // so be it; at least we won't crash. 1154 for (CXXRecordDecl::base_class_const_iterator I = Child->bases_begin(), 1155 E = Child->bases_end(); 1156 I != E; ++I) { 1157 if (I->getType()->getAsCXXRecordDecl() == Base) 1158 return true; 1159 } 1160 1161 return false; 1162} 1163 1164RegionOffset MemRegion::getAsOffset() const { 1165 const MemRegion *R = this; 1166 const MemRegion *SymbolicOffsetBase = 0; 1167 int64_t Offset = 0; 1168 1169 while (1) { 1170 switch (R->getKind()) { 1171 case GenericMemSpaceRegionKind: 1172 case StackLocalsSpaceRegionKind: 1173 case StackArgumentsSpaceRegionKind: 1174 case HeapSpaceRegionKind: 1175 case UnknownSpaceRegionKind: 1176 case StaticGlobalSpaceRegionKind: 1177 case GlobalInternalSpaceRegionKind: 1178 case GlobalSystemSpaceRegionKind: 1179 case GlobalImmutableSpaceRegionKind: 1180 // Stores can bind directly to a region space to set a default value. 1181 assert(Offset == 0 && !SymbolicOffsetBase); 1182 goto Finish; 1183 1184 case FunctionTextRegionKind: 1185 case BlockTextRegionKind: 1186 case BlockDataRegionKind: 1187 // These will never have bindings, but may end up having values requested 1188 // if the user does some strange casting. 1189 if (Offset != 0) 1190 SymbolicOffsetBase = R; 1191 goto Finish; 1192 1193 case SymbolicRegionKind: 1194 case AllocaRegionKind: 1195 case CompoundLiteralRegionKind: 1196 case CXXThisRegionKind: 1197 case StringRegionKind: 1198 case ObjCStringRegionKind: 1199 case VarRegionKind: 1200 case CXXTempObjectRegionKind: 1201 // Usual base regions. 1202 goto Finish; 1203 1204 case ObjCIvarRegionKind: 1205 // This is a little strange, but it's a compromise between 1206 // ObjCIvarRegions having unknown compile-time offsets (when using the 1207 // non-fragile runtime) and yet still being distinct, non-overlapping 1208 // regions. Thus we treat them as "like" base regions for the purposes 1209 // of computing offsets. 1210 goto Finish; 1211 1212 case CXXBaseObjectRegionKind: { 1213 const CXXBaseObjectRegion *BOR = cast<CXXBaseObjectRegion>(R); 1214 R = BOR->getSuperRegion(); 1215 1216 QualType Ty; 1217 bool RootIsSymbolic = false; 1218 if (const TypedValueRegion *TVR = dyn_cast<TypedValueRegion>(R)) { 1219 Ty = TVR->getDesugaredValueType(getContext()); 1220 } else if (const SymbolicRegion *SR = dyn_cast<SymbolicRegion>(R)) { 1221 // If our base region is symbolic, we don't know what type it really is. 1222 // Pretend the type of the symbol is the true dynamic type. 1223 // (This will at least be self-consistent for the life of the symbol.) 1224 Ty = SR->getSymbol()->getType()->getPointeeType(); 1225 RootIsSymbolic = true; 1226 } 1227 1228 const CXXRecordDecl *Child = Ty->getAsCXXRecordDecl(); 1229 if (!Child) { 1230 // We cannot compute the offset of the base class. 1231 SymbolicOffsetBase = R; 1232 } 1233 1234 if (RootIsSymbolic) { 1235 // Base layers on symbolic regions may not be type-correct. 1236 // Double-check the inheritance here, and revert to a symbolic offset 1237 // if it's invalid (e.g. due to a reinterpret_cast). 1238 if (BOR->isVirtual()) { 1239 if (!Child->isVirtuallyDerivedFrom(BOR->getDecl())) 1240 SymbolicOffsetBase = R; 1241 } else { 1242 if (!isImmediateBase(Child, BOR->getDecl())) 1243 SymbolicOffsetBase = R; 1244 } 1245 } 1246 1247 // Don't bother calculating precise offsets if we already have a 1248 // symbolic offset somewhere in the chain. 1249 if (SymbolicOffsetBase) 1250 continue; 1251 1252 CharUnits BaseOffset; 1253 const ASTRecordLayout &Layout = getContext().getASTRecordLayout(Child); 1254 if (BOR->isVirtual()) 1255 BaseOffset = Layout.getVBaseClassOffset(BOR->getDecl()); 1256 else 1257 BaseOffset = Layout.getBaseClassOffset(BOR->getDecl()); 1258 1259 // The base offset is in chars, not in bits. 1260 Offset += BaseOffset.getQuantity() * getContext().getCharWidth(); 1261 break; 1262 } 1263 case ElementRegionKind: { 1264 const ElementRegion *ER = cast<ElementRegion>(R); 1265 R = ER->getSuperRegion(); 1266 1267 QualType EleTy = ER->getValueType(); 1268 if (!IsCompleteType(getContext(), EleTy)) { 1269 // We cannot compute the offset of the base class. 1270 SymbolicOffsetBase = R; 1271 continue; 1272 } 1273 1274 SVal Index = ER->getIndex(); 1275 if (Optional<nonloc::ConcreteInt> CI = 1276 Index.getAs<nonloc::ConcreteInt>()) { 1277 // Don't bother calculating precise offsets if we already have a 1278 // symbolic offset somewhere in the chain. 1279 if (SymbolicOffsetBase) 1280 continue; 1281 1282 int64_t i = CI->getValue().getSExtValue(); 1283 // This type size is in bits. 1284 Offset += i * getContext().getTypeSize(EleTy); 1285 } else { 1286 // We cannot compute offset for non-concrete index. 1287 SymbolicOffsetBase = R; 1288 } 1289 break; 1290 } 1291 case FieldRegionKind: { 1292 const FieldRegion *FR = cast<FieldRegion>(R); 1293 R = FR->getSuperRegion(); 1294 1295 const RecordDecl *RD = FR->getDecl()->getParent(); 1296 if (RD->isUnion() || !RD->isCompleteDefinition()) { 1297 // We cannot compute offset for incomplete type. 1298 // For unions, we could treat everything as offset 0, but we'd rather 1299 // treat each field as a symbolic offset so they aren't stored on top 1300 // of each other, since we depend on things in typed regions actually 1301 // matching their types. 1302 SymbolicOffsetBase = R; 1303 } 1304 1305 // Don't bother calculating precise offsets if we already have a 1306 // symbolic offset somewhere in the chain. 1307 if (SymbolicOffsetBase) 1308 continue; 1309 1310 // Get the field number. 1311 unsigned idx = 0; 1312 for (RecordDecl::field_iterator FI = RD->field_begin(), 1313 FE = RD->field_end(); FI != FE; ++FI, ++idx) 1314 if (FR->getDecl() == *FI) 1315 break; 1316 1317 const ASTRecordLayout &Layout = getContext().getASTRecordLayout(RD); 1318 // This is offset in bits. 1319 Offset += Layout.getFieldOffset(idx); 1320 break; 1321 } 1322 } 1323 } 1324 1325 Finish: 1326 if (SymbolicOffsetBase) 1327 return RegionOffset(SymbolicOffsetBase, RegionOffset::Symbolic); 1328 return RegionOffset(R, Offset); 1329} 1330 1331//===----------------------------------------------------------------------===// 1332// BlockDataRegion 1333//===----------------------------------------------------------------------===// 1334 1335std::pair<const VarRegion *, const VarRegion *> 1336BlockDataRegion::getCaptureRegions(const VarDecl *VD) { 1337 MemRegionManager &MemMgr = *getMemRegionManager(); 1338 const VarRegion *VR = 0; 1339 const VarRegion *OriginalVR = 0; 1340 1341 if (!VD->getAttr<BlocksAttr>() && VD->hasLocalStorage()) { 1342 VR = MemMgr.getVarRegion(VD, this); 1343 OriginalVR = MemMgr.getVarRegion(VD, LC); 1344 } 1345 else { 1346 if (LC) { 1347 VR = MemMgr.getVarRegion(VD, LC); 1348 OriginalVR = VR; 1349 } 1350 else { 1351 VR = MemMgr.getVarRegion(VD, MemMgr.getUnknownRegion()); 1352 OriginalVR = MemMgr.getVarRegion(VD, LC); 1353 } 1354 } 1355 return std::make_pair(VR, OriginalVR); 1356} 1357 1358void BlockDataRegion::LazyInitializeReferencedVars() { 1359 if (ReferencedVars) 1360 return; 1361 1362 AnalysisDeclContext *AC = getCodeRegion()->getAnalysisDeclContext(); 1363 AnalysisDeclContext::referenced_decls_iterator I, E; 1364 llvm::tie(I, E) = AC->getReferencedBlockVars(BC->getDecl()); 1365 1366 if (I == E) { 1367 ReferencedVars = (void*) 0x1; 1368 return; 1369 } 1370 1371 MemRegionManager &MemMgr = *getMemRegionManager(); 1372 llvm::BumpPtrAllocator &A = MemMgr.getAllocator(); 1373 BumpVectorContext BC(A); 1374 1375 typedef BumpVector<const MemRegion*> VarVec; 1376 VarVec *BV = (VarVec*) A.Allocate<VarVec>(); 1377 new (BV) VarVec(BC, E - I); 1378 VarVec *BVOriginal = (VarVec*) A.Allocate<VarVec>(); 1379 new (BVOriginal) VarVec(BC, E - I); 1380 1381 for ( ; I != E; ++I) { 1382 const VarRegion *VR = 0; 1383 const VarRegion *OriginalVR = 0; 1384 llvm::tie(VR, OriginalVR) = getCaptureRegions(*I); 1385 assert(VR); 1386 assert(OriginalVR); 1387 BV->push_back(VR, BC); 1388 BVOriginal->push_back(OriginalVR, BC); 1389 } 1390 1391 ReferencedVars = BV; 1392 OriginalVars = BVOriginal; 1393} 1394 1395BlockDataRegion::referenced_vars_iterator 1396BlockDataRegion::referenced_vars_begin() const { 1397 const_cast<BlockDataRegion*>(this)->LazyInitializeReferencedVars(); 1398 1399 BumpVector<const MemRegion*> *Vec = 1400 static_cast<BumpVector<const MemRegion*>*>(ReferencedVars); 1401 1402 if (Vec == (void*) 0x1) 1403 return BlockDataRegion::referenced_vars_iterator(0, 0); 1404 1405 BumpVector<const MemRegion*> *VecOriginal = 1406 static_cast<BumpVector<const MemRegion*>*>(OriginalVars); 1407 1408 return BlockDataRegion::referenced_vars_iterator(Vec->begin(), 1409 VecOriginal->begin()); 1410} 1411 1412BlockDataRegion::referenced_vars_iterator 1413BlockDataRegion::referenced_vars_end() const { 1414 const_cast<BlockDataRegion*>(this)->LazyInitializeReferencedVars(); 1415 1416 BumpVector<const MemRegion*> *Vec = 1417 static_cast<BumpVector<const MemRegion*>*>(ReferencedVars); 1418 1419 if (Vec == (void*) 0x1) 1420 return BlockDataRegion::referenced_vars_iterator(0, 0); 1421 1422 BumpVector<const MemRegion*> *VecOriginal = 1423 static_cast<BumpVector<const MemRegion*>*>(OriginalVars); 1424 1425 return BlockDataRegion::referenced_vars_iterator(Vec->end(), 1426 VecOriginal->end()); 1427} 1428 1429const VarRegion *BlockDataRegion::getOriginalRegion(const VarRegion *R) const { 1430 for (referenced_vars_iterator I = referenced_vars_begin(), 1431 E = referenced_vars_end(); 1432 I != E; ++I) { 1433 if (I.getCapturedRegion() == R) 1434 return I.getOriginalRegion(); 1435 } 1436 return 0; 1437} 1438