LLVM  7.0.0svn
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  return getForSource(cast<AnyMemTransferInst>(MTI));
69 }
70 
72  return getForSource(cast<AnyMemTransferInst>(MTI));
73 }
74 
76  uint64_t Size = UnknownSize;
77  if (ConstantInt *C = dyn_cast<ConstantInt>(MTI->getLength()))
78  Size = C->getValue().getZExtValue();
79 
80  // memcpy/memmove can have AA tags. For memcpy, they apply
81  // to both the source and the destination.
83  MTI->getAAMetadata(AATags);
84 
85  return MemoryLocation(MTI->getRawSource(), Size, AATags);
86 }
87 
89  return getForDest(cast<AnyMemIntrinsic>(MI));
90 }
91 
93  return getForDest(cast<AnyMemIntrinsic>(MI));
94 }
95 
97  uint64_t Size = UnknownSize;
98  if (ConstantInt *C = dyn_cast<ConstantInt>(MI->getLength()))
99  Size = C->getValue().getZExtValue();
100 
101  // memcpy/memmove can have AA tags. For memcpy, they apply
102  // to both the source and the destination.
104  MI->getAAMetadata(AATags);
105 
106  return MemoryLocation(MI->getRawDest(), Size, AATags);
107 }
108 
110  unsigned ArgIdx,
111  const TargetLibraryInfo &TLI) {
113  CS->getAAMetadata(AATags);
114  const Value *Arg = CS.getArgument(ArgIdx);
115 
116  // We may be able to produce an exact size for known intrinsics.
117  if (const IntrinsicInst *II = dyn_cast<IntrinsicInst>(CS.getInstruction())) {
118  const DataLayout &DL = II->getModule()->getDataLayout();
119 
120  switch (II->getIntrinsicID()) {
121  default:
122  break;
123  case Intrinsic::memset:
124  case Intrinsic::memcpy:
125  case Intrinsic::memmove:
126  assert((ArgIdx == 0 || ArgIdx == 1) &&
127  "Invalid argument index for memory intrinsic");
128  if (ConstantInt *LenCI = dyn_cast<ConstantInt>(II->getArgOperand(2)))
129  return MemoryLocation(Arg, LenCI->getZExtValue(), AATags);
130  break;
131 
132  case Intrinsic::lifetime_start:
133  case Intrinsic::lifetime_end:
134  case Intrinsic::invariant_start:
135  assert(ArgIdx == 1 && "Invalid argument index");
136  return MemoryLocation(
137  Arg, cast<ConstantInt>(II->getArgOperand(0))->getZExtValue(), AATags);
138 
139  case Intrinsic::invariant_end:
140  assert(ArgIdx == 2 && "Invalid argument index");
141  return MemoryLocation(
142  Arg, cast<ConstantInt>(II->getArgOperand(1))->getZExtValue(), AATags);
143 
144  case Intrinsic::arm_neon_vld1:
145  assert(ArgIdx == 0 && "Invalid argument index");
146  // LLVM's vld1 and vst1 intrinsics currently only support a single
147  // vector register.
148  return MemoryLocation(Arg, DL.getTypeStoreSize(II->getType()), AATags);
149 
150  case Intrinsic::arm_neon_vst1:
151  assert(ArgIdx == 0 && "Invalid argument index");
152  return MemoryLocation(
153  Arg, DL.getTypeStoreSize(II->getArgOperand(1)->getType()), AATags);
154  }
155  }
156 
157  // We can bound the aliasing properties of memset_pattern16 just as we can
158  // for memcpy/memset. This is particularly important because the
159  // LoopIdiomRecognizer likes to turn loops into calls to memset_pattern16
160  // whenever possible.
161  LibFunc F;
162  if (CS.getCalledFunction() && TLI.getLibFunc(*CS.getCalledFunction(), F) &&
163  F == LibFunc_memset_pattern16 && TLI.has(F)) {
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 }
uint64_t CallInst * C
Value * getValueOperand()
Definition: Instructions.h:399
A parsed version of the target data layout string in and methods for querying it. ...
Definition: DataLayout.h:111
Compute iterated dominance frontiers using a linear time algorithm.
Definition: AllocatorList.h:24
an instruction that atomically checks whether a specified value is in a memory location, and, if it is, stores a new value there.
Definition: Instructions.h:518
F(f)
An instruction for reading from memory.
Definition: Instructions.h:168
an instruction that atomically reads a memory location, combines it with another value, and then stores the result back.
Definition: Instructions.h:681
Value * getLength() const
const DataLayout & getDataLayout() const
Get the data layout for the module&#39;s target platform.
Definition: Module.cpp:361
InstrTy * getInstruction() const
Definition: CallSite.h:92
Value * getPointerOperand()
Type * getType() const
All values are typed, get the type of this value.
Definition: Value.h:245
static MemoryLocation getForDest(const MemIntrinsic *MI)
Return a location representing the destination of a memory set or transfer.
bool has(LibFunc F) const
Tests whether a library function is available.
An instruction for storing to memory.
Definition: Instructions.h:310
void getAAMetadata(AAMDNodes &N, bool Merge=false) const
Fills the AAMDNodes structure with AA metadata from this instruction.
static MemoryLocation get(const LoadInst *LI)
Return a location with information about the memory reference by the given instruction.
LocationSize Size
The maximum size of the location, in address-units, or UnknownSize if the size is not known...
Value * getPointerOperand()
Definition: Instructions.h:274
This class represents the va_arg llvm instruction, which returns an argument of the specified type gi...
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:787
This is the common base class for memset/memcpy/memmove.
This is the shared class of boolean and integer constants.
Definition: Constants.h:84
ValTy * getArgument(unsigned ArgNo) const
Definition: CallSite.h:186
Module.h This file contains the declarations for the Module class.
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:642
MemoryLocation(const Value *Ptr=nullptr, LocationSize Size=UnknownSize, const AAMDNodes &AATags=AAMDNodes())
Value * getRawSource() const
Return the arguments to the instruction.
const Module * getModule() const
Return the module owning the function this instruction belongs to or nullptr it the function does not...
Definition: Instruction.cpp:56
bool getLibFunc(StringRef funcName, LibFunc &F) const
Searches for a particular function name.
amdgpu Simplify well known AMD library false Value Value * Arg
This class wraps the llvm.memcpy/memmove intrinsics.
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:783
Establish a view to a call site for examination.
Definition: CallSite.h:714
FunTy * getCalledFunction() const
Return the function being called if this is a direct call, otherwise return null (if it&#39;s an indirect...
Definition: CallSite.h:107
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
LLVM Value Representation.
Definition: Value.h:73
uint64_t getTypeStoreSize(Type *Ty) const
Returns the maximum number of bytes that may be overwritten by storing the specified type...
Definition: DataLayout.h:411
IRTranslator LLVM IR MI
Value * getPointerOperand()
Definition: Instructions.h:402
Value * getRawDest() const
A wrapper class for inspecting calls to intrinsic functions.
Definition: IntrinsicInst.h:44
static MemoryLocation getForSource(const MemTransferInst *MTI)
Return a location representing the source of a memory transfer.