reference, declaration → definition
definition → references, declarations, derived classes, virtual overrides
reference to multiple definitions → definitions
unreferenced

References

include/llvm/IR/IRBuilder.h

 1611     return CreateLoad(Ptr->getType()->getPointerElementType(), Ptr, Name);
 1635     LoadInst *LI = CreateLoad(Ty, Ptr, Name);

lib/CodeGen/AtomicExpandPass.cpp

  384   auto *NewLI = Builder.CreateLoad(NewTy, NewAddr);
  878   LoadInst *InitLoaded = Builder.CreateLoad(PMV.WordType, PMV.AlignedAddr);
 1377   LoadInst *InitLoaded = Builder.CreateLoad(ResultTy, Addr);

lib/CodeGen/ExpandMemCmp.cpp

  287   Value *LoadSrc1 = Builder.CreateLoad(LoadSizeType, Source1);
  288   Value *LoadSrc2 = Builder.CreateLoad(LoadSizeType, Source2);
  353       LoadSrc1 = Builder.CreateLoad(LoadSizeType, Source1);
  359       LoadSrc2 = Builder.CreateLoad(LoadSizeType, Source2);
  456   Value *LoadSrc1 = Builder.CreateLoad(LoadSizeType, Source1);
  457   Value *LoadSrc2 = Builder.CreateLoad(LoadSizeType, Source2);
  577   Value *LoadSrc1 = Builder.CreateLoad(LoadSizeType, Source1);
  578   Value *LoadSrc2 = Builder.CreateLoad(LoadSizeType, Source2);

lib/CodeGen/SafeStack.cpp

  456         DynamicTop ? IRB.CreateLoad(StackPtrTy, DynamicTop) : StaticTop;
  465   Value *V = IRB.CreateLoad(StackPtrTy, StackGuardSlot);
  655     Value *SP = IRB.CreatePtrToInt(IRB.CreateLoad(StackPtrTy, UnsafeStackPtr),
  693         Instruction *LI = IRB.CreateLoad(StackPtrTy, UnsafeStackPtr);

lib/ExecutionEngine/Orc/IndirectionUtils.cpp

  243   LoadInst *ImplAddr = Builder.CreateLoad(F.getType(), &ImplPointer);

lib/IR/AutoUpgrade.cpp

 2240       Value *Load = Builder.CreateLoad(EltTy, Cast);

lib/Target/AArch64/AArch64PromoteConstant.cpp

  497         Builder.CreateLoad(PromotedGV.getValueType(), &PromotedGV);

lib/Target/AMDGPU/AMDGPUCodeGenPrepare.cpp

  943     LoadInst *WidenLoad = Builder.CreateLoad(I32Ty, BitCast);

lib/Target/AMDGPU/AMDGPULibCalls.cpp

 1367     Instruction *Reload = B.CreateLoad(Alloc->getAllocatedType(), Alloc);
 1372     Instruction *Reload = B.CreateLoad(Alloc->getAllocatedType(), Alloc);

lib/Target/AMDGPU/AMDGPUPromoteAlloca.cpp

  433       Value *VecValue = Builder.CreateLoad(VectorTy, BitCast);
  448       Value *VecValue = Builder.CreateLoad(VectorTy, BitCast);

lib/Target/WebAssembly/WebAssemblyLowerEmscriptenEHSjLj.cpp

  439       IRB.CreateLoad(IRB.getInt32Ty(), ThrewGV, ThrewGV->getName() + ".val");
  554   Value *ThrewValue = IRB.CreateLoad(IRB.getInt32Ty(), ThrewValueGV,
  567   Value *LoadedThrew = IRB.CreateLoad(IRB.getInt32Ty(), ThrewInt,

lib/Target/X86/X86WinEHState.cpp

  340       Value *Val = Builder.CreateLoad(Int32Ty, Cookie);
  436   Value *Next = Builder.CreateLoad(LinkTy->getPointerTo(), FSZero);
  451   Value *Next = Builder.CreateLoad(LinkTy->getPointerTo(),
  787       State = Builder.CreateLoad(Builder.getInt32Ty(), StateField);

lib/Transforms/CFGuard/CFGuard.cpp

  169   LoadInst *GuardCheckLoad = B.CreateLoad(GuardFnPtrType, GuardFnGlobal);
  199   LoadInst *GuardDispatchLoad = B.CreateLoad(CalledOperandType, GuardFnGlobal);

lib/Transforms/Coroutines/CoroCleanup.cpp

   52   auto *Load = Builder.CreateLoad(FrameTy->getElementType(Index), Gep);

lib/Transforms/Coroutines/CoroFrame.cpp

  649                : Builder.CreateLoad(FrameTy->getElementType(Index), G,
 1204   auto ValueBeforeCall = Builder.CreateLoad(ValueTy, Alloca);
 1283     auto FinalValue = Builder.CreateLoad(ValueTy, Alloca);

lib/Transforms/Coroutines/CoroSplit.cpp

  385     auto *Load = Builder.CreateLoad(Shape.getSwitchResumePointerType(),
  535       MappedResult = Builder.CreateLoad(ValueTy, Slot);

lib/Transforms/IPO/ArgumentPromotion.cpp

  269           Args.push_back(IRB.CreateLoad(STy->getElementType(i), Idx,
  306               IRB.CreateLoad(OrigLoad->getType(), V, V->getName() + ".val");

lib/Transforms/IPO/LowerTypeTests.cpp

  679     Value *Byte = B.CreateLoad(Int8Ty, ByteAddr);

lib/Transforms/IPO/WholeProgramDevirt.cpp

 1375       Value *Bits = B.CreateLoad(Int8Ty, Addr);
 1382       Value *Val = B.CreateLoad(RetType, ValAddr);
 1632     Value *LoadedValue = LoadB.CreateLoad(Int8PtrTy, GEPPtr);

lib/Transforms/InstCombine/InstCombineCalls.cpp

  186   LoadInst *L = Builder.CreateLoad(IntType, Src);
 2374       Value *Load = Builder.CreateLoad(VTy, Ptr);

lib/Transforms/InstCombine/InstCombineLoadStoreAlloca.cpp

 1029             Builder.CreateLoad(LI.getType(), SI->getOperand(1),
 1032             Builder.CreateLoad(LI.getType(), SI->getOperand(2),

lib/Transforms/InstCombine/InstructionCombining.cpp

 2749       Instruction *NL = Builder.CreateLoad(EV.getType(), GEP);

lib/Transforms/Instrumentation/AddressSanitizer.cpp

  994         {IRB.CreateLoad(IntptrTy, DynamicAllocaLayout), DynamicAreaPtr});
 1701       IRB.CreateLoad(ShadowTy, IRB.CreateIntToPtr(ShadowPtr, ShadowPtrTy));
 2579     LocalDynamicShadow = IRB.CreateLoad(IntptrTy, GlobalDynamicAddress);
 3086         IRB.CreateLoad(IRB.getInt32Ty(), OptionDetectUseAfterReturn),
 3219         Value *SavedFlagPtr = IRBPoison.CreateLoad(

lib/Transforms/Instrumentation/DataFlowSanitizer.cpp

 1039             IRB.CreateLoad(DFS.ShadowTy, getArgTLS(A->getArgNo(), ArgTLSPos));
 1071     ShadowPtrMaskValue = IRB.CreateLoad(IntptrTy, ExternalShadowMask);
 1189       return IRB.CreateLoad(DFS.ShadowTy, i->second);
 1660               IRB.CreateLoad(DFSF.DFS.ShadowTy, DFSF.LabelReturnAlloca);
 1698       LoadInst *LI = NextIRB.CreateLoad(DFSF.DFS.ShadowTy, DFSF.getRetvalTLS());

lib/Transforms/Instrumentation/GCOVProfiling.cpp

  829           Value *Count = Builder.CreateLoad(Builder.getInt64Ty(), Phi);
  840             Value *Count = Builder.CreateLoad(Builder.getInt64Ty(), Counter);
 1104       {Builder.CreateLoad(StartFileCallArgsTy->getElementType(0),
 1107        Builder.CreateLoad(StartFileCallArgsTy->getElementType(1),
 1110        Builder.CreateLoad(StartFileCallArgsTy->getElementType(2),
 1116       Builder.CreateLoad(FileInfoTy->getElementType(1),
 1119       Builder.CreateLoad(FileInfoTy->getElementType(2),
 1122       Builder.CreateLoad(FileInfoTy->getElementType(3),
 1135       {Builder.CreateLoad(EmitFunctionCallArgsTy->getElementType(0),
 1138        Builder.CreateLoad(EmitFunctionCallArgsTy->getElementType(1),
 1141        Builder.CreateLoad(EmitFunctionCallArgsTy->getElementType(2),
 1144        Builder.CreateLoad(EmitFunctionCallArgsTy->getElementType(3),
 1147        Builder.CreateLoad(EmitFunctionCallArgsTy->getElementType(4),
 1161       {Builder.CreateLoad(
 1164        Builder.CreateLoad(EmitArcsCallArgsTy->getElementType(1),

lib/Transforms/Instrumentation/HWAddressSanitizer.cpp

  502     return IRB.CreateLoad(Int8PtrTy, GlobalDynamicAddress);
  633   Value *MemTag = IRB.CreateLoad(Int8Ty, Shadow);
  667   Value *InlineTag = IRB.CreateLoad(Int8Ty, InlineTagAddr);
  937   Instruction *ThreadLong = IRB.CreateLoad(IntptrTy, SlotPtr);
  951     LoadInst *ReloadThreadLong = IRB.CreateLoad(IntptrTy, SlotPtr);

lib/Transforms/Instrumentation/InstrProfiling.cpp

 1008   auto *Load = IRB.CreateLoad(Int32Ty, Var);

lib/Transforms/Instrumentation/MemorySanitizer.cpp

 1659             setOrigin(A, EntryIRB.CreateLoad(MS.OriginTy, OriginPtr));
 2499         setOrigin(&I, IRB.CreateLoad(MS.OriginTy, OriginPtr));
 2901     Value *Origin = MS.TrackOrigins ? IRB.CreateLoad(MS.OriginTy, OriginPtr)
 2976             getOrigin(PassThru), IRB.CreateLoad(MS.OriginTy, OriginPtr));
 3385       setOrigin(&I, IRBAfter.CreateLoad(MS.OriginTy,
 3943           IRB.CreateLoad(IRB.getInt64Ty(), MS.VAArgOverflowSizeTLS);
 3968           IRB.CreateLoad(RegSaveAreaPtrTy, RegSaveAreaPtrPtr);
 3985           IRB.CreateLoad(OverflowArgAreaPtrTy, OverflowArgAreaPtrPtr);
 4087     VAArgSize = IRB.CreateLoad(IRB.getInt64Ty(), MS.VAArgOverflowSizeTLS);
 4109           IRB.CreateLoad(RegSaveAreaPtrTy, RegSaveAreaPtrPtr);
 4259     return IRB.CreateLoad(Type::getInt64Ty(*MS.C), SaveAreaPtrPtr);
 4269     Value *SaveArea32 = IRB.CreateLoad(IRB.getInt32Ty(), SaveAreaPtr);
 4281           IRB.CreateLoad(IRB.getInt64Ty(), MS.VAArgOverflowSizeTLS);
 4524     VAArgSize = IRB.CreateLoad(IRB.getInt64Ty(), MS.VAArgOverflowSizeTLS);
 4546           IRB.CreateLoad(RegSaveAreaPtrTy, RegSaveAreaPtrPtr);

lib/Transforms/Instrumentation/SanitizerCoverage.cpp

  882     auto Load = IRB.CreateLoad(Int8Ty, CounterPtr);
  897     auto LowestStack = IRB.CreateLoad(IntptrTy, SanCovLowestStack);

lib/Transforms/Scalar/LowerAtomic.cpp

   29   LoadInst *Orig = Builder.CreateLoad(Val->getType(), Ptr);
   47   LoadInst *Orig = Builder.CreateLoad(Val->getType(), Ptr);

lib/Transforms/Scalar/MergeICmps.cpp

  629         Builder.CreateLoad(FirstCmp.Lhs().LoadI->getType(), Lhs);
  631         Builder.CreateLoad(FirstCmp.Rhs().LoadI->getType(), Rhs);

lib/Transforms/Scalar/SROA.cpp

 1302     LoadInst *Load = PredBuilder.CreateLoad(
 1366     LoadInst *TL = IRB.CreateLoad(LI->getType(), TV,
 1368     LoadInst *FL = IRB.CreateLoad(LI->getType(), FV,

lib/Transforms/Utils/VNCoercion.cpp

  432     LoadInst *NewLoad = Builder.CreateLoad(DestTy, PtrVal);

lib/Transforms/Vectorize/SLPVectorizer.cpp

 4032       LI = Builder.CreateLoad(VecTy, VecPtr);

unittests/Analysis/MemorySSATest.cpp

   95   LoadInst *LoadInst = B.CreateLoad(B.getInt8Ty(), PointerArg);
  141   LoadInst *FirstLoad = B.CreateLoad(B.getInt8Ty(), PointerArg);
  169   LoadInst *SecondLoad = B.CreateLoad(B.getInt8Ty(), PointerArg);
  235   LoadInst *LoadInst = B.CreateLoad(B.getInt8Ty(), PointerArg);
  265   LoadInst *LoadInst1 = B.CreateLoad(B.getInt8Ty(), PointerArg);
  313   B.CreateLoad(B.getInt8Ty(), PointerArg);
  349   auto *MergeLoad = B.CreateLoad(B.getInt8Ty(), PointerArg);
  395   auto *MergeLoad = B.CreateLoad(B.getInt8Ty(), PointerArg);
  439   auto *MergeLoad = B.CreateLoad(B.getInt8Ty(), PointerArg);
  493   LoadInst *LoadInst = B.CreateLoad(B.getInt8Ty(), PointerArg);
  538   LoadInst *LoadInst = B.CreateLoad(B.getInt8Ty(), PointerArg);
  634   Instruction *LI = B.CreateLoad(Int8, Alloca);
  774   Instruction *Load = B.CreateLoad(Int8, AllocA);
  803   Instruction *LIA = B.CreateLoad(Int8, AllocaA);
  837   LoadInst *LoadB = B.CreateLoad(Int8, B_);
  841   LoadInst *LoadC = B.CreateLoad(Int8, C);
  905   LoadInst *LoadInst = B.CreateLoad(B.getInt8Ty(), FirstArg);

unittests/Analysis/OrderedInstructionsTest.cpp

   47   LoadInst *LoadInstX = B.CreateLoad(B.getInt8Ty(), PointerArg);
   48   LoadInst *LoadInstY = B.CreateLoad(B.getInt8Ty(), PointerArg);
   53   LoadInst *LoadInstZ = B.CreateLoad(B.getInt8Ty(), PointerArg);

unittests/Analysis/SparsePropagation.cpp

  384   LoadInst *Cond = Builder.CreateLoad(Type::getInt1Ty(Context), F->arg_begin());
  424   LoadInst *Cond = Builder.CreateLoad(Type::getInt1Ty(Context), F->arg_begin());

unittests/ExecutionEngine/MCJIT/MCJITMultipleModuleTest.cpp

  214   endFunctionWithRet(FA, Builder.CreateLoad(Builder.getInt32Ty(), GVA));
  217   endFunctionWithRet(FB, Builder.CreateLoad(Builder.getInt32Ty(), GVB));

unittests/ExecutionEngine/MCJIT/MCJITTest.cpp

  104   Value *ReadGlobal = Builder.CreateLoad(Builder.getInt32Ty(), GV);

unittests/IR/IRBuilderTest.cpp

   57   V = Builder.CreateLoad(GV->getValueType(), GV);
  180   V = Builder.CreateLoad(GV->getValueType(), GV);
  181   VDouble = Builder.CreateLoad(GVDouble->getValueType(), GVDouble);
  378   Value *V = Builder.CreateLoad(GV->getValueType(), GV);
  403   F = Builder.CreateLoad(GV->getValueType(), GV);
  590   Value *V = Builder.CreateLoad(G->getValueType(), G);
  657   Value *F = Builder.CreateLoad(GV->getValueType(), GV);

unittests/IR/PatternMatch.cpp

  863   Value *LoadInst = IRB.CreateLoad(IRB.getInt32Ty(), Alloca);

unittests/Transforms/Utils/FunctionComparatorTest.cpp

   34     LoadInst *LoadInst = B.CreateLoad(T, PointerArg);