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

Declarations

include/llvm/IR/Instruction.def

  127 HANDLE_TERM_INST  ( 1, Ret           , ReturnInst)

include/llvm/Transforms/Utils/BasicBlockUtils.h

   39 class ReturnInst;

include/llvm/Transforms/Utils/Cloning.h

   48 class ReturnInst;

lib/CodeGen/SelectionDAG/SelectionDAGBuilder.h

   78 class ReturnInst;

References

examples/BrainF/BrainF.cpp

  136   ReturnInst::Create(C, endbb);

examples/BrainF/BrainFDriver.cpp

  102   ReturnInst::Create(mod->getContext(),

examples/Fibonacci/fibonacci.cpp

   80   ReturnInst::Create(Context, One, RetBB);
   97   ReturnInst::Create(Context, Sum, RecurseBB);

examples/ModuleMaker/ModuleMaker.cpp

   61   BB->getInstList().push_back(ReturnInst::Create(Context, Add));

examples/ParallelJIT/ParallelJIT.cpp

   74   ReturnInst::Create(Context, Add, BB);
  110   ReturnInst::Create(Context, One, RetBB);
  125   ReturnInst::Create(Context, Sum, RecurseBB);

include/llvm/ADT/ArrayRef.h

  108         const ArrayRef<U *> &A,
  110            std::is_convertible<U *const *, T const *>::value>::type * = nullptr)
  118       const SmallVectorTemplateCommon<U *, DummyT> &Vec,
  120           std::is_convertible<U *const *, T const *>::value>::type * = nullptr)

include/llvm/ADT/DenseMapInfo.h

   39   static inline T* getEmptyKey() {
   41     Val <<= PointerLikeTypeTraits<T*>::NumLowBitsAvailable;
   45   static inline T* getTombstoneKey() {
   47     Val <<= PointerLikeTypeTraits<T*>::NumLowBitsAvailable;
   51   static unsigned getHashValue(const T *PtrVal) {
   56   static bool isEqual(const T *LHS, const T *RHS) { return LHS == RHS; }
   56   static bool isEqual(const T *LHS, const T *RHS) { return LHS == RHS; }

include/llvm/CodeGen/Analysis.h

  134                               const ReturnInst *Ret,
  142                                      const ReturnInst *Ret,

include/llvm/IR/IRBuilder.h

  845   InstTy *Insert(InstTy *I, const Twine &Name = "") const {
  845   InstTy *Insert(InstTy *I, const Twine &Name = "") const {
  875   ReturnInst *CreateRetVoid() {
  876     return Insert(ReturnInst::Create(Context));
  880   ReturnInst *CreateRet(Value *V) {
  881     return Insert(ReturnInst::Create(Context, V));
  891   ReturnInst *CreateAggregateRet(Value *const *retVals, unsigned N) {
  895     return Insert(ReturnInst::Create(Context, V));

include/llvm/IR/InstVisitor.h

  234   RetTy visitReturnInst(ReturnInst &I) {

include/llvm/IR/Instructions.h

 2894   ReturnInst(const ReturnInst &RI);
 2917   ReturnInst *cloneImpl() const;
 2920   static ReturnInst* Create(LLVMContext &C, Value *retVal = nullptr,
 2922     return new(!!retVal) ReturnInst(C, retVal, InsertBefore);
 2925   static ReturnInst* Create(LLVMContext &C, Value *retVal,
 2927     return new(!!retVal) ReturnInst(C, retVal, InsertAtEnd);
 2930   static ReturnInst* Create(LLVMContext &C, BasicBlock *InsertAtEnd) {
 2931     return new(0) ReturnInst(C, InsertAtEnd);
 2963 struct OperandTraits<ReturnInst> : public VariadicOperandTraits<ReturnInst> {

include/llvm/IR/OperandTraits.h

   69   static Use *op_begin(SubClass* U) {
   71         !std::is_polymorphic<SubClass>::value,
   75   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);
   66   static inline bool doit(const From &) { return true; }
   77     return isa_impl<To, From>::doit(Val);
   92     return isa_impl<To, From>::doit(*Val);
  104   static inline bool doit(const From *Val) {
  106     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,
  165   using ret_type = To &;       // Normal case, return Ty&
  168   using ret_type = const To &; // Normal case, return Ty&
  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
  252       X, const Y, typename simplify_type<const Y>::SimpleType>::doit(Val);
  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) {
  263 inline typename cast_retty<X, Y *>::ret_type cast(Y *Val) {
  263 inline typename cast_retty<X, Y *>::ret_type cast(Y *Val) {
  265   return cast_convert_val<X, Y*,
  265   return cast_convert_val<X, Y*,
  266                           typename simplify_type<Y*>::SimpleType>::doit(Val);
  337 LLVM_NODISCARD inline typename cast_retty<X, Y>::ret_type dyn_cast(Y &Val) {
  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/Support/PointerLikeTypeTraits.h

   56   static inline void *getAsVoidPointer(T *P) { return P; }
   57   static inline T *getFromVoidPointer(void *P) { return static_cast<T *>(P); }
   59   enum { NumLowBitsAvailable = detail::ConstantLog2<alignof(T)>::value };

include/llvm/Transforms/IPO/Attributor.h

  859       const function_ref<bool(Value &, const SmallSetVector<ReturnInst *, 4> &)>
 1549       const function_ref<bool(Value &, const SmallSetVector<ReturnInst *, 4> &)>
 1553       MapVector<Value *, SmallSetVector<ReturnInst *, 4>>::iterator;
 1555       MapVector<Value *, SmallSetVector<ReturnInst *, 4>>::const_iterator;

include/llvm/Transforms/Utils/BasicBlockUtils.h

  276 ReturnInst *FoldReturnIntoUncondBranch(ReturnInst *RI, BasicBlock *BB,
  276 ReturnInst *FoldReturnIntoUncondBranch(ReturnInst *RI, BasicBlock *BB,

include/llvm/Transforms/Utils/Cloning.h

  140                        SmallVectorImpl<ReturnInst*> &Returns,
  149                                SmallVectorImpl<ReturnInst *> &Returns,
  166                                SmallVectorImpl<ReturnInst*> &Returns,

lib/Analysis/CFLGraph.h

  263     void visitReturnInst(ReturnInst &Inst) {
  605                                     !isa<ReturnInst>(Inst);

lib/Analysis/CaptureTracking.cpp

   60       if (isa<ReturnInst>(U->getUser()) && !ReturnCaptures)
  146       if (isa<ReturnInst>(U->getUser()) && !ReturnCaptures)

lib/Analysis/CodeMetrics.cpp

  177   if (isa<ReturnInst>(BB->getTerminator()))

lib/Analysis/InlineCost.cpp

  282   bool visitReturnInst(ReturnInst &RI);
 1336 bool CallAnalyzer::visitReturnInst(ReturnInst &RI) {

lib/Analysis/Lint.cpp

  104     void visitReturnInst(ReturnInst &I);
  401 void Lint::visitReturnInst(ReturnInst &I) {

lib/Analysis/ValueTracking.cpp

 4256   if (isa<ReturnInst>(I))

lib/AsmParser/LLParser.cpp

 5906     Inst = ReturnInst::Create(Context);
 5917   Inst = ReturnInst::Create(Context, RV);

lib/Bitcode/Reader/BitcodeReader.cpp

 4215           I = ReturnInst::Create(Context);
 4227         I = ReturnInst::Create(Context, Op);

lib/CodeGen/Analysis.cpp

  516   const ReturnInst *Ret = dyn_cast<ReturnInst>(Term);
  516   const ReturnInst *Ret = dyn_cast<ReturnInst>(Term);
  558                                     const ReturnInst *Ret,
  616                                            const ReturnInst *Ret,

lib/CodeGen/CodeGenPrepare.cpp

 1976   ReturnInst *RetI = dyn_cast<ReturnInst>(BB->getTerminator());
 1976   ReturnInst *RetI = dyn_cast<ReturnInst>(BB->getTerminator());

lib/CodeGen/GlobalISel/IRTranslator.cpp

  363   const ReturnInst &RI = cast<ReturnInst>(U);
  363   const ReturnInst &RI = cast<ReturnInst>(U);

lib/CodeGen/SafeStack.cpp

  149   void checkStackGuard(IRBuilder<> &IRB, Function &F, ReturnInst &RI,
  158                  SmallVectorImpl<ReturnInst *> &Returns,
  174                                         ArrayRef<ReturnInst *> Returns,
  381                           SmallVectorImpl<ReturnInst *> &Returns,
  398     } else if (auto RI = dyn_cast<ReturnInst>(&I)) {
  463 void SafeStack::checkStackGuard(IRBuilder<> &IRB, Function &F, ReturnInst &RI,
  488     ArrayRef<Argument *> ByValArguments, ArrayRef<ReturnInst *> Returns,
  747   SmallVector<ReturnInst *, 4> Returns;
  800     for (ReturnInst *RI : Returns) {
  826   for (ReturnInst *RI : Returns) {

lib/CodeGen/SelectionDAG/SelectionDAGBuilder.cpp

  168   if (auto *R = dyn_cast<ReturnInst>(V))
 1764 void SelectionDAGBuilder::visitRet(const ReturnInst &I) {

lib/CodeGen/SelectionDAG/SelectionDAGBuilder.h

  631   void visitRet(const ReturnInst &I);

lib/CodeGen/SelectionDAG/SelectionDAGISel.cpp

  487       if (isa<UnreachableInst>(Term) || isa<ReturnInst>(Term))

lib/CodeGen/SjLjEHPrepare.cpp

  354   SmallVector<ReturnInst *, 16> Returns;
  371     } else if (auto *RI = dyn_cast<ReturnInst>(BB.getTerminator())) {
  371     } else if (auto *RI = dyn_cast<ReturnInst>(BB.getTerminator())) {
  466   for (ReturnInst *Return : Returns)

lib/CodeGen/StackProtector.cpp

  382 static bool CreatePrologue(Function *F, Module *M, ReturnInst *RI,
  413     ReturnInst *RI = dyn_cast<ReturnInst>(BB->getTerminator());
  413     ReturnInst *RI = dyn_cast<ReturnInst>(BB->getTerminator());
  545   return HasPrologue && !HasIRCheck && isa<ReturnInst>(BB.getTerminator());

lib/CodeGen/SwiftErrorValueTracking.cpp

  305     } else if (const ReturnInst *R = dyn_cast<const ReturnInst>(&*It)) {
  305     } else if (const ReturnInst *R = dyn_cast<const ReturnInst>(&*It)) {

lib/CodeGen/WinEHPrepare.cpp

  981       bool IsUnreachableRet = isa<ReturnInst>(TI) && FuncletPad;

lib/ExecutionEngine/Interpreter/Execution.cpp

  916 void Interpreter::visitReturnInst(ReturnInst &I) {

lib/ExecutionEngine/Interpreter/Interpreter.h

  122   void visitReturnInst(ReturnInst &I);

lib/ExecutionEngine/Orc/IndirectionUtils.cpp

  317   SmallVector<ReturnInst *, 8> Returns; // Ignore returns cloned.

lib/FuzzMutate/IRMutator.cpp

   32   ReturnInst::Create(Context, BB);

lib/IR/AsmWriter.cpp

 3822   } else if (isa<ReturnInst>(I) && !Operand) {
 4030         || isa<ReturnInst>(I)) {

lib/IR/BasicBlock.cpp

  153   const ReturnInst *RI = dyn_cast<ReturnInst>(&InstList.back());
  153   const ReturnInst *RI = dyn_cast<ReturnInst>(&InstList.back());
  184   auto *RI = dyn_cast<ReturnInst>(&InstList.back());

lib/IR/Instructions.cpp

  864 ReturnInst::ReturnInst(const ReturnInst &RI)
  866                   OperandTraits<ReturnInst>::op_end(this) - RI.getNumOperands(),
  875                   OperandTraits<ReturnInst>::op_end(this) - !!retVal, !!retVal,
  883                   OperandTraits<ReturnInst>::op_end(this) - !!retVal, !!retVal,
  891                   OperandTraits<ReturnInst>::op_end(this), 0, InsertAtEnd) {}
 4258 ReturnInst *ReturnInst::cloneImpl() const {
 4259   return new(getNumOperands()) ReturnInst(*this);

lib/IR/Verifier.cpp

  469   void visitReturnInst(ReturnInst &RI);
 2448 void Verifier::visitReturnInst(ReturnInst &RI) {
 3106   ReturnInst *Ret = dyn_cast_or_null<ReturnInst>(Next);
 3106   ReturnInst *Ret = dyn_cast_or_null<ReturnInst>(Next);
 4671       auto *RI = dyn_cast<ReturnInst>(Call.getNextNode());
 4671       auto *RI = dyn_cast<ReturnInst>(Call.getNextNode());

lib/Target/AArch64/AArch64FastISel.cpp

 3835   const ReturnInst *Ret = cast<ReturnInst>(I);
 3835   const ReturnInst *Ret = cast<ReturnInst>(I);

lib/Target/AArch64/AArch64StackTagging.cpp

  559       if (isa<ReturnInst>(I) || isa<ResumeInst>(I) || isa<CleanupReturnInst>(I))

lib/Target/AMDGPU/AMDGPUInline.cpp

  168     if (isa<ReturnInst>(*std::next(I->getIterator()))) {

lib/Target/AMDGPU/AMDGPURewriteOutArguments.cpp

  262   DenseMap<ReturnInst *, ReplacementVec> Replacements;
  264   SmallVector<ReturnInst *, 4> Returns;
  266     if (ReturnInst *RI = dyn_cast<ReturnInst>(&BB.back()))
  266     if (ReturnInst *RI = dyn_cast<ReturnInst>(&BB.back()))
  287       SmallVector<std::pair<ReturnInst *, StoreInst *>, 4> ReplaceableStores;
  302       for (ReturnInst *RI : Returns) {
  323       for (std::pair<ReturnInst *, StoreInst *> Store : ReplaceableStores) {
  384   for (std::pair<ReturnInst *, ReplacementVec> &Replacement : Replacements) {
  385     ReturnInst *RI = Replacement.first;

lib/Target/AMDGPU/AMDGPUUnifyDivergentExitNodes.cpp

  130     ReturnInst::Create(F.getContext(), nullptr, NewRetBlock);
  136     ReturnInst::Create(F.getContext(), PN, NewRetBlock);
  176     if (isa<ReturnInst>(BB->getTerminator())) {
  190         ReturnInst::Create(F.getContext(), RetVal, DummyReturnBB);
  247       ReturnInst::Create(F.getContext(), RetVal, UnreachableBlock);

lib/Target/AMDGPU/R600OpenCLImageTypeLoweringPass.cpp

  318     SmallVector<ReturnInst*, 8> Returns;

lib/Target/ARM/ARMCodeGenPrepare.cpp

  268   if (auto *Return = dyn_cast<ReturnInst>(V))
  268   if (auto *Return = dyn_cast<ReturnInst>(V))

lib/Target/ARM/ARMFastISel.cpp

 2091   const ReturnInst *Ret = cast<ReturnInst>(I);
 2091   const ReturnInst *Ret = cast<ReturnInst>(I);

lib/Target/Mips/Mips16HardFloat.cpp

  384       if (const ReturnInst *RI = dyn_cast<ReturnInst>(&I)) {
  384       if (const ReturnInst *RI = dyn_cast<ReturnInst>(&I)) {

lib/Target/Mips/MipsFastISel.cpp

 1683   const ReturnInst *Ret = cast<ReturnInst>(I);
 1683   const ReturnInst *Ret = cast<ReturnInst>(I);

lib/Target/PowerPC/PPCBoolRetToInt.cpp

  141         return isa<ReturnInst>(V) || isa<CallInst>(V) || isa<PHINode>(V) ||
  203         if (auto *R = dyn_cast<ReturnInst>(&I))
  203         if (auto *R = dyn_cast<ReturnInst>(&I))
  239     if (isa<ReturnInst>(U.getUser()))

lib/Target/PowerPC/PPCFastISel.cpp

 1694   const ReturnInst *Ret = cast<ReturnInst>(I);
 1694   const ReturnInst *Ret = cast<ReturnInst>(I);

lib/Target/WebAssembly/WebAssemblyFastISel.cpp

 1301   const auto *Ret = cast<ReturnInst>(I);
 1301   const auto *Ret = cast<ReturnInst>(I);

lib/Target/WebAssembly/WebAssemblyFixFunctionBitcasts.cpp

  183       ReturnInst::Create(M->getContext(), BB);
  186       ReturnInst::Create(M->getContext(), UndefValue::get(RtnType), BB);
  188       ReturnInst::Create(M->getContext(), Call, BB);
  194       ReturnInst::Create(M->getContext(), Cast, BB);

lib/Target/WebAssembly/WebAssemblyLowerEmscriptenEHSjLj.cpp

 1055     if (isa<ReturnInst>(TI))

lib/Target/WebAssembly/WebAssemblyLowerGlobalDtors.cpp

  151       ReturnInst::Create(C, BB);
  179       ReturnInst::Create(C, RetBB);

lib/Target/X86/X86FastISel.cpp

 1145   const ReturnInst *Ret = cast<ReturnInst>(I);
 1145   const ReturnInst *Ret = cast<ReturnInst>(I);

lib/Target/X86/X86WinEHState.cpp

  369     if (!isa<ReturnInst>(T))

lib/Transforms/Coroutines/CoroEarly.cpp

  127     ReturnInst::Create(C, Entry);

lib/Transforms/Coroutines/CoroSplit.cpp

  652   SmallVector<ReturnInst *, 4> Returns;
  707     for (ReturnInst *Return : Returns)
  912     if (isa<ReturnInst>(I)) {
 1426   ReturnInst::Create(C, Entry);

lib/Transforms/IPO/Attributor.cpp

  850   MapVector<Value *, SmallSetVector<ReturnInst *, 4>> ReturnedValues;
  890           ReturnInstSet.insert(cast<ReturnInst>(RI));
  937       const function_ref<bool(Value &, const SmallSetVector<ReturnInst *, 4> &)>
 1057     const function_ref<bool(Value &, const SmallSetVector<ReturnInst *, 4> &)>
 1089     SmallSetVector<ReturnInst *, 4> RetInsts;
 1115     ReturnInst &Ret = cast<ReturnInst>(I);
 1115     ReturnInst &Ret = cast<ReturnInst>(I);
 1223     for (ReturnInst *RI : It.second)
 3077     if (isa<ReturnInst>(UInst))
 4321     const function_ref<bool(Value &, const SmallSetVector<ReturnInst *, 4> &)>

lib/Transforms/IPO/CalledValuePropagation.cpp

  180       return visitReturn(*cast<ReturnInst>(&I), ChangedValues, SS);
  240   void visitReturn(ReturnInst &I,

lib/Transforms/IPO/DeadArgumentElimination.cpp

  381     if (const ReturnInst *RI = dyn_cast<ReturnInst>(V)) {
  381     if (const ReturnInst *RI = dyn_cast<ReturnInst>(V)) {
  519     if (const ReturnInst *RI = dyn_cast<ReturnInst>(BB->getTerminator())) {
  519     if (const ReturnInst *RI = dyn_cast<ReturnInst>(BB->getTerminator())) {
 1034       if (ReturnInst *RI = dyn_cast<ReturnInst>(BB.getTerminator())) {
 1034       if (ReturnInst *RI = dyn_cast<ReturnInst>(BB.getTerminator())) {
 1068         ReturnInst::Create(F->getContext(), RetVal, RI);

lib/Transforms/IPO/FunctionAttrs.cpp

  594         if (auto *Ret = dyn_cast<ReturnInst>(BB.getTerminator())) {
  594         if (auto *Ret = dyn_cast<ReturnInst>(BB.getTerminator())) {
  864     if (ReturnInst *Ret = dyn_cast<ReturnInst>(BB.getTerminator()))
  864     if (ReturnInst *Ret = dyn_cast<ReturnInst>(BB.getTerminator()))
  977     if (auto *Ret = dyn_cast<ReturnInst>(BB.getTerminator()))
  977     if (auto *Ret = dyn_cast<ReturnInst>(BB.getTerminator()))

lib/Transforms/IPO/GlobalDCE.cpp

   91     if (auto *RI = dyn_cast<ReturnInst>(&I))
   91     if (auto *RI = dyn_cast<ReturnInst>(&I))

lib/Transforms/IPO/GlobalOpt.cpp

 2861     if (isa<ReturnInst>(I))

lib/Transforms/IPO/HotColdSplitting.cpp

  100   return !(isa<ReturnInst>(I) || isa<IndirectBrInst>(I));

lib/Transforms/IPO/IPConstantPropagation.cpp

  179     if (ReturnInst *RI = dyn_cast<ReturnInst>(BB.getTerminator())) {
  179     if (ReturnInst *RI = dyn_cast<ReturnInst>(BB.getTerminator())) {

lib/Transforms/IPO/LoopExtractor.cpp

  120       if (!isa<ReturnInst>(ExitBlocks[i]->getTerminator())) {

lib/Transforms/IPO/LowerTypeTests.cpp

 1259     ReturnInst::Create(M.getContext(), BB);

lib/Transforms/IPO/MergeFunctions.cpp

  714   ReturnInst *RI = nullptr;

lib/Transforms/IPO/PartialInlining.cpp

  569     return isa<ReturnInst>(TI);

lib/Transforms/IPO/PruneEH.cpp

  112         } else if (CheckReturn && isa<ReturnInst>(TI)) {

lib/Transforms/IPO/WholeProgramDevirt.cpp

 1078   ReturnInst::Create(M.getContext(), nullptr, BB);

lib/Transforms/InstCombine/InstCombineCalls.cpp

 3905     if (!CannotRemove && (isa<ReturnInst>(TI) || isa<ResumeInst>(TI)))

lib/Transforms/InstCombine/InstCombineInternal.h

  440   Instruction *visitReturnInst(ReturnInst &RI);

lib/Transforms/InstCombine/InstructionCombining.cpp

 2539 Instruction *InstCombiner::visitReturnInst(ReturnInst &RI) {

lib/Transforms/Instrumentation/AddressSanitizer.cpp

  965   void visitReturnInst(ReturnInst &RI) { RetVec.push_back(&RI); }
  981     if (!isa<ReturnInst>(InstBefore)) {
 1772     if (ReturnInst *RI = dyn_cast<ReturnInst>(BB.getTerminator()))
 1772     if (ReturnInst *RI = dyn_cast<ReturnInst>(BB.getTerminator()))
 2036   return IRBuilder<>(ReturnInst::Create(*C, AsanDtorBB));

lib/Transforms/Instrumentation/DataFlowSanitizer.cpp

  447   void visitReturnInst(ReturnInst &RI);
  672       ReturnInst::Create(*Ctx, BB);
  674       ReturnInst::Create(*Ctx, CI, BB);
  693     ReturnInst *RI;
  695       RI = ReturnInst::Create(*Ctx, BB);
  697       RI = ReturnInst::Create(*Ctx, CI, BB);
 1512 void DFSanVisitor::visitReturnInst(ReturnInst &RI) {

lib/Transforms/Instrumentation/GCOVProfiling.cpp

  725         } else if (isa<ReturnInst>(TI)) {
  790         if (isa<ReturnInst>(TI)) {
  834           if (isa<ReturnInst>(TI)) {

lib/Transforms/Instrumentation/HWAddressSanitizer.cpp

 1126       if (isa<ReturnInst>(Inst) || isa<ResumeInst>(Inst) ||

lib/Transforms/Instrumentation/MemorySanitizer.cpp

 3399   void visitReturnInst(ReturnInst &I) {

lib/Transforms/Instrumentation/PoisonChecking.cpp

  285         if (auto *RI = dyn_cast<ReturnInst>(&I))
  285         if (auto *RI = dyn_cast<ReturnInst>(&I))

lib/Transforms/ObjCARC/ObjCARCOpts.cpp

  692       if (isa<ReturnInst>(U) || GetBasicARCInstKind(U) == ARCInstKind::RetainRV)
 2120                                        ReturnInst *Ret,
 2158     ReturnInst *Ret = dyn_cast<ReturnInst>(&BB.back());
 2158     ReturnInst *Ret = dyn_cast<ReturnInst>(&BB.back());

lib/Transforms/Scalar/ADCE.cpp

  301     if (isa<ReturnInst>(Info.Terminator)) {

lib/Transforms/Scalar/CallSiteSplitting.cpp

  250   ReturnInst* RI = dyn_cast<ReturnInst>(&*II);
  250   ReturnInst* RI = dyn_cast<ReturnInst>(&*II);

lib/Transforms/Scalar/CorrelatedValuePropagation.cpp

  894       auto *RI = cast<ReturnInst>(Term);
  894       auto *RI = cast<ReturnInst>(Term);

lib/Transforms/Scalar/RewriteStatepointsForGC.cpp

 1386       auto *RI = cast<ReturnInst>(OldI->getParent()->getTerminator());
 1386       auto *RI = cast<ReturnInst>(OldI->getParent()->getTerminator());

lib/Transforms/Scalar/SCCP.cpp

  613   void visitReturnInst(ReturnInst &I);
  834 void SCCPSolver::visitReturnInst(ReturnInst &I) {
 1920                              SmallVector<ReturnInst *, 8> &ReturnsToZap,
 1963     if (auto *RI = dyn_cast<ReturnInst>(BB.getTerminator()))
 1963     if (auto *RI = dyn_cast<ReturnInst>(BB.getTerminator()))
 2189   SmallVector<ReturnInst*, 8> ReturnsToZap;

lib/Transforms/Scalar/SimplifyCFGPass.cpp

   82     ReturnInst *Ret = dyn_cast<ReturnInst>(BB.getTerminator());
   82     ReturnInst *Ret = dyn_cast<ReturnInst>(BB.getTerminator());
  114           cast<ReturnInst>(RetBlock->getTerminator())->getOperand(0)) {
  123       Value *InVal = cast<ReturnInst>(RetBlock->getTerminator())->getOperand(0);

lib/Transforms/Scalar/TailRecursionElimination.cpp

  362 static bool isDynamicConstant(Value *V, CallInst *CI, ReturnInst *RI) {
  396 static Value *getCommonReturnValue(ReturnInst *IgnoreRI, CallInst *CI) {
  401     ReturnInst *RI = dyn_cast<ReturnInst>(BBI.getTerminator());
  401     ReturnInst *RI = dyn_cast<ReturnInst>(BBI.getTerminator());
  433   if (!I->hasOneUse() || !isa<ReturnInst>(I->user_back()))
  439   return getCommonReturnValue(cast<ReturnInst>(I->user_back()), CI);
  500     CallInst *CI, ReturnInst *Ret, BasicBlock *&OldEntry,
  669       if (ReturnInst *RI = dyn_cast<ReturnInst>(BBI.getTerminator()))
  669       if (ReturnInst *RI = dyn_cast<ReturnInst>(BBI.getTerminator()))
  687     BasicBlock *BB, ReturnInst *Ret, BasicBlock *&OldEntry,
  716       ReturnInst *RI = FoldReturnIntoUncondBranch(Ret, BB, Pred, &DTU);
  736     ReturnInst *Ret, BasicBlock *&OldEntry, bool &TailCallsAreMarkedTail,
  783     if (ReturnInst *Ret = dyn_cast<ReturnInst>(BB->getTerminator())) {
  783     if (ReturnInst *Ret = dyn_cast<ReturnInst>(BB->getTerminator())) {

lib/Transforms/Utils/BasicBlockUtils.cpp

  767 ReturnInst *llvm::FoldReturnIntoUncondBranch(ReturnInst *RI, BasicBlock *BB,
  767 ReturnInst *llvm::FoldReturnIntoUncondBranch(ReturnInst *RI, BasicBlock *BB,
  807   return cast<ReturnInst>(NewRet);

lib/Transforms/Utils/CloneFunction.cpp

   87                              SmallVectorImpl<ReturnInst*> &Returns,
  188     if (ReturnInst *RI = dyn_cast<ReturnInst>(CBB->getTerminator()))
  188     if (ReturnInst *RI = dyn_cast<ReturnInst>(CBB->getTerminator()))
  264   SmallVector<ReturnInst*, 8> Returns;  // Ignore returns cloned.
  452                                      SmallVectorImpl<ReturnInst *> &Returns,
  714     if (ReturnInst *RI = dyn_cast<ReturnInst>(I->getTerminator()))
  714     if (ReturnInst *RI = dyn_cast<ReturnInst>(I->getTerminator()))
  729                                      SmallVectorImpl<ReturnInst*> &Returns,

lib/Transforms/Utils/CloneModule.cpp

  163     SmallVector<ReturnInst *, 8> Returns; // Ignore returns cloned.

lib/Transforms/Utils/CodeExtractor.cpp

  746     if (ReturnInst *RI = dyn_cast<ReturnInst>(Block->getTerminator())) {
  746     if (ReturnInst *RI = dyn_cast<ReturnInst>(Block->getTerminator())) {
 1218           ReturnInst::Create(Context, brVal, NewTarget);
 1285       ReturnInst::Create(Context, nullptr, TheSwitch);  // Return void
 1288       ReturnInst::Create(Context, TheSwitch->getCondition(), TheSwitch);
 1292       ReturnInst::Create(Context,
 1596     return isa<ReturnInst>(Term) || isa<ResumeInst>(Term);

lib/Transforms/Utils/EntryExitInstrumenter.cpp

   94       if (!isa<ReturnInst>(T))

lib/Transforms/Utils/EscapeEnumerator.cpp

   40     if (!isa<ReturnInst>(TI) && !isa<ResumeInst>(TI))

lib/Transforms/Utils/Evaluator.cpp

  631       } else if (isa<ReturnInst>(CurInst)) {
  707       ReturnInst *RI = cast<ReturnInst>(CurBB->getTerminator());
  707       ReturnInst *RI = cast<ReturnInst>(CurBB->getTerminator());

lib/Transforms/Utils/InlineFunction.cpp

 1671   SmallVector<ReturnInst*, 8> Returns;
 1993       for (ReturnInst *RI : Returns) {
 2021     for (ReturnInst *RI : Returns) {
 2124       SmallVector<ReturnInst *, 8> NormalReturns;
 2129       for (ReturnInst *RI : Returns) {
 2180     SmallVector<ReturnInst *, 8> NormalReturns;
 2181     for (ReturnInst *RI : Returns) {
 2242       ReturnInst *R = Returns[0];
 2327         ReturnInst *RI = Returns[i];
 2337       ReturnInst *RI = Returns[i];

lib/Transforms/Utils/ModuleUtils.cpp

  132   IRBuilder<> IRB(ReturnInst::Create(M.getContext(), CtorBB));

lib/Transforms/Utils/SimplifyCFG.cpp

  194   bool SimplifyReturn(ReturnInst *RI, IRBuilder<> &Builder);
 2450   ReturnInst *TrueRet = cast<ReturnInst>(TrueSucc->getTerminator());
 2450   ReturnInst *TrueRet = cast<ReturnInst>(TrueSucc->getTerminator());
 2451   ReturnInst *FalseRet = cast<ReturnInst>(FalseSucc->getTerminator());
 2451   ReturnInst *FalseRet = cast<ReturnInst>(FalseSucc->getTerminator());
 4108 bool SimplifyCFGOpt::SimplifyReturn(ReturnInst *RI, IRBuilder<> &Builder) {
 4154     if (isa<ReturnInst>(BI->getSuccessor(0)->getTerminator()) &&
 4155         isa<ReturnInst>(BI->getSuccessor(1)->getTerminator()) &&
 5492     if (PHI->hasOneUse() && isa<ReturnInst>(*PHI->user_begin()) &&
 6092   } else if (auto *RI = dyn_cast<ReturnInst>(BB->getTerminator())) {
 6092   } else if (auto *RI = dyn_cast<ReturnInst>(BB->getTerminator())) {

lib/Transforms/Utils/UnifyFunctionExitNodes.cpp

   52     if (isa<ReturnInst>(I.getTerminator()))
   91     ReturnInst::Create(F.getContext(), nullptr, NewRetBlock);
   97     ReturnInst::Create(F.getContext(), PN, NewRetBlock);

tools/bugpoint/Miscompilation.cpp

  819       ReturnInst::Create(Safe->getContext(), call, BB);
  916             ReturnInst::Create(F->getContext(), DoCallBB);
  920             ReturnInst::Create(F->getContext(), Call, DoCallBB);

tools/clang/lib/CodeGen/CGExpr.cpp

 3177   llvm::ReturnInst::Create(Ctx, nullptr, BB);

tools/clang/lib/CodeGen/CGVTables.cpp

  221       if (isa<llvm::ReturnInst>(T)) {

tools/llvm-reduce/deltas/ReduceBasicBlocks.cpp

   47     ReturnInst::Create(BB.getContext(), nullptr, &BB);
   68     ReturnInst::Create(SwInst.getContext(), nullptr, SwInst.getParent());

tools/llvm-stress/llvm-stress.cpp

  674   ReturnInst::Create(F->getContext(), BB);

tools/polly/lib/Analysis/ScopDetection.cpp

  647   if (isa<ReturnInst>(TI) && CurRegion.isTopLevelRegion())

tools/polly/lib/CodeGen/PerfMonitor.cpp

  121 static ReturnInst *ReturnFromFinal = nullptr;

tools/polly/lib/Support/ScopHelper.cpp

  418       if (isa<ReturnInst>(I.getTerminator()) && !DT.dominates(&BB, &I))
  593         if (isa<ReturnInst>(I.getTerminator()) && !DT.dominates(&BB, &I))

unittests/Analysis/AliasAnalysisTest.cpp

  189   ReturnInst::Create(C, nullptr, BB);

unittests/Analysis/DivergenceAnalysisTest.cpp

   83   ReturnInst::Create(Context, nullptr, BB);
  155   auto &RetInst = *cast<ReturnInst>(ExitBlock.begin());
  155   auto &RetInst = *cast<ReturnInst>(ExitBlock.begin());
  209   auto &RetInst = *cast<ReturnInst>(ExitBlock.begin());
  209   auto &RetInst = *cast<ReturnInst>(ExitBlock.begin());

unittests/Analysis/ScalarEvolutionTest.cpp

   73   ReturnInst::Create(Context, nullptr, BB);
  127   ReturnInst::Create(Context, nullptr, ExitBB);
  159   ReturnInst::Create(Context, nullptr, ExitBB);
  394   ReturnInst::Create(Context, nullptr, ExitBB);
  425   ReturnInst::Create(Context, nullptr, EntryBB);
  466   ReturnInst::Create(Context, nullptr, EntryBB);
  715   ReturnInst::Create(Context, nullptr, EndBB);
 1025   ReturnInst::Create(Context, nullptr, ExitBB);
 1083   ReturnInst::Create(Context, nullptr, ExitBB);
 1104   ReturnInst::Create(Context, nullptr, BB);

unittests/Analysis/SparsePropagation.cpp

  148       return visitReturn(*cast<ReturnInst>(&I), ChangedValues, SS);
  186   void visitReturn(ReturnInst &I,

unittests/Analysis/TBAATest.cpp

   42   ReturnInst::Create(C, nullptr, BB);

unittests/FuzzMutate/OperationsTest.cpp

  185   auto *RI = ReturnInst::Create(Ctx, BB);
  185   auto *RI = ReturnInst::Create(Ctx, BB);
  267   auto *RI = ReturnInst::Create(Ctx, BB3);
  267   auto *RI = ReturnInst::Create(Ctx, BB3);
  290   auto *RI = ReturnInst::Create(Ctx, BB);
  290   auto *RI = ReturnInst::Create(Ctx, BB);

unittests/IR/IRBuilderTest.cpp

  728   ReturnInst *R = Builder.CreateRetVoid();

unittests/IR/InstructionsTest.cpp

   44   const ReturnInst* r0 = ReturnInst::Create(C);
   44   const ReturnInst* r0 = ReturnInst::Create(C);
   50   const ReturnInst* r1 = ReturnInst::Create(C, One);
   50   const ReturnInst* r1 = ReturnInst::Create(C, One);

unittests/IR/LegacyPassManagerTest.cpp

  543         ReturnInst::Create(Context, int32_3, label_entry);
  559         ReturnInst::Create(Context, int32_6, label_entry_5);
  575         ReturnInst::Create(Context, int32_9, label_entry_8);
  603         ReturnInst::Create(Context, label_return);

unittests/IR/MetadataTest.cpp

  353   auto *R0 = ReturnInst::Create(Context, BB0);
  353   auto *R0 = ReturnInst::Create(Context, BB0);
  354   auto *R1 = ReturnInst::Create(Context, BB1);
  354   auto *R1 = ReturnInst::Create(Context, BB1);
  415   auto *R0 = ReturnInst::Create(Context, BB0);
  415   auto *R0 = ReturnInst::Create(Context, BB0);

unittests/IR/VerifierTest.cpp

   32   ReturnInst::Create(C, Exit);
   85   ReturnInst::Create(C, ConstZero, Entry1);
   86   ReturnInst::Create(C, ConstZero, Entry3);

unittests/Linker/LinkModulesTest.cpp

  261   auto *RI = cast<ReturnInst>(BB->getTerminator());
  261   auto *RI = cast<ReturnInst>(BB->getTerminator());
  290   RI = cast<ReturnInst>(BB->getTerminator());

unittests/Transforms/Utils/CloningTest.cpp

  175   SmallVector<ReturnInst*, 4> Returns;
  198   SmallVector<ReturnInst*, 4> Returns;
  702   SmallVector<ReturnInst*, 8> Returns;

unittests/Transforms/Utils/SSAUpdaterBulkTest.cpp

  153   ReturnInst *Return = B.CreateRet(FirstArg);

usr/include/c++/7.4.0/type_traits

 1983     { typedef _Up     type; };