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

References

include/llvm/Analysis/TargetTransformInfoImpl.h

  735     assert(Ptr->getType()->getScalarType()->getPointerElementType() ==

include/llvm/Analysis/Utils/Local.h

   39   unsigned IntPtrWidth = IntPtrTy->getScalarType()->getIntegerBitWidth();

include/llvm/CodeGen/BasicTTIImpl.h

  658                           ->getArithmeticInstrCost(Opcode, Ty->getScalarType());
  791           Opcode, Dst->getScalarType(), Src->getScalarType(), I);
  791           Opcode, Dst->getScalarType(), Src->getScalarType(), I);
  852         CondTy = CondTy->getScalarType();
  854           Opcode, ValTy->getScalarType(), CondTy, I);
  867         getTLI()->getTypeLegalizationCost(DL, Val->getScalarType());
 1185         ScalarRetTy = RetTy->getScalarType();
 1194           Ty = Ty->getScalarType();
 1515           Ty = Ty->getScalarType();
 1519           IID, RetTy->getScalarType(), ScalarTys, FMF);

include/llvm/FuzzMutate/OpDescriptor.h

  210     return V->getType() == Cur[0]->getType()->getScalarType();
  214     return makeConstantsWithType(Cur[0]->getType()->getScalarType());

include/llvm/IR/DerivedTypes.h

  636   return cast<PointerType>(getScalarType())->getAddressSpace();

include/llvm/IR/Instructions.h

  914           cast<PointerType>(Ptr->getType()->getScalarType())->getElementType();
  918           cast<PointerType>(Ptr->getType()->getScalarType())->getElementType());
  930           cast<PointerType>(Ptr->getType()->getScalarType())->getElementType();
  934           cast<PointerType>(Ptr->getType()->getScalarType())->getElementType());
  985            cast<PointerType>(getType()->getScalarType())->getElementType());
 1044       cast<PointerType>(Ptr->getType()->getScalarType())->getElementType(),
 1124          cast<PointerType>(getType()->getScalarType())->getElementType());
 1138          cast<PointerType>(getType()->getScalarType())->getElementType());

include/llvm/IR/Type.h

  185   bool isFPOrFPVectorTy() const { return getScalarType()->isFloatingPointTy(); }
  203   bool isIntOrIntVectorTy() const { return getScalarType()->isIntegerTy(); }
  208     return getScalarType()->isIntegerTy(BitWidth);
  227   bool isPtrOrPtrVectorTy() const { return getScalarType()->isPointerTy(); }

lib/Analysis/ConstantFolding.cpp

  537         if (DL.isNonIntegralPointerType(LoadTy->getScalarType()))
  768   Type *IntPtrScalarTy = IntPtrTy->getScalarType();
  776         Ops[i]->getType()->getScalarType() != IntPtrScalarTy) {
  780                           : IntPtrTy->getScalarType();

lib/Analysis/DemandedBits.cpp

  428       DL.getTypeSizeInBits(I->getType()->getScalarType()));

lib/Analysis/InstructionSimplify.cpp

  659   Type *IntPtrTy = DL.getIntPtrType(V->getType())->getScalarType();
  665   IntPtrTy = DL.getIntPtrType(V->getType())->getScalarType();
 3992       cast<PointerType>(Ops[0]->getType()->getScalarType())->getAddressSpace();

lib/Analysis/ValueTracking.cpp

  205   IntegerType *IT = cast<IntegerType>(LHS->getType()->getScalarType());
 1136     Type *ScalarTy = SrcTy->getScalarType();
 1644   Type *ScalarTy = V->getType()->getScalarType();
 2114   unsigned BitWidth = getBitWidth(V->getType()->getScalarType(), Q.DL);
 2381   Type *ScalarTy = V->getType()->getScalarType();

lib/Analysis/VectorUtils.cpp

  707          VecTy1->getScalarType() == VecTy2->getScalarType() &&
  707          VecTy1->getScalarType() == VecTy2->getScalarType() &&

lib/AsmParser/LLParser.cpp

 3577       auto *BasePointerType = cast<PointerType>(BaseType->getScalarType());
 7196   PointerType *BasePointerType = dyn_cast<PointerType>(BaseType->getScalarType());

lib/Bitcode/Reader/BitcodeReader.cpp

 2612           getPointerElementFlatType(Elt0FullTy->getScalarType());
 3974             getPointerElementTypes(FullBaseTy->getScalarType());
 3975       } else if (Ty != getPointerElementFlatType(FullBaseTy->getScalarType()))

lib/CodeGen/CodeGenPrepare.cpp

 5088     if (ExtTy->getScalarType()->getIntegerBitWidth() >
 5089         CurTy->getScalarType()->getIntegerBitWidth()) {

lib/CodeGen/SelectionDAG/SelectionDAGBuilder.cpp

 3838   unsigned AS = Op0->getType()->getScalarType()->getPointerAddressSpace();

lib/CodeGen/SelectionDAG/StatepointLowering.cpp

  491       auto Opt = S.isGCManagedPointer(V->getType()->getScalarType());
  498       auto Opt = S.isGCManagedPointer(V->getType()->getScalarType());
  999   auto *Ty = Relocate.getType()->getScalarType();

lib/ExecutionEngine/Interpreter/Execution.cpp

 1275     Type *DstVecTy = DstTy->getScalarType();
 1295     Type *DstVecTy = DstTy->getScalarType();
 1315     Type *DstVecTy = DstTy->getScalarType();
 1336     assert(SrcVal->getType()->getScalarType()->isDoubleTy() &&
 1337            DstTy->getScalarType()->isFloatTy() &&
 1359     assert(SrcVal->getType()->getScalarType()->isFloatTy() &&
 1360            DstTy->getScalarType()->isDoubleTy() && "Invalid FPExt instruction");
 1382     Type *DstVecTy = DstTy->getScalarType();
 1383     Type *SrcVecTy = SrcTy->getScalarType();
 1420     Type *DstVecTy = DstTy->getScalarType();
 1421     Type *SrcVecTy = SrcTy->getScalarType();
 1456     Type *DstVecTy = DstTy->getScalarType();
 1488     Type *DstVecTy = DstTy->getScalarType();
 1562       SrcElemTy = SrcTy->getScalarType();
 1575       DstElemTy = DstTy->getScalarType();

lib/IR/AutoUpgrade.cpp

 1123     Amt = Builder.CreateIntCast(Amt, Ty->getScalarType(), false);
 1193     Amt = Builder.CreateIntCast(Amt, Ty->getScalarType(), false);

lib/IR/ConstantFold.cpp

 2192       PointerType *PtrTy = cast<PointerType>(C->getType()->getScalarType());
 2418         ConstantInt::get(CurrIdx->getType()->getScalarType(), NumElements);

lib/IR/Constants.cpp

  327   Type *ScalarTy = Ty->getScalarType();
  654   Constant *C = get(cast<IntegerType>(Ty->getScalarType()), V, isSigned);
  677   assert(C->getType() == Ty->getScalarType() &&
  721   FV.convert(*TypeToFloatSemantics(Ty->getScalarType()),
  734   assert(C->getType() == Ty->getScalarType() &&
  747   APFloat FV(*TypeToFloatSemantics(Ty->getScalarType()), Str);
  758   const fltSemantics &Semantics = *TypeToFloatSemantics(Ty->getScalarType());
  769   const fltSemantics &Semantics = *TypeToFloatSemantics(Ty->getScalarType());
  780   const fltSemantics &Semantics = *TypeToFloatSemantics(Ty->getScalarType());
  791   const fltSemantics &Semantics = *TypeToFloatSemantics(Ty->getScalarType());
  840   const fltSemantics &Semantics = *TypeToFloatSemantics(Ty->getScalarType());
 1823   PointerType *SrcScalarTy = cast<PointerType>(C->getType()->getScalarType());
 1824   PointerType *DstScalarTy = cast<PointerType>(DstTy->getScalarType());
 2012     Ty = cast<PointerType>(C->getType()->getScalarType())->getElementType();
 2015            cast<PointerType>(C->getType()->getScalarType())->getElementType());

lib/IR/ConstantsContext.h

  557                      : cast<PointerType>(Ops[0]->getType()->getScalarType())

lib/IR/Core.cpp

 1646       cast<PointerType>(Val->getType()->getScalarType())->getElementType();
 1657       cast<PointerType>(Val->getType()->getScalarType())->getElementType();
 3589       cast<PointerType>(Val->getType()->getScalarType())->getElementType();
 3606       cast<PointerType>(Val->getType()->getScalarType())->getElementType();
 3622       cast<PointerType>(Val->getType()->getScalarType())->getElementType();

lib/IR/DataLayout.cpp

  674   Ty = Ty->getScalarType();
  690   Ty = Ty->getScalarType();

lib/IR/Instruction.cpp

  479        getType()->getScalarType() != I->getType()->getScalarType() :
  479        getType()->getScalarType() != I->getType()->getScalarType() :
  487         getOperand(i)->getType()->getScalarType() !=
  488           I->getOperand(i)->getType()->getScalarType() :

lib/IR/Instructions.cpp

 2707       if (SrcTy->getScalarType()->getPointerElementType() ==
 2708           DstTy->getScalarType()->getPointerElementType())
 3249     PointerType *SrcPtrTy = dyn_cast<PointerType>(SrcTy->getScalarType());
 3250     PointerType *DstPtrTy = dyn_cast<PointerType>(DstTy->getScalarType());
 3279     PointerType *SrcPtrTy = dyn_cast<PointerType>(SrcTy->getScalarType());
 3283     PointerType *DstPtrTy = dyn_cast<PointerType>(DstTy->getScalarType());

lib/IR/SafepointIRVerifier.cpp

  266     return isGCPointerType(VT->getScalarType());

lib/IR/Type.cpp

  135   return getScalarType()->getPrimitiveSizeInBits();

lib/IR/Verifier.cpp

 1926         !DL.isNonIntegralPointerType(cast<PointerType>(PtrTy->getScalarType())),
 2726   if (auto *PTy = dyn_cast<PointerType>(SrcTy->getScalarType()))
 2753   if (auto *PTy = dyn_cast<PointerType>(DestTy->getScalarType()))
 3274   Type *TargetTy = GEP.getPointerOperandType()->getScalarType();
 4499     Assert(isa<PointerType>(Call.getType()->getScalarType()),

lib/Target/AArch64/AArch64TargetTransformInfo.cpp

  204     return VectorType::get(ArgTy->getScalarType(),
  685     auto *SubVecTy = VectorType::get(VecTy->getScalarType(), NumElts / Factor);

lib/Target/AMDGPU/AMDGPUCodeGenPrepare.cpp

  546   if (!Ty->getScalarType()->isFloatTy())

lib/Target/ARM/ARMTargetTransformInfo.cpp

  729     unsigned Cost = getArithmeticInstrCost(Opcode, Ty->getScalarType());
  767   bool EltIs64Bits = DL.getTypeSizeInBits(VecTy->getScalarType()) == 64;
  772     auto *SubVecTy = VectorType::get(VecTy->getScalarType(), NumElts / Factor);

lib/Target/Hexagon/HexagonCommonGEP.cpp

 1127     Type *ElTy = cast<PointerType>(InpTy->getScalarType())->getElementType();

lib/Target/PowerPC/PPCTargetTransformInfo.cpp

  324             if (CI->getArgOperand(0)->getType()->getScalarType()->
  433                J->getType()->getScalarType()->isPPC_FP128Ty()) {
  439       if (CI->getSrcTy()->getScalarType()->isPPC_FP128Ty() ||
  440           CI->getDestTy()->getScalarType()->isPPC_FP128Ty() ||
  441           isLargeIntegerTy(!TM.isPPC64(), CI->getSrcTy()->getScalarType()) ||
  442           isLargeIntegerTy(!TM.isPPC64(), CI->getDestTy()->getScalarType()))
  445                                 J->getType()->getScalarType()) &&
  452                isLargeIntegerTy(false, J->getType()->getScalarType()) &&
  615   else if (Ty && Ty->getScalarType()->isFloatTy())
  772   if (ST->hasVSX() && Val->getScalarType()->isDoubleTy()) {
  780   } else if (ST->hasQPX() && Val->getScalarType()->isFloatingPointTy()) {
  787   } else if (Val->getScalarType()->isIntegerTy() && Index != -1U) {

lib/Target/SystemZ/SystemZTargetTransformInfo.cpp

  433             getArithmeticInstrCost(Opcode, Ty->getScalarType());
  525   if (Tp->getScalarType()->isFP128Ty())
  645     Type *ElTy = OpTy->getScalarType();
  723       unsigned ScalarCost = getCastInstrCost(Opcode, Dst->getScalarType(),
  724                                              Src->getScalarType());
  840       unsigned CmpCostPerVector = (ValTy->getScalarType()->isFloatTy() ? 10 : 1);

lib/Target/X86/X86TargetTransformInfo.cpp

  879         Opcode, Ty->getScalarType(), Op1Info, Op2Info,
 2379   Type *ScalarType = Val->getScalarType();
 2427       int Cost = BaseT::getMemoryOpCost(Opcode, VTy->getScalarType(), Alignment,
 2477         NumElem * BaseT::getMemoryOpCost(Opcode, SrcVTy->getScalarType(),
 3157     Type *SplitSrcTy = VectorType::get(SrcVTy->getScalarType(), VF / SplitFactor);
 3167   return GSOverhead + VF * getMemoryOpCost(Opcode, SrcVTy->getScalarType(),
 3197   int MemoryOpCost = VF * getMemoryOpCost(Opcode, SrcVTy->getScalarType(),
 3269   Type *ScalarTy = DataTy->getScalarType();
 3376   Type *ScalarTy = DataTy->getScalarType();
 3628   MVT VT = MVT::getVectorVT(MVT::getVT(VecTy->getScalarType()), VF);

lib/Transforms/IPO/ArgumentPromotion.cpp

  199             cast<PointerType>(I->getType()->getScalarType())->getElementType(),

lib/Transforms/InstCombine/InstCombineAddSub.cpp

 1524       Type *FScalarTy = FTy->getScalarType();
 1525       Type *IScalarTy = ITy->getScalarType();

lib/Transforms/InstCombine/InstCombineCalls.cpp

  971   bool IsPD = VecTy->getScalarType()->isDoubleTy();
 2467     assert(RetType->getScalarType()->isFloatTy() &&
 3478           = II->getType()->getScalarType()->getFltSemantics();

lib/Transforms/InstCombine/InstCombineCasts.cpp

  668   Type *DestScalarTy = DestTy->getScalarType();
 2323         cast<PointerType>(Src->getType()->getScalarType())->getElementType();
 2476   PointerType *SrcTy = cast<PointerType>(Src->getType()->getScalarType());
 2477   PointerType *DestTy = cast<PointerType>(CI.getType()->getScalarType());

lib/Transforms/InstCombine/InstCombineCompares.cpp

 4933                           : DL.getIndexTypeSizeInBits(Ty->getScalarType());
 6090           X->getType()->getScalarType()->getFltSemantics();

lib/Transforms/InstCombine/InstCombineMulDivRem.cpp

  116       Elts.push_back(UndefValue::get(Ty->getScalarType()));
  121     Elts.push_back(ConstantInt::get(Ty->getScalarType(), IVal->logBase2()));

lib/Transforms/InstCombine/InstCombineSelect.cpp

  909   auto *SelEltTy = dyn_cast<IntegerType>(SelTy->getScalarType());
 1428         DL.getTypeSizeInBits(TrueVal->getType()->getScalarType());
 2042   if (!shouldChangeType(Ty->getScalarType()->getIntegerBitWidth(), NewBitWidth))

lib/Transforms/InstCombine/InstCombineShifts.cpp

  220         SumOfShAmts, ConstantInt::get(SumOfShAmts->getType()->getScalarType(),
  245         ShAmtsDiff, ConstantInt::get(ShAmtsDiff->getType()->getScalarType(),

lib/Transforms/InstCombine/InstCombineVectorOps.cpp

  218     bool NeedSrcBitcast = SrcTy->getScalarType()->isFloatingPointTy();
 1271           VectorType::get(I->getType()->getScalarType(),
 1293   Type *EltTy = V->getType()->getScalarType();

lib/Transforms/InstCombine/InstructionCombining.cpp

 1493     assert(Inst.getType()->getScalarType() == V1->getType()->getScalarType() &&
 1493     assert(Inst.getType()->getScalarType() == V1->getType()->getScalarType() &&
 1505     UndefValue *UndefScalar = UndefValue::get(C->getType()->getScalarType());
 1651       DL.getIndexType(GEP.getPointerOperandType()->getScalarType());

lib/Transforms/Instrumentation/AddressSanitizer.cpp

 1415     Type *PtrTy = cast<PointerType>(PtrOperand->getType()->getScalarType());
 1516   uint64_t ElemTypeSize = DL.getTypeStoreSizeInBits(VTy->getScalarType());

lib/Transforms/Instrumentation/HWAddressSanitizer.cpp

  549     Type *PtrTy = cast<PointerType>(PtrOperand->getType()->getScalarType());

lib/Transforms/Instrumentation/MemorySanitizer.cpp

 2075     assert(!(Ty->isVectorTy() && Ty->getScalarType()->isPointerTy()) &&

lib/Transforms/Instrumentation/ThreadSanitizer.cpp

  330     Type *PtrTy = cast<PointerType>(Addr->getType()->getScalarType());

lib/Transforms/Scalar/Reassociate.cpp

  456   unsigned Bitwidth = I->getType()->getScalarType()->getPrimitiveSizeInBits();

lib/Transforms/Scalar/RewriteStatepointsForGC.cpp

  344     return isGCPointerType(VT->getScalarType());
 1294     auto AS = Ty->getScalarType()->getPointerAddressSpace();

lib/Transforms/Scalar/SROA.cpp

 1481     unsigned ElementSizeInBits = DL.getTypeSizeInBits(VecTy->getScalarType());
 1730   OldTy = OldTy->getScalarType();
 1731   NewTy = NewTy->getScalarType();
 2778     Type *ScalarTy = AllocaTy->getScalarType();

lib/Transforms/Scalar/Scalarizer.cpp

  489   return Intrinsic::getDeclaration(M, ID, { Ty->getScalarType() });

lib/Transforms/Utils/SimplifyLibCalls.cpp

 1901     if (Ty->getScalarType()->isFloatTy()) {
 1906     } else if (Ty->getScalarType()->isDoubleTy()) {

lib/Transforms/Utils/VNCoercion.cpp

   38   if (DL.isNonIntegralPointerType(StoredVal->getType()->getScalarType()) !=
   39       DL.isNonIntegralPointerType(LoadTy->getScalarType())) {
  228   if (DL.isNonIntegralPointerType(StoredVal->getType()->getScalarType()) !=
  229       DL.isNonIntegralPointerType(LoadTy->getScalarType())) {
  253   if (DL.isNonIntegralPointerType(DepLI->getType()->getScalarType()) !=
  254       DL.isNonIntegralPointerType(LoadTy->getScalarType()))
  294     if (DL.isNonIntegralPointerType(LoadTy->getScalarType())) {
  324   if (DL.isNonIntegralPointerType(LoadTy->getScalarType()))

lib/Transforms/Vectorize/LoadStoreVectorizer.cpp

  328       DL.getTypeStoreSize(PtrATy->getScalarType()) !=
  329           DL.getTypeStoreSize(PtrBTy->getScalarType()))
  758       if (!VectorType::isValidElementType(Ty->getScalarType()))
  805       if (!VectorType::isValidElementType(Ty->getScalarType()))
  994     VecTy = VectorType::get(StoreTy->getScalarType(),
 1055         if (Extract->getType() != StoreTy->getScalarType())
 1056           Extract = Builder.CreateBitCast(Extract, StoreTy->getScalarType());
 1067       if (Extract->getType() != StoreTy->getScalarType())
 1069             Builder.CreateBitOrPointerCast(Extract, StoreTy->getScalarType());
 1144     VecTy = VectorType::get(LoadTy->getScalarType(),

lib/Transforms/Vectorize/LoopVectorize.cpp

 1897   Type *STy = Val->getType()->getScalarType();
 1954   Type *ScalarIVTy = ScalarIV->getType()->getScalarType();
 3681         RK, VecTy->getScalarType());
 4301           TysForDecl[0] = VectorType::get(CI->getType()->getScalarType(), VF);
 5115                           (unsigned)DL.getTypeSizeInBits(T->getScalarType()));
 5117                           (unsigned)DL.getTypeSizeInBits(T->getScalarType()));
 5387     unsigned TypeSize = DL.getTypeSizeInBits(Ty->getScalarType());
 5748   Cost += VF * TTI.getMemoryOpCost(I->getOpcode(), ValTy->getScalarType(),

tools/clang/lib/CodeGen/CGBuiltin.cpp

 5826   if (OTy->getScalarType()->isFloatingPointTy()) {
 9606     Amt = CGF.Builder.CreateIntCast(Amt, Ty->getScalarType(), false);

tools/llvm-stress/llvm-stress.cpp

  246         TempValues.push_back(getRandomConstant(VTp->getScalarType()));
  388     bool isFloat = Val0->getType()->getScalarType()->isFloatingPointTy();
  526     Value *Val1 = getRandomValue(Val0->getType()->getScalarType());
  562     unsigned VSize = VTy->getScalarType()->getPrimitiveSizeInBits();
  563     unsigned DestSize = DestTy->getScalarType()->getPrimitiveSizeInBits();
  649     bool fp = Val0->getType()->getScalarType()->isFloatingPointTy();