s/NDEBUG/LLVM_NDEBUG/ in most places to match the same LLVM change.

[• tstellarAMD]

Ping.

lib/ARCMigrate/TransProperties.cpp

private:
   bool isUserDeclared(ObjCIvarDecl *ivarD) const {
     return ivarD && !ivarD->getSynthesize();
   }
 
   QualType getPropertyType(PropsTy &props) const {
     assert(!props.empty());
     QualType ty = props[0].PropD->getType().getUnqualifiedType();
 
-#ifndef NDEBUG
+#ifndef LLVM_NDEBUG
     for (PropsTy::iterator I = props.begin(), E = props.end(); I != E; ++I)
       assert(ty == I->PropD->getType().getUnqualifiedType());
 #endif
 
     return ty;
   }
 
   ObjCPropertyDecl::PropertyAttributeKind
   getPropertyAttrs(PropsTy &props) const {
     assert(!props.empty());
     ObjCPropertyDecl::PropertyAttributeKind
       attrs = props[0].PropD->getPropertyAttributesAsWritten();
 
-#ifndef NDEBUG
+#ifndef LLVM_NDEBUG
     for (PropsTy::iterator I = props.begin(), E = props.end(); I != E; ++I)
       assert(attrs == I->PropD->getPropertyAttributesAsWritten());
 #endif
 
     return attrs;
   }
 };
 
 } // anonymous namespace
 
 void PropertyRewriteTraverser::traverseObjCImplementation(
                                            ObjCImplementationContext &ImplCtx) {
   PropertiesRewriter(ImplCtx.getMigrationContext())
                                   .doTransform(ImplCtx.getImplementationDecl());
 }

lib/AST/ASTContext.cpp

 enum FloatingRank {
   HalfRank, FloatRank, DoubleRank, LongDoubleRank
 };
 
 RawComment *ASTContext::getRawCommentForDeclNoCache(const Decl *D) const {
   if (!CommentsLoaded && ExternalSource) {
     ExternalSource->ReadComments();
 
-#ifndef NDEBUG
+#ifndef LLVM_NDEBUG
     ArrayRef<RawComment *> RawComments = Comments.getComments();
     assert(std::is_sorted(RawComments.begin(), RawComments.end(),
                           BeforeThanCompare<RawComment>(SourceMgr)));
 #endif
 
     CommentsLoaded = true;
   }
 
ASTContext::getFunctionType(QualType ResultTy, ArrayRef<QualType> ArgArray,
   FunctionProtoType *FTP = (FunctionProtoType*) Allocate(Size, TypeAlignment);
   FunctionProtoType::ExtProtoInfo newEPI = EPI;
   new (FTP) FunctionProtoType(ResultTy, ArgArray, Canonical, newEPI);
   Types.push_back(FTP);
   FunctionProtoTypes.InsertNode(FTP, InsertPos);
   return QualType(FTP, 0);
 }
 
-#ifndef NDEBUG
+#ifndef LLVM_NDEBUG
 static bool NeedsInjectedClassNameType(const RecordDecl *D) {
   if (!isa<CXXRecordDecl>(D)) return false;
   const CXXRecordDecl *RD = cast<CXXRecordDecl>(D);
   if (isa<ClassTemplatePartialSpecializationDecl>(RD))
     return true;
   if (RD->getDescribedClassTemplate() &&
       !isa<ClassTemplateSpecializationDecl>(RD))
     return true;
ASTContext::getSubstTemplateTypeParmType(const TemplateTypeParmType *Parm,
 
   return QualType(SubstParm, 0);
 }
 
 /// \brief Retrieve a 
 QualType ASTContext::getSubstTemplateTypeParmPackType(
                                           const TemplateTypeParmType *Parm,
                                               const TemplateArgument &ArgPack) {
-#ifndef NDEBUG
+#ifndef LLVM_NDEBUG
   for (const auto &P : ArgPack.pack_elements()) {
     assert(P.getKind() == TemplateArgument::Type &&"Pack contains a non-type");
     assert(P.getAsType().isCanonical() && "Pack contains non-canonical type");
   }
 #endif
   
   llvm::FoldingSetNodeID ID;
   SubstTemplateTypeParmPackType::Profile(ID, Parm, ArgPack);
ASTContext::getTemplateSpecializationType(TemplateName Template,
   ArgVec.reserve(NumArgs);
   for (unsigned i = 0; i != NumArgs; ++i)
     ArgVec.push_back(Args[i].getArgument());
 
   return getTemplateSpecializationType(Template, ArgVec.data(), NumArgs,
                                        Underlying);
 }
 
-#ifndef NDEBUG
+#ifndef LLVM_NDEBUG
 static bool hasAnyPackExpansions(const TemplateArgument *Args,
                                  unsigned NumArgs) {
   for (unsigned I = 0; I != NumArgs; ++I)
     if (Args[I].isPackExpansion())
       return true;
   
   return true;
 }
void ASTContext::getObjCEncodingForStructureImpl(RecordDecl *RDecl,
 
   CharUnits size;
   if (CXXRec) {
     size = includeVBases ? layout.getSize() : layout.getNonVirtualSize();
   } else {
     size = layout.getSize();
   }
 
-#ifndef NDEBUG
+#ifndef LLVM_NDEBUG
   uint64_t CurOffs = 0;
 #endif
   std::multimap<uint64_t, NamedDecl *>::iterator
     CurLayObj = FieldOrBaseOffsets.begin();
 
   if (CXXRec && CXXRec->isDynamicClass() &&
       (CurLayObj == FieldOrBaseOffsets.end() || CurLayObj->first != 0)) {
     if (FD) {
       S += "\"_vptr$";
       std::string recname = CXXRec->getNameAsString();
       if (recname.empty()) recname = "?";
       S += recname;
       S += '"';
     }
     S += "^^?";
-#ifndef NDEBUG
+#ifndef LLVM_NDEBUG
     CurOffs += getTypeSize(VoidPtrTy);
 #endif
   }
 
   if (!RDecl->hasFlexibleArrayMember()) {
     // Mark the end of the structure.
     uint64_t offs = toBits(size);
     FieldOrBaseOffsets.insert(FieldOrBaseOffsets.upper_bound(offs),
                               std::make_pair(offs, nullptr));
   }
 
   for (; CurLayObj != FieldOrBaseOffsets.end(); ++CurLayObj) {
-#ifndef NDEBUG
+#ifndef LLVM_NDEBUG
     assert(CurOffs <= CurLayObj->first);
     if (CurOffs < CurLayObj->first) {
       uint64_t padding = CurLayObj->first - CurOffs; 
       // FIXME: There doesn't seem to be a way to indicate in the encoding that
       // packing/alignment of members is different that normal, in which case
       // the encoding will be out-of-sync with the real layout.
       // If the runtime switches to just consider the size of types without
       // taking into account alignment, we could make padding explicit in the
#endif
     if (CXXRecordDecl *base = dyn_cast<CXXRecordDecl>(dcl)) {
       // We expand the bases without their virtual bases since those are going
       // in the initial structure. Note that this differs from gcc which
       // expands virtual bases each time one is encountered in the hierarchy,
       // making the encoding type bigger than it really is.
       getObjCEncodingForStructureImpl(base, S, FD, /*includeVBases*/false,
                                       NotEncodedT);
       assert(!base->isEmpty());
-#ifndef NDEBUG
+#ifndef LLVM_NDEBUG
       CurOffs += toBits(getASTRecordLayout(base).getNonVirtualSize());
 #endif
     } else {
       FieldDecl *field = cast<FieldDecl>(dcl);
       if (FD) {
         S += '"';
         S += field->getNameAsString();
         S += '"';
       }
 
       if (field->isBitField()) {
         EncodeBitField(this, S, field->getType(), field);
-#ifndef NDEBUG
+#ifndef LLVM_NDEBUG
         CurOffs += field->getBitWidthValue(*this);
 #endif
       } else {
         QualType qt = field->getType();
         getLegacyIntegralTypeEncoding(qt);
         getObjCEncodingForTypeImpl(qt, S, false, true, FD,
                                    /*OutermostType*/false,
                                    /*EncodingProperty*/false,
                                    /*StructField*/true,
                                    false, false, false, NotEncodedT);
-#ifndef NDEBUG
+#ifndef LLVM_NDEBUG
         CurOffs += getTypeSize(field->getType());
 #endif
       }
     }
   }
 }
 
 void ASTContext::getObjCEncodingForTypeQualifier(Decl::ObjCDeclQualifier QT,
Qualifiers::GC ASTContext::getObjCGCAttrKind(QualType Ty) const {
   if (GCAttrs == Qualifiers::GCNone) {
     if (Ty->isObjCObjectPointerType() || Ty->isBlockPointerType())
       return Qualifiers::Strong;
     else if (Ty->isPointerType())
       return getObjCGCAttrKind(Ty->getAs<PointerType>()->getPointeeType());
   } else {
     // It's not valid to set GC attributes on anything that isn't a
     // pointer.
-#ifndef NDEBUG
+#ifndef LLVM_NDEBUG
     QualType CT = Ty->getCanonicalTypeInternal();
     while (const ArrayType *AT = dyn_cast<ArrayType>(CT))
       CT = AT->getElementType();
     assert(CT->isAnyPointerType() || CT->isBlockPointerType());
 #endif
   }
   return GCAttrs;
 }

lib/AST/CommentLexer.cpp

 } // unnamed namespace
 
 void Lexer::formTokenWithChars(Token &Result, const char *TokEnd,
                                tok::TokenKind Kind) {
   const unsigned TokLen = TokEnd - BufferPtr;
   Result.setLocation(getSourceLocation(BufferPtr));
   Result.setKind(Kind);
   Result.setLength(TokLen);
-#ifndef NDEBUG
+#ifndef LLVM_NDEBUG
   Result.TextPtr = "<UNSET>";
   Result.IntVal = 7;
 #endif
   BufferPtr = TokEnd;
 }
 
 void Lexer::lexCommentText(Token &T) {
   assert(CommentState == LCS_InsideBCPLComment ||

lib/AST/CommentParser.cpp

class TextTokenRetokenizer {
   void formTokenWithChars(Token &Result,
                           SourceLocation Loc,
                           const char *TokBegin,
                           unsigned TokLength,
                           StringRef Text) {
     Result.setLocation(Loc);
     Result.setKind(tok::text);
     Result.setLength(TokLength);
-#ifndef NDEBUG
+#ifndef LLVM_NDEBUG
     Result.TextPtr = "<UNSET>";
     Result.IntVal = 7;
 #endif
     Result.setText(Text);
   }
 
 public:
   TextTokenRetokenizer(llvm::BumpPtrAllocator &Allocator, Parser &P):

lib/AST/Decl.cpp

if (computation == LVForLinkageOnly && D->hasCachedLinkage())
       return LinkageInfo(D->getCachedLinkage(), DefaultVisibility, false);
 
     LinkageInfo LV = computeLVForDecl(D, computation);
     if (D->hasCachedLinkage())
       assert(D->getCachedLinkage() == LV.getLinkage());
 
     D->setCachedLinkage(LV.getLinkage());
 
-#ifndef NDEBUG
+#ifndef LLVM_NDEBUG
     // In C (because of gnu inline) and in c++ with microsoft extensions an
     // static can follow an extern, so we can have two decls with different
     // linkages.
     const LangOptions &Opts = D->getASTContext().getLangOpts();
     if (!Opts.CPlusPlus || Opts.MicrosoftExt)
       return LV;
 
     // We have just computed the linkage for this decl. By induction we know
void RecordDecl::LoadFieldsFromExternalStorage() const {
   ExternalASTSource::Deserializing TheFields(Source);
 
   SmallVector<Decl*, 64> Decls;
   LoadedFieldsFromExternalStorage = true;
   Source->FindExternalLexicalDecls(this, [](Decl::Kind K) {
     return FieldDecl::classofKind(K) || IndirectFieldDecl::classofKind(K);
   }, Decls);
 
-#ifndef NDEBUG
+#ifndef LLVM_NDEBUG
   // Check that all decls we got were FieldDecls.
   for (unsigned i=0, e=Decls.size(); i != e; ++i)
     assert(isa<FieldDecl>(Decls[i]) || isa<IndirectFieldDecl>(Decls[i]));
 #endif
 
   if (Decls.empty())
     return;
 

lib/AST/DeclBase.cpp

SourceLocation Decl::getBodyRBrace() const {
 
   if (Stmt *Body = getBody())
     return Body->getSourceRange().getEnd();
 
   return SourceLocation();
 }
 
 bool Decl::AccessDeclContextSanity() const {
-#ifndef NDEBUG
+#ifndef LLVM_NDEBUG
   // Suppress this check if any of the following hold:
   // 1. this is the translation unit (and thus has no parent)
   // 2. this is a template parameter (and thus doesn't belong to its context)
   // 3. this is a non-type template parameter
   // 4. the context is not a record
   // 5. it's invalid
   // 6. it's a C++0x static_assert.
   if (isa<TranslationUnitDecl>(this) ||

lib/AST/DeclFriend.cpp

return cast_or_null<FriendDecl>(
                            NextFriend.get(getASTContext().getExternalSource()));
 }
 
 FriendDecl *FriendDecl::Create(ASTContext &C, DeclContext *DC,
                                SourceLocation L,
                                FriendUnion Friend,
                                SourceLocation FriendL,
                         ArrayRef<TemplateParameterList*> FriendTypeTPLists) {
-#ifndef NDEBUG
+#ifndef LLVM_NDEBUG
   if (Friend.is<NamedDecl*>()) {
     NamedDecl *D = Friend.get<NamedDecl*>();
     assert(isa<FunctionDecl>(D) ||
            isa<CXXRecordDecl>(D) ||
            isa<FunctionTemplateDecl>(D) ||
            isa<ClassTemplateDecl>(D));
 
     // As a temporary hack, we permit template instantiation to point

lib/AST/DeclTemplate.cpp

 }
 
 template<class Derived, class EntryType>
 void RedeclarableTemplateDecl::addSpecializationImpl(
     llvm::FoldingSetVector<EntryType> &Specializations, EntryType *Entry,
     void *InsertPos) {
   typedef SpecEntryTraits<EntryType> SETraits;
   if (InsertPos) {
-#ifndef NDEBUG
+#ifndef LLVM_NDEBUG
     void *CorrectInsertPos;
     assert(!findSpecializationImpl(Specializations,
                                    SETraits::getTemplateArgs(Entry),
                                    CorrectInsertPos) &&
            InsertPos == CorrectInsertPos &&
            "given incorrect InsertPos for specialization");
 #endif
     Specializations.InsertNode(Entry, InsertPos);

lib/AST/ExprCXX.cpp

if (ParamTy->isIntegerType())
     return LOK_Integer;
   if (ParamTy->isFloatingType())
     return LOK_Floating;
 
   llvm_unreachable("unknown kind of literal operator");
 }
 
 Expr *UserDefinedLiteral::getCookedLiteral() {
-#ifndef NDEBUG
+#ifndef LLVM_NDEBUG
   LiteralOperatorKind LOK = getLiteralOperatorKind();
   assert(LOK != LOK_Template && LOK != LOK_Raw && "not a cooked literal");
 #endif
   return getArg(0);
 }
 
 const IdentifierInfo *UserDefinedLiteral::getUDSuffix() const {
   return cast<FunctionDecl>(getCalleeDecl())->getLiteralIdentifier();

lib/AST/ExprConstant.cpp

static bool HandleConstructorCall(SourceLocation CallLoc, const LValue &This,
   if (RD->isInvalidDecl()) return false;
   const ASTRecordLayout &Layout = Info.Ctx.getASTRecordLayout(RD);
 
   // A scope for temporaries lifetime-extended by reference members.
   BlockScopeRAII LifetimeExtendedScope(Info);
 
   bool Success = true;
   unsigned BasesSeen = 0;
-#ifndef NDEBUG
+#ifndef LLVM_NDEBUG
   CXXRecordDecl::base_class_const_iterator BaseIt = RD->bases_begin();
 #endif
   for (const auto *I : Definition->inits()) {
     LValue Subobject = This;
     APValue *Value = &Result;
 
     // Determine the subobject to initialize.
     FieldDecl *FD = nullptr;
     if (I->isBaseInitializer()) {
       QualType BaseType(I->getBaseClass(), 0);
-#ifndef NDEBUG
+#ifndef LLVM_NDEBUG
       // Non-virtual base classes are initialized in the order in the class
       // definition. We have already checked for virtual base classes.
       assert(!BaseIt->isVirtual() && "virtual base for literal type");
       assert(Info.Ctx.hasSameType(BaseIt->getType(), BaseType) &&
              "base class initializers not in expected order");
       ++BaseIt;
 #endif
       if (!HandleLValueDirectBase(Info, I->getInit(), Subobject, RD,

lib/AST/RecordLayout.cpp

ASTRecordLayout::ASTRecordLayout(const ASTContext &Ctx,
   CXXInfo->HasOwnVFPtr = hasOwnVFPtr;
   CXXInfo->VBPtrOffset = vbptroffset;
   CXXInfo->HasExtendableVFPtr = hasExtendableVFPtr;
   CXXInfo->BaseSharingVBPtr = BaseSharingVBPtr;
   CXXInfo->HasZeroSizedSubObject = HasZeroSizedSubObject;
   CXXInfo->LeadsWithZeroSizedBase = LeadsWithZeroSizedBase;
 
 
-#ifndef NDEBUG
+#ifndef LLVM_NDEBUG
     if (const CXXRecordDecl *PrimaryBase = getPrimaryBase()) {
       if (isPrimaryBaseVirtual()) {
         if (Ctx.getTargetInfo().getCXXABI().hasPrimaryVBases()) {
           assert(getVBaseClassOffset(PrimaryBase).isZero() &&
                  "Primary virtual base must be at offset 0!");
         }
       } else {
         assert(getBaseClassOffset(PrimaryBase).isZero() &&
                "Primary base must be at offset 0!");
       }
     }
 #endif        
 }

lib/AST/RecordLayoutBuilder.cpp

void ItaniumRecordLayoutBuilder::Layout(const CXXRecordDecl *RD) {
 
   // Lay out the virtual bases and add the primary virtual base offsets.
   LayoutVirtualBases(RD, RD);
 
   // Finally, round the size of the total struct up to the alignment
   // of the struct itself.
   FinishLayout(RD);
 
-#ifndef NDEBUG
+#ifndef LLVM_NDEBUG
   // Check that we have base offsets for all bases.
   for (const CXXBaseSpecifier &Base : RD->bases()) {
     if (Base.isVirtual())
       continue;
 
     const CXXRecordDecl *BaseDecl = Base.getType()->getAsCXXRecordDecl();
 
     assert(Bases.count(BaseDecl) && "Did not find base offset!");

lib/AST/StmtViz.cpp

 
 #include "clang/AST/StmtGraphTraits.h"
 #include "clang/AST/Decl.h"
 #include "llvm/Support/GraphWriter.h"
 
 using namespace clang;
 
 void Stmt::viewAST() const {
-#ifndef NDEBUG
+#ifndef LLVM_NDEBUG
   llvm::ViewGraph(this,"AST");
 #else
   llvm::errs() << "Stmt::viewAST is only available in debug builds on "
                << "systems with Graphviz or gv!\n";
 #endif
 }
 
 namespace llvm {
 template<>
 struct DOTGraphTraits<const Stmt*> : public DefaultDOTGraphTraits {
   DOTGraphTraits (bool isSimple=false) : DefaultDOTGraphTraits(isSimple) {}
 
   static std::string getNodeLabel(const Stmt* Node, const Stmt* Graph) {
 
-#ifndef NDEBUG
+#ifndef LLVM_NDEBUG
     std::string OutSStr;
     llvm::raw_string_ostream Out(OutSStr);
 
     if (Node)
       Out << Node->getStmtClassName();
     else
       Out << "<NULL>";
 

lib/ASTMatchers/Dynamic/Marshallers.h

if (Constructed.size() > 1) {
       Error->addError(NameRange, Error->ET_RegistryAmbiguousOverload);
       return VariantMatcher();
     }
     return Constructed[0];
   }
 
   bool isVariadic() const override {
     bool Overload0Variadic = Overloads[0]->isVariadic();
-#ifndef NDEBUG
+#ifndef LLVM_NDEBUG
     for (const auto &O : Overloads) {
       assert(Overload0Variadic == O->isVariadic());
     }
 #endif
     return Overload0Variadic;
   }
 
   unsigned getNumArgs() const override {
     unsigned Overload0NumArgs = Overloads[0]->getNumArgs();
-#ifndef NDEBUG
+#ifndef LLVM_NDEBUG
     for (const auto &O : Overloads) {
       assert(Overload0NumArgs == O->getNumArgs());
     }
 #endif
     return Overload0NumArgs;
   }
 
   void getArgKinds(ast_type_traits::ASTNodeKind ThisKind, unsigned ArgNo,

lib/Analysis/CFG.cpp

Stmt *CFGBlock::getTerminatorCondition(bool StripParens) {
   return E ? E->IgnoreParens() : nullptr;
 }
 
 //===----------------------------------------------------------------------===//
 // CFG Graphviz Visualization
 //===----------------------------------------------------------------------===//
 
 
-#ifndef NDEBUG
+#ifndef LLVM_NDEBUG
 static StmtPrinterHelper* GraphHelper;
 #endif
 
 void CFG::viewCFG(const LangOptions &LO) const {
-#ifndef NDEBUG
+#ifndef LLVM_NDEBUG
   StmtPrinterHelper H(this, LO);
   GraphHelper = &H;
   llvm::ViewGraph(this,"CFG");
   GraphHelper = nullptr;
 #endif
 }
 
 namespace llvm {
 template<>
 struct DOTGraphTraits<const CFG*> : public DefaultDOTGraphTraits {
 
   DOTGraphTraits (bool isSimple=false) : DefaultDOTGraphTraits(isSimple) {}
 
   static std::string getNodeLabel(const CFGBlock *Node, const CFG* Graph) {
 
-#ifndef NDEBUG
+#ifndef LLVM_NDEBUG
     std::string OutSStr;
     llvm::raw_string_ostream Out(OutSStr);
     print_block(Out,Graph, *Node, *GraphHelper, false, false);
     std::string& OutStr = Out.str();
 
     if (OutStr[0] == '\n') OutStr.erase(OutStr.begin());
 
     // Process string output to make it nicer...

lib/Basic/DiagnosticIDs.cpp

 };
 
 static const unsigned StaticDiagInfoSize = llvm::array_lengthof(StaticDiagInfo);
 
 /// GetDiagInfo - Return the StaticDiagInfoRec entry for the specified DiagID,
 /// or null if the ID is invalid.
 static const StaticDiagInfoRec *GetDiagInfo(unsigned DiagID) {
   // If assertions are enabled, verify that the StaticDiagInfo array is sorted.
-#ifndef NDEBUG
+#ifndef LLVM_NDEBUG
   static bool IsFirst = true; // So the check is only performed on first call.
   if (IsFirst) {
     for (unsigned i = 1; i != StaticDiagInfoSize; ++i) {
       assert(StaticDiagInfo[i-1].DiagID != StaticDiagInfo[i].DiagID &&
              "Diag ID conflict, the enums at the start of clang::diag (in "
              "DiagnosticIDs.h) probably need to be increased");
 
       assert(StaticDiagInfo[i-1] < StaticDiagInfo[i] &&

lib/Basic/VirtualFileSystem.cpp

 UniqueID vfs::getNextVirtualUniqueID() {
   static std::atomic<unsigned> UID;
   unsigned ID = ++UID;
   // The following assumes that uint64_t max will never collide with a real
   // dev_t value from the OS.
   return UniqueID(std::numeric_limits<uint64_t>::max(), ID);
 }
 
-#ifndef NDEBUG
+#ifndef LLVM_NDEBUG
 static bool pathHasTraversal(StringRef Path) {
   using namespace llvm::sys;
   for (StringRef Comp : llvm::make_range(path::begin(Path), path::end(Path)))
     if (Comp == "." || Comp == "..")
       return true;
   return false;
 }
 #endif

lib/CodeGen/CGBuilder.h

void InsertHelper(llvm::Instruction *I, const llvm::Twine &Name,
                     llvm::BasicBlock::iterator InsertPt) const;
 private:
   void operator=(const CGBuilderInserter &) = delete;
 
   CodeGenFunction *CGF;
 };
 
 // Don't preserve names on values in an optimized build.
-#ifdef NDEBUG
+#ifdef LLVM_NDEBUG
 #define PreserveNames false
 #else
 #define PreserveNames true
 #endif
 typedef CGBuilderInserter<PreserveNames> CGBuilderInserterTy;
 typedef llvm::IRBuilder<PreserveNames, llvm::ConstantFolder,
                         CGBuilderInserterTy> CGBuilderTy;
 #undef PreserveNames
 
 }  // end namespace CodeGen
 }  // end namespace clang
 
 #endif

lib/CodeGen/CGBuiltin.cpp

 static bool AArch64SIMDIntrinsicsProvenSorted = false;
 static bool AArch64SISDIntrinsicsProvenSorted = false;
 
 
 static const NeonIntrinsicInfo *
 findNeonIntrinsicInMap(ArrayRef<NeonIntrinsicInfo> IntrinsicMap,
                        unsigned BuiltinID, bool &MapProvenSorted) {
 
-#ifndef NDEBUG
+#ifndef LLVM_NDEBUG
   if (!MapProvenSorted) {
     // FIXME: use std::is_sorted once C++11 is allowed
     for (unsigned i = 0; i < IntrinsicMap.size() - 1; ++i)
       assert(IntrinsicMap[i].BuiltinID <= IntrinsicMap[i + 1].BuiltinID);
     MapProvenSorted = true;
   }
 #endif
 

lib/CodeGen/CGCall.cpp

if (CallInfo.isVariadic()) {
       unsigned CalleeAS =
           cast<llvm::PointerType>(Callee->getType())->getAddressSpace();
       Callee = Builder.CreateBitCast(
           Callee, getTypes().GetFunctionType(CallInfo)->getPointerTo(CalleeAS));
     } else {
       llvm::Type *LastParamTy =
           IRFuncTy->getParamType(IRFuncTy->getNumParams() - 1);
       if (Arg->getType() != LastParamTy) {
-#ifndef NDEBUG
+#ifndef LLVM_NDEBUG
         // Assert that these structs have equivalent element types.
         llvm::StructType *FullTy = CallInfo.getArgStruct();
         llvm::StructType *DeclaredTy = cast<llvm::StructType>(
             cast<llvm::PointerType>(LastParamTy)->getElementType());
         assert(DeclaredTy->getNumElements() == FullTy->getNumElements());
         for (llvm::StructType::element_iterator DI = DeclaredTy->element_begin(),
                                                 DE = DeclaredTy->element_end(),
                                                 FI = FullTy->element_begin();

lib/CodeGen/CGExpr.cpp

void CodeGenFunction::EmitCheck(
   if (FatalCond && RecoverableCond)
     JointCond = Builder.CreateAnd(FatalCond, RecoverableCond);
   else
     JointCond = FatalCond ? FatalCond : RecoverableCond;
   assert(JointCond);
 
   CheckRecoverableKind RecoverKind = getRecoverableKind(Checked[0].second);
   assert(SanOpts.has(Checked[0].second));
-#ifndef NDEBUG
+#ifndef LLVM_NDEBUG
   for (int i = 1, n = Checked.size(); i < n; ++i) {
     assert(RecoverKind == getRecoverableKind(Checked[i].second) &&
            "All recoverable kinds in a single check must be same!");
     assert(SanOpts.has(Checked[i].second));
   }
 #endif
 
   llvm::BasicBlock *Cont = createBasicBlock("cont");

lib/CodeGen/CGExprAgg.cpp

#endif
   CodeGenFunction::FieldConstructionScope FCS(CGF, Dest.getAddr());
 
   if (record->isUnion()) {
     // Only initialize one field of a union. The field itself is
     // specified by the initializer list.
     if (!E->getInitializedFieldInUnion()) {
       // Empty union; we have nothing to do.
 
-#ifndef NDEBUG
+#ifndef LLVM_NDEBUG
       // Make sure that it's really an empty and not a failure of
       // semantic analysis.
       for (const auto *Field : record->fields())
         assert(Field->isUnnamedBitfield() && "Only unnamed bitfields allowed");
 #endif
       return;
     }
 

lib/CodeGen/CGRecordLayoutBuilder.cpp

CGRecordLayout *CodeGenTypes::ComputeRecordLayout(const RecordDecl *D,
   if (getContext().getLangOpts().DumpRecordLayouts) {
     llvm::outs() << "\n*** Dumping IRgen Record Layout\n";
     llvm::outs() << "Record: ";
     D->dump(llvm::outs());
     llvm::outs() << "\nLayout: ";
     RL->print(llvm::outs());
   }
 
-#ifndef NDEBUG
+#ifndef LLVM_NDEBUG
   // Verify that the computed LLVM struct size matches the AST layout size.
   const ASTRecordLayout &Layout = getContext().getASTRecordLayout(D);
 
   uint64_t TypeSizeInBits = getContext().toBits(Layout.getSize());
   assert(TypeSizeInBits == getDataLayout().getTypeAllocSizeInBits(Ty) &&
          "Type size mismatch!");
 
   if (BaseTy) {

lib/CodeGen/CGVTables.cpp

static void setThunkProperties(CodeGenModule &CGM, const ThunkInfo &Thunk,
   // Set the right visibility.
   const CXXMethodDecl *MD = cast<CXXMethodDecl>(GD.getDecl());
   setThunkVisibility(CGM, MD, Thunk, ThunkFn);
 
   if (CGM.supportsCOMDAT() && ThunkFn->isWeakForLinker())
     ThunkFn->setComdat(CGM.getModule().getOrInsertComdat(ThunkFn->getName()));
 }
 
-#ifndef NDEBUG
+#ifndef LLVM_NDEBUG
 static bool similar(const ABIArgInfo &infoL, CanQualType typeL,
                     const ABIArgInfo &infoR, CanQualType typeR) {
   return (infoL.getKind() == infoR.getKind() &&
           (typeL == typeR ||
            (isa<PointerType>(typeL) && isa<PointerType>(typeR)) ||
            (isa<ReferenceType>(typeL) && isa<ReferenceType>(typeR))));
 }
 #endif
if (isa<CXXDestructorDecl>(MD))
     CGM.getCXXABI().adjustCallArgsForDestructorThunk(*this, CurGD, CallArgs);
 
   // Add the rest of the arguments.
   for (const ParmVarDecl *PD : MD->params())
     EmitDelegateCallArg(CallArgs, PD, PD->getLocStart());
 
   const FunctionProtoType *FPT = MD->getType()->getAs<FunctionProtoType>();
 
-#ifndef NDEBUG
+#ifndef LLVM_NDEBUG
   const CGFunctionInfo &CallFnInfo =
     CGM.getTypes().arrangeCXXMethodCall(CallArgs, FPT,
                                        RequiredArgs::forPrototypePlus(FPT, 1));
   assert(CallFnInfo.getRegParm() == CurFnInfo->getRegParm() &&
          CallFnInfo.isNoReturn() == CurFnInfo->isNoReturn() &&
          CallFnInfo.getCallingConvention() == CurFnInfo->getCallingConvention());
   assert(isa<CXXDestructorDecl>(MD) || // ignore dtor return types
          similar(CallFnInfo.getReturnInfo(), CallFnInfo.getReturnType(),
static bool shouldEmitVTableAtEndOfTranslationUnit(CodeGenModule &CGM,
   // If it's external then maybe we will need it as available_externally
   return shouldEmitAvailableExternallyVTable(CGM, RD);
 }
 
 /// Given that at some point we emitted a reference to one or more
 /// v-tables, and that we are now at the end of the translation unit,
 /// decide whether we should emit them.
 void CodeGenModule::EmitDeferredVTables() {
-#ifndef NDEBUG
+#ifndef LLVM_NDEBUG
   // Remember the size of DeferredVTables, because we're going to assume
   // that this entire operation doesn't modify it.
   size_t savedSize = DeferredVTables.size();
 #endif
 
   for (const CXXRecordDecl *RD : DeferredVTables)
     if (shouldEmitVTableAtEndOfTranslationUnit(*this, RD))
       VTables.GenerateClassData(RD);

lib/CodeGen/CodeGenFunction.h

public:
   static bool hasAggregateEvaluationKind(QualType T) {
     return getEvaluationKind(T) == TEK_Aggregate;
   }
 
   /// createBasicBlock - Create an LLVM basic block.
   llvm::BasicBlock *createBasicBlock(const Twine &name = "",
                                      llvm::Function *parent = nullptr,
                                      llvm::BasicBlock *before = nullptr) {
-#ifdef NDEBUG
+#ifdef LLVM_NDEBUG
     return llvm::BasicBlock::Create(getLLVMContext(), "", parent, before);
 #else
     return llvm::BasicBlock::Create(getLLVMContext(), name, parent, before);
 #endif
   }
 
   /// getBasicBlockForLabel - Return the LLVM basicblock that the specified
   /// label maps to.
llvm::Value* EmitAsmInput(const TargetInfo::ConstraintInfo &Info,
                             const Expr *InputExpr, std::string &ConstraintStr);
 
   llvm::Value* EmitAsmInputLValue(const TargetInfo::ConstraintInfo &Info,
                                   LValue InputValue, QualType InputType,
                                   std::string &ConstraintStr,
                                   SourceLocation Loc);
 
 public:
-#ifndef NDEBUG
+#ifndef LLVM_NDEBUG
   // Determine whether the given argument is an Objective-C method
   // that may have type parameters in its signature.
   static bool isObjCMethodWithTypeParams(const ObjCMethodDecl *method) {
     const DeclContext *dc = method->getDeclContext();
     if (const ObjCInterfaceDecl *classDecl= dyn_cast<ObjCInterfaceDecl>(dc)) {
       return classDecl->getTypeParamListAsWritten();
     }
 
void EmitCallArgs(CallArgList &Args, const T *CallArgTypeInfo,
                     const FunctionDecl *CalleeDecl = nullptr,
                     unsigned ParamsToSkip = 0) {
     SmallVector<QualType, 16> ArgTypes;
     CallExpr::const_arg_iterator Arg = ArgRange.begin();
 
     assert((ParamsToSkip == 0 || CallArgTypeInfo) &&
            "Can't skip parameters if type info is not provided");
     if (CallArgTypeInfo) {
-#ifndef NDEBUG
+#ifndef LLVM_NDEBUG
       bool isGenericMethod = isObjCMethodWithTypeParams(CallArgTypeInfo);
 #endif
 
       // First, use the argument types that the type info knows about
       for (auto I = CallArgTypeInfo->param_type_begin() + ParamsToSkip,
                 E = CallArgTypeInfo->param_type_end();
            I != E; ++I, ++Arg) {
         assert(Arg != ArgRange.end() && "Running over edge of argument list!");

lib/CodeGen/CodeGenFunction.cpp

void CGBuilderInserter<PreserveNames>::InsertHelper(
     llvm::Instruction *I, const llvm::Twine &Name, llvm::BasicBlock *BB,
     llvm::BasicBlock::iterator InsertPt) const {
   llvm::IRBuilderDefaultInserter<PreserveNames>::InsertHelper(I, Name, BB,
                                                               InsertPt);
   if (CGF)
     CGF->InsertHelper(I, Name, BB, InsertPt);
 }
 
-#ifdef NDEBUG
+#ifdef LLVM_NDEBUG
 #define PreserveNames false
 #else
 #define PreserveNames true
 #endif
 template void CGBuilderInserter<PreserveNames>::InsertHelper(
     llvm::Instruction *I, const llvm::Twine &Name, llvm::BasicBlock *BB,
     llvm::BasicBlock::iterator InsertPt) const;
 #undef PreserveNames

lib/CodeGen/MicrosoftCXXABI.cpp

llvm::GlobalVariable *MicrosoftCXXABI::getAddrOfVTable(const CXXRecordDecl *RD,
   MicrosoftVTableContext &VTContext = CGM.getMicrosoftVTableContext();
   const VPtrInfoVector &VFPtrs = VTContext.getVFPtrOffsets(RD);
 
   if (DeferredVFTables.insert(RD).second) {
     // We haven't processed this record type before.
     // Queue up this v-table for possible deferred emission.
     CGM.addDeferredVTable(RD);
 
-#ifndef NDEBUG
+#ifndef LLVM_NDEBUG
     // Create all the vftables at once in order to make sure each vftable has
     // a unique mangled name.
     llvm::StringSet<> ObservedMangledNames;
     for (size_t J = 0, F = VFPtrs.size(); J != F; ++J) {
       SmallString<256> Name;
       mangleVFTableName(getMangleContext(), RD, VFPtrs[J], Name);
       if (!ObservedMangledNames.insert(Name.str()).second)
         llvm_unreachable("Already saw this mangling before?");

lib/Driver/Multilib.cpp

 
 MultilibSet &MultilibSet::FilterOut(FilterCallback F) {
   filterInPlace(F, Multilibs);
   return *this;
 }
 
 MultilibSet &MultilibSet::FilterOut(const char *Regex) {
   llvm::Regex R(Regex);
-#ifndef NDEBUG
+#ifndef LLVM_NDEBUG
   std::string Error;
   if (!R.isValid(Error)) {
     llvm::errs() << Error;
     llvm_unreachable("Invalid regex!");
   }
 #endif
 
   filterInPlace([&R](const Multilib &M) { return R.match(M.gccSuffix()); },

lib/Driver/Tools.cpp

void Clang::ConstructJob(Compilation &C, const JobAction &JA,
 
   // We normally speed up the clang process a bit by skipping destructors at
   // exit, but when we're generating diagnostics we can rely on some of the
   // cleanup.
   if (!C.isForDiagnostics())
     CmdArgs.push_back("-disable-free");
 
 // Disable the verification pass in -asserts builds.
-#ifdef NDEBUG
+#ifdef LLVM_NDEBUG
   CmdArgs.push_back("-disable-llvm-verifier");
 #endif
 
   // Set the main file name, so that debug info works even with
   // -save-temps.
   CmdArgs.push_back("-main-file-name");
   CmdArgs.push_back(getBaseInputName(Args, Input));
 

lib/Format/UnwrappedLineFormatter.cpp

 static void markFinalized(FormatToken *Tok) {
   for (; Tok; Tok = Tok->Next) {
     Tok->Finalized = true;
     for (AnnotatedLine *Child : Tok->Children)
       markFinalized(Child->First);
   }
 }
 
-#ifndef NDEBUG
+#ifndef LLVM_NDEBUG
 static void printLineState(const LineState &State) {
   llvm::dbgs() << "State: ";
   for (const ParenState &P : State.Stack) {
     llvm::dbgs() << P.Indent << "|" << P.LastSpace << "|" << P.NestedBlockIndent
                  << " ";
   }
   llvm::dbgs() << State.NextToken->TokenText << "\n";
 }

lib/Frontend/ASTUnit.cpp

if (empty())
     return;
 
   NumLines = std::count(Buffer.begin(), Buffer.end(), '\n');
 
   if (Buffer.back() != '\n')
     ++NumLines;
 }
 
-#ifndef NDEBUG
+#ifndef LLVM_NDEBUG
 ASTUnit::ConcurrencyState::ConcurrencyState() {
   Mutex = new llvm::sys::MutexImpl(/*recursive=*/true);
 }
 
 ASTUnit::ConcurrencyState::~ConcurrencyState() {
   delete static_cast<llvm::sys::MutexImpl *>(Mutex);
 }
 
 void ASTUnit::ConcurrencyState::start() {
   bool acquired = static_cast<llvm::sys::MutexImpl *>(Mutex)->tryacquire();
   assert(acquired && "Concurrent access to ASTUnit!");
 }
 
 void ASTUnit::ConcurrencyState::finish() {
   static_cast<llvm::sys::MutexImpl *>(Mutex)->release();
 }
 
-#else // NDEBUG
+#else // LLVM_NDEBUG
 
 ASTUnit::ConcurrencyState::ConcurrencyState() { Mutex = 0; }
 ASTUnit::ConcurrencyState::~ConcurrencyState() {}
 void ASTUnit::ConcurrencyState::start() {}
 void ASTUnit::ConcurrencyState::finish() {}
 
 #endif

lib/Frontend/VerifyDiagnosticConsumer.cpp

 VerifyDiagnosticConsumer::~VerifyDiagnosticConsumer() {
   assert(!ActiveSourceFiles && "Incomplete parsing of source files!");
   assert(!CurrentPreprocessor && "CurrentPreprocessor should be invalid!");
   SrcManager = nullptr;
   CheckDiagnostics();
   Diags.takeClient().release();
 }
 
-#ifndef NDEBUG
+#ifndef LLVM_NDEBUG
 namespace {
 class VerifyFileTracker : public PPCallbacks {
   VerifyDiagnosticConsumer &Verify;
   SourceManager &SM;
 
 public:
   VerifyFileTracker(VerifyDiagnosticConsumer &Verify, SourceManager &SM)
     : Verify(Verify), SM(SM) { }
void VerifyDiagnosticConsumer::BeginSourceFile(const LangOptions &LangOpts,
                                                const Preprocessor *PP) {
   // Attach comment handler on first invocation.
   if (++ActiveSourceFiles == 1) {
     if (PP) {
       CurrentPreprocessor = PP;
       this->LangOpts = &LangOpts;
       setSourceManager(PP->getSourceManager());
       const_cast<Preprocessor*>(PP)->addCommentHandler(this);
-#ifndef NDEBUG
+#ifndef LLVM_NDEBUG
       // Debug build tracks parsed files.
       const_cast<Preprocessor*>(PP)->addPPCallbacks(
                       llvm::make_unique<VerifyFileTracker>(*this, *SrcManager));
 #endif
     }
   }
 
   assert((!PP || CurrentPreprocessor == PP) && "Preprocessor changed!");
void VerifyDiagnosticConsumer::HandleDiagnostic(
   if (Info.hasSourceManager()) {
     // If this diagnostic is for a different source manager, ignore it.
     if (SrcManager && &Info.getSourceManager() != SrcManager)
       return;
 
     setSourceManager(Info.getSourceManager());
   }
 
-#ifndef NDEBUG
+#ifndef LLVM_NDEBUG
   // Debug build tracks unparsed files for possible
   // unparsed expected-* directives.
   if (SrcManager) {
     SourceLocation Loc = Info.getLocation();
     if (Loc.isValid()) {
       ParsedStatus PS = IsUnparsed;
 
       Loc = SrcManager->getExpansionLoc(Loc);
for (size_t last = 0;; loc = C.find('\\', last)) {
     }
   }
 
   if (!C2.empty())
     ParseDirective(C2, &ED, SM, &PP, CommentBegin, Status);
   return false;
 }
 
-#ifndef NDEBUG
+#ifndef LLVM_NDEBUG
 /// \brief Lex the specified source file to determine whether it contains
 /// any expected-* directives.  As a Lexer is used rather than a full-blown
 /// Preprocessor, directives inside skipped #if blocks will still be found.
 ///
 /// \return true if any directives were found.
 static bool findDirectives(SourceManager &SM, FileID FID,
                            const LangOptions &LangOpts) {
   // Create a raw lexer to pull all the comments out of FID.
while (Tok.isNot(tok::eof)) {
 
     // Find first directive.
     if (ParseDirective(Comment, nullptr, SM, nullptr, Tok.getLocation(),
                        Status))
       return true;
   }
   return false;
 }
-#endif // !NDEBUG
+#endif // !LLVM_NDEBUG
 
 /// \brief Takes a list of diagnostics that have been generated but not matched
 /// by an expected-* directive and produces a diagnostic to the user from this.
 static unsigned PrintUnexpected(DiagnosticsEngine &Diags, SourceManager *SourceMgr,
                                 const_diag_iterator diag_begin,
                                 const_diag_iterator diag_end,
                                 const char *Kind) {
   if (diag_begin == diag_end) return 0;

 }
 
 void VerifyDiagnosticConsumer::UpdateParsedFileStatus(SourceManager &SM,
                                                       FileID FID,
                                                       ParsedStatus PS) {
   // Check SourceManager hasn't changed.
   setSourceManager(SM);
 
-#ifndef NDEBUG
+#ifndef LLVM_NDEBUG
   if (FID.isInvalid())
     return;
 
   const FileEntry *FE = SM.getFileEntryForID(FID);
 
   if (PS == IsParsed) {
     // Move the FileID from the unparsed set to the parsed set.
     UnparsedFiles.erase(FID);

 }
 
 void VerifyDiagnosticConsumer::CheckDiagnostics() {
   // Ensure any diagnostics go to the primary client.
   DiagnosticConsumer *CurClient = Diags.getClient();
   std::unique_ptr<DiagnosticConsumer> Owner = Diags.takeClient();
   Diags.setClient(PrimaryClient, false);
 
-#ifndef NDEBUG
+#ifndef LLVM_NDEBUG
   // In a debug build, scan through any files that may have been missed
   // during parsing and issue a fatal error if directives are contained
   // within these files.  If a fatal error occurs, this suggests that
   // this file is being parsed separately from the main file, in which
   // case consider moving the directives to the correct place, if this
   // is applicable.
   if (UnparsedFiles.size() > 0) {
     // Generate a cache of parsed FileEntry pointers for alias lookups.
for (UnparsedFilesMap::iterator I = UnparsedFiles.begin(),
                                        " than during normal parsing of ",
                                  StringRef(FE ? FE->getName() : "(unknown)")));
       }
     }
 
     // UnparsedFiles has been processed now, so clear it.
     UnparsedFiles.clear();
   }
-#endif // !NDEBUG
+#endif // !LLVM_NDEBUG
 
   if (SrcManager) {
     // Produce an error if no expected-* directives could be found in the
     // source file(s) processed.
     if (Status == HasNoDirectives) {
       Diags.Report(diag::err_verify_no_directives).setForceEmit();
       ++NumErrors;
       Status = HasNoDirectivesReported;

lib/Lex/ModuleMap.cpp

ModuleMap::findHeaderInUmbrellaDirs(const FileEntry *File,
   return KnownHeader();
 }
 
 static bool violatesPrivateInclude(Module *RequestingModule,
                                    const FileEntry *IncFileEnt,
                                    ModuleMap::ModuleHeaderRole Role,
                                    Module *RequestedModule) {
   bool IsPrivateRole = Role & ModuleMap::PrivateHeader;
-#ifndef NDEBUG
+#ifndef LLVM_NDEBUG
   if (IsPrivateRole) {
     // Check for consistency between the module header role
     // as obtained from the lookup and as obtained from the module.
     // This check is not cheap, so enable it only for debugging.
     bool IsPrivate = false;
     SmallVectorImpl<Module::Header> *HeaderList[] = {
         &RequestedModule->Headers[Module::HK_Private],
         &RequestedModule->Headers[Module::HK_PrivateTextual]};

lib/Sema/Sema.cpp

 
 /// ImpCastExprToType - If Expr is not of type 'Type', insert an implicit cast.
 /// If there is already an implicit cast, merge into the existing one.
 /// The result is of the given category.
 ExprResult Sema::ImpCastExprToType(Expr *E, QualType Ty,
                                    CastKind Kind, ExprValueKind VK,
                                    const CXXCastPath *BasePath,
                                    CheckedConversionKind CCK) {
-#ifndef NDEBUG
+#ifndef LLVM_NDEBUG
   if (VK == VK_RValue && !E->isRValue()) {
     switch (Kind) {
     default:
       llvm_unreachable("can't implicitly cast lvalue to rvalue with this cast "
                        "kind");
     case CK_LValueToRValue:
     case CK_ArrayToPointerDecay:
     case CK_FunctionToPointerDecay:

lib/Sema/SemaDecl.cpp

void Sema::EnterDeclaratorContext(Scope *S, DeclContext *DC) {
   // Both of these imply that we should push a scope whose context
   // is the semantic context of the declaration.  We can't use
   // PushDeclContext here because that context is not necessarily
   // lexically contained in the current context.  Fortunately,
   // the containing scope should have the appropriate information.
 
   assert(!S->getEntity() && "scope already has entity");
 
-#ifndef NDEBUG
+#ifndef LLVM_NDEBUG
   Scope *Ancestor = S->getParent();
   while (!Ancestor->getEntity()) Ancestor = Ancestor->getParent();
   assert(Ancestor->getEntity() == CurContext && "ancestor context mismatch");
 #endif
 
   CurContext = DC;
   S->setEntity(DC);
 }
static bool isFunctionDefinitionDiscarded(Sema &S, FunctionDecl *FD) {
   if (!FD->isInlined()) return false;
 
   // This is only possible in C++ with the gnu_inline attribute.
   if (S.getLangOpts().CPlusPlus && !FD->hasAttr<GNUInlineAttr>())
     return false;
 
   // Okay, go ahead and call the relatively-more-expensive function.
 
-#ifndef NDEBUG
+#ifndef LLVM_NDEBUG
   // AST quite reasonably asserts that it's working on a function
   // definition.  We don't really have a way to tell it that we're
   // currently defining the function, so just lie to it in +Asserts
   // builds.  This is an awful hack.
   FD->setLazyBody(1);
 #endif
 
   bool isC99Inline =
       S.Context.GetGVALinkageForFunction(FD) == GVA_AvailableExternally;
 
-#ifndef NDEBUG
+#ifndef LLVM_NDEBUG
   FD->setLazyBody(0);
 #endif
 
   return isC99Inline;
 }
 
 /// Determine whether a variable is extern "C" prior to attaching
 /// an initializer. We can't just call isExternC() here, because that

lib/Sema/SemaLookup.cpp

if (IdentifierInfo *Id = NameInfo.getName().getAsIdentifierInfo()) {
     if (unsigned BuiltinID = Id->getBuiltinID()) {
       if (!getSema().Context.BuiltinInfo.isPredefinedLibFunction(BuiltinID))
         AllowHidden = true;
     }
   }
 }
 
 bool LookupResult::sanity() const {
-  // This function is never called by NDEBUG builds.
+  // This function is never called by LLVM_NDEBUG builds.
   assert(ResultKind != NotFound || Decls.size() == 0);
   assert(ResultKind != Found || Decls.size() == 1);
   assert(ResultKind != FoundOverloaded || Decls.size() > 1 ||
          (Decls.size() == 1 &&
           isa<FunctionTemplateDecl>((*begin())->getUnderlyingDecl())));
   assert(ResultKind != FoundUnresolvedValue || sanityCheckUnresolved());
   assert(ResultKind != Ambiguous || Decls.size() > 1 ||
          (Decls.size() == 1 && (Ambiguity == AmbiguousBaseSubobjects ||

lib/Sema/SemaOverload.cpp

 
 /// \brief Add the overload candidates named by callee and/or found by argument
 /// dependent lookup to the given overload set.
 void Sema::AddOverloadedCallCandidates(UnresolvedLookupExpr *ULE,
                                        ArrayRef<Expr *> Args,
                                        OverloadCandidateSet &CandidateSet,
                                        bool PartialOverloading) {
 
-#ifndef NDEBUG
+#ifndef LLVM_NDEBUG
   // Verify that ArgumentDependentLookup is consistent with the rules
   // in C++0x [basic.lookup.argdep]p3:
   //
   //   Let X be the lookup set produced by unqualified lookup (3.4.1)
   //   and let Y be the lookup set produced by argument dependent
   //   lookup (defined as follows). If X contains
   //
   //     -- a declaration of a class member, or

 /// the given function.
 /// \returns true when an the ExprResult output parameter has been set.
 bool Sema::buildOverloadedCallSet(Scope *S, Expr *Fn,
                                   UnresolvedLookupExpr *ULE,
                                   MultiExprArg Args,
                                   SourceLocation RParenLoc,
                                   OverloadCandidateSet *CandidateSet,
                                   ExprResult *Result) {
-#ifndef NDEBUG
+#ifndef LLVM_NDEBUG
   if (ULE->requiresADL()) {
     // To do ADL, we must have found an unqualified name.
     assert(!ULE->getQualifier() && "qualified name with ADL");
 
     // We don't perform ADL for implicit declarations of builtins.
     // Verify that this was correctly set up.
     FunctionDecl *F;
     if (ULE->decls_begin() + 1 == ULE->decls_end() &&

lib/Sema/SemaTemplateDeduction.cpp

SpecializeCorrespondingLambdaCallOperatorAndInvoker(
   // ptr-to-functions (now including return type), and have successfully 
   // specialized our corresponding call operator, we are ready to
   // specialize the static invoker with the deduced arguments of our
   // ptr-to-function.
   FunctionDecl *InvokerSpecialized = nullptr;
   FunctionTemplateDecl *InvokerTemplate = LambdaClass->
                   getLambdaStaticInvoker()->getDescribedFunctionTemplate();
 
-#ifndef NDEBUG
+#ifndef LLVM_NDEBUG
   Sema::TemplateDeductionResult LLVM_ATTRIBUTE_UNUSED Result =
 #endif
     S.FinishTemplateArgumentDeduction(InvokerTemplate, DeducedArguments, 0, 
           InvokerSpecialized, TDInfo);
   assert(Result == Sema::TDK_Success && 
     "If the call operator succeeded so should the invoker!");
   // Set the result type to match the corresponding call operator
   // specialization's result type.

lib/Sema/SemaTemplateInstantiate.cpp

LocalInstantiationScope::findInstantiationOf(const Decl *D) {
   assert(isa<LabelDecl>(D) && "declaration not instantiated in this scope");
   return nullptr;
 }
 
 void LocalInstantiationScope::InstantiatedLocal(const Decl *D, Decl *Inst) {
   D = getCanonicalParmVarDecl(D);
   llvm::PointerUnion<Decl *, DeclArgumentPack *> &Stored = LocalDecls[D];
   if (Stored.isNull()) {
-#ifndef NDEBUG
+#ifndef LLVM_NDEBUG
     // It should not be present in any surrounding scope either.
     LocalInstantiationScope *Current = this;
     while (Current->CombineWithOuterScope && Current->Outer) {
       Current = Current->Outer;
       assert(Current->LocalDecls.find(D) == Current->LocalDecls.end() &&
              "Instantiated local in inner and outer scopes");
     }
 #endif
     Stored = Inst;
   } else if (DeclArgumentPack *Pack = Stored.dyn_cast<DeclArgumentPack *>()) {
     Pack->push_back(Inst);
   } else {
     assert(Stored.get<Decl *>() == Inst && "Already instantiated this local");
   }
 }
 
 void LocalInstantiationScope::InstantiatedLocalPackArg(const Decl *D, 
                                                        Decl *Inst) {
   D = getCanonicalParmVarDecl(D);
   DeclArgumentPack *Pack = LocalDecls[D].get<DeclArgumentPack *>();
   Pack->push_back(Inst);
 }
 
 void LocalInstantiationScope::MakeInstantiatedLocalArgPack(const Decl *D) {
-#ifndef NDEBUG
+#ifndef LLVM_NDEBUG
   // This should be the first time we've been told about this decl.
   for (LocalInstantiationScope *Current = this;
        Current && Current->CombineWithOuterScope; Current = Current->Outer)
     assert(Current->LocalDecls.find(D) == Current->LocalDecls.end() &&
            "Creating local pack after instantiation of local");
 #endif
 
   D = getCanonicalParmVarDecl(D);

lib/Sema/TreeTransform.h

if (IsPackExpansion)
       NewType = getSema().Context.getPackExpansionType(NewType,
                                                        NumExpansions);
 
     OutParamTypes.push_back(NewType);
     if (PVars)
       PVars->push_back(nullptr);
   }
 
-#ifndef NDEBUG
+#ifndef LLVM_NDEBUG
   if (PVars) {
     for (unsigned i = 0, e = PVars->size(); i != e; ++i)
       if (ParmVarDecl *parm = (*PVars)[i])
         assert(parm->getFunctionScopeIndex() == i);
   }
 #endif
 
   return false;
TreeTransform<Derived>::TransformBlockExpr(BlockExpr *E) {
 
   // Transform the body
   StmtResult body = getDerived().TransformStmt(E->getBody());
   if (body.isInvalid()) {
     getSema().ActOnBlockError(E->getCaretLocation(), /*Scope=*/nullptr);
     return ExprError();
   }
 
-#ifndef NDEBUG
+#ifndef LLVM_NDEBUG
   // In builds with assertions, make sure that we captured everything we
   // captured before.
   if (!SemaRef.getDiagnostics().hasErrorOccurred()) {
     for (const auto &I : oldBlock->captures()) {
       VarDecl *oldCapture = I.getVariable();
 
       // Ignore parameter packs.
       if (isa<ParmVarDecl>(oldCapture) &&

lib/Sema/TypeLocBuilder.h

class TypeLocBuilder {
   char *Buffer;
 
   /// The capacity of the current buffer.
   size_t Capacity;
 
   /// The index of the first occupied byte in the buffer.
   size_t Index;
 
-#ifndef NDEBUG
+#ifndef LLVM_NDEBUG
   /// The last type pushed on this builder.
   QualType LastTy;
 #endif
     
   /// The inline buffer.
   enum { BufferMaxAlignment = llvm::AlignOf<void*>::Alignment };
   llvm::AlignedCharArray<BufferMaxAlignment, InlineCapacity> InlineBuffer;
   unsigned NumBytesAtAlign4, NumBytesAtAlign8;
public:
   TypeSpecTypeLoc pushTypeSpec(QualType T) {
     size_t LocalSize = TypeSpecTypeLoc::LocalDataSize;
     unsigned LocalAlign = TypeSpecTypeLoc::LocalDataAlignment;
     return pushImpl(T, LocalSize, LocalAlign).castAs<TypeSpecTypeLoc>();
   }
 
   /// Resets this builder to the newly-initialized state.
   void clear() {
-#ifndef NDEBUG
+#ifndef LLVM_NDEBUG
     LastTy = QualType();
 #endif
     Index = Capacity;
     NumBytesAtAlign4 = NumBytesAtAlign8 = 0;
   }  
 
   /// \brief Tell the TypeLocBuilder that the type it is storing has been
   /// modified in some safe way that doesn't affect type-location information.
   void TypeWasModifiedSafely(QualType T) {
-#ifndef NDEBUG
+#ifndef LLVM_NDEBUG
     LastTy = T;
 #endif
   }
   
   /// Pushes space for a new TypeLoc of the given type.  Invalidates
   /// any TypeLocs previously retrieved from this builder.
   template <class TyLocType> TyLocType push(QualType T) {
     TyLocType Loc = TypeLoc(T, nullptr).castAs<TyLocType>();
     size_t LocalSize = Loc.getLocalDataSize();
     unsigned LocalAlign = Loc.getLocalDataAlignment();
     return pushImpl(T, LocalSize, LocalAlign).castAs<TyLocType>();
   }
 
   /// Creates a TypeSourceInfo for the given type.
   TypeSourceInfo *getTypeSourceInfo(ASTContext& Context, QualType T) {
-#ifndef NDEBUG
+#ifndef LLVM_NDEBUG
     assert(T == LastTy && "type doesn't match last type pushed!");
 #endif
 
     size_t FullDataSize = Capacity - Index;
     TypeSourceInfo *DI = Context.CreateTypeSourceInfo(T, FullDataSize);
     memcpy(DI->getTypeLoc().getOpaqueData(), &Buffer[Index], FullDataSize);
     return DI;
   }
 
   /// \brief Copies the type-location information to the given AST context and 
   /// returns a \c TypeLoc referring into the AST context.
   TypeLoc getTypeLocInContext(ASTContext &Context, QualType T) {
-#ifndef NDEBUG
+#ifndef LLVM_NDEBUG
     assert(T == LastTy && "type doesn't match last type pushed!");
 #endif
     
     size_t FullDataSize = Capacity - Index;
     void *Mem = Context.Allocate(FullDataSize);
     memcpy(Mem, &Buffer[Index], FullDataSize);
     return TypeLoc(T, Mem);
   }
 
 private:
 
   TypeLoc pushImpl(QualType T, size_t LocalSize, unsigned LocalAlignment);
 
   /// Grow to the given capacity.
   void grow(size_t NewCapacity);
 
   /// \brief Retrieve a temporary TypeLoc that refers into this \c TypeLocBuilder
   /// object.
   ///
   /// The resulting \c TypeLoc should only be used so long as the 
   /// \c TypeLocBuilder is active and has not had more type information
   /// pushed into it.
   TypeLoc getTemporaryTypeLoc(QualType T) {
-#ifndef NDEBUG
+#ifndef LLVM_NDEBUG
     assert(LastTy == T && "type doesn't match last type pushed!");
 #endif
     return TypeLoc(T, &Buffer[Index]);
   }
 };
 
 }
 
 #endif

lib/Sema/TypeLocBuilder.cpp

if (Buffer != InlineBuffer.buffer)
     delete[] Buffer;
 
   Buffer = NewBuffer;
   Capacity = NewCapacity;
   Index = NewIndex;
 }
 
 TypeLoc TypeLocBuilder::pushImpl(QualType T, size_t LocalSize, unsigned LocalAlignment) {
-#ifndef NDEBUG
+#ifndef LLVM_NDEBUG
   QualType TLast = TypeLoc(T, nullptr).getNextTypeLoc().getType();
   assert(TLast == LastTy &&
          "mismatch between last type and new type's inner type");
   LastTy = T;
 #endif
 
   assert(LocalAlignment <= BufferMaxAlignment && "Unexpected alignment");
 

lib/Serialization/ASTReader.cpp

 /// find information about the declarations within the given declaration
 /// context. For example, C++ and Objective-C classes, C structs/unions, and
 /// Objective-C protocols, categories, and extensions are all defined in a
 /// single place in the source code, so they have definitive module files
 /// associated with them. C++ namespaces, on the other hand, can have
 /// definitions in multiple different module files.
 ///
 /// Note: this needs to be kept in sync with ASTWriter::AddedVisibleDecl's
-/// NDEBUG checking.
+/// LLVM_NDEBUG checking.
 static ModuleFile *getDefinitiveModuleFileFor(const DeclContext *DC,
                                               ASTReader &Reader) {
   if (const DeclContext *DefDC = getDefinitiveDeclContext(DC))
     return Reader.getOwningModuleFile(cast<Decl>(DefDC));
 
   return nullptr;
 }
 

lib/Serialization/ASTReaderStmt.cpp

Stmt *ASTReader::ReadStmtFromStream(ModuleFile &F) {
 
   ReadingKindTracker ReadingKind(Read_Stmt, *this);
   llvm::BitstreamCursor &Cursor = F.DeclsCursor;
   
   // Map of offset to previously deserialized stmt. The offset points
   /// just after the stmt record.
   llvm::DenseMap<uint64_t, Stmt *> StmtEntries;
 
-#ifndef NDEBUG
+#ifndef LLVM_NDEBUG
   unsigned PrevNumStmts = StmtStack.size();
 #endif
 
   RecordData Record;
   unsigned Idx;
   ASTStmtReader Reader(*this, F, Cursor, Record, Idx);
   Stmt::EmptyShell Empty;
 

lib/Serialization/ASTWriter.cpp

void ASTWriter::WriteIdentifierTable(Preprocessor &PP,
   // Write the offsets table for identifier IDs.
   BitCodeAbbrev *Abbrev = new BitCodeAbbrev();
   Abbrev->Add(BitCodeAbbrevOp(IDENTIFIER_OFFSET));
   Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32)); // # of identifiers
   Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Fixed, 32)); // first ID
   Abbrev->Add(BitCodeAbbrevOp(BitCodeAbbrevOp::Blob));
   unsigned IdentifierOffsetAbbrev = Stream.EmitAbbrev(Abbrev);
 
-#ifndef NDEBUG
+#ifndef LLVM_NDEBUG
   for (unsigned I = 0, N = IdentifierOffsets.size(); I != N; ++I)
     assert(IdentifierOffsets[I] && "Missing identifier offset?");
 #endif
   
   RecordData Record;
   Record.push_back(IDENTIFIER_OFFSET);
   Record.push_back(IdentifierOffsets.size());
   Record.push_back(FirstIdentID - NUM_PREDEF_IDENT_IDS);

lib/Serialization/ASTWriterStmt.cpp

void ASTWriter::WriteSubStmt(Stmt *S,
 
   llvm::DenseMap<Stmt *, uint64_t>::iterator I = SubStmtEntries.find(S);
   if (I != SubStmtEntries.end()) {
     Record.push_back(I->second);
     Stream.EmitRecord(serialization::STMT_REF_PTR, Record);
     return;
   }
 
-#ifndef NDEBUG
+#ifndef LLVM_NDEBUG
   assert(!ParentStmts.count(S) && "There is a Stmt cycle!");
 
   struct ParentStmtInserterRAII {
     Stmt *S;
     llvm::DenseSet<Stmt *> &ParentStmts;
 
     ParentStmtInserterRAII(Stmt *S, llvm::DenseSet<Stmt *> &ParentStmts)
       : S(S), ParentStmts(ParentStmts) {
#endif
   // Redirect ASTWriter::AddStmt to collect sub-stmts.
   SmallVector<Stmt *, 16> SubStmts;
   CollectedStmts = &SubStmts;
 
   Writer.Code = serialization::STMT_NULL_PTR;
   Writer.AbbrevToUse = 0;
   Writer.Visit(S);
   
-#ifndef NDEBUG
+#ifndef LLVM_NDEBUG
   if (Writer.Code == serialization::STMT_NULL_PTR) {
     SourceManager &SrcMgr
       = DeclIDs.begin()->first->getASTContext().getSourceManager();
     S->dump(SrcMgr);
     llvm_unreachable("Unhandled sub-statement writing AST file");
   }
 #endif
 

lib/Serialization/ModuleManager.cpp

 #include "clang/Lex/ModuleMap.h"
 #include "clang/Serialization/GlobalModuleIndex.h"
 #include "clang/Serialization/ModuleManager.h"
 #include "llvm/Support/MemoryBuffer.h"
 #include "llvm/Support/Path.h"
 #include "llvm/Support/raw_ostream.h"
 #include <system_error>
 
-#ifndef NDEBUG
+#ifndef LLVM_NDEBUG
 #include "llvm/Support/GraphWriter.h"
 #endif
 
 using namespace clang;
 using namespace serialization;
 
 ModuleFile *ModuleManager::lookup(StringRef Name) {
   const FileEntry *Entry = FileMgr.getFile(Name, /*openFile=*/false,
if ((ExpectedSize && ExpectedSize != File->getSize()) ||
       (ExpectedModTime && ExpectedModTime != File->getModificationTime()))
     // Do not destroy File, as it may be referenced. If we need to rebuild it,
     // it will be destroyed by removeModules.
     return true;
 
   return false;
 }
 
-#ifndef NDEBUG
+#ifndef LLVM_NDEBUG
 namespace llvm {
   template<>
   struct GraphTraits<ModuleManager> {
     typedef ModuleFile NodeType;
     typedef llvm::SetVector<ModuleFile *>::const_iterator ChildIteratorType;
     typedef ModuleManager::ModuleConstIterator nodes_iterator;
     
     static ChildIteratorType child_begin(NodeType *Node) {

lib/StaticAnalyzer/Core/BugReporterVisitors.cpp

PathDiagnosticPiece *visitNodeInitial(const ExplodedNode *N,
     PathDiagnosticLocation L(Ret, BRC.getSourceManager(), StackFrame);
     return new PathDiagnosticEventPiece(L, Out.str());
   }
 
   PathDiagnosticPiece *visitNodeMaybeUnsuppress(const ExplodedNode *N,
                                                 const ExplodedNode *PrevN,
                                                 BugReporterContext &BRC,
                                                 BugReport &BR) {
-#ifndef NDEBUG
+#ifndef LLVM_NDEBUG
     ExprEngine &Eng = BRC.getBugReporter().getEngine();
     AnalyzerOptions &Options = Eng.getAnalysisManager().options;
     assert(hasCounterSuppression(Options));
 #endif
 
     // Are we at the entry node for this call?
     Optional<CallEnter> CE = N->getLocationAs<CallEnter>();
     if (!CE)

lib/StaticAnalyzer/Core/CheckerManager.cpp

return !StmtCheckers.empty()              ||
          !LiveSymbolsCheckers.empty()       ||
          !DeadSymbolsCheckers.empty()       ||
          !RegionChangesCheckers.empty()     ||
          !EvalAssumeCheckers.empty()        ||
          !EvalCallCheckers.empty();
 }
 
 void CheckerManager::finishedCheckerRegistration() {
-#ifndef NDEBUG
+#ifndef LLVM_NDEBUG
   // Make sure that for every event that has listeners, there is at least
   // one dispatcher registered for it.
   for (llvm::DenseMap<EventTag, EventInfo>::iterator
          I = Events.begin(), E = Events.end(); I != E; ++I)
     assert(I->second.HasDispatcher && "No dispatcher registered for an event");
 #endif
 }
 
for (std::vector<EvalCallFunc>::iterator
         CheckerContext C(B, Eng, Pred, L);
         evaluated = (*EI)(CE, C);
       }
       assert(!(evaluated && anyEvaluated)
              && "There are more than one checkers evaluating the call");
       if (evaluated) {
         anyEvaluated = true;
         Dst.insert(checkDst);
-#ifdef NDEBUG
+#ifdef LLVM_NDEBUG
         break; // on release don't check that no other checker also evals.
 #endif
       }
     }
     
     // If none of the checkers evaluated the call, ask ExprEngine to handle it.
     if (!anyEvaluated) {
       NodeBuilder B(Pred, Dst, Eng.getBuilderContext());

lib/StaticAnalyzer/Core/ExplodedGraph.cpp

 
 //===----------------------------------------------------------------------===//
 // Node auditing.
 //===----------------------------------------------------------------------===//
 
 // An out of line virtual method to provide a home for the class vtable.
 ExplodedNode::Auditor::~Auditor() {}
 
-#ifndef NDEBUG
+#ifndef LLVM_NDEBUG
 static ExplodedNode::Auditor* NodeAuditor = nullptr;
 #endif
 
 void ExplodedNode::SetAuditor(ExplodedNode::Auditor* A) {
-#ifndef NDEBUG
+#ifndef LLVM_NDEBUG
   NodeAuditor = A;
 #endif
 }
 
 //===----------------------------------------------------------------------===//
 // Cleanup.
 //===----------------------------------------------------------------------===//
 

 // 4. The group contains more than one node.
 typedef BumpVector<ExplodedNode *> ExplodedNodeVector;
 typedef llvm::PointerUnion<ExplodedNode *, ExplodedNodeVector *> GroupStorage;
 
 void ExplodedNode::addPredecessor(ExplodedNode *V, ExplodedGraph &G) {
   assert (!V->isSink());
   Preds.addNode(V, G);
   V->Succs.addNode(this, G);
-#ifndef NDEBUG
+#ifndef LLVM_NDEBUG
   if (NodeAuditor) NodeAuditor->AddEdge(V, this);
 #endif
 }
 
 void ExplodedNode::NodeGroup::replaceNode(ExplodedNode *node) {
   assert(!getFlag());
 
   GroupStorage &Storage = reinterpret_cast<GroupStorage&>(P);

lib/StaticAnalyzer/Core/ExprEngine.cpp

 #include "clang/StaticAnalyzer/Core/BugReporter/BugType.h"
 #include "clang/StaticAnalyzer/Core/CheckerManager.h"
 #include "clang/StaticAnalyzer/Core/PathSensitive/AnalysisManager.h"
 #include "clang/StaticAnalyzer/Core/PathSensitive/CallEvent.h"
 #include "llvm/ADT/ImmutableList.h"
 #include "llvm/ADT/Statistic.h"
 #include "llvm/Support/raw_ostream.h"
 
-#ifndef NDEBUG
+#ifndef LLVM_NDEBUG
 #include "llvm/Support/GraphWriter.h"
 #endif
 
 using namespace clang;
 using namespace ento;
 using llvm::APSInt;
 
 #define DEBUG_TYPE "ExprEngine"
static SVal RecoverCastedSymbol(ProgramStateManager& StateMgr,
 
   if (!bitsInit || !T->isIntegralOrEnumerationType() ||
       Ctx.getTypeSize(T) > bits)
     return UnknownVal();
 
   return state->getSVal(Ex, LCtx);
 }
 
-#ifndef NDEBUG
+#ifndef LLVM_NDEBUG
 static const Stmt *getRightmostLeaf(const Stmt *Condition) {
   while (Condition) {
     const BinaryOperator *BO = dyn_cast<BinaryOperator>(Condition);
     if (!BO || !BO->isLogicalOp()) {
       return Condition;
     }
     Condition = BO->getRHS()->IgnoreParens();
   }
void ExprEngine::VisitMSAsmStmt(const MSAsmStmt *A, ExplodedNode *Pred,
   StmtNodeBuilder Bldr(Pred, Dst, *currBldrCtx);
   Bldr.generateNode(A, Pred, Pred->getState());
 }
 
 //===----------------------------------------------------------------------===//
 // Visualization.
 //===----------------------------------------------------------------------===//
 
-#ifndef NDEBUG
+#ifndef LLVM_NDEBUG
 static ExprEngine* GraphPrintCheckerState;
 static SourceManager* GraphPrintSourceManager;
 
 namespace llvm {
 template<>
 struct DOTGraphTraits<ExplodedNode*> :
   public DefaultDOTGraphTraits {
 
#endif
     }
     return Out.str();
   }
 };
 } // end llvm namespace
 #endif
 
 void ExprEngine::ViewGraph(bool trim) {
-#ifndef NDEBUG
+#ifndef LLVM_NDEBUG
   if (trim) {
     std::vector<const ExplodedNode*> Src;
 
     // Flush any outstanding reports to make sure we cover all the nodes.
     // This does not cause them to get displayed.
     for (BugReporter::iterator I=BR.begin(), E=BR.end(); I!=E; ++I)
       const_cast<BugType*>(*I)->FlushReports(BR);
 
else {
 
     GraphPrintCheckerState = nullptr;
     GraphPrintSourceManager = nullptr;
   }
 #endif
 }
 
 void ExprEngine::ViewGraph(ArrayRef<const ExplodedNode*> Nodes) {
-#ifndef NDEBUG
+#ifndef LLVM_NDEBUG
   GraphPrintCheckerState = this;
   GraphPrintSourceManager = &getContext().getSourceManager();
 
   std::unique_ptr<ExplodedGraph> TrimmedG(G.trim(Nodes));
 
   if (!TrimmedG.get())
     llvm::errs() << "warning: Trimmed ExplodedGraph is empty.\n";
   else
     llvm::ViewGraph(*TrimmedG->roots_begin(), "TrimmedExprEngine");
 
   GraphPrintCheckerState = nullptr;
   GraphPrintSourceManager = nullptr;
 #endif
 }