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

Declarations

include/llvm/IR/Instruction.def

  186 HANDLE_CAST_INST(40, SExt    , SExtInst    )  // Sign extend integers

References

include/llvm/Analysis/TargetTransformInfoImpl.h

  647     if (const auto* Cast = dyn_cast<SExtInst>(Val)) {
  647     if (const auto* Cast = dyn_cast<SExtInst>(Val)) {
  876     if (isa<SExtInst>(U) || isa<ZExtInst>(U) || isa<FPExtInst>(U))

include/llvm/CodeGen/BasicTTIImpl.h

  298     if (isa<ZExtInst>(I) || isa<SExtInst>(I))

include/llvm/IR/InstVisitor.h

  180   RetTy visitSExtInst(SExtInst &I)                { DELEGATE(CastInst);}

include/llvm/IR/Instructions.h

 4796   SExtInst *cloneImpl() const;

include/llvm/Support/Casting.h

   58     return To::classof(&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;
  227   static typename cast_retty<To, FromTy>::ret_type doit(const FromTy &Val) {
  228     typename cast_retty<To, FromTy>::ret_type Res2
  256 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*,
  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;

lib/Analysis/BasicAliasAnalysis.cpp

  376   if (isa<SExtInst>(V) || isa<ZExtInst>(V)) {
  389     if (isa<SExtInst>(V) && ZExtBits == 0) {

lib/Analysis/InstructionSimplify.cpp

 3329     if (isa<SExtInst>(LHS)) {
 3332       if (SExtInst *RI = dyn_cast<SExtInst>(RHS)) {
 3332       if (SExtInst *RI = dyn_cast<SExtInst>(RHS)) {

lib/Analysis/ValueTracking.cpp

 2122   if (isa<SExtInst>(V) || isa<ZExtInst>(V))

lib/Analysis/VectorUtils.cpp

  388       if (TTI && (isa<ZExtInst>(&I) || isa<SExtInst>(&I)) &&
  434     if (isa<SExtInst>(I) || isa<ZExtInst>(I) || isa<LoadInst>(I) ||

lib/CodeGen/CodeGenPrepare.cpp

 3733   if (IsSExt && isa<SExtInst>(Inst))
 3810   else if ((IsSExt && isa<SExtInst>(Opnd)) || (!IsSExt && isa<ZExtInst>(Opnd)))
 3827   bool IsSExt = isa<SExtInst>(Ext);
 3842   if (isa<SExtInst>(ExtOpnd) || isa<TruncInst>(ExtOpnd) ||
 5061   bool IsSExt = isa<SExtInst>(FirstUser);
 5065     if ((IsSExt && !isa<SExtInst>(UI)) || (!IsSExt && !isa<ZExtInst>(UI)))
 5213       if (RemovedInsts.count(Inst) || !isa<SExtInst>(Inst) ||
 6955     if (isa<ZExtInst>(I) || isa<SExtInst>(I)) {

lib/ExecutionEngine/Interpreter/Execution.cpp

 1712 void Interpreter::visitSExtInst(SExtInst &I) {

lib/ExecutionEngine/Interpreter/Interpreter.h

  140   void visitSExtInst(SExtInst &I);

lib/IR/Instructions.cpp

 2754   case SExt:          return new SExtInst          (S, Ty, Name, InsertBefore);
 2776   case SExt:          return new SExtInst          (S, Ty, Name, InsertAtEnd);
 4180 SExtInst *SExtInst::cloneImpl() const {
 4181   return new SExtInst(getOperand(0), getType());

lib/IR/Verifier.cpp

  439   void visitSExtInst(SExtInst &I);
 2574 void Verifier::visitSExtInst(SExtInst &I) {

lib/Target/AArch64/AArch64FastISel.cpp

  747         } else if (const auto *SE = dyn_cast<SExtInst>(I)) {
  747         } else if (const auto *SE = dyn_cast<SExtInst>(I)) {
  831         } else if (const auto *SE = dyn_cast<SExtInst>(I)) {
  831         } else if (const auto *SE = dyn_cast<SExtInst>(I)) {
  890     } else if (const auto *SE = dyn_cast<SExtInst>(U)) {
  890     } else if (const auto *SE = dyn_cast<SExtInst>(U)) {
 2016     } else if (const auto *SE = dyn_cast<SExtInst>(I->use_begin()->getUser())) {
 2016     } else if (const auto *SE = dyn_cast<SExtInst>(I->use_begin()->getUser())) {
 4707       } else if (const auto *SExt = dyn_cast<SExtInst>(Src0)) {
 4707       } else if (const auto *SExt = dyn_cast<SExtInst>(Src0)) {
 4774     } else if (const auto *SExt = dyn_cast<SExtInst>(Op0)) {
 4774     } else if (const auto *SExt = dyn_cast<SExtInst>(Op0)) {

lib/Target/AArch64/AArch64TargetTransformInfo.cpp

  233       (!isa<SExtInst>(Args[1]) && !isa<ZExtInst>(Args[1])) ||
  872   if (!isa<SExtInst>(&I))

lib/Target/ARM/ARMParallelDSP.cpp

  102         if (auto *SExt = dyn_cast<SExtInst>(V)) {
  102         if (auto *SExt = dyn_cast<SExtInst>(V)) {
  335   if (auto *SExt = dyn_cast<SExtInst>(V)) {
  335   if (auto *SExt = dyn_cast<SExtInst>(V)) {
  364         !Ld->hasOneUse() || !isa<SExtInst>(Ld->user_back()))
  739   Instruction *BaseSExt = dyn_cast<SExtInst>(Base->user_back());
  740   Instruction *OffsetSExt = dyn_cast<SExtInst>(Offset->user_back());

lib/Target/Hexagon/HexagonOptimizeSZextends.cpp

   77           if (isa<SExtInst>(*UI)) {
   79             SExtInst* SI = new SExtInst(&Arg, Use->getType());
   79             SExtInst* SI = new SExtInst(&Arg, Use->getType());

lib/Target/SystemZ/SystemZTargetTransformInfo.cpp

  923     else if (isa<SExtInst>(UserI))
 1018               (isa<TruncInst>(OtherOp) || isa<SExtInst>(OtherOp) ||

lib/Target/WebAssembly/WebAssemblyFastISel.cpp

  983   const auto *SExt = cast<SExtInst>(I);
  983   const auto *SExt = cast<SExtInst>(I);

lib/Target/X86/X86TargetTransformInfo.cpp

 3136           !isa<SExtInst>(GEP->getOperand(i))) ||

lib/Transforms/AggressiveInstCombine/TruncInstCombine.cpp

  241     bool IsExtInst = (isa<ZExtInst>(I) || isa<SExtInst>(I));

lib/Transforms/InstCombine/InstCombineAndOrXor.cpp

 1527       return new SExtInst(NewOp, DestTy);

lib/Transforms/InstCombine/InstCombineCasts.cpp

 1360 Instruction *InstCombiner::visitSExt(SExtInst &CI) {
 1715         return new SExtInst(SrcI, FITy);

lib/Transforms/InstCombine/InstCombineInternal.h

  411   Instruction *visitSExt(SExtInst &CI);

lib/Transforms/InstCombine/InstCombineMulDivRem.cpp

 1094       return new SExtInst(NarrowOp, Op0->getType());

lib/Transforms/InstCombine/InstCombineSelect.cpp

 2289       return new SExtInst(CondVal, SelType);
 2300       return new SExtInst(NotCond, SelType);

lib/Transforms/InstCombine/InstCombineShifts.cpp

 1189       return new SExtInst(X, Ty);
 1228       return new SExtInst(NewSh, Ty);

lib/Transforms/Instrumentation/MemorySanitizer.cpp

 1883   void visitSExtInst(SExtInst &I) {

lib/Transforms/Scalar/CorrelatedValuePropagation.cpp

  719 static bool processSExt(SExtInst *SDI, LazyValueInfo *LVI) {
  874         BBChanged |= processSExt(cast<SExtInst>(II), LVI);

lib/Transforms/Scalar/IndVarSimplify.cpp

 1467       SExtInst *User = dyn_cast<SExtInst>(U.getUser());
 1467       SExtInst *User = dyn_cast<SExtInst>(U.getUser());
 1518       SExtInst *User = dyn_cast<SExtInst>(U.getUser());
 1518       SExtInst *User = dyn_cast<SExtInst>(U.getUser());
 1587   if ((isa<SExtInst>(DU.NarrowUse) && canWidenBySExt()) ||

lib/Transforms/Scalar/LoopRerollPass.cpp

  555                 isa<SExtInst>(UUser))
 1178         if (isa<SExtInst>(UUser)) {

lib/Transforms/Scalar/LowerExpectIntrinsic.cpp

  125     if (SExtInst *SExt = dyn_cast<SExtInst>(V)) {
  125     if (SExtInst *SExt = dyn_cast<SExtInst>(V)) {

lib/Transforms/Scalar/NaryReassociate.cpp

  334   if (SExtInst *SExt = dyn_cast<SExtInst>(IndexToSplit)) {
  334   if (SExtInst *SExt = dyn_cast<SExtInst>(IndexToSplit)) {

lib/Transforms/Scalar/SeparateConstOffsetFromGEP.cpp

  593   } else if (isa<SExtInst>(V)) {
 1177         Instruction *NewSExt = new SExtInst(Dom, I->getType(), "", I);

lib/Transforms/Utils/SimplifyIndVar.cpp

  596       Ext = new SExtInst(Op1, IVTy, "sext", ICI);

lib/Transforms/Vectorize/LoadStoreVectorizer.cpp

  436   if (!isa<SExtInst>(OpA) && !isa<ZExtInst>(OpA))
  439   bool Signed = isa<SExtInst>(OpA);

lib/Transforms/Vectorize/SLPVectorizer.cpp

 3014               if ((isa<SExtInst>(Ext) || isa<ZExtInst>(Ext)) &&

tools/llvm-stress/llvm-stress.cpp

  581         return PT->push_back(new SExtInst(V, DestTy, "Se", BB->getTerminator()));