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

Declarations

include/llvm/IR/Instruction.def

  184 HANDLE_CAST_INST(38, Trunc   , TruncInst   )  // Truncate integers

References

include/llvm/IR/InstVisitor.h

  178   RetTy visitTruncInst(TruncInst &I)              { DELEGATE(CastInst);}

include/llvm/IR/Instructions.h

 4718   TruncInst *cloneImpl() const;

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);
  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,
  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) {
  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;

lib/Analysis/VectorUtils.cpp

  393       if ((isa<TruncInst>(&I) || isa<ICmpInst>(&I)) &&
  398         if (TTI && isa<TruncInst>(&I) && TTI->isTypeLegal(I.getType()))

lib/CodeGen/Analysis.cpp

  310     } else if (isa<TruncInst>(I) &&

lib/CodeGen/CodeGenPrepare.cpp

 1507   if (!isa<TruncInst>(User)) {
 1527   auto *TruncI = cast<TruncInst>(User);
 1527   auto *TruncI = cast<TruncInst>(User);
 1653       if (isa<TruncInst>(User) && shiftIsLegal
 3785   if (!isa<TruncInst>(Inst))
 3837   if (isa<TruncInst>(ExtOpnd) && InsertedInsts.count(ExtOpnd))
 3842   if (isa<SExtInst>(ExtOpnd) || isa<TruncInst>(ExtOpnd) ||
 5637       InsertedTrunc = new TruncInst(I, Src->getType(), "", &*InsertPt);

lib/ExecutionEngine/Interpreter/Execution.cpp

 1707 void Interpreter::visitTruncInst(TruncInst &I) {

lib/ExecutionEngine/Interpreter/Interpreter.h

  138   void visitTruncInst(TruncInst &I);

lib/IR/Instructions.cpp

 2752   case Trunc:         return new TruncInst         (S, Ty, Name, InsertBefore);
 2774   case Trunc:         return new TruncInst         (S, Ty, Name, InsertAtEnd);
 4172 TruncInst *TruncInst::cloneImpl() const {
 4173   return new TruncInst(getOperand(0), getType());

lib/IR/Verifier.cpp

  437   void visitTruncInst(TruncInst &I);
 2538 void Verifier::visitTruncInst(TruncInst &I) {

lib/Target/ARM/ARMCodeGenPrepare.cpp

  247   else if (auto *Trunc = dyn_cast<TruncInst>(V))
  247   else if (auto *Trunc = dyn_cast<TruncInst>(V))
  686     if (NewInsts.count(Src) && isa<TruncInst>(Src) &&
  688       auto *Trunc = cast<TruncInst>(Src);
  688       auto *Trunc = cast<TruncInst>(Src);
  714     if (!isa<TruncInst>(V) || Sources->count(V))
  717     auto *Trunc = cast<TruncInst>(V);
  717     auto *Trunc = cast<TruncInst>(V);
  769     if (!isa<TruncInst>(V) || Sources.count(V))
  771     auto *Trunc = cast<TruncInst>(V);
  771     auto *Trunc = cast<TruncInst>(V);

lib/Target/ARM/ARMFastISel.cpp

 1271   } else if (TruncInst *TI = dyn_cast<TruncInst>(BI->getCondition())) {
 1271   } else if (TruncInst *TI = dyn_cast<TruncInst>(BI->getCondition())) {

lib/Target/Hexagon/HexagonLoopIdiomRecognition.cpp

 1035   if (TruncInst *T = dyn_cast<TruncInst>(In)) {
 1035   if (TruncInst *T = dyn_cast<TruncInst>(In)) {

lib/Target/PowerPC/PPCBoolRetToInt.cpp

  265     Value *BackToBool = new TruncInst(IntRetVal, Int1Ty, "backToBool", I);

lib/Target/SystemZ/SystemZTargetTransformInfo.cpp

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

lib/Target/WebAssembly/WebAssemblyFastISel.cpp

  947   const auto *Trunc = cast<TruncInst>(I);
  947   const auto *Trunc = cast<TruncInst>(I);

lib/Target/X86/X86FastISel.cpp

 1707   } else if (TruncInst *TI = dyn_cast<TruncInst>(BI->getCondition())) {
 1707   } else if (TruncInst *TI = dyn_cast<TruncInst>(BI->getCondition())) {
 3269     auto *TI = dyn_cast<TruncInst>(Val);
 3269     auto *TI = dyn_cast<TruncInst>(Val);

lib/Transforms/AggressiveInstCombine/AggressiveInstCombineInternal.h

   58   SmallVector<TruncInst *, 4> Worklist;
   61   TruncInst *CurrentTruncInst;

lib/Transforms/AggressiveInstCombine/TruncInstCombine.cpp

  335         if (auto *NewCI = dyn_cast<TruncInst>(Res))
  335         if (auto *NewCI = dyn_cast<TruncInst>(Res))
  339       } else if (auto *NewCI = dyn_cast<TruncInst>(Res))
  339       } else if (auto *NewCI = dyn_cast<TruncInst>(Res))
  396       if (auto *CI = dyn_cast<TruncInst>(&I))
  396       if (auto *CI = dyn_cast<TruncInst>(&I))

lib/Transforms/InstCombine/InstCombineAddSub.cpp

 1198   return TruncInst::CreateTruncOrBitCast(NewAShr, I.getType());
 1794         return TruncInst::CreateTruncOrBitCast(NewShift, Op1->getType());
 1806         return TruncInst::CreateTruncOrBitCast(NewShift, Op1->getType());

lib/Transforms/InstCombine/InstCombineCalls.cpp

 1899       return new TruncInst(V, IIOperand->getType());

lib/Transforms/InstCombine/InstCombineCasts.cpp

  456 static Instruction *foldVecTruncToExtElt(TruncInst &Trunc, InstCombiner &IC) {
  495 Instruction *InstCombiner::narrowRotate(TruncInst &Trunc) {
  579 Instruction *InstCombiner::narrowBinOp(TruncInst &Trunc) {
  637 static Instruction *shrinkSplatShuffle(TruncInst &Trunc,
  684 Instruction *InstCombiner::visitTrunc(TruncInst &CI) {
 1091   if (CI.hasOneUse() && isa<TruncInst>(CI.user_back()))
 1141   if (TruncInst *CSrc = dyn_cast<TruncInst>(Src)) {   // A->B->C cast
 1141   if (TruncInst *CSrc = dyn_cast<TruncInst>(Src)) {   // A->B->C cast
 1363   if (CI.hasOneUse() && isa<TruncInst>(CI.user_back()))
 1719       return new TruncInst(SrcI, FITy);
 2373       if (isa<TruncInst>(Src) || isa<ZExtInst>(Src)) {

lib/Transforms/InstCombine/InstCombineCompares.cpp

 1306     TruncInst *TI = dyn_cast<TruncInst>(U);
 1306     TruncInst *TI = dyn_cast<TruncInst>(U);
 1529                                                  TruncInst *Trunc,
 1726     return new TruncInst(And->getOperand(0), Cmp.getType());
 2890   if (auto *TI = dyn_cast<TruncInst>(Cmp.getOperand(0))) {
 2890   if (auto *TI = dyn_cast<TruncInst>(Cmp.getOperand(0))) {
 4568       if (TruncInst *TI = dyn_cast<TruncInst>(U)) {
 4568       if (TruncInst *TI = dyn_cast<TruncInst>(U)) {
 4603         if (TruncInst *Trunc = dyn_cast<TruncInst>(ZextArg))
 4603         if (TruncInst *Trunc = dyn_cast<TruncInst>(ZextArg))
 4698       if (TruncInst *TI = dyn_cast<TruncInst>(U)) {
 4698       if (TruncInst *TI = dyn_cast<TruncInst>(U)) {

lib/Transforms/InstCombine/InstCombineInternal.h

  409   Instruction *visitTrunc(TruncInst &CI);
  599   Instruction *narrowBinOp(TruncInst &Trunc);
  602   Instruction *narrowRotate(TruncInst &Trunc);
  929   Instruction *foldICmpTruncConstant(ICmpInst &Cmp, TruncInst *Trunc,

lib/Transforms/InstCombine/InstCombinePHI.cpp

  996       if (isa<TruncInst>(UserI)) {
 1003           !UserI->hasOneUse() || !isa<TruncInst>(UserI->user_back()) ||

lib/Transforms/InstCombine/InstCombineShifts.cpp

  634   if (TruncInst *TI = dyn_cast<TruncInst>(Op0)) {
  634   if (TruncInst *TI = dyn_cast<TruncInst>(Op0)) {
  674       return new TruncInst(And, I.getType());
 1162   return TruncInst::CreateTruncOrBitCast(NewAShr, OldAShr.getType());

lib/Transforms/InstCombine/InstCombineVectorOps.cpp

  250     return new TruncInst(Scalar, DestTy);

lib/Transforms/Instrumentation/MemorySanitizer.cpp

 1895   void visitTruncInst(TruncInst &I) {

lib/Transforms/Scalar/LoopInterchange.cpp

  886     if (isa<BranchInst>(I) || isa<CmpInst>(I) || isa<TruncInst>(I) ||

lib/Transforms/Scalar/LoopStrengthReduce.cpp

 2738   if (TruncInst *Trunc = dyn_cast<TruncInst>(Oper))
 2738   if (TruncInst *Trunc = dyn_cast<TruncInst>(Oper))

lib/Transforms/Scalar/SeparateConstOffsetFromGEP.cpp

  589   } else if (isa<TruncInst>(V)) {

lib/Transforms/Utils/Local.cpp

 2832     if (TruncInst *Trunc = dyn_cast<TruncInst>(I->user_back())) {
 2832     if (TruncInst *Trunc = dyn_cast<TruncInst>(I->user_back())) {

lib/Transforms/Utils/SimplifyIndVar.cpp

   85     bool eliminateTrunc(TruncInst *TI);
  500 bool SimplifyIndvar::eliminateTrunc(TruncInst *TI) {
  641   if (auto *TI = dyn_cast<TruncInst>(UseInst))
  641   if (auto *TI = dyn_cast<TruncInst>(UseInst))

lib/Transforms/Vectorize/LoopVectorize.cpp

  446   void widenIntOrFpInduction(PHINode *IV, TruncInst *Trunc = nullptr);
 1155     auto *Trunc = dyn_cast<TruncInst>(I);
 1155     auto *Trunc = dyn_cast<TruncInst>(I);
 1683   if (isa<TruncInst>(EntryVal)) {
 1730     if (isa<TruncInst>(EntryVal))
 1778   if (isa<TruncInst>(EntryVal))
 1794 void InnerLoopVectorizer::widenIntOrFpInduction(PHINode *IV, TruncInst *Trunc) {
 6274       auto *Trunc = cast<TruncInst>(I);
 6274       auto *Trunc = cast<TruncInst>(I);
 6801   if (isa<TruncInst>(I) && LoopVectorizationPlanner::getDecisionAndClampRange(
 6804                                              cast<TruncInst>(I));

lib/Transforms/Vectorize/VPlan.h

  748   TruncInst *Trunc;
  751   VPWidenIntOrFpInductionRecipe(PHINode *IV, TruncInst *Trunc = nullptr)

tools/lldb/source/Expression/IRInterpreter.cpp

 1237       const TruncInst *trunc_inst = dyn_cast<TruncInst>(inst);
 1237       const TruncInst *trunc_inst = dyn_cast<TruncInst>(inst);

tools/llvm-stress/llvm-stress.cpp

  575           new TruncInst(V, DestTy, "Tr", BB->getTerminator()));

usr/include/c++/7.4.0/type_traits

 1983     { typedef _Up     type; };