1//===- TypeBasedAliasAnalysis.cpp - Type-Based Alias Analysis -------------===// 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 the TypeBasedAliasAnalysis pass, which implements 11// metadata-based TBAA. 12// 13// In LLVM IR, memory does not have types, so LLVM's own type system is not 14// suitable for doing TBAA. Instead, metadata is added to the IR to describe 15// a type system of a higher level language. This can be used to implement 16// typical C/C++ TBAA, but it can also be used to implement custom alias 17// analysis behavior for other languages. 18// 19// We now support two types of metadata format: scalar TBAA and struct-path 20// aware TBAA. After all testing cases are upgraded to use struct-path aware 21// TBAA and we can auto-upgrade existing bc files, the support for scalar TBAA 22// can be dropped. 23// 24// The scalar TBAA metadata format is very simple. TBAA MDNodes have up to 25// three fields, e.g.: 26// !0 = metadata !{ metadata !"an example type tree" } 27// !1 = metadata !{ metadata !"int", metadata !0 } 28// !2 = metadata !{ metadata !"float", metadata !0 } 29// !3 = metadata !{ metadata !"const float", metadata !2, i64 1 } 30// 31// The first field is an identity field. It can be any value, usually 32// an MDString, which uniquely identifies the type. The most important 33// name in the tree is the name of the root node. Two trees with 34// different root node names are entirely disjoint, even if they 35// have leaves with common names. 36// 37// The second field identifies the type's parent node in the tree, or 38// is null or omitted for a root node. A type is considered to alias 39// all of its descendants and all of its ancestors in the tree. Also, 40// a type is considered to alias all types in other trees, so that 41// bitcode produced from multiple front-ends is handled conservatively. 42// 43// If the third field is present, it's an integer which if equal to 1 44// indicates that the type is "constant" (meaning pointsToConstantMemory 45// should return true; see 46// http://llvm.org/docs/AliasAnalysis.html#OtherItfs). 47// 48// With struct-path aware TBAA, the MDNodes attached to an instruction using 49// "!tbaa" are called path tag nodes. 50// 51// The path tag node has 4 fields with the last field being optional. 52// 53// The first field is the base type node, it can be a struct type node 54// or a scalar type node. The second field is the access type node, it 55// must be a scalar type node. The third field is the offset into the base type. 56// The last field has the same meaning as the last field of our scalar TBAA: 57// it's an integer which if equal to 1 indicates that the access is "constant". 58// 59// The struct type node has a name and a list of pairs, one pair for each member 60// of the struct. The first element of each pair is a type node (a struct type 61// node or a sclar type node), specifying the type of the member, the second 62// element of each pair is the offset of the member. 63// 64// Given an example 65// typedef struct { 66// short s; 67// } A; 68// typedef struct { 69// uint16_t s; 70// A a; 71// } B; 72// 73// For an acess to B.a.s, we attach !5 (a path tag node) to the load/store 74// instruction. The base type is !4 (struct B), the access type is !2 (scalar 75// type short) and the offset is 4. 76// 77// !0 = metadata !{metadata !"Simple C/C++ TBAA"} 78// !1 = metadata !{metadata !"omnipotent char", metadata !0} // Scalar type node 79// !2 = metadata !{metadata !"short", metadata !1} // Scalar type node 80// !3 = metadata !{metadata !"A", metadata !2, i64 0} // Struct type node 81// !4 = metadata !{metadata !"B", metadata !2, i64 0, metadata !3, i64 4} 82// // Struct type node 83// !5 = metadata !{metadata !4, metadata !2, i64 4} // Path tag node 84// 85// The struct type nodes and the scalar type nodes form a type DAG. 86// Root (!0) 87// char (!1) -- edge to Root 88// short (!2) -- edge to char 89// A (!3) -- edge with offset 0 to short 90// B (!4) -- edge with offset 0 to short and edge with offset 4 to A 91// 92// To check if two tags (tagX and tagY) can alias, we start from the base type 93// of tagX, follow the edge with the correct offset in the type DAG and adjust 94// the offset until we reach the base type of tagY or until we reach the Root 95// node. 96// If we reach the base type of tagY, compare the adjusted offset with 97// offset of tagY, return Alias if the offsets are the same, return NoAlias 98// otherwise. 99// If we reach the Root node, perform the above starting from base type of tagY 100// to see if we reach base type of tagX. 101// 102// If they have different roots, they're part of different potentially 103// unrelated type systems, so we return Alias to be conservative. 104// If neither node is an ancestor of the other and they have the same root, 105// then we say NoAlias. 106// 107// TODO: The current metadata format doesn't support struct 108// fields. For example: 109// struct X { 110// double d; 111// int i; 112// }; 113// void foo(struct X *x, struct X *y, double *p) { 114// *x = *y; 115// *p = 0.0; 116// } 117// Struct X has a double member, so the store to *x can alias the store to *p. 118// Currently it's not possible to precisely describe all the things struct X 119// aliases, so struct assignments must use conservative TBAA nodes. There's 120// no scheme for attaching metadata to @llvm.memcpy yet either. 121// 122//===----------------------------------------------------------------------===// 123 124#include "llvm/Analysis/Passes.h" 125#include "llvm/Analysis/AliasAnalysis.h" 126#include "llvm/IR/Constants.h" 127#include "llvm/IR/LLVMContext.h" 128#include "llvm/IR/Metadata.h" 129#include "llvm/IR/Module.h" 130#include "llvm/Pass.h" 131#include "llvm/Support/CommandLine.h" 132#include "llvm/ADT/SetVector.h" 133using namespace llvm; 134 135// A handy option for disabling TBAA functionality. The same effect can also be 136// achieved by stripping the !tbaa tags from IR, but this option is sometimes 137// more convenient. 138static cl::opt<bool> EnableTBAA("enable-tbaa", cl::init(true)); 139 140namespace { 141 /// TBAANode - This is a simple wrapper around an MDNode which provides a 142 /// higher-level interface by hiding the details of how alias analysis 143 /// information is encoded in its operands. 144 class TBAANode { 145 const MDNode *Node; 146 147 public: 148 TBAANode() : Node(nullptr) {} 149 explicit TBAANode(const MDNode *N) : Node(N) {} 150 151 /// getNode - Get the MDNode for this TBAANode. 152 const MDNode *getNode() const { return Node; } 153 154 /// getParent - Get this TBAANode's Alias tree parent. 155 TBAANode getParent() const { 156 if (Node->getNumOperands() < 2) 157 return TBAANode(); 158 MDNode *P = dyn_cast_or_null<MDNode>(Node->getOperand(1)); 159 if (!P) 160 return TBAANode(); 161 // Ok, this node has a valid parent. Return it. 162 return TBAANode(P); 163 } 164 165 /// TypeIsImmutable - Test if this TBAANode represents a type for objects 166 /// which are not modified (by any means) in the context where this 167 /// AliasAnalysis is relevant. 168 bool TypeIsImmutable() const { 169 if (Node->getNumOperands() < 3) 170 return false; 171 ConstantInt *CI = mdconst::dyn_extract<ConstantInt>(Node->getOperand(2)); 172 if (!CI) 173 return false; 174 return CI->getValue()[0]; 175 } 176 }; 177 178 /// This is a simple wrapper around an MDNode which provides a 179 /// higher-level interface by hiding the details of how alias analysis 180 /// information is encoded in its operands. 181 class TBAAStructTagNode { 182 /// This node should be created with createTBAAStructTagNode. 183 const MDNode *Node; 184 185 public: 186 explicit TBAAStructTagNode(const MDNode *N) : Node(N) {} 187 188 /// Get the MDNode for this TBAAStructTagNode. 189 const MDNode *getNode() const { return Node; } 190 191 const MDNode *getBaseType() const { 192 return dyn_cast_or_null<MDNode>(Node->getOperand(0)); 193 } 194 const MDNode *getAccessType() const { 195 return dyn_cast_or_null<MDNode>(Node->getOperand(1)); 196 } 197 uint64_t getOffset() const { 198 return mdconst::extract<ConstantInt>(Node->getOperand(2))->getZExtValue(); 199 } 200 /// TypeIsImmutable - Test if this TBAAStructTagNode represents a type for 201 /// objects which are not modified (by any means) in the context where this 202 /// AliasAnalysis is relevant. 203 bool TypeIsImmutable() const { 204 if (Node->getNumOperands() < 4) 205 return false; 206 ConstantInt *CI = mdconst::dyn_extract<ConstantInt>(Node->getOperand(3)); 207 if (!CI) 208 return false; 209 return CI->getValue()[0]; 210 } 211 }; 212 213 /// This is a simple wrapper around an MDNode which provides a 214 /// higher-level interface by hiding the details of how alias analysis 215 /// information is encoded in its operands. 216 class TBAAStructTypeNode { 217 /// This node should be created with createTBAAStructTypeNode. 218 const MDNode *Node; 219 220 public: 221 TBAAStructTypeNode() : Node(nullptr) {} 222 explicit TBAAStructTypeNode(const MDNode *N) : Node(N) {} 223 224 /// Get the MDNode for this TBAAStructTypeNode. 225 const MDNode *getNode() const { return Node; } 226 227 /// Get this TBAAStructTypeNode's field in the type DAG with 228 /// given offset. Update the offset to be relative to the field type. 229 TBAAStructTypeNode getParent(uint64_t &Offset) const { 230 // Parent can be omitted for the root node. 231 if (Node->getNumOperands() < 2) 232 return TBAAStructTypeNode(); 233 234 // Fast path for a scalar type node and a struct type node with a single 235 // field. 236 if (Node->getNumOperands() <= 3) { 237 uint64_t Cur = Node->getNumOperands() == 2 238 ? 0 239 : mdconst::extract<ConstantInt>(Node->getOperand(2)) 240 ->getZExtValue(); 241 Offset -= Cur; 242 MDNode *P = dyn_cast_or_null<MDNode>(Node->getOperand(1)); 243 if (!P) 244 return TBAAStructTypeNode(); 245 return TBAAStructTypeNode(P); 246 } 247 248 // Assume the offsets are in order. We return the previous field if 249 // the current offset is bigger than the given offset. 250 unsigned TheIdx = 0; 251 for (unsigned Idx = 1; Idx < Node->getNumOperands(); Idx += 2) { 252 uint64_t Cur = mdconst::extract<ConstantInt>(Node->getOperand(Idx + 1)) 253 ->getZExtValue(); 254 if (Cur > Offset) { 255 assert(Idx >= 3 && 256 "TBAAStructTypeNode::getParent should have an offset match!"); 257 TheIdx = Idx - 2; 258 break; 259 } 260 } 261 // Move along the last field. 262 if (TheIdx == 0) 263 TheIdx = Node->getNumOperands() - 2; 264 uint64_t Cur = mdconst::extract<ConstantInt>(Node->getOperand(TheIdx + 1)) 265 ->getZExtValue(); 266 Offset -= Cur; 267 MDNode *P = dyn_cast_or_null<MDNode>(Node->getOperand(TheIdx)); 268 if (!P) 269 return TBAAStructTypeNode(); 270 return TBAAStructTypeNode(P); 271 } 272 }; 273} 274 275namespace { 276 /// TypeBasedAliasAnalysis - This is a simple alias analysis 277 /// implementation that uses TypeBased to answer queries. 278 class TypeBasedAliasAnalysis : public ImmutablePass, 279 public AliasAnalysis { 280 public: 281 static char ID; // Class identification, replacement for typeinfo 282 TypeBasedAliasAnalysis() : ImmutablePass(ID) { 283 initializeTypeBasedAliasAnalysisPass(*PassRegistry::getPassRegistry()); 284 } 285 286 bool doInitialization(Module &M) override; 287 288 /// getAdjustedAnalysisPointer - This method is used when a pass implements 289 /// an analysis interface through multiple inheritance. If needed, it 290 /// should override this to adjust the this pointer as needed for the 291 /// specified pass info. 292 void *getAdjustedAnalysisPointer(const void *PI) override { 293 if (PI == &AliasAnalysis::ID) 294 return (AliasAnalysis*)this; 295 return this; 296 } 297 298 bool Aliases(const MDNode *A, const MDNode *B) const; 299 bool PathAliases(const MDNode *A, const MDNode *B) const; 300 301 private: 302 void getAnalysisUsage(AnalysisUsage &AU) const override; 303 AliasResult alias(const Location &LocA, const Location &LocB) override; 304 bool pointsToConstantMemory(const Location &Loc, bool OrLocal) override; 305 ModRefBehavior getModRefBehavior(ImmutableCallSite CS) override; 306 ModRefBehavior getModRefBehavior(const Function *F) override; 307 ModRefResult getModRefInfo(ImmutableCallSite CS, 308 const Location &Loc) override; 309 ModRefResult getModRefInfo(ImmutableCallSite CS1, 310 ImmutableCallSite CS2) override; 311 }; 312} // End of anonymous namespace 313 314// Register this pass... 315char TypeBasedAliasAnalysis::ID = 0; 316INITIALIZE_AG_PASS(TypeBasedAliasAnalysis, AliasAnalysis, "tbaa", 317 "Type-Based Alias Analysis", false, true, false) 318 319ImmutablePass *llvm::createTypeBasedAliasAnalysisPass() { 320 return new TypeBasedAliasAnalysis(); 321} 322 323bool TypeBasedAliasAnalysis::doInitialization(Module &M) { 324 InitializeAliasAnalysis(this, &M.getDataLayout()); 325 return true; 326} 327 328void 329TypeBasedAliasAnalysis::getAnalysisUsage(AnalysisUsage &AU) const { 330 AU.setPreservesAll(); 331 AliasAnalysis::getAnalysisUsage(AU); 332} 333 334/// Check the first operand of the tbaa tag node, if it is a MDNode, we treat 335/// it as struct-path aware TBAA format, otherwise, we treat it as scalar TBAA 336/// format. 337static bool isStructPathTBAA(const MDNode *MD) { 338 // Anonymous TBAA root starts with a MDNode and dragonegg uses it as 339 // a TBAA tag. 340 return isa<MDNode>(MD->getOperand(0)) && MD->getNumOperands() >= 3; 341} 342 343/// Aliases - Test whether the type represented by A may alias the 344/// type represented by B. 345bool 346TypeBasedAliasAnalysis::Aliases(const MDNode *A, 347 const MDNode *B) const { 348 // Make sure that both MDNodes are struct-path aware. 349 if (isStructPathTBAA(A) && isStructPathTBAA(B)) 350 return PathAliases(A, B); 351 352 // Keep track of the root node for A and B. 353 TBAANode RootA, RootB; 354 355 // Climb the tree from A to see if we reach B. 356 for (TBAANode T(A); ; ) { 357 if (T.getNode() == B) 358 // B is an ancestor of A. 359 return true; 360 361 RootA = T; 362 T = T.getParent(); 363 if (!T.getNode()) 364 break; 365 } 366 367 // Climb the tree from B to see if we reach A. 368 for (TBAANode T(B); ; ) { 369 if (T.getNode() == A) 370 // A is an ancestor of B. 371 return true; 372 373 RootB = T; 374 T = T.getParent(); 375 if (!T.getNode()) 376 break; 377 } 378 379 // Neither node is an ancestor of the other. 380 381 // If they have different roots, they're part of different potentially 382 // unrelated type systems, so we must be conservative. 383 if (RootA.getNode() != RootB.getNode()) 384 return true; 385 386 // If they have the same root, then we've proved there's no alias. 387 return false; 388} 389 390/// Test whether the struct-path tag represented by A may alias the 391/// struct-path tag represented by B. 392bool 393TypeBasedAliasAnalysis::PathAliases(const MDNode *A, 394 const MDNode *B) const { 395 // Verify that both input nodes are struct-path aware. 396 assert(isStructPathTBAA(A) && "MDNode A is not struct-path aware."); 397 assert(isStructPathTBAA(B) && "MDNode B is not struct-path aware."); 398 399 // Keep track of the root node for A and B. 400 TBAAStructTypeNode RootA, RootB; 401 TBAAStructTagNode TagA(A), TagB(B); 402 403 // TODO: We need to check if AccessType of TagA encloses AccessType of 404 // TagB to support aggregate AccessType. If yes, return true. 405 406 // Start from the base type of A, follow the edge with the correct offset in 407 // the type DAG and adjust the offset until we reach the base type of B or 408 // until we reach the Root node. 409 // Compare the adjusted offset once we have the same base. 410 411 // Climb the type DAG from base type of A to see if we reach base type of B. 412 const MDNode *BaseA = TagA.getBaseType(); 413 const MDNode *BaseB = TagB.getBaseType(); 414 uint64_t OffsetA = TagA.getOffset(), OffsetB = TagB.getOffset(); 415 for (TBAAStructTypeNode T(BaseA); ; ) { 416 if (T.getNode() == BaseB) 417 // Base type of A encloses base type of B, check if the offsets match. 418 return OffsetA == OffsetB; 419 420 RootA = T; 421 // Follow the edge with the correct offset, OffsetA will be adjusted to 422 // be relative to the field type. 423 T = T.getParent(OffsetA); 424 if (!T.getNode()) 425 break; 426 } 427 428 // Reset OffsetA and climb the type DAG from base type of B to see if we reach 429 // base type of A. 430 OffsetA = TagA.getOffset(); 431 for (TBAAStructTypeNode T(BaseB); ; ) { 432 if (T.getNode() == BaseA) 433 // Base type of B encloses base type of A, check if the offsets match. 434 return OffsetA == OffsetB; 435 436 RootB = T; 437 // Follow the edge with the correct offset, OffsetB will be adjusted to 438 // be relative to the field type. 439 T = T.getParent(OffsetB); 440 if (!T.getNode()) 441 break; 442 } 443 444 // Neither node is an ancestor of the other. 445 446 // If they have different roots, they're part of different potentially 447 // unrelated type systems, so we must be conservative. 448 if (RootA.getNode() != RootB.getNode()) 449 return true; 450 451 // If they have the same root, then we've proved there's no alias. 452 return false; 453} 454 455AliasAnalysis::AliasResult 456TypeBasedAliasAnalysis::alias(const Location &LocA, 457 const Location &LocB) { 458 if (!EnableTBAA) 459 return AliasAnalysis::alias(LocA, LocB); 460 461 // Get the attached MDNodes. If either value lacks a tbaa MDNode, we must 462 // be conservative. 463 const MDNode *AM = LocA.AATags.TBAA; 464 if (!AM) return AliasAnalysis::alias(LocA, LocB); 465 const MDNode *BM = LocB.AATags.TBAA; 466 if (!BM) return AliasAnalysis::alias(LocA, LocB); 467 468 // If they may alias, chain to the next AliasAnalysis. 469 if (Aliases(AM, BM)) 470 return AliasAnalysis::alias(LocA, LocB); 471 472 // Otherwise return a definitive result. 473 return NoAlias; 474} 475 476bool TypeBasedAliasAnalysis::pointsToConstantMemory(const Location &Loc, 477 bool OrLocal) { 478 if (!EnableTBAA) 479 return AliasAnalysis::pointsToConstantMemory(Loc, OrLocal); 480 481 const MDNode *M = Loc.AATags.TBAA; 482 if (!M) return AliasAnalysis::pointsToConstantMemory(Loc, OrLocal); 483 484 // If this is an "immutable" type, we can assume the pointer is pointing 485 // to constant memory. 486 if ((!isStructPathTBAA(M) && TBAANode(M).TypeIsImmutable()) || 487 (isStructPathTBAA(M) && TBAAStructTagNode(M).TypeIsImmutable())) 488 return true; 489 490 return AliasAnalysis::pointsToConstantMemory(Loc, OrLocal); 491} 492 493AliasAnalysis::ModRefBehavior 494TypeBasedAliasAnalysis::getModRefBehavior(ImmutableCallSite CS) { 495 if (!EnableTBAA) 496 return AliasAnalysis::getModRefBehavior(CS); 497 498 ModRefBehavior Min = UnknownModRefBehavior; 499 500 // If this is an "immutable" type, we can assume the call doesn't write 501 // to memory. 502 if (const MDNode *M = CS.getInstruction()->getMetadata(LLVMContext::MD_tbaa)) 503 if ((!isStructPathTBAA(M) && TBAANode(M).TypeIsImmutable()) || 504 (isStructPathTBAA(M) && TBAAStructTagNode(M).TypeIsImmutable())) 505 Min = OnlyReadsMemory; 506 507 return ModRefBehavior(AliasAnalysis::getModRefBehavior(CS) & Min); 508} 509 510AliasAnalysis::ModRefBehavior 511TypeBasedAliasAnalysis::getModRefBehavior(const Function *F) { 512 // Functions don't have metadata. Just chain to the next implementation. 513 return AliasAnalysis::getModRefBehavior(F); 514} 515 516AliasAnalysis::ModRefResult 517TypeBasedAliasAnalysis::getModRefInfo(ImmutableCallSite CS, 518 const Location &Loc) { 519 if (!EnableTBAA) 520 return AliasAnalysis::getModRefInfo(CS, Loc); 521 522 if (const MDNode *L = Loc.AATags.TBAA) 523 if (const MDNode *M = 524 CS.getInstruction()->getMetadata(LLVMContext::MD_tbaa)) 525 if (!Aliases(L, M)) 526 return NoModRef; 527 528 return AliasAnalysis::getModRefInfo(CS, Loc); 529} 530 531AliasAnalysis::ModRefResult 532TypeBasedAliasAnalysis::getModRefInfo(ImmutableCallSite CS1, 533 ImmutableCallSite CS2) { 534 if (!EnableTBAA) 535 return AliasAnalysis::getModRefInfo(CS1, CS2); 536 537 if (const MDNode *M1 = 538 CS1.getInstruction()->getMetadata(LLVMContext::MD_tbaa)) 539 if (const MDNode *M2 = 540 CS2.getInstruction()->getMetadata(LLVMContext::MD_tbaa)) 541 if (!Aliases(M1, M2)) 542 return NoModRef; 543 544 return AliasAnalysis::getModRefInfo(CS1, CS2); 545} 546 547bool MDNode::isTBAAVtableAccess() const { 548 if (!isStructPathTBAA(this)) { 549 if (getNumOperands() < 1) return false; 550 if (MDString *Tag1 = dyn_cast<MDString>(getOperand(0))) { 551 if (Tag1->getString() == "vtable pointer") return true; 552 } 553 return false; 554 } 555 556 // For struct-path aware TBAA, we use the access type of the tag. 557 if (getNumOperands() < 2) return false; 558 MDNode *Tag = cast_or_null<MDNode>(getOperand(1)); 559 if (!Tag) return false; 560 if (MDString *Tag1 = dyn_cast<MDString>(Tag->getOperand(0))) { 561 if (Tag1->getString() == "vtable pointer") return true; 562 } 563 return false; 564} 565 566MDNode *MDNode::getMostGenericTBAA(MDNode *A, MDNode *B) { 567 if (!A || !B) 568 return nullptr; 569 570 if (A == B) 571 return A; 572 573 // For struct-path aware TBAA, we use the access type of the tag. 574 bool StructPath = isStructPathTBAA(A) && isStructPathTBAA(B); 575 if (StructPath) { 576 A = cast_or_null<MDNode>(A->getOperand(1)); 577 if (!A) return nullptr; 578 B = cast_or_null<MDNode>(B->getOperand(1)); 579 if (!B) return nullptr; 580 } 581 582 SmallSetVector<MDNode *, 4> PathA; 583 MDNode *T = A; 584 while (T) { 585 if (PathA.count(T)) 586 report_fatal_error("Cycle found in TBAA metadata."); 587 PathA.insert(T); 588 T = T->getNumOperands() >= 2 ? cast_or_null<MDNode>(T->getOperand(1)) 589 : nullptr; 590 } 591 592 SmallSetVector<MDNode *, 4> PathB; 593 T = B; 594 while (T) { 595 if (PathB.count(T)) 596 report_fatal_error("Cycle found in TBAA metadata."); 597 PathB.insert(T); 598 T = T->getNumOperands() >= 2 ? cast_or_null<MDNode>(T->getOperand(1)) 599 : nullptr; 600 } 601 602 int IA = PathA.size() - 1; 603 int IB = PathB.size() - 1; 604 605 MDNode *Ret = nullptr; 606 while (IA >= 0 && IB >=0) { 607 if (PathA[IA] == PathB[IB]) 608 Ret = PathA[IA]; 609 else 610 break; 611 --IA; 612 --IB; 613 } 614 if (!StructPath) 615 return Ret; 616 617 if (!Ret) 618 return nullptr; 619 // We need to convert from a type node to a tag node. 620 Type *Int64 = IntegerType::get(A->getContext(), 64); 621 Metadata *Ops[3] = {Ret, Ret, 622 ConstantAsMetadata::get(ConstantInt::get(Int64, 0))}; 623 return MDNode::get(A->getContext(), Ops); 624} 625 626void Instruction::getAAMetadata(AAMDNodes &N, bool Merge) const { 627 if (Merge) 628 N.TBAA = 629 MDNode::getMostGenericTBAA(N.TBAA, getMetadata(LLVMContext::MD_tbaa)); 630 else 631 N.TBAA = getMetadata(LLVMContext::MD_tbaa); 632 633 if (Merge) 634 N.Scope = MDNode::getMostGenericAliasScope( 635 N.Scope, getMetadata(LLVMContext::MD_alias_scope)); 636 else 637 N.Scope = getMetadata(LLVMContext::MD_alias_scope); 638 639 if (Merge) 640 N.NoAlias = 641 MDNode::intersect(N.NoAlias, getMetadata(LLVMContext::MD_noalias)); 642 else 643 N.NoAlias = getMetadata(LLVMContext::MD_noalias); 644} 645 646