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

Declarations

include/llvm/IR/Instruction.def

  218 HANDLE_OTHER_INST(65, InsertValue, InsertValueInst)  // insert into aggregate

include/llvm/Transforms/Vectorize/SLPVectorizer.h

   38 class InsertValueInst;

References

include/llvm/IR/IRBuilder.h

  845   InstTy *Insert(InstTy *I, const Twine &Name = "") const {
  845   InstTy *Insert(InstTy *I, const Twine &Name = "") const {
 2387     return Insert(InsertValueInst::Create(Agg, Val, Idxs), Name);

include/llvm/IR/InstVisitor.h

  197   RetTy visitInsertValueInst(InsertValueInst &I)  { DELEGATE(Instruction); }

include/llvm/IR/Instructions.h

 2406   InsertValueInst(const InsertValueInst &IVI);
 2435   InsertValueInst *cloneImpl() const;
 2443   static InsertValueInst *Create(Value *Agg, Value *Val,
 2447     return new InsertValueInst(Agg, Val, Idxs, NameStr, InsertBefore);
 2450   static InsertValueInst *Create(Value *Agg, Value *Val,
 2454     return new InsertValueInst(Agg, Val, Idxs, NameStr, InsertAtEnd);
 2511   public FixedNumOperandTraits<InsertValueInst, 2> {
 2520                 OperandTraits<InsertValueInst>::op_begin(this),
 2531                 OperandTraits<InsertValueInst>::op_begin(this),

include/llvm/IR/NoFolder.h

  339     return InsertValueInst::Create(Agg, Val, IdxList);

include/llvm/IR/OperandTraits.h

   31   static Use *op_begin(SubClass* U) {
   33         !std::is_polymorphic<SubClass>::value,
   37   static Use *op_end(SubClass* U) {

include/llvm/IR/User.h

  127   template <int Idx, typename U> static Use &OpFrom(const U *that) {
  129       ? OperandTraits<U>::op_end(const_cast<U*>(that))[Idx]
  130       : OperandTraits<U>::op_begin(const_cast<U*>(that))[Idx];

include/llvm/Support/Casting.h

   58     return To::classof(&Val);
   77     return isa_impl<To, From>::doit(Val);
   92     return isa_impl<To, From>::doit(*Val);
  106     return isa_impl<To, From>::doit(*Val);
  122     return isa_impl_wrap<To, SimpleFrom,
  132     return isa_impl_cl<To,FromTy>::doit(Val);
  142   return isa_impl_wrap<X, const Y,
  172   using ret_type = To *;       // Pointer arg case, return Ty*
  176   using ret_type = const To *; // Constant pointer arg case, return const Ty*
  198   using ret_type = typename cast_retty<To, SimpleFrom>::ret_type;
  204   using ret_type = typename cast_retty_impl<To,FromTy>::ret_type;
  210       To, From, typename simplify_type<From>::SimpleType>::ret_type;
  218   static typename cast_retty<To, From>::ret_type doit(From &Val) {
  219     return cast_convert_val<To, SimpleFrom,
  227   static typename cast_retty<To, FromTy>::ret_type doit(const FromTy &Val) {
  228     typename cast_retty<To, FromTy>::ret_type Res2
  248                                typename cast_retty<X, const Y>::ret_type>::type
  256 inline typename cast_retty<X, Y>::ret_type cast(Y &Val) {
  258   return cast_convert_val<X, Y,
  263 inline typename cast_retty<X, Y *>::ret_type cast(Y *Val) {
  265   return cast_convert_val<X, Y*,
  331                             typename cast_retty<X, const Y>::ret_type>::type
  337 LLVM_NODISCARD inline typename cast_retty<X, Y>::ret_type dyn_cast(Y &Val) {
  338   return isa<X>(Val) ? cast<X>(Val) : nullptr;
  338   return isa<X>(Val) ? cast<X>(Val) : nullptr;
  342 LLVM_NODISCARD inline typename cast_retty<X, Y *>::ret_type dyn_cast(Y *Val) {
  343   return isa<X>(Val) ? cast<X>(Val) : nullptr;
  343   return isa<X>(Val) ? cast<X>(Val) : nullptr;
  366 LLVM_NODISCARD inline typename cast_retty<X, Y *>::ret_type
  368   return (Val && isa<X>(Val)) ? cast<X>(Val) : nullptr;
  368   return (Val && isa<X>(Val)) ? cast<X>(Val) : nullptr;

include/llvm/Transforms/Vectorize/SLPVectorizer.h

  121   bool vectorizeInsertValueInst(InsertValueInst *IVI, BasicBlock *BB,

lib/Analysis/CFLGraph.h

  490     void visitInsertValueInst(InsertValueInst &Inst) {

lib/Analysis/ConstantFolding.cpp

 1173   if (auto *IVI = dyn_cast<InsertValueInst>(I)) {
 1173   if (auto *IVI = dyn_cast<InsertValueInst>(I)) {

lib/Analysis/InlineCost.cpp

  280   bool visitInsertValue(InsertValueInst &I);
 1184 bool CallAnalyzer::visitInsertValue(InsertValueInst &I) {

lib/Analysis/InstructionSimplify.cpp

 4183   for (auto *IVI = dyn_cast<InsertValueInst>(Agg); IVI != nullptr;
 4183   for (auto *IVI = dyn_cast<InsertValueInst>(Agg); IVI != nullptr;
 4184        IVI = dyn_cast<InsertValueInst>(IVI->getAggregateOperand())) {
 5340     InsertValueInst *IV = cast<InsertValueInst>(I);
 5340     InsertValueInst *IV = cast<InsertValueInst>(I);

lib/Analysis/ValueTracking.cpp

 3311           InsertValueInst* Del = cast<InsertValueInst>(PrevTo);
 3311           InsertValueInst* Del = cast<InsertValueInst>(PrevTo);
 3335   return InsertValueInst::Create(To, V, makeArrayRef(Idxs).slice(IdxSkip),
 3387   if (InsertValueInst *I = dyn_cast<InsertValueInst>(V)) {
 3387   if (InsertValueInst *I = dyn_cast<InsertValueInst>(V)) {

lib/AsmParser/LLParser.cpp

 7283   Inst = InsertValueInst::Create(Val0, Val1, Indices);

lib/Bitcode/Reader/BitcodeReader.cpp

 4074       I = InsertValueInst::Create(Agg, Val, INSERTVALIdx);

lib/Bitcode/Writer/BitcodeWriter.cpp

 2663     const InsertValueInst *IVI = cast<InsertValueInst>(&I);
 2663     const InsertValueInst *IVI = cast<InsertValueInst>(&I);

lib/CodeGen/Analysis.cpp

  319     } else if (const InsertValueInst *IVI = dyn_cast<InsertValueInst>(V)) {
  319     } else if (const InsertValueInst *IVI = dyn_cast<InsertValueInst>(V)) {

lib/CodeGen/DwarfEHPrepare.cpp

  105   InsertValueInst *SelIVI = dyn_cast<InsertValueInst>(V);
  105   InsertValueInst *SelIVI = dyn_cast<InsertValueInst>(V);
  107   InsertValueInst *ExcIVI = nullptr;
  112       ExcIVI = dyn_cast<InsertValueInst>(SelIVI->getOperand(0));

lib/CodeGen/GlobalISel/IRTranslator.cpp

  954   } else if (const InsertValueInst *IVI = dyn_cast<InsertValueInst>(&U)) {
  954   } else if (const InsertValueInst *IVI = dyn_cast<InsertValueInst>(&U)) {

lib/CodeGen/SelectionDAG/SelectionDAGBuilder.cpp

 3742   if (const InsertValueInst *IV = dyn_cast<InsertValueInst>(&I))
 3742   if (const InsertValueInst *IV = dyn_cast<InsertValueInst>(&I))

lib/ExecutionEngine/Interpreter/Execution.cpp

 1974 void Interpreter::visitInsertValueInst(InsertValueInst &I) {

lib/ExecutionEngine/Interpreter/Interpreter.h

  168   void visitInsertValueInst(InsertValueInst &I);

lib/FuzzMutate/Operations.cpp

  270     return InsertValueInst::Create(Srcs[0], Srcs[1], {Idx}, "I", Inst);

lib/IR/AsmWriter.cpp

 3771   } else if (const InsertValueInst *IVI = dyn_cast<InsertValueInst>(&I)) {
 3771   } else if (const InsertValueInst *IVI = dyn_cast<InsertValueInst>(&I)) {

lib/IR/Constants.cpp

 3012     return InsertValueInst::Create(Ops[0], Ops[1], getIndices());

lib/IR/Core.cpp

 2964   if (auto *IV = dyn_cast<InsertValueInst>(I))
 2964   if (auto *IV = dyn_cast<InsertValueInst>(I))
 2976   if (auto *IV = dyn_cast<InsertValueInst>(I))
 2976   if (auto *IV = dyn_cast<InsertValueInst>(I))

lib/IR/Instruction.cpp

  415   if (const InsertValueInst *IVI = dyn_cast<InsertValueInst>(I1))
  415   if (const InsertValueInst *IVI = dyn_cast<InsertValueInst>(I1))
  416     return IVI->getIndices() == cast<InsertValueInst>(I2)->getIndices();

lib/IR/Instructions.cpp

 2126 InsertValueInst::InsertValueInst(const InsertValueInst &IVI)
 2128                 OperandTraits<InsertValueInst>::op_begin(this), 2),
 4125 InsertValueInst *InsertValueInst::cloneImpl() const {
 4126   return new InsertValueInst(*this);

lib/IR/Verifier.cpp

  485   void visitInsertValueInst(InsertValueInst &IVI);
 3570 void Verifier::visitInsertValueInst(InsertValueInst &IVI) {

lib/Target/AArch64/AArch64PromoteConstant.cpp

  269   if (isa<const InsertValueInst>(Instr) && OpIdx > 1)

lib/Transforms/IPO/DeadArgumentElimination.cpp

  406     if (const InsertValueInst *IV = dyn_cast<InsertValueInst>(V)) {
  406     if (const InsertValueInst *IV = dyn_cast<InsertValueInst>(V)) {
  407       if (U->getOperandNo() != InsertValueInst::getAggregateOperandIndex()
  993             RetVal = InsertValueInst::Create(RetVal, V, i, "oldret", InsertPt);
 1057                 RetVal = InsertValueInst::Create(RetVal, EV, NewRetIdxs[i],

lib/Transforms/InstCombine/InstCombineInternal.h

  441   Instruction *visitInsertValueInst(InsertValueInst &IV);
  687     return InsertValueInst::Create(Struct, Result, 0);

lib/Transforms/InstCombine/InstCombineLoadStoreAlloca.cpp

 1078   while (auto *IV = dyn_cast<InsertValueInst>(V)) {
 1078   while (auto *IV = dyn_cast<InsertValueInst>(V)) {

lib/Transforms/InstCombine/InstCombineVectorOps.cpp

  697 Instruction *InstCombiner::visitInsertValueInst(InsertValueInst &I) {
  709     auto UserInsInst = dyn_cast<InsertValueInst>(U);

lib/Transforms/InstCombine/InstructionCombining.cpp

 2654   if (InsertValueInst *IV = dyn_cast<InsertValueInst>(Agg)) {
 2654   if (InsertValueInst *IV = dyn_cast<InsertValueInst>(Agg)) {
 2690       return InsertValueInst::Create(NewEV, IV->getInsertedValueOperand(),

lib/Transforms/Instrumentation/ControlHeightReduction.cpp

  500       isa<InsertValueInst>(I);

lib/Transforms/Instrumentation/DataFlowSanitizer.cpp

  454   void visitInsertValueInst(InsertValueInst &I);
 1434 void DFSanVisitor::visitInsertValueInst(InsertValueInst &I) {

lib/Transforms/Instrumentation/MemorySanitizer.cpp

 3590   void visitInsertValueInst(InsertValueInst &I) {

lib/Transforms/Scalar/EarlyCSE.cpp

  116            isa<InsertValueInst>(Inst);
  237   if (const InsertValueInst *IVI = dyn_cast<InsertValueInst>(Inst))
  237   if (const InsertValueInst *IVI = dyn_cast<InsertValueInst>(Inst))

lib/Transforms/Scalar/GVN.cpp

  299   } else if (InsertValueInst *E = dyn_cast<InsertValueInst>(I)) {
  299   } else if (InsertValueInst *E = dyn_cast<InsertValueInst>(I)) {
  300     for (InsertValueInst::idx_iterator II = E->idx_begin(), IE = E->idx_end();

lib/Transforms/Scalar/LICM.cpp

 1041           isa<InsertValueInst>(I));

lib/Transforms/Scalar/NewGVN.cpp

 1202   if (auto *II = dyn_cast<InsertValueInst>(I)) {
 1202   if (auto *II = dyn_cast<InsertValueInst>(I)) {

lib/Transforms/Scalar/SCCP.cpp

  622   void visitInsertValueInst(InsertValueInst &IVI);
  908 void SCCPSolver::visitInsertValueInst(InsertValueInst &IVI) {
 1455         if (isa<ExtractValueInst>(I) || isa<InsertValueInst>(I))

lib/Transforms/Utils/Evaluator.cpp

  427     } else if (auto *IVI = dyn_cast<InsertValueInst>(CurInst)) {
  427     } else if (auto *IVI = dyn_cast<InsertValueInst>(CurInst)) {

lib/Transforms/Utils/FunctionComparator.cpp

  587   if (const InsertValueInst *IVI = dyn_cast<InsertValueInst>(L)) {
  587   if (const InsertValueInst *IVI = dyn_cast<InsertValueInst>(L)) {
  589     ArrayRef<unsigned> RIndices = cast<InsertValueInst>(R)->getIndices();

lib/Transforms/Vectorize/SLPVectorizer.cpp

 6652 static bool findBuildAggregate(InsertValueInst *IV,
 6659     IV = dyn_cast<InsertValueInst>(V);
 6826 bool SLPVectorizerPass::vectorizeInsertValueInst(InsertValueInst *IVI,
 6876     if (auto *LastInsertValue = dyn_cast<InsertValueInst>(I))
 6876     if (auto *LastInsertValue = dyn_cast<InsertValueInst>(I))
 7014         isa<InsertValueInst>(it))