[libclang] Avoid builtin trap for __debug parser_crash pragma

[arphaman]

Summary

This patch allows libclang to report a parser crash that's caused by #pragma clang __debug parser_crash without using the LLVM_BUILTIN_TRAP. Instead a new flag in PPOpts is used to let libclang know that a simulated crash has occurred. This flag allows clients to test that libclang can report a parser crash (CXError_Crash) when libclang is ran under a debugger that breaks on LLVM_BUILTIN_TRAP.

[benlangmuir]

Did you consider just using a different pragma that triggers this behaviour instead of avoiding the crash? I don't really have a strong preference but I'd be interested to hear what you think the pros/cons are.

lib/Parse/ParseDecl.cpp

5657

This should return immediately (and keep exiting until ~ParseAST) or it won't really behave like a trap.

[arphaman]

It turns out there's already something that works much better: #pragma clang __debug handle_crash. Sorry about the redundant patch!

include/clang/Frontend/ASTUnit.h

static ASTUnit *LoadFromCommandLine(
       TranslationUnitKind TUKind = TU_Complete,
       bool CacheCodeCompletionResults = false,
       bool IncludeBriefCommentsInCodeCompletion = false,
       bool AllowPCHWithCompilerErrors = false, bool SkipFunctionBodies = false,
       bool SingleFileParse = false,
       bool UserFilesAreVolatile = false, bool ForSerialization = false,
       llvm::Optional<StringRef> ModuleFormat = llvm::None,
       std::unique_ptr<ASTUnit> *ErrAST = nullptr,
-      IntrusiveRefCntPtr<vfs::FileSystem> VFS = nullptr);
+      IntrusiveRefCntPtr<vfs::FileSystem> VFS = nullptr,
+      bool AvoidTrapOnBuiltinDebugCrash = false);
 
   /// \brief Reparse the source files using the same command-line options that
   /// were originally used to produce this translation unit.
   ///
   /// \param VFS - A vfs::FileSystem to be used for all file accesses. Note that
   /// preamble is saved to a temporary directory on a RealFileSystem, so in order
   /// for it to be loaded correctly, VFS should give an access to this(i.e. be an
   /// overlay over RealFileSystem). FileMgr->getVirtualFileSystem() will be used if

include/clang/Lex/PreprocessorOptions.h

public:
   /// \brief The set of modules that failed to build.
   ///
   /// This pointer will be shared among all of the compiler instances created
   /// to (re)build modules, so that once a module fails to build anywhere,
   /// other instances will see that the module has failed and won't try to
   /// build it again.
   std::shared_ptr<FailedModulesSet> FailedModules;
 
+  /// Whether the compiler should avoid trapping when it encounters a
+  /// __debug parser_crash pragma.
+  bool AvoidTrapOnParserCrashPragma = false;
+
+  /// True if the compiler has seen the __debug parser_crash pragma.
+  bool SeenParserCrashPragma = false;
+
 public:
   PreprocessorOptions() : PrecompiledPreambleBytes(0, false) {}
 
   void addMacroDef(StringRef Name) { Macros.emplace_back(Name, false); }
   void addMacroUndef(StringRef Name) { Macros.emplace_back(Name, true); }
 
   void addRemappedFile(StringRef From, StringRef To) {
     RemappedFiles.emplace_back(From, To);

lib/Frontend/ASTUnit.cpp

ASTUnit *ASTUnit::LoadFromCommandLine(
     IntrusiveRefCntPtr<DiagnosticsEngine> Diags, StringRef ResourceFilesPath,
     bool OnlyLocalDecls, bool CaptureDiagnostics,
     ArrayRef<RemappedFile> RemappedFiles, bool RemappedFilesKeepOriginalName,
     unsigned PrecompilePreambleAfterNParses, TranslationUnitKind TUKind,
     bool CacheCodeCompletionResults, bool IncludeBriefCommentsInCodeCompletion,
     bool AllowPCHWithCompilerErrors, bool SkipFunctionBodies,
     bool SingleFileParse, bool UserFilesAreVolatile, bool ForSerialization,
     llvm::Optional<StringRef> ModuleFormat, std::unique_ptr<ASTUnit> *ErrAST,
-    IntrusiveRefCntPtr<vfs::FileSystem> VFS) {
+    IntrusiveRefCntPtr<vfs::FileSystem> VFS,
+    bool AvoidTrapOnBuiltinDebugCrash) {
   assert(Diags.get() && "no DiagnosticsEngine was provided");
 
   SmallVector<StoredDiagnostic, 4> StoredDiagnostics;
 
   std::shared_ptr<CompilerInvocation> CI;
 
   {
 
ASTUnit *ASTUnit::LoadFromCommandLine(
   for (const auto &RemappedFile : RemappedFiles) {
     CI->getPreprocessorOpts().addRemappedFile(RemappedFile.first,
                                               RemappedFile.second);
   }
   PreprocessorOptions &PPOpts = CI->getPreprocessorOpts();
   PPOpts.RemappedFilesKeepOriginalName = RemappedFilesKeepOriginalName;
   PPOpts.AllowPCHWithCompilerErrors = AllowPCHWithCompilerErrors;
   PPOpts.SingleFileParseMode = SingleFileParse;
+  PPOpts.AvoidTrapOnParserCrashPragma = AvoidTrapOnBuiltinDebugCrash;
   
   // Override the resources path.
   CI->getHeaderSearchOpts().ResourceDir = ResourceFilesPath;
 
   CI->getFrontendOpts().SkipFunctionBodies = SkipFunctionBodies;
 
   if (ModuleFormat)
     CI->getHeaderSearchOpts().ModuleFormat = ModuleFormat.getValue();

lib/Parse/ParseDecl.cpp

 #include "clang/Parse/Parser.h"
 #include "clang/Parse/RAIIObjectsForParser.h"
 #include "clang/AST/ASTContext.h"
 #include "clang/AST/DeclTemplate.h"
 #include "clang/Basic/AddressSpaces.h"
 #include "clang/Basic/Attributes.h"
 #include "clang/Basic/CharInfo.h"
 #include "clang/Basic/TargetInfo.h"
+#include "clang/Lex/PreprocessorOptions.h"
 #include "clang/Parse/ParseDiagnostic.h"
 #include "clang/Sema/Lookup.h"
 #include "clang/Sema/ParsedTemplate.h"
 #include "clang/Sema/PrettyDeclStackTrace.h"
 #include "clang/Sema/Scope.h"
 #include "clang/Sema/SemaDiagnostic.h"
 #include "llvm/ADT/Optional.h"
 #include "llvm/ADT/SmallSet.h"
if (Tok.is(tok::l_paren)) {
     D.SetIdentifier(nullptr, Tok.getLocation());
 
     // The grammar for abstract-pack-declarator does not allow grouping parens.
     // FIXME: Revisit this once core issue 1488 is resolved.
     if (D.hasEllipsis() && D.hasGroupingParens())
       Diag(PP.getLocForEndOfToken(D.getEllipsisLoc()),
            diag::ext_abstract_pack_declarator_parens);
   } else {
-    if (Tok.getKind() == tok::annot_pragma_parser_crash)
+    if (Tok.getKind() == tok::annot_pragma_parser_crash) {
+      if (!PP.getPreprocessorOpts().AvoidTrapOnParserCrashPragma)
         LLVM_BUILTIN_TRAP;
+      else
+        PP.getPreprocessorOpts().SeenParserCrashPragma = true;
+    }
     if (Tok.is(tok::l_square))
       return ParseMisplacedBracketDeclarator(D);
     if (D.getContext() == Declarator::MemberContext) {
       // Objective-C++: Detect C++ keywords and try to prevent further errors by
       // treating these keyword as valid member names.
       if (getLangOpts().ObjC1 && getLangOpts().CPlusPlus &&
           Tok.getIdentifierInfo() &&
           Tok.getIdentifierInfo()->isCPlusPlusKeyword(getLangOpts())) {

tools/libclang/CIndex.cpp

 #include "clang/Frontend/CompilerInstance.h"
 #include "clang/Frontend/FrontendDiagnostic.h"
 #include "clang/Index/CodegenNameGenerator.h"
 #include "clang/Index/CommentToXML.h"
 #include "clang/Lex/HeaderSearch.h"
 #include "clang/Lex/Lexer.h"
 #include "clang/Lex/PreprocessingRecord.h"
 #include "clang/Lex/Preprocessor.h"
+#include "clang/Lex/PreprocessorOptions.h"
 #include "clang/Serialization/SerializationDiagnostic.h"
 #include "llvm/ADT/Optional.h"
 #include "llvm/ADT/STLExtras.h"
 #include "llvm/ADT/StringSwitch.h"
 #include "llvm/Config/llvm-config.h"
 #include "llvm/Support/Compiler.h"
 #include "llvm/Support/CrashRecoveryContext.h"
 #include "llvm/Support/Format.h"
std::unique_ptr<ASTUnit> Unit(ASTUnit::LoadFromCommandLine(
       Args->data(), Args->data() + Args->size(),
       CXXIdx->getPCHContainerOperations(), Diags,
       CXXIdx->getClangResourcesPath(), CXXIdx->getOnlyLocalDecls(),
       /*CaptureDiagnostics=*/true, *RemappedFiles.get(),
       /*RemappedFilesKeepOriginalName=*/true, PrecompilePreambleAfterNParses,
       TUKind, CacheCodeCompletionResults, IncludeBriefCommentsInCodeCompletion,
       /*AllowPCHWithCompilerErrors=*/true, SkipFunctionBodies, SingleFileParse,
       /*UserFilesAreVolatile=*/true, ForSerialization,
-      CXXIdx->getPCHContainerOperations()->getRawReader().getFormat(),
-      &ErrUnit));
+      CXXIdx->getPCHContainerOperations()->getRawReader().getFormat(), &ErrUnit,
+      /*VFS=*/nullptr, /*AvoidTrapOnBuiltinDebugCrash=*/true));
 
   // Early failures in LoadFromCommandLine may return with ErrUnit unset.
   if (!Unit && !ErrUnit)
     return CXError_ASTReadError;
 
   if (NumErrors != Diags->getClient()->getNumErrors()) {
     // Make sure to check that 'Unit' is non-NULL.
     if (CXXIdx->getDisplayDiagnostics())
       printDiagsToStderr(Unit ? Unit.get() : ErrUnit.get());
   }
 
   if (isASTReadError(Unit ? Unit.get() : ErrUnit.get()))
     return CXError_ASTReadError;
 
+  bool Crash =
+      Unit->getPreprocessor().getPreprocessorOpts().SeenParserCrashPragma;
   *out_TU = MakeCXTranslationUnit(CXXIdx, std::move(Unit));
   if (CXTranslationUnitImpl *TU = *out_TU) {
     TU->ParsingOptions = options;
     TU->Arguments.reserve(Args->size());
     for (const char *Arg : *Args)
       TU->Arguments.push_back(Arg);
-    return CXError_Success;
+    return Crash ? CXError_Crashed : CXError_Success;
   }
-  return CXError_Failure;
+  return Crash ? CXError_Crashed : CXError_Failure;
 }
 
 CXTranslationUnit
 clang_parseTranslationUnit(CXIndex CIdx,
                            const char *source_filename,
                            const char *const *command_line_args,
                            int num_command_line_args,
                            struct CXUnsavedFile *unsaved_files,

unittests/libclang/LibclangTest.cpp

TEST_F(LibclangReparseTest, clang_parseTranslationUnit2FullArgv) {
 
   EXPECT_EQ(CXError_Success,
             clang_parseTranslationUnit2FullArgv(Index, Filename.c_str(), Argv,
                                                 sizeof(Argv) / sizeof(Argv[0]),
                                                 nullptr, 0, TUFlags, &ClangTU));
   EXPECT_EQ(0U, clang_getNumDiagnostics(ClangTU));
   DisplayDiagnostics();
 }
+
+TEST_F(LibclangReparseTest, clang_parseTranslationUnit2FullArgv_Crash) {
+  std::string Filename = "test.cc";
+  WriteFile(Filename, "#  pragma clang __debug parser_crash\n");
+
+  const char *Argv[] = {"clang"};
+
+  EXPECT_EQ(CXError_Crashed,
+            clang_parseTranslationUnit2FullArgv(Index, Filename.c_str(), Argv,
+                                                sizeof(Argv) / sizeof(Argv[0]),
+                                                nullptr, 0, TUFlags, &ClangTU));
+}