LLVM  3.7.0
MemoryLocation.cpp
Go to the documentation of this file.
1 //===- MemoryLocation.cpp - Memory location descriptions -------------------==//
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 
12 #include "llvm/IR/BasicBlock.h"
13 #include "llvm/IR/DataLayout.h"
14 #include "llvm/IR/Instructions.h"
15 #include "llvm/IR/IntrinsicInst.h"
16 #include "llvm/IR/LLVMContext.h"
17 #include "llvm/IR/Module.h"
18 #include "llvm/IR/Type.h"
19 using namespace llvm;
20 
23  LI->getAAMetadata(AATags);
24  const auto &DL = LI->getModule()->getDataLayout();
25 
26  return MemoryLocation(LI->getPointerOperand(),
27  DL.getTypeStoreSize(LI->getType()), AATags);
28 }
29 
32  SI->getAAMetadata(AATags);
33  const auto &DL = SI->getModule()->getDataLayout();
34 
35  return MemoryLocation(SI->getPointerOperand(),
36  DL.getTypeStoreSize(SI->getValueOperand()->getType()),
37  AATags);
38 }
39 
42  VI->getAAMetadata(AATags);
43 
45 }
46 
49  CXI->getAAMetadata(AATags);
50  const auto &DL = CXI->getModule()->getDataLayout();
51 
52  return MemoryLocation(
53  CXI->getPointerOperand(),
54  DL.getTypeStoreSize(CXI->getCompareOperand()->getType()), AATags);
55 }
56 
59  RMWI->getAAMetadata(AATags);
60  const auto &DL = RMWI->getModule()->getDataLayout();
61 
62  return MemoryLocation(RMWI->getPointerOperand(),
63  DL.getTypeStoreSize(RMWI->getValOperand()->getType()),
64  AATags);
65 }
66 
68  uint64_t Size = UnknownSize;
69  if (ConstantInt *C = dyn_cast<ConstantInt>(MTI->getLength()))
70  Size = C->getValue().getZExtValue();
71 
72  // memcpy/memmove can have AA tags. For memcpy, they apply
73  // to both the source and the destination.
75  MTI->getAAMetadata(AATags);
76 
77  return MemoryLocation(MTI->getRawSource(), Size, AATags);
78 }
79 
81  uint64_t Size = UnknownSize;
82  if (ConstantInt *C = dyn_cast<ConstantInt>(MTI->getLength()))
83  Size = C->getValue().getZExtValue();
84 
85  // memcpy/memmove can have AA tags. For memcpy, they apply
86  // to both the source and the destination.
88  MTI->getAAMetadata(AATags);
89 
90  return MemoryLocation(MTI->getRawDest(), Size, AATags);
91 }
92 
93 // FIXME: This code is duplicated with BasicAliasAnalysis and should be hoisted
94 // to some common utility location.
95 static bool isMemsetPattern16(const Function *MS,
96  const TargetLibraryInfo &TLI) {
97  if (TLI.has(LibFunc::memset_pattern16) &&
98  MS->getName() == "memset_pattern16") {
99  FunctionType *MemsetType = MS->getFunctionType();
100  if (!MemsetType->isVarArg() && MemsetType->getNumParams() == 3 &&
101  isa<PointerType>(MemsetType->getParamType(0)) &&
102  isa<PointerType>(MemsetType->getParamType(1)) &&
103  isa<IntegerType>(MemsetType->getParamType(2)))
104  return true;
105  }
106 
107  return false;
108 }
109 
111  unsigned ArgIdx,
112  const TargetLibraryInfo &TLI) {
114  CS->getAAMetadata(AATags);
115  const Value *Arg = CS.getArgument(ArgIdx);
116 
117  // We may be able to produce an exact size for known intrinsics.
118  if (const IntrinsicInst *II = dyn_cast<IntrinsicInst>(CS.getInstruction())) {
119  const DataLayout &DL = II->getModule()->getDataLayout();
120 
121  switch (II->getIntrinsicID()) {
122  default:
123  break;
124  case Intrinsic::memset:
125  case Intrinsic::memcpy:
126  case Intrinsic::memmove:
127  assert((ArgIdx == 0 || ArgIdx == 1) &&
128  "Invalid argument index for memory intrinsic");
129  if (ConstantInt *LenCI = dyn_cast<ConstantInt>(II->getArgOperand(2)))
130  return MemoryLocation(Arg, LenCI->getZExtValue(), AATags);
131  break;
132 
133  case Intrinsic::lifetime_start:
134  case Intrinsic::lifetime_end:
135  case Intrinsic::invariant_start:
136  assert(ArgIdx == 1 && "Invalid argument index");
137  return MemoryLocation(
138  Arg, cast<ConstantInt>(II->getArgOperand(0))->getZExtValue(), AATags);
139 
140  case Intrinsic::invariant_end:
141  assert(ArgIdx == 2 && "Invalid argument index");
142  return MemoryLocation(
143  Arg, cast<ConstantInt>(II->getArgOperand(1))->getZExtValue(), AATags);
144 
145  case Intrinsic::arm_neon_vld1:
146  assert(ArgIdx == 0 && "Invalid argument index");
147  // LLVM's vld1 and vst1 intrinsics currently only support a single
148  // vector register.
149  return MemoryLocation(Arg, DL.getTypeStoreSize(II->getType()), AATags);
150 
151  case Intrinsic::arm_neon_vst1:
152  assert(ArgIdx == 0 && "Invalid argument index");
153  return MemoryLocation(
154  Arg, DL.getTypeStoreSize(II->getArgOperand(1)->getType()), AATags);
155  }
156  }
157 
158  // We can bound the aliasing properties of memset_pattern16 just as we can
159  // for memcpy/memset. This is particularly important because the
160  // LoopIdiomRecognizer likes to turn loops into calls to memset_pattern16
161  // whenever possible.
162  if (CS.getCalledFunction() &&
164  assert((ArgIdx == 0 || ArgIdx == 1) &&
165  "Invalid argument index for memset_pattern16");
166  if (ArgIdx == 1)
167  return MemoryLocation(Arg, 16, AATags);
168  if (const ConstantInt *LenCI = dyn_cast<ConstantInt>(CS.getArgument(2)))
169  return MemoryLocation(Arg, LenCI->getZExtValue(), AATags);
170  }
171  // FIXME: Handle memset_pattern4 and memset_pattern8 also.
172 
173  return MemoryLocation(CS.getArgument(ArgIdx), UnknownSize, AATags);
174 }
Value * getValueOperand()
Definition: Instructions.h:406
A parsed version of the target data layout string in and methods for querying it. ...
Definition: DataLayout.h:104
ValTy * getArgument(unsigned ArgNo) const
Definition: CallSite.h:119
unsigned getNumParams() const
getNumParams - Return the number of fixed parameters this function type requires. ...
Definition: DerivedTypes.h:136
InstrTy * getInstruction() const
Definition: CallSite.h:82
AtomicCmpXchgInst - an instruction that atomically checks whether a specified value is in a memory lo...
Definition: Instructions.h:515
LoadInst - an instruction for reading from memory.
Definition: Instructions.h:177
AtomicRMWInst - an instruction that atomically reads a memory location, combines it with another valu...
Definition: Instructions.h:674
StringRef getName() const
Return a constant reference to the value's name.
Definition: Value.cpp:188
bool has(LibFunc::Func F) const
Tests whether a library function is available.
Value * getPointerOperand()
FunctionType - Class to represent function types.
Definition: DerivedTypes.h:96
static bool isMemsetPattern16(const Function *MS, const TargetLibraryInfo &TLI)
static MemoryLocation getForDest(const MemIntrinsic *MI)
Return a location representing the destination of a memory set or transfer.
StoreInst - an instruction for storing to memory.
Definition: Instructions.h:316
static MemoryLocation get(const LoadInst *LI)
Return a location with information about the memory reference by the given instruction.
Type * getParamType(unsigned i) const
Parameter type accessors.
Definition: DerivedTypes.h:131
FunTy * getCalledFunction() const
getCalledFunction - Return the function being called if this is a direct call, otherwise return null ...
Definition: CallSite.h:99
Value * getRawDest() const
Value * getPointerOperand()
Definition: Instructions.h:284
VAArgInst - This class represents the va_arg llvm instruction, which returns an argument of the speci...
static MemoryLocation getForArgument(ImmutableCallSite CS, unsigned ArgIdx, const TargetLibraryInfo &TLI)
Return a location representing a particular argument of a call.
Representation for a specific memory location.
Value * getValOperand()
Definition: Instructions.h:783
MemIntrinsic - This is the common base class for memset/memcpy/memmove.
This is the shared class of boolean and integer constants.
Definition: Constants.h:47
const Module * getModule() const
Return the module owning the function this instruction belongs to or nullptr it the function does not...
Definition: Instruction.cpp:57
Module.h This file contains the declarations for the Module class.
Type * getType() const
All values are typed, get the type of this value.
Definition: Value.h:222
Provides information about what library functions are available for the current target.
A collection of metadata nodes that might be associated with a memory access used by the alias-analys...
Definition: Metadata.h:548
Value * getLength() const
MemTransferInst - This class wraps the llvm.memcpy/memmove intrinsics.
const DataLayout & getDataLayout() const
Get the data layout for the module's target platform.
Definition: Module.cpp:372
AAMDNodes AATags
The metadata nodes which describes the aliasing of the location (each member is null if that kind of ...
This file provides utility analysis objects describing memory locations.
Value * getPointerOperand()
Definition: Instructions.h:779
void getAAMetadata(AAMDNodes &N, bool Merge=false) const
getAAMetadata - Fills the AAMDNodes structure with AA metadata from this instruction.
ImmutableCallSite - establish a view to a call site for examination.
Definition: CallSite.h:418
FunctionType * getFunctionType() const
Definition: Function.cpp:227
uint64_t getTypeStoreSize(Type *Ty) const
Returns the maximum number of bytes that may be overwritten by storing the specified type...
Definition: DataLayout.h:371
bool isVarArg() const
Definition: DerivedTypes.h:120
Value * getRawSource() const
get* - Return the arguments to the instruction.
LLVM Value Representation.
Definition: Value.h:69
MemoryLocation(const Value *Ptr=nullptr, uint64_t Size=UnknownSize, const AAMDNodes &AATags=AAMDNodes())
Value * getPointerOperand()
Definition: Instructions.h:409
IntrinsicInst - A useful wrapper class for inspecting calls to intrinsic functions.
Definition: IntrinsicInst.h:37
uint64_t Size
The maximum size of the location, in address-units, or UnknownSize if the size is not known...
static MemoryLocation getForSource(const MemTransferInst *MTI)
Return a location representing the source of a memory transfer.