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

References

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/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;
  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
  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) {
  265   return cast_convert_val<X, Y*,
  331                             typename cast_retty<X, const Y>::ret_type>::type
  337 LLVM_NODISCARD inline typename cast_retty<X, Y>::ret_type dyn_cast(Y &Val) {
  338   return isa<X>(Val) ? cast<X>(Val) : nullptr;
  338   return isa<X>(Val) ? cast<X>(Val) : nullptr;
  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 };

lib/Analysis/ConstantFolding.cpp

  422   if (auto *CS = dyn_cast<ConstantStruct>(C)) {
  422   if (auto *CS = dyn_cast<ConstantStruct>(C)) {
 2141         return ConstantStruct::get(
 2181       return ConstantStruct::get(cast<StructType>(Ty), Ops);

lib/Analysis/InstructionSimplify.cpp

 5020       return ConstantStruct::get(

lib/Analysis/ModuleSummaryAnalysis.cpp

  502   if (auto *C = dyn_cast<ConstantStruct>(I)) {

lib/Analysis/TypeMetadataUtils.cpp

  140   if (auto *C = dyn_cast<ConstantStruct>(I)) {
  140   if (auto *C = dyn_cast<ConstantStruct>(I)) {

lib/AsmParser/LLParser.cpp

 5238       V = ConstantStruct::get(

lib/Bitcode/Reader/BitcodeReader.cpp

 2440         V = ConstantStruct::get(STy, Elts);

lib/Bitcode/Reader/ValueList.cpp

  207       } else if (ConstantStruct *UserCS = dyn_cast<ConstantStruct>(UserC)) {
  207       } else if (ConstantStruct *UserCS = dyn_cast<ConstantStruct>(UserC)) {
  208         NewC = ConstantStruct::get(UserCS->getType(), NewOps);

lib/CodeGen/AsmPrinter/AsmPrinter.cpp

 2005     ConstantStruct *CS = dyn_cast<ConstantStruct>(O);
 2005     ConstantStruct *CS = dyn_cast<ConstantStruct>(O);
 2446                                      const ConstantStruct *CS, AsmPrinter &AP,
 2713   if (const ConstantStruct *CVS = dyn_cast<ConstantStruct>(CV))
 2713   if (const ConstantStruct *CVS = dyn_cast<ConstantStruct>(CV))

lib/CodeGen/GlobalMerge.cpp

  502     Constant *MergedInit = ConstantStruct::get(MergedTy, Inits);

lib/CodeGen/LowerEmuTLS.cpp

  157       ConstantStruct::get(EmuTlsVarType, ElementValueArray));

lib/CodeGen/SelectionDAG/SelectionDAGBuilder.cpp

 1471     if (isa<ConstantStruct>(C) || isa<ConstantArray>(C)) {

lib/CodeGen/ShadowStackGCLowering.cpp

  124       ConstantStruct::get(FrameMapTy, BaseElts),
  130   Constant *FrameMap = ConstantStruct::get(STy, DescriptorElts);

lib/ExecutionEngine/ExecutionEngine.cpp

  387     ConstantStruct *CS = dyn_cast<ConstantStruct>(InitList->getOperand(i));
  387     ConstantStruct *CS = dyn_cast<ConstantStruct>(InitList->getOperand(i));
 1159   if (const ConstantStruct *CPS = dyn_cast<ConstantStruct>(Init)) {
 1159   if (const ConstantStruct *CPS = dyn_cast<ConstantStruct>(Init)) {

lib/ExecutionEngine/Orc/ExecutionUtils.cpp

   49   ConstantStruct *CS = dyn_cast<ConstantStruct>(InitList->getOperand(I));
   49   ConstantStruct *CS = dyn_cast<ConstantStruct>(InitList->getOperand(I));

lib/IR/AsmWriter.cpp

 1444   if (const ConstantStruct *CS = dyn_cast<ConstantStruct>(CV)) {
 1444   if (const ConstantStruct *CS = dyn_cast<ConstantStruct>(CV)) {

lib/IR/AutoUpgrade.cpp

  858     NewCtors[i] = ConstantStruct::get(

lib/IR/ConstantFold.cpp

  935     return ConstantStruct::get(ST, Result);

lib/IR/ConstantsContext.h

  364   using ValType = ConstantAggrKeyType<ConstantStruct>;
  377   ConstantAggrKeyType(ArrayRef<Constant *> Operands, const ConstantClass *)
  380   ConstantAggrKeyType(const ConstantClass *C,
  392   bool operator==(const ConstantClass *C) const {
  405   using TypeClass = typename ConstantInfo<ConstantClass>::TypeClass;
  407   ConstantClass *create(TypeClass *Ty) const {
  408     return new (Operands.size()) ConstantClass(Ty, Operands);
  572   using ValType = typename ConstantInfo<ConstantClass>::ValType;
  573   using TypeClass = typename ConstantInfo<ConstantClass>::TypeClass;
  581     using ConstantClassInfo = DenseMapInfo<ConstantClass *>;
  583     static inline ConstantClass *getEmptyKey() {
  587     static inline ConstantClass *getTombstoneKey() {
  591     static unsigned getHashValue(const ConstantClass *CP) {
  596     static bool isEqual(const ConstantClass *LHS, const ConstantClass *RHS) {
  596     static bool isEqual(const ConstantClass *LHS, const ConstantClass *RHS) {
  608     static bool isEqual(const LookupKey &LHS, const ConstantClass *RHS) {
  616     static bool isEqual(const LookupKeyHashed &LHS, const ConstantClass *RHS) {
  622   using MapTy = DenseSet<ConstantClass *, MapInfo>;
  637   ConstantClass *create(TypeClass *Ty, ValType V, LookupKeyHashed &HashKey) {
  638     ConstantClass *Result = V.create(Ty);
  648   ConstantClass *getOrCreate(TypeClass *Ty, ValType V) {
  653     ConstantClass *Result = nullptr;
  666   void remove(ConstantClass *CP) {
  673   ConstantClass *replaceOperandsInPlace(ArrayRef<Constant *> Operands,
  674                                         ConstantClass *CP, Value *From,

lib/IR/Core.cpp

 1407   return wrap(ConstantStruct::getAnon(*unwrap(C), makeArrayRef(Elements, Count),
 1423   return wrap(ConstantStruct::get(Ty, makeArrayRef(Elements, Count)));

lib/IR/LLVMContextImpl.cpp

   86   for (auto *I : StructConstants)

lib/IR/LLVMContextImpl.h

 1296   using StructConstantsTy = ConstantUniqueMap<ConstantStruct>;

lib/LTO/LTOModule.cpp

  265   const ConstantStruct *c = dyn_cast<ConstantStruct>(clgv->getInitializer());
  265   const ConstantStruct *c = dyn_cast<ConstantStruct>(clgv->getInitializer());
  299   const ConstantStruct *c = dyn_cast<ConstantStruct>(clgv->getInitializer());
  299   const ConstantStruct *c = dyn_cast<ConstantStruct>(clgv->getInitializer());

lib/Target/BPF/BPFISelDAGToDAG.cpp

   89   bool fillConstantStruct(const DataLayout &DL, const ConstantStruct *CS,
  356     if (const ConstantStruct *CS = dyn_cast<ConstantStruct>(Init))
  356     if (const ConstantStruct *CS = dyn_cast<ConstantStruct>(Init))
  421   if (const ConstantStruct *CVS = dyn_cast<ConstantStruct>(CV))
  421   if (const ConstantStruct *CVS = dyn_cast<ConstantStruct>(CV))
  453                                          const ConstantStruct *CS,

lib/Target/NVPTX/NVPTXAsmPrinter.cpp

 1947   if (isa<ConstantStruct>(CPV)) {

lib/Target/WebAssembly/WebAssemblyLowerGlobalDtors.cpp

   83     auto *CS = dyn_cast<ConstantStruct>(O);
   83     auto *CS = dyn_cast<ConstantStruct>(O);

lib/Transforms/Coroutines/CoroEarly.cpp

  131     Constant* NoopCoroConst = ConstantStruct::get(FrameTy, Values);

lib/Transforms/Coroutines/CoroInstr.h

  155     ConstantStruct *OutlinedParts = nullptr;
  170     if ((Result.OutlinedParts = dyn_cast<ConstantStruct>(Initializer)))

lib/Transforms/IPO/GlobalOpt.cpp

 2409     return ConstantStruct::get(STy, Elts);
 2533           CurrentGV->setInitializer(ConstantStruct::get(STy, Elts));

lib/Transforms/IPO/GlobalSplit.cpp

   47   auto *Init = dyn_cast_or_null<ConstantStruct>(GV.getInitializer());
   47   auto *Init = dyn_cast_or_null<ConstantStruct>(GV.getInitializer());

lib/Transforms/IPO/LowerTypeTests.cpp

  857   Constant *NewInit = ConstantStruct::getAnon(M.getContext(), GlobalInits);

lib/Transforms/IPO/WholeProgramDevirt.cpp

 1508   auto NewInit = ConstantStruct::getAnon(

lib/Transforms/InstCombine/InstCombineInternal.h

  686     Constant *Struct = ConstantStruct::get(ST, V);

lib/Transforms/Instrumentation/AddressSanitizer.cpp

 1257   auto LocStruct = ConstantStruct::getAnon(LocData);
 1788     ConstantStruct *CS = cast<ConstantStruct>(OP);
 1788     ConstantStruct *CS = cast<ConstantStruct>(OP);
 2142         ConstantStruct::get(LivenessTy, Initializer->getAggregateElement(0u),
 2282     Constant *NewInitializer = ConstantStruct::get(
 2366     Constant *Initializer = ConstantStruct::get(

lib/Transforms/Instrumentation/GCOVProfiling.cpp

  997     auto *StartFileCallArgs = ConstantStruct::get(
 1007       EmitFunctionCallArgsArray.push_back(ConstantStruct::get(
 1019       EmitArcsCallArgsArray.push_back(ConstantStruct::get(
 1049     FileInfos.push_back(ConstantStruct::get(

lib/Transforms/Instrumentation/HWAddressSanitizer.cpp

 1258     Initializer = ConstantStruct::getAnon({Initializer, Padding});
 1303     Descriptor->setInitializer(ConstantStruct::getAnon({GVRelPtr, SizeAndTag}));
 1384   Note->setInitializer(ConstantStruct::getAnon(

lib/Transforms/Instrumentation/InstrProfiling.cpp

  839                                   ConstantStruct::get(DataTy, DataVals),

lib/Transforms/Instrumentation/MemorySanitizer.cpp

 1555       return ConstantStruct::get(ST, Vals);

lib/Transforms/ObjCARC/ObjCARCAPElim.cpp

  161     Function *F = dyn_cast<Function>(cast<ConstantStruct>(Op)->getOperand(1));

lib/Transforms/Scalar/CorrelatedValuePropagation.cpp

  505   Constant *Struct = ConstantStruct::get(ST,

lib/Transforms/Scalar/SCCP.cpp

 1767     Const = ConstantStruct::get(ST, ConstVals);

lib/Transforms/Utils/CtorUtils.cpp

   72     ConstantStruct *CS = cast<ConstantStruct>(V);
   72     ConstantStruct *CS = cast<ConstantStruct>(V);
   97     ConstantStruct *CS = cast<ConstantStruct>(V);
   97     ConstantStruct *CS = cast<ConstantStruct>(V);

lib/Transforms/Utils/FunctionComparator.cpp

  315     const ConstantStruct *LS = cast<ConstantStruct>(L);
  315     const ConstantStruct *LS = cast<ConstantStruct>(L);
  316     const ConstantStruct *RS = cast<ConstantStruct>(R);
  316     const ConstantStruct *RS = cast<ConstantStruct>(R);

lib/Transforms/Utils/ModuleUtils.cpp

   49       ConstantStruct::get(EltTy, makeArrayRef(CSVals, EltTy->getNumElements()));

lib/Transforms/Utils/SanitizerStats.cpp

   85       ConstantStruct::getAnon(

lib/Transforms/Utils/ValueMapper.cpp

  477   if (isa<ConstantStruct>(C))
  478     return getVM()[V] = ConstantStruct::get(cast<StructType>(NewTy), Ops);
  980       auto *S = cast<ConstantStruct>(V);
  980       auto *S = cast<ConstantStruct>(V);
  984       NewV = ConstantStruct::get(cast<StructType>(EltTy), E1, E2, Null);

tools/bugpoint/ExtractFunction.cpp

  237     ArrayElts.push_back(ConstantStruct::get(STy, Elts));
  259     if (ConstantStruct *CS =
  260             dyn_cast<ConstantStruct>(InitList->getOperand(i))) {

tools/clang/lib/CodeGen/CGDecl.cpp

  872   if (isa<llvm::ConstantArray>(Init) || isa<llvm::ConstantStruct>(Init)) {
 1035   return llvm::ConstantStruct::getAnon(Values, STy->isPacked());
 1267     return llvm::ConstantStruct::get(cast<llvm::StructType>(Ty), Values);

tools/clang/lib/CodeGen/CGExpr.cpp

 2820   llvm::Constant *Descriptor = llvm::ConstantStruct::getAnon(Components);
 2918   return llvm::ConstantStruct::getAnon(Data);
 3073       llvm::Constant *Info = llvm::ConstantStruct::getAnon(StaticArgs);
 3134     llvm::Constant *Info = llvm::ConstantStruct::getAnon(StaticArgs);

tools/clang/lib/CodeGen/CGExprConstant.cpp

  482   llvm::StructType *STy = llvm::ConstantStruct::getTypeForElements(
  492   return llvm::ConstantStruct::get(STy, Packed ? PackedElems : UnpackedElems);
  520       Elems[First] = llvm::ConstantStruct::get(STy, Elems[First]);
  974   return llvm::ConstantStruct::get(SType, Elements);
 1067       return llvm::ConstantStruct::get(STy, Elts);
 1686     return llvm::ConstantStruct::getAnon(elts);
 2036     return llvm::ConstantStruct::get(STy, Complex);
 2059     return llvm::ConstantStruct::get(STy, Complex);
 2272   return llvm::ConstantStruct::get(structure, elements);

tools/clang/lib/CodeGen/CodeGenFunction.cpp

  797             llvm::ConstantStruct::getAnon(PrologueStructElems, /*Packed=*/true);

tools/clang/lib/CodeGen/CodeGenModule.cpp

 2220   return llvm::ConstantStruct::getAnon(Fields);
 5727   return llvm::ConstantStruct::getAnon(Fields);

tools/clang/lib/CodeGen/ConstantInitBuilder.cpp

  272     constant = llvm::ConstantStruct::get(ty, elts);
  274     constant = llvm::ConstantStruct::getAnon(elts, Packed);

tools/clang/lib/CodeGen/CoverageMappingGen.cpp

 1338   FunctionRecords.push_back(llvm::ConstantStruct::get(
 1429   auto CovDataHeaderVal = llvm::ConstantStruct::get(
 1439       llvm::ConstantStruct::get(CovDataTy, makeArrayRef(TUDataVals));

tools/clang/lib/CodeGen/ItaniumCXXABI.cpp

  943   return llvm::ConstantStruct::getAnon(Values);
 1015   return llvm::ConstantStruct::getAnon(MemPtr);
 3492   llvm::Constant *Init = llvm::ConstantStruct::getAnon(Fields);

tools/clang/lib/CodeGen/MicrosoftCXXABI.cpp

 2663   llvm::Constant *Res = llvm::ConstantStruct::getAnon(fields);
 2699   return llvm::ConstantStruct::getAnon(fields);
 3612   CHD->setInitializer(llvm::ConstantStruct::get(Type, Fields));
 3693   BCD->setInitializer(llvm::ConstantStruct::get(Type, Fields));
 3738   COL->setInitializer(llvm::ConstantStruct::get(Type, FieldsRef));
 3839       llvm::ConstantStruct::get(TypeDescriptorType, Fields),
 4077       llvm::ConstantStruct::get(CTType, Fields), MangledName);
 4195       llvm::ConstantStruct::get(CTAType, Fields), MangledName);
 4264       llvm::ConstantStruct::get(TIType, Fields), StringRef(MangledName));

tools/clang/lib/CodeGen/PatternInit.cpp

   84   return llvm::ConstantStruct::get(StructTy, Struct);

tools/clang/tools/clang-offload-wrapper/ClangOffloadWrapper.cpp

  219       ImagesInits.push_back(ConstantStruct::get(getDeviceImageTy(), ImageB,
  237     auto *DescInit = ConstantStruct::get(

tools/lldb/source/Expression/IRExecutionUnit.cpp

  985         if (llvm::ConstantStruct *ctor_struct =
  986                 llvm::dyn_cast<llvm::ConstantStruct>(ctor_use)) {

tools/lldb/source/Plugins/ExpressionParser/Clang/IRForTarget.cpp

  586       ConstantStruct *nsstring_struct =
  587           dyn_cast<ConstantStruct>(nsstring_global->getInitializer());

tools/polly/lib/CodeGen/LoopGeneratorsKMP.cpp

  484     Constant *LocInitStruct = ConstantStruct::get(

tools/polly/lib/CodeGen/PerfMonitor.cpp

   51       ConstantStruct::get(ST, Builder.getInt32(10), Fn,

unittests/FuzzMutate/OperationsTest.cpp

   92       ConstantStruct::get(StructType::create(Ctx, "OpaqueStruct"));

unittests/Linker/LinkModulesTest.cpp

  167   GV->setInitializer(ConstantStruct::get(STy, F));

usr/include/c++/7.4.0/type_traits

 1983     { typedef _Up     type; };