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

Derived Classes

include/llvm/IR/DerivedTypes.h

  238 class StructType : public CompositeType {
  380 class SequentialType : public CompositeType {

References

include/llvm/IR/Constants.h

  391   ConstantAggregate(CompositeType *T, ValueTy VT, ArrayRef<Constant *> V);

include/llvm/IR/DerivedTypes.h

  238 class StructType : public CompositeType {
  380 class SequentialType : public CompositeType {

include/llvm/Support/Casting.h

   57   static inline bool doit(const From &Val) {
   58     return To::classof(&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) {
  342 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;

lib/CodeGen/Analysis.cpp

  398 static bool indexReallyValid(CompositeType *T, unsigned Idx) {
  422 static bool advanceToNextLeafType(SmallVectorImpl<CompositeType *> &SubTypes,
  440     CompositeType *CT = cast<CompositeType>(DeeperType);
  440     CompositeType *CT = cast<CompositeType>(DeeperType);
  464                           SmallVectorImpl<CompositeType *> &SubTypes,
  470          indexReallyValid(cast<CompositeType>(Next), 0)) {
  471     SubTypes.push_back(cast<CompositeType>(Next));
  473     Next = cast<CompositeType>(Next)->getTypeAtIndex(0U);
  493 static bool nextRealType(SmallVectorImpl<CompositeType *> &SubTypes,
  651   SmallVector<CompositeType *, 4> RetSubTypes, CallSubTypes;

lib/FuzzMutate/Operations.cpp

  247     auto *CTy = cast<CompositeType>(Cur[0]->getType());
  247     auto *CTy = cast<CompositeType>(Cur[0]->getType());
  257     auto *CTy = cast<CompositeType>(Cur[0]->getType());
  257     auto *CTy = cast<CompositeType>(Cur[0]->getType());

lib/IR/ConstantFold.cpp

 2338        Prev = Ty, Ty = cast<CompositeType>(Ty)->getTypeAtIndex(Idxs[i]), ++i) {

lib/IR/Constants.cpp

  993 ConstantAggregate::ConstantAggregate(CompositeType *T, ValueTy VT,

lib/IR/Instructions.cpp

 1639     CompositeType *CT = dyn_cast<CompositeType>(Agg);
 1639     CompositeType *CT = dyn_cast<CompositeType>(Agg);
 2182     Agg = cast<CompositeType>(Agg)->getTypeAtIndex(Index);

lib/Transforms/IPO/ArgumentPromotion.cpp

  297                 ElTy = cast<CompositeType>(ElTy)->getTypeAtIndex(II);
  787   if (!isa<CompositeType>(type))

lib/Transforms/IPO/GlobalOpt.cpp

  144           if (isa<CompositeType>(InnerTy))

lib/Transforms/IPO/StripSymbols.cpp

  151     if (isa<CompositeType>(C->getType()))

lib/Transforms/InstCombine/InstCombineCasts.cpp

 2332            isa<CompositeType>(SrcElTy) && !SrcElTy->isPointerTy() &&
 2334       SrcElTy = cast<CompositeType>(SrcElTy)->getTypeAtIndex(0U);

lib/Transforms/InstCombine/InstructionCombining.cpp

 1746           } else if (auto *CT = dyn_cast<CompositeType>(CurTy)) {
 1746           } else if (auto *CT = dyn_cast<CompositeType>(CurTy)) {

tools/clang/unittests/CodeGen/CodeGenExternalTest.cpp

  202         llvm::CompositeType* structTy = dyn_cast<CompositeType>(llvmTy);
  202         llvm::CompositeType* structTy = dyn_cast<CompositeType>(llvmTy);

usr/include/c++/7.4.0/type_traits

 1983     { typedef _Up     type; };