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

References

include/llvm/IR/Constants.h

  349   ConstantAggregateZero(const ConstantAggregateZero &) = delete;
  351   static ConstantAggregateZero *get(Type *Ty);

include/llvm/IR/IRBuilder.h

 2496     Value *Zeros = ConstantAggregateZero::get(VectorType::get(I32Ty, NumElts));

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/ConstantFolding.cpp

  385   if (isa<ConstantAggregateZero>(C) || isa<UndefValue>(C))

lib/Analysis/ValueTracking.cpp

 1659   if (isa<ConstantPointerNull>(V) || isa<ConstantAggregateZero>(V)) {

lib/CodeGen/AsmPrinter/AsmPrinter.cpp

 2679   if (isa<ConstantAggregateZero>(CV) || isa<UndefValue>(CV))

lib/CodeGen/GlobalISel/IRTranslator.cpp

 2126   else if (auto CAZ = dyn_cast<ConstantAggregateZero>(&C)) {

lib/CodeGen/GlobalMerge.cpp

  474         Inits.push_back(ConstantAggregateZero::get(Tys.back()));

lib/CodeGen/LowerEmuTLS.cpp

  103     if (isa<ConstantAggregateZero>(InitValue) ||

lib/ExecutionEngine/ExecutionEngine.cpp

  922     const ConstantAggregateZero *CAZ = dyn_cast<ConstantAggregateZero>(C);
  922     const ConstantAggregateZero *CAZ = dyn_cast<ConstantAggregateZero>(C);
 1146   if (isa<ConstantAggregateZero>(Init)) {

lib/IR/AsmWriter.cpp

 1381   if (isa<ConstantAggregateZero>(CV)) {

lib/IR/AutoUpgrade.cpp

 1086   Value *PassThru = ZeroMask ? ConstantAggregateZero::get(Ty)
 1204                     ZeroMask     ? ConstantAggregateZero::get(CI.getType()) :
 2524       V0 = (Imm & 0x08) ? ConstantAggregateZero::get(CI->getType()) : V0;
 2525       V1 = (Imm & 0x80) ? ConstantAggregateZero::get(CI->getType()) : V1;
 3291       Value *PassThru = ZeroMask ? ConstantAggregateZero::get(CI->getType())
 3319       Value *PassThru = ZeroMask ? ConstantAggregateZero::get(CI->getType())
 3355       Value *PassThru = ZeroMask ? ConstantAggregateZero::get(CI->getType())
 3385       Value *PassThru = ZeroMask ? ConstantAggregateZero::get(CI->getType())

lib/IR/ConstantFold.cpp

  145       if (isa<ConstantAggregateZero>(V))

lib/IR/Constants.cpp

   96   return isa<ConstantAggregateZero>(this) || isa<ConstantPointerNull>(this) ||
  317     return ConstantAggregateZero::get(Ty);
  363   if (const ConstantAggregateZero *CAZ = dyn_cast<ConstantAggregateZero>(this))
  363   if (const ConstantAggregateZero *CAZ = dyn_cast<ConstantAggregateZero>(this))
 1023     return ConstantAggregateZero::get(Ty);
 1038     return ConstantAggregateZero::get(Ty);
 1096     return ConstantAggregateZero::get(ST);
 1136     return ConstantAggregateZero::get(T);
 1363 ConstantAggregateZero *ConstantAggregateZero::get(Type *Ty) {
 1367   std::unique_ptr<ConstantAggregateZero> &Entry =
 1370     Entry.reset(new ConstantAggregateZero(Ty));
 1401   if (isa<ConstantAggregateZero>(this))
 2491     return ConstantAggregateZero::get(Ty);
 2883     return ConstantAggregateZero::get(getType());
 2923     return ConstantAggregateZero::get(getType());

lib/IR/Instructions.cpp

 1855   if (isa<UndefValue>(Mask) || isa<ConstantAggregateZero>(Mask))

lib/IR/LLVMContextImpl.h

 1291   DenseMap<Type *, std::unique_ptr<ConstantAggregateZero>> CAZConstants;

lib/LTO/LTO.cpp

  972                                   ConstantAggregateZero::get(Ty), "");

lib/Target/AArch64/AArch64InstructionSelector.cpp

 3607   if (!isa<ConstantAggregateZero>(Mask))

lib/Target/AMDGPU/AMDGPULibCalls.cpp

  879   ConstantAggregateZero *CZero;
  884   CZero = dyn_cast<ConstantAggregateZero>(opr1);

lib/Target/AMDGPU/AMDGPUPrintfRuntimeBinding.cpp

  190         } else if (isa<ConstantAggregateZero>(Init)) {

lib/Target/BPF/BPFISelDAGToDAG.cpp

  395   if (isa<ConstantAggregateZero>(CV) || isa<UndefValue>(CV))

lib/Target/NVPTX/NVPTXAsmPrinter.cpp

 1902     } else if (isa<ConstantAggregateZero>(CPV))

lib/Target/TargetLoweringObjectFile.cpp

  110   if (isa<ConstantAggregateZero>(C))

lib/Transforms/IPO/GlobalOpt.cpp

  333         if (Init && isa<ConstantAggregateZero>(Init) && GEP->isInBounds())

lib/Transforms/IPO/LowerTypeTests.cpp

  839           ConstantAggregateZero::get(ArrayType::get(Int8Ty, Padding)));

lib/Transforms/InstCombine/InstCombineCalls.cpp

  358   auto CAZ = dyn_cast<ConstantAggregateZero>(Arg1);
  398       return ConstantAggregateZero::get(VT);
  686   ConstantAggregateZero *ZeroVector = ConstantAggregateZero::get(VecTy);
  686   ConstantAggregateZero *ZeroVector = ConstantAggregateZero::get(VecTy);
  789           ConstantAggregateZero::get(ShufTy), ConstantVector::get(ShuffleMask));
 1305   if (isa<ConstantAggregateZero>(Mask))
 1341   if (isa<ConstantAggregateZero>(Mask)) {
 2471     if (isa<ConstantAggregateZero>(Arg))
 2472       return replaceInstUsesWith(*II, ConstantAggregateZero::get(RetType));
 2890                                    ConstantAggregateZero::get(II->getType()));
 3053     if (isa<ConstantAggregateZero>(Mask))
 3264     if (isa<ConstantAggregateZero>(Arg0) || isa<ConstantAggregateZero>(Arg1)) {
 3264     if (isa<ConstantAggregateZero>(Arg0) || isa<ConstantAggregateZero>(Arg1)) {
 3265       return replaceInstUsesWith(CI, ConstantAggregateZero::get(II->getType()));

lib/Transforms/InstCombine/InstCombineSimplifyDemanded.cpp

 1496         return ConstantAggregateZero::get(II->getType());

lib/Transforms/InstCombine/InstCombineVectorOps.cpp

  619   if (isa<ConstantAggregateZero>(V)) {
 1298   if (isa<ConstantAggregateZero>(V))
 1299     return ConstantAggregateZero::get(VectorType::get(EltTy, Mask.size()));

lib/Transforms/InstCombine/InstructionCombining.cpp

 2870       if (isa<ConstantAggregateZero>(FilterClause)) {
 3032       if (isa<ConstantAggregateZero>(LFilter)) { // LFilter only contains zeros.
 3035         if (isa<ConstantAggregateZero>(Filter)) {
 3045       if (isa<ConstantAggregateZero>(Filter)) { // Filter only contains zeros.

lib/Transforms/Instrumentation/AddressSanitizer.cpp

 1787     if (isa<ConstantAggregateZero>(OP)) continue;

lib/Transforms/Scalar/RewriteStatepointsForGC.cpp

  445     return BaseDefiningValueResult(ConstantAggregateZero::get(I->getType()),

lib/Transforms/Utils/CtorUtils.cpp

   90   if (isa<ConstantAggregateZero>(GV->getInitializer()))
   95     if (isa<ConstantAggregateZero>(V))

lib/Transforms/Utils/ValueMapper.cpp

  484   if (isa<ConstantAggregateZero>(C))
  485     return getVM()[V] = ConstantAggregateZero::get(NewTy);

tools/bugpoint/CrashDebugger.cpp

  215   if (isa<ConstantAggregateZero>(UsedVar->getInitializer())) {

tools/clang/lib/CodeGen/CGBuiltin.cpp

 4377       return llvm::ConstantAggregateZero::get(VTy);
 5723                                 ConstantAggregateZero::get(Ty));
 5861     Value *ZeroTbl = ConstantAggregateZero::get(TblTy);
 9982   Value *PassThru = ZeroMask ? ConstantAggregateZero::get(Ty) : Ops[0];
11208         OutOps[l] = llvm::ConstantAggregateZero::get(Ops[0]->getType());

tools/clang/lib/CodeGen/CGDecl.cpp

  862   if (isa<llvm::ConstantAggregateZero>(Init) ||
  944   if (isa<llvm::ConstantAggregateZero>(Init)) return true;

tools/clang/lib/CodeGen/CGExprConstant.cpp

   68     return llvm::ConstantAggregateZero::get(Ty);
  360   if (isa<llvm::ConstantAggregateZero>(C)) {
  930     return llvm::ConstantAggregateZero::get(DesiredType);
  953     Elements.back() = llvm::ConstantAggregateZero::get(FillerType);
 1683       llvm::ConstantAggregateZero::get(
 2139       return llvm::ConstantAggregateZero::get(AType);

tools/clang/lib/CodeGen/CGExprScalar.cpp

 3969     Value *Zero = llvm::ConstantAggregateZero::get(LHS->getType());
 4053     Value *Zero = llvm::ConstantAggregateZero::get(LHS->getType());

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

  190     auto *DummyInit =
  191         ConstantAggregateZero::get(ArrayType::get(getEntryTy(), 0u));

tools/llvm-diff/DifferenceEngine.cpp

  401     if (isa<ConstantPointerNull>(L) || isa<UndefValue>(L) || isa<ConstantAggregateZero>(L))

unittests/IR/PatternMatch.cpp

  930   Value *Zero = ConstantAggregateZero::get(i32VecTy);

usr/include/c++/7.4.0/bits/unique_ptr.h

   68         default_delete(const default_delete<_Up>&) noexcept { }
   72       operator()(_Tp* __ptr) const
   74 	static_assert(!is_void<_Tp>::value,
   76 	static_assert(sizeof(_Tp)>0,
  122 	  using type = _Up*;
  137       using pointer = typename _Ptr<_Tp, _Dp>::type;
  161 	typename __uniq_ptr_impl<_Tp, _Up>::_DeleterConstraint::type;
  163       __uniq_ptr_impl<_Tp, _Dp> _M_t;
  166       using pointer	  = typename __uniq_ptr_impl<_Tp, _Dp>::pointer;
  167       using element_type  = _Tp;
  252 	unique_ptr(unique_ptr<_Up, _Ep>&& __u) noexcept
  297           __safe_conversion_up<_Up, _Ep>,
  301 	operator=(unique_ptr<_Up, _Ep>&& __u) noexcept

usr/include/c++/7.4.0/type_traits

  215     : public __is_void_helper<typename remove_cv<_Tp>::type>::type
  581     : public __or_<is_lvalue_reference<_Tp>,
  582                    is_rvalue_reference<_Tp>>::type
  601     : public __not_<__or_<is_function<_Tp>, is_reference<_Tp>,
  601     : public __not_<__or_<is_function<_Tp>, is_reference<_Tp>,
  602                           is_void<_Tp>>>::type
  638     : public __or_<is_object<_Tp>, is_reference<_Tp>>::type
  638     : public __or_<is_object<_Tp>, is_reference<_Tp>>::type
 1554     { typedef _Tp     type; };
 1563     { typedef _Tp     type; };
 1574       remove_const<typename remove_volatile<_Tp>::type>::type     type;
 1645     { typedef _Tp&   type; };
 1650     : public __add_lvalue_reference_helper<_Tp>