[clang-tidy] Output currently processing check and nodes on crash

[njames93]

Summary

Create a PrettyStackTraceEvent that will dump the current check as well as the bound nodes if a ClangTidyCheck::check call results in a segfault.
This should help massively in debugging random crashes users may be experiencing where the check causing the crash is unknown as well as the source location of the crash.

[LegalizeAdulthood]

clang-tools-extra/clang-tidy/ClangTidyDiagnosticConsumer.cpp

155

Insert a blank line after the last closing namespace, please.

347

blank line between translation unit decls

[LegalizeAdulthood]

clang-tools-extra/clang-tidy/ClangTidyDiagnosticConsumer.cpp

180

blank line before onResultEntry

[LegalizeAdulthood]

LGTM with a few whitespace nits.

[Eugene.Zelenko]

clang-tools-extra/clang-tidy/ClangTidyDiagnosticConsumer.cpp

190

Please separate with newline.

clang-tools-extra/clang-tidy/ClangTidyDiagnosticConsumer.h

23–28

Please sort alphabetically.

[njames93]

Refactored implementation to not store state in ClangTidyContext. This will let external consumers of clang-tidy opt into the behaviour. As well as integrate the reporting to any signal handlers they may be using.

[njames93]

@Eugene.Zelenko Do you think I should update release notes for this?

[Eugene.Zelenko]

Sure, this is important improvement.

[LegalizeAdulthood]

Still LGTM and my comments are just thought experiments,
not must haves before pushing.

clang-tools-extra/clang-tidy/ClangTidyDiagnosticConsumer.cpp

165

Does the LLVM style guide say anything about preferring member initializers over initializing constant expressions?

clang-tools-extra/clang-tidy/ClangTidyDiagnosticConsumer.h

235

We repeat this if (CurrentlyProcessing) fragment 3 times...
Maybe initializing to a Null Object would be better?

[njames93]

Added release notes.
Remove AST dump of bound nodes, typically isn't very helpful

[njames93]

clang-tools-extra/clang-tidy/ClangTidyDiagnosticConsumer.h

235

I don't think thats an improvement, as if we aren't in a context where the stack trace would be emitted, we don't want to be storing the state on each match.

[njames93]

Add testing infrastructure to verify stack trace output

[njames93]

clang-tools-extra/test/CMakeLists.txt

100

Fairly certain llvm_add_library isnt the correct function to use as that will put the test module in the build/lib directory. However thats what the other plugin module is using so I've copied that for now.

[njames93]

Ignore the CTCrashTestTrace implementation file in the lit tests, Fixes 'Test has no 'RUN'' error.

[njames93]

@thakis I tried to test this on the gn build and got no issues, however I'm aware that the CTCrashTestTrace plugin isn't even compiled on the gn build. Not sure its worth the effort fixing that. The lit test should be disabled anyway.

[aaron.ballman]

LGTM

clang-tools-extra/clang-tidy/ClangTidyDiagnosticConsumer.cpp

165

I know we document that we prefer sticking with the local style used around the change. I don't know if we say anything about initializers, but for new code I've been suggesting folks use member initializers when possible.

349–352

This function does a whole lot of things that shouldn't be used in signal handlers: http://eel.is/c++draft/support.signal#3

Unless you know of a problem from the assert, I'd say go ahead and use it.

[njames93]

I have decided to move this behaviour into the ast matcher directly, I feel in the long term, that should be a better home for this functionality.

clang-tools-extra/clang-tidy/ClangTidyCheck.cpp

 
 DiagnosticBuilder
 ClangTidyCheck::configurationDiag(StringRef Description,
                                   DiagnosticIDs::Level Level) const {
   return Context->configurationDiag(Description, Level);
 }
 
 void ClangTidyCheck::run(const ast_matchers::MatchFinder::MatchResult &Result) {
+  Context->onProcessingCheckStart(CheckName, Result.Nodes);
   // For historical reasons, checks don't implement the MatchFinder run()
   // callback directly. We keep the run()/check() distinction to avoid interface
   // churn, and to allow us to add cross-cutting logic in the future.
   check(Result);
+  Context->onProcessingCheckEnd();
 }
 
 ClangTidyCheck::OptionsView::OptionsView(
     StringRef CheckName, const ClangTidyOptions::OptionMap &CheckOptions,
     ClangTidyContext *Context)
     : NamePrefix(CheckName.str() + "."), CheckOptions(CheckOptions),
       Context(Context) {}
 

clang-tools-extra/clang-tidy/ClangTidyDiagnosticConsumer.h

 #include "clang/Basic/Diagnostic.h"
 #include "clang/Tooling/Core/Diagnostic.h"
 #include "llvm/ADT/DenseMap.h"
 #include "llvm/Support/Regex.h"
 
 namespace clang {
 
 class ASTContext;
 class SourceManager;
 
+namespace ast_matchers {
+class BoundNodes;
+} // namespace ast_matchers
+
 namespace tidy {
 class CachedGlobList;
 
 /// A detected error complete with information to display diagnostic and
 /// automatic fix.
 ///
 /// This is used as an intermediate format to transport Diagnostics without a
 /// dependency on a SourceManager.
struct ClangTidyStats {
   unsigned ErrorsIgnoredLineFilter = 0;
 
   unsigned errorsIgnored() const {
     return ErrorsIgnoredNOLINT + ErrorsIgnoredCheckFilter +
            ErrorsIgnoredNonUserCode + ErrorsIgnoredLineFilter;
   }
 };
 
+class CurProcessingCheckState {
+public:
+  void dump(raw_ostream &OS) const;
+  void onProcessingCheckStart(StringRef CheckName,
+                              const ast_matchers::BoundNodes &BoundNodes) {
+    assert(CurContext && "ASTContext not set");
+    CurrentCheckName = CheckName;
+    CurNodes = &BoundNodes;
+  }
+
+  void onProcessingCheckEnd() {
+    CurrentCheckName = "";
+    CurNodes = nullptr;
+  }
+
+  void setContext(const ASTContext &Ctx) { CurContext = &Ctx; }
+
+  void clearContext() { CurContext = nullptr; }
+
+private:
+  mutable StringRef CurrentCheckName;
+  const ast_matchers::BoundNodes *CurNodes;
+  const ASTContext *CurContext;
+};
+
 /// Every \c ClangTidyCheck reports errors through a \c DiagnosticsEngine
 /// provided by this context.
 ///
 /// A \c ClangTidyCheck always has access to the active context to report
 /// warnings like:
 /// \code
 /// Context->Diag(Loc, "Single-argument constructors must be explicit")
 ///     << FixItHint::CreateInsertion(Loc, "explicit ");
 /// \endcode
 class ClangTidyContext {
 public:
   /// Initializes \c ClangTidyContext instance.
   ClangTidyContext(std::unique_ptr<ClangTidyOptionsProvider> OptionsProvider,
                    bool AllowEnablingAnalyzerAlphaCheckers = false);
   /// Sets the DiagnosticsEngine that diag() will emit diagnostics to.
   // FIXME: this is required initialization, and should be a constructor param.
   // Fix the context -> diag engine -> consumer -> context initialization cycle.
   void setDiagnosticsEngine(DiagnosticsEngine *DiagEngine) {
     this->DiagEngine = DiagEngine;
   }
 
+  void setCrashTraceEngine(CurProcessingCheckState *State) {
+    this->CurrentlyProcessing = State;
+  }
+
   ~ClangTidyContext();
 
   /// Report any errors detected using this method.
   ///
   /// This is still under heavy development and will likely change towards using
   /// tablegen'd diagnostic IDs.
   /// FIXME: Figure out a way to manage ID spaces.
   DiagnosticBuilder diag(StringRef CheckName, SourceLocation Loc,
DiagLevelAndFormatString getDiagLevelAndFormatString(unsigned DiagnosticID,
                                                        SourceLocation Loc) {
     return DiagLevelAndFormatString(
         static_cast<DiagnosticIDs::Level>(
             DiagEngine->getDiagnosticLevel(DiagnosticID, Loc)),
         std::string(
             DiagEngine->getDiagnosticIDs()->getDescription(DiagnosticID)));
   }
 
+  void onProcessingCheckStart(StringRef CheckName,
+                              const ast_matchers::BoundNodes &Result) const {
+    if (CurrentlyProcessing)
+      CurrentlyProcessing->onProcessingCheckStart(CheckName, Result);
+  }
+
+  void onProcessingCheckEnd() const {
+    if (CurrentlyProcessing)
+      CurrentlyProcessing->onProcessingCheckEnd();
+  }
+
 private:
   // Writes to Stats.
   friend class ClangTidyDiagnosticConsumer;
 
   DiagnosticsEngine *DiagEngine;
   std::unique_ptr<ClangTidyOptionsProvider> OptionsProvider;
+  CurProcessingCheckState *CurrentlyProcessing;
 
   std::string CurrentFile;
   ClangTidyOptions CurrentOptions;
 
   std::unique_ptr<CachedGlobList> CheckFilter;
   std::unique_ptr<CachedGlobList> WarningAsErrorFilter;
 
   LangOptions LangOpts;

clang-tools-extra/clang-tidy/ClangTidyDiagnosticConsumer.cpp

 
 #include "ClangTidyDiagnosticConsumer.h"
 #include "ClangTidyOptions.h"
 #include "GlobList.h"
 #include "NoLintDirectiveHandler.h"
 #include "clang/AST/ASTContext.h"
 #include "clang/AST/ASTDiagnostic.h"
 #include "clang/AST/Attr.h"
+#include "clang/ASTMatchers/ASTMatchers.h"
 #include "clang/Basic/Diagnostic.h"
 #include "clang/Basic/DiagnosticOptions.h"
 #include "clang/Basic/FileManager.h"
 #include "clang/Basic/SourceManager.h"
 #include "clang/Frontend/DiagnosticRenderer.h"
 #include "clang/Lex/Lexer.h"
 #include "clang/Tooling/Core/Diagnostic.h"
 #include "clang/Tooling/Core/Replacement.h"
void endDiagnostic(DiagOrStoredDiag D,
     assert(!Error.Message.Message.empty() && "Message has not been set");
   }
 
 private:
   ClangTidyError &Error;
 };
 } // end anonymous namespace
 
 ClangTidyError::ClangTidyError(StringRef CheckName,
                                ClangTidyError::Level DiagLevel,
                                StringRef BuildDirectory, bool IsWarningAsError)
     : tooling::Diagnostic(CheckName, DiagLevel, BuildDirectory),
       IsWarningAsError(IsWarningAsError) {}
 
 ClangTidyContext::ClangTidyContext(
     std::unique_ptr<ClangTidyOptionsProvider> OptionsProvider,
     bool AllowEnablingAnalyzerAlphaCheckers)
     : DiagEngine(nullptr), OptionsProvider(std::move(OptionsProvider)),
-      Profile(false),
+      CurrentlyProcessing(nullptr), Profile(false),
       AllowEnablingAnalyzerAlphaCheckers(AllowEnablingAnalyzerAlphaCheckers) {
   // Before the first translation unit we can get errors related to command-line
   // parsing, use empty string for the file name in this case.
   setCurrentFile("");
 }
 
 ClangTidyContext::~ClangTidyContext() = default;
 
 DiagnosticBuilder ClangTidyContext::diag(
     StringRef CheckName, SourceLocation Loc, StringRef Description,
     DiagnosticIDs::Level Level /* = DiagnosticIDs::Warning*/) {
   assert(Loc.isValid());
   unsigned ID = DiagEngine->getDiagnosticIDs()->getCustomDiagID(
       Level, (Description + " [" + CheckName + "]").str());
   CheckNamesByDiagnosticID.try_emplace(ID, CheckName);
   return DiagEngine->Report(Loc, ID);
 }
 
 DiagnosticBuilder ClangTidyContext::diag(
     StringRef CheckName, StringRef Description,
     DiagnosticIDs::Level Level /* = DiagnosticIDs::Warning*/) {
   unsigned ID = DiagEngine->getDiagnosticIDs()->getCustomDiagID(
       Level, (Description + " [" + CheckName + "]").str());
   CheckNamesByDiagnosticID.try_emplace(ID, CheckName);
   return DiagEngine->Report(ID);
 }
 
 DiagnosticBuilder ClangTidyContext::diag(const tooling::Diagnostic &Error) {
   SourceManager &SM = DiagEngine->getSourceManager();
   llvm::ErrorOr<const FileEntry *> File =
       SM.getFileManager().getFile(Error.Message.FilePath);
   FileID ID = SM.getOrCreateFileID(*File, SrcMgr::C_User);
   SourceLocation FileStartLoc = SM.getLocForStartOfFile(ID);
void ClangTidyContext::setCurrentFile(StringRef File) {
   CheckFilter = std::make_unique<CachedGlobList>(*getOptions().Checks);
   WarningAsErrorFilter =
       std::make_unique<CachedGlobList>(*getOptions().WarningsAsErrors);
 }
 
 void ClangTidyContext::setASTContext(ASTContext *Context) {
   DiagEngine->SetArgToStringFn(&FormatASTNodeDiagnosticArgument, Context);
   LangOpts = Context->getLangOpts();
+  if (CurrentlyProcessing)
+    CurrentlyProcessing->setContext(*Context);
 }
 
 const ClangTidyGlobalOptions &ClangTidyContext::getGlobalOptions() const {
   return OptionsProvider->getGlobalOptions();
 }
 
 const ClangTidyOptions &ClangTidyContext::getOptions() const {
   return CurrentOptions;
if (!Note.Fix.empty()) {
       if (Result)
         // We have 2 different fixes in notes, bail out.
         return nullptr;
       Result = &Note.Fix;
     }
   }
   return Result;
 }
-
 } // namespace tidy
 } // namespace clang
 
+void CurProcessingCheckState::dump(raw_ostream &OS) const {
+  if (CurrentCheckName.empty())
+    return;
+  // This should be an assert, but asserts shouldn't be used in signal
+  // handlers
+  if (!CurContext)
+    return;
+  OS << "Processing check " << CurrentCheckName << '\n';
+  CurrentCheckName = "";
+  const clang::ast_matchers::BoundNodes::IDToNodeMap &Map = CurNodes->getMap();
+  if (Map.empty()) {
+    OS << "No bound nodes\n";
+    return;
+  }
+  OS << "--- Bound Nodes Begin ---\n";
+  for (const auto &Item : Map) {
+    OS << "    " << Item.first << " - { ";
+    if (const auto *D = Item.second.get<Decl>()) {
+      OS << D->getDeclKindName() << "Decl ";
+      if (const auto *ND = dyn_cast<NamedDecl>(D))
+        OS << ND->getDeclName() << " : ";
+      else
+        OS << "<anonymous> ";
+      D->getSourceRange().print(OS, CurContext->getSourceManager());
+    } else if (const auto *S = Item.second.get<Stmt>()) {
+      OS << S->getStmtClassName() << " : ";
+      S->getSourceRange().print(OS, CurContext->getSourceManager());
+    } else if (const auto *T = Item.second.get<Type>()) {
+      OS << T->getTypeClassName() << "Type : ";
+      QualType(T, 0).print(OS, CurContext->getPrintingPolicy());
+    } else if (const auto *QT = Item.second.get<QualType>()) {
+      OS << "QualType : ";
+      QT->print(OS, CurContext->getPrintingPolicy());
+    } else {
+      OS << Item.second.getNodeKind().asStringRef() << " : ";
+      Item.second.getSourceRange().print(OS, CurContext->getSourceManager());
+    }
+    OS << " }\n";
+  }
+  OS << "--- Bound Nodes End ---\n";
+}
+
 void ClangTidyDiagnosticConsumer::HandleDiagnostic(
     DiagnosticsEngine::Level DiagLevel, const Diagnostic &Info) {
   if (LastErrorWasIgnored && DiagLevel == DiagnosticsEngine::Note)
     return;
 
   SmallVector<tooling::Diagnostic, 1> SuppressionErrors;
   if (Context.shouldSuppressDiagnostic(DiagLevel, Info, SuppressionErrors,
                                        EnableNolintBlocks)) {

clang-tools-extra/clang-tidy/tool/ClangTidyMain.cpp

 
 #include "ClangTidyMain.h"
 #include "../ClangTidy.h"
 #include "../ClangTidyForceLinker.h"
 #include "../GlobList.h"
 #include "clang/Tooling/CommonOptionsParser.h"
 #include "llvm/Support/InitLLVM.h"
 #include "llvm/Support/PluginLoader.h"
+#include "llvm/Support/PrettyStackTrace.h"
 #include "llvm/Support/Process.h"
 #include "llvm/Support/Signals.h"
 #include "llvm/Support/TargetSelect.h"
 #include "llvm/Support/WithColor.h"
 
 using namespace clang::tooling;
 using namespace llvm;
 
getVfsFromFile(const std::string &OverlayFile,
   if (!FS) {
     llvm::errs() << "Error: invalid virtual filesystem overlay file '"
                  << OverlayFile << "'.\n";
     return nullptr;
   }
   return FS;
 }
 
+class ClangTidyCrashTraceReporter : public llvm::PrettyStackTraceEntry,
+                                    public CurProcessingCheckState {
+public:
+  void print(raw_ostream &OS) const override { return dump(OS); }
+};
+
 int clangTidyMain(int argc, const char **argv) {
   llvm::InitLLVM X(argc, argv);
 
   // Enable help for -load option, if plugins are enabled.
   if (cl::Option *LoadOpt = cl::getRegisteredOptions().lookup("load"))
     LoadOpt->addCategory(ClangTidyCategory);
 
   llvm::Expected<CommonOptionsParser> OptionsParser =
if (PathList.empty()) {
     llvm::cl::PrintHelpMessage(/*Hidden=*/false, /*Categorized=*/true);
     return 1;
   }
 
   llvm::InitializeAllTargetInfos();
   llvm::InitializeAllTargetMCs();
   llvm::InitializeAllAsmParsers();
 
+  ClangTidyCrashTraceReporter Trace;
+
   ClangTidyContext Context(std::move(OwningOptionsProvider),
                            AllowEnablingAnalyzerAlphaCheckers);
+  Context.setCrashTraceEngine(&Trace);
   std::vector<ClangTidyError> Errors =
       runClangTidy(Context, OptionsParser->getCompilations(), PathList, BaseFS,
                    FixNotes, EnableCheckProfile, ProfilePrefix);
   bool FoundErrors = llvm::find_if(Errors, [](const ClangTidyError &E) {
                        return E.DiagLevel == ClangTidyError::Error;
                      }) != Errors.end();
 
   // --fix-errors and --fix-notes imply --fix.

clang-tools-extra/docs/ReleaseNotes.rst

 Improvements to clang-rename
 ----------------------------
 
 The improvements are...
 
 Improvements to clang-tidy
 --------------------------
 
+- Added trace code to help narrow down any checks and the relevant source code
+  that result in crashes.
+
 New checks
 ^^^^^^^^^^
 
 New check aliases
 ^^^^^^^^^^^^^^^^^
 
 Changes in existing checks
 ^^^^^^^^^^^^^^^^^^^^^^^^^^

clang-tools-extra/test/CMakeLists.txt

if(TARGET CTTestTidyModule)
       list(APPEND CLANG_TOOLS_TEST_DEPS CTTestTidyModule LLVMHello)
       target_include_directories(CTTestTidyModule PUBLIC BEFORE "${CLANG_TOOLS_SOURCE_DIR}")
       if(LLVM_ENABLE_PLUGINS AND (WIN32 OR CYGWIN))
         set(LLVM_LINK_COMPONENTS
           Support
         )
       endif()
   endif()
+
+  llvm_add_library(
+      CTCrashTestTrace
+      MODULE clang-tidy/CTCrashTestTrace.cpp
+      PLUGIN_TOOL clang-tidy
+      DEPENDS clang-tidy-headers)
+
+  if(TARGET CTCrashTestTrace)
+      list(APPEND CLANG_TOOLS_TEST_DEPS CTCrashTestTrace LLVMHello)
+      target_include_directories(CTCrashTestTrace PUBLIC BEFORE "${CLANG_TOOLS_SOURCE_DIR}")
+      if(LLVM_ENABLE_PLUGINS AND (WIN32 OR CYGWIN))
+        set(LLVM_LINK_COMPONENTS
+          Support
+        )
+      endif()
+  endif()
 endif()
 
 add_lit_testsuite(check-clang-tools "Running the Clang extra tools' regression tests"
   ${CMAKE_CURRENT_BINARY_DIR}
   DEPENDS ${CLANG_TOOLS_TEST_DEPS}
   ARGS ${CLANG_TOOLS_TEST_EXTRA_ARGS}
   )
 
 set_target_properties(check-clang-tools PROPERTIES FOLDER "Clang extra tools' tests")
 
 add_lit_testsuites(CLANG-EXTRA ${CMAKE_CURRENT_SOURCE_DIR}
   DEPENDS ${CLANG_TOOLS_TEST_DEPS}
   )

clang-tools-extra/test/clang-tidy/CTCrashTestTrace.cpp

+//===------------------------ CTCrashTestTrace.cpp ------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+///
+///  \file This file implements a clang-tidy plugin that registers one check
+///  designed to crash on any match. This is to test clang-tidys stack trace
+///  output for when a buggy check causes a crash.
+///
+//===----------------------------------------------------------------------===//
+
+#include "clang-tidy/ClangTidyCheck.h"
+#include "clang-tidy/ClangTidyModule.h"
+#include "clang-tidy/ClangTidyModuleRegistry.h"
+#include "clang/ASTMatchers/ASTMatchers.h"
+
+using namespace clang;
+using namespace clang::tidy;
+using namespace clang::ast_matchers;
+
+namespace {
+class CrashingCheck : public ClangTidyCheck {
+public:
+  using ClangTidyCheck::ClangTidyCheck;
+
+  void registerMatchers(MatchFinder *Finder) override {
+    Finder->addMatcher(
+        forStmt(
+            hasLoopInit(
+                declStmt(hasSingleDecl(varDecl(hasType(qualType().bind("QT")),
+                                               hasType(type().bind("T")),
+                                               hasInitializer(
+                                                   integerLiteral().bind("IL")))
+                                           .bind("VD")))
+                    .bind("DS")))
+            .bind("FS"),
+        this);
+  }
+
+  void check(const MatchFinder::MatchResult &Result) override {
+    LLVM_BUILTIN_TRAP;
+  }
+
+  llvm::Optional<TraversalKind> getCheckTraversalKind() const override {
+    return TK_IgnoreUnlessSpelledInSource;
+  }
+};
+
+class CTCrashTestTraceModule : public ClangTidyModule {
+public:
+  void addCheckFactories(ClangTidyCheckFactories &CheckFactories) override {
+    CheckFactories.registerCheck<CrashingCheck>("crash-test");
+  }
+};
+} // namespace
+
+namespace tidy {
+// Register the CTCrashTestTraceModule using this statically initialized
+// variable.
+static ClangTidyModuleRegistry::Add<::CTCrashTestTraceModule>
+    X("crash-module", "Add a check which will trap on any match");
+} // namespace tidy
+
+// This anchor is used to force the linker to link in the generated object file
+// and thus register the CTCrashTestTraceModule.
+volatile int CTCrashTestTraceAnchor = 0;

clang-tools-extra/test/clang-tidy/infrastructure/crash-trace.c

+// REQUIRES: plugins, backtraces, crash-recovery
+// RUN: not --crash clang-tidy %s -checks='-*,crash-test' -load               \
+// RUN:   %llvmshlibdir/CTCrashTestTrace%pluginext 2>&1 | FileCheck %s
+
+void foo() {
+  for (int I = 0; I < 5; ++I) {
+  }
+}
+// CHECK: Processing check crash-test
+// CHECK-NEXT: --- Bound Nodes Begin ---
+// CHECK-DAG: FS - { ForStmt : <{{.*}}/crash-trace.c:6:3, line:7:3> }
+// CHECK-DAG: DS - { DeclStmt : <{{.*}}/crash-trace.c:6:8, col:17> }
+// CHECK-DAG: VD - { VarDecl I : <{{.*}}/crash-trace.c:6:8, col:16> }
+// CHECK-DAG: IL - { IntegerLiteral : <{{.*}}/crash-trace.c:6:16> }
+// CHECK-DAG: QT - { QualType : int }
+// CHECK-DAG: T - { BuiltinType : int }
+// CHECK-NEXT: --- Bound Nodes End ---

clang-tools-extra/test/lit.cfg.py

 config.test_format = lit.formats.ShTest(execute_external)
 
 # suffixes: A list of file extensions to treat as test files.
 config.suffixes = ['.c', '.cpp', '.hpp', '.m', '.mm', '.cu', '.ll', '.cl', '.s',
   '.modularize', '.module-map-checker', '.test']
 
 # Test-time dependencies located in directories called 'Inputs' are excluded
 # from test suites; there won't be any lit tests within them.
-config.excludes = ['Inputs']
+config.excludes = ['Inputs', 'CTCrashTestTrace.cpp']
 
 # test_source_root: The root path where tests are located.
 config.test_source_root = os.path.dirname(__file__)
 
 # test_exec_root: The root path where tests should be run.
 config.test_exec_root = os.path.join(config.clang_tools_binary_dir, 'test')
 
 # Clear some environment variables that might affect Clang.