From 0de0dd49231a9613339b95c0e1e4a3838eeb6bb3 Mon Sep 17 00:00:00 2001 From: "Tareq A. Siraj" Date: Tue, 16 Apr 2013 18:41:26 +0000 Subject: [PATCH] Parser support for #pragma clang __debug captured MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit This patch implements parsing ‘#pragma clang __debug’ as a first step for implementing captured statements. Captured statements are a mechanism for doing outlining in the AST. see http://lists.cs.uiuc.edu/pipermail/cfe-dev/2013-January/027540.html. Currently returns StmtEmpty Author: Andy Zhang Differential Revision: http://llvm-reviews.chandlerc.com/D369 llvm-svn: 179614 --- clang/include/clang/Basic/TokenKinds.def | 5 ++++ clang/include/clang/Lex/PPCallbacks.h | 6 ++++ clang/include/clang/Parse/Parser.h | 4 +++ .../lib/Frontend/PrintPreprocessedOutput.cpp | 12 ++++++++ clang/lib/Lex/Pragma.cpp | 30 +++++++++++++++++++ clang/lib/Parse/ParsePragma.cpp | 15 ++++++++++ clang/lib/Parse/ParseStmt.cpp | 3 ++ clang/test/Parser/captured-statements.c | 14 +++++++++ clang/test/Preprocessor/pragma-captured.c | 13 ++++++++ 9 files changed, 102 insertions(+) create mode 100644 clang/test/Parser/captured-statements.c create mode 100644 clang/test/Preprocessor/pragma-captured.c diff --git a/clang/include/clang/Basic/TokenKinds.def b/clang/include/clang/Basic/TokenKinds.def index fb2edcec0d39..bcf0f31dcbf6 100644 --- a/clang/include/clang/Basic/TokenKinds.def +++ b/clang/include/clang/Basic/TokenKinds.def @@ -615,6 +615,11 @@ ANNOTATION(pragma_pack) // handles them. ANNOTATION(pragma_parser_crash) +// Annotation for #pragma clang __debug captured... +// The lexer produces these so that they only take effect when the parser +// handles them. +ANNOTATION(pragma_captured) + // Annotation for #pragma ms_struct... // The lexer produces these so that they only take effect when the parser // handles them. diff --git a/clang/include/clang/Lex/PPCallbacks.h b/clang/include/clang/Lex/PPCallbacks.h index 96359a2aa3a4..661a3a79ec50 100644 --- a/clang/include/clang/Lex/PPCallbacks.h +++ b/clang/include/clang/Lex/PPCallbacks.h @@ -159,6 +159,12 @@ public: const std::string &Str) { } + /// \brief Callback invoked when a \#pragma clang __debug directive is read. + /// \param Loc The location of the debug directive. + /// \param DebugType The identifier following __debug. + virtual void PragmaDebug(SourceLocation Loc, StringRef DebugType) { + } + /// \brief Callback invoked when a \#pragma message directive is read. /// \param Loc The location of the message directive. /// \param Str The text of the message directive. diff --git a/clang/include/clang/Parse/Parser.h b/clang/include/clang/Parse/Parser.h index 8cc60a29dfa3..812a09baa6da 100644 --- a/clang/include/clang/Parse/Parser.h +++ b/clang/include/clang/Parse/Parser.h @@ -422,6 +422,10 @@ private: /// #pragma OPENCL EXTENSION... void HandlePragmaOpenCLExtension(); + /// \brief Handle the annotation token produced for + /// #pragma clang __debug captured + StmtResult HandlePragmaCaptured(); + /// GetLookAheadToken - This peeks ahead N tokens and returns that token /// without consuming any tokens. LookAhead(0) returns 'Tok', LookAhead(1) /// returns the token after Tok, etc. diff --git a/clang/lib/Frontend/PrintPreprocessedOutput.cpp b/clang/lib/Frontend/PrintPreprocessedOutput.cpp index 432428bb9690..6734d7759b4d 100644 --- a/clang/lib/Frontend/PrintPreprocessedOutput.cpp +++ b/clang/lib/Frontend/PrintPreprocessedOutput.cpp @@ -140,6 +140,7 @@ public: virtual void PragmaComment(SourceLocation Loc, const IdentifierInfo *Kind, const std::string &Str); virtual void PragmaMessage(SourceLocation Loc, StringRef Str); + virtual void PragmaDebug(SourceLocation Loc, StringRef DebugType); virtual void PragmaDiagnosticPush(SourceLocation Loc, StringRef Namespace); virtual void PragmaDiagnosticPop(SourceLocation Loc, @@ -419,6 +420,17 @@ void PrintPPOutputPPCallbacks::PragmaMessage(SourceLocation Loc, setEmittedDirectiveOnThisLine(); } +void PrintPPOutputPPCallbacks::PragmaDebug(SourceLocation Loc, + StringRef DebugType) { + startNewLineIfNeeded(); + MoveToLine(Loc); + + OS << "#pragma clang __debug "; + OS << DebugType; + + setEmittedDirectiveOnThisLine(); +} + void PrintPPOutputPPCallbacks:: PragmaDiagnosticPush(SourceLocation Loc, StringRef Namespace) { startNewLineIfNeeded(); diff --git a/clang/lib/Lex/Pragma.cpp b/clang/lib/Lex/Pragma.cpp index 95e8a8ca8fc8..af58c50f054b 100644 --- a/clang/lib/Lex/Pragma.cpp +++ b/clang/lib/Lex/Pragma.cpp @@ -995,10 +995,40 @@ struct PragmaDebugHandler : public PragmaHandler { llvm::CrashRecoveryContext *CRC =llvm::CrashRecoveryContext::GetCurrent(); if (CRC) CRC->HandleCrash(); + } else if (II->isStr("captured")) { + HandleCaptured(PP); } else { PP.Diag(Tok, diag::warn_pragma_debug_unexpected_command) << II->getName(); } + + PPCallbacks *Callbacks = PP.getPPCallbacks(); + if (Callbacks) + Callbacks->PragmaDebug(Tok.getLocation(), II->getName()); + } + + void HandleCaptured(Preprocessor &PP) { + // Skip if emitting preprocessed output. + if (PP.isPreprocessedOutput()) + return; + + Token Tok; + PP.LexUnexpandedToken(Tok); + + if (Tok.isNot(tok::eod)) { + PP.Diag(Tok, diag::ext_pp_extra_tokens_at_eol) + << "pragma clang __debug captured"; + return; + } + + SourceLocation NameLoc = Tok.getLocation(); + Token *Toks = PP.getPreprocessorAllocator().Allocate(1); + Toks->startToken(); + Toks->setKind(tok::annot_pragma_captured); + Toks->setLocation(NameLoc); + + PP.EnterTokenStream(Toks, 1, /*DisableMacroExpansion=*/true, + /*OwnsTokens=*/false); } // Disable MSVC warning about runtime stack overflow. diff --git a/clang/lib/Parse/ParsePragma.cpp b/clang/lib/Parse/ParsePragma.cpp index dc6b3ed4fa98..038636d10801 100644 --- a/clang/lib/Parse/ParsePragma.cpp +++ b/clang/lib/Parse/ParsePragma.cpp @@ -122,6 +122,19 @@ void Parser::HandlePragmaFPContract() { ConsumeToken(); // The annotation token. } +StmtResult Parser::HandlePragmaCaptured() +{ + assert(Tok.is(tok::annot_pragma_captured)); + ConsumeToken(); + + if (Tok.isNot(tok::l_brace)) { + PP.Diag(Tok, diag::err_expected_lbrace); + return StmtError(); + } + + return StmtEmpty(); +} + namespace { typedef llvm::PointerIntPair OpenCLExtData; } @@ -151,6 +164,8 @@ void Parser::HandlePragmaOpenCLExtension() { } } + + // #pragma GCC visibility comes in two variants: // 'push' '(' [visibility] ')' // 'pop' diff --git a/clang/lib/Parse/ParseStmt.cpp b/clang/lib/Parse/ParseStmt.cpp index 355f3694bb6c..5fa4f170265f 100644 --- a/clang/lib/Parse/ParseStmt.cpp +++ b/clang/lib/Parse/ParseStmt.cpp @@ -289,6 +289,9 @@ Retry: HandlePragmaOpenCLExtension(); return StmtEmpty(); + case tok::annot_pragma_captured: + return HandlePragmaCaptured(); + case tok::annot_pragma_openmp: SourceLocation DeclStart = Tok.getLocation(); DeclGroupPtrTy Res = ParseOpenMPDeclarativeDirective(); diff --git a/clang/test/Parser/captured-statements.c b/clang/test/Parser/captured-statements.c new file mode 100644 index 000000000000..30dddb549c9c --- /dev/null +++ b/clang/test/Parser/captured-statements.c @@ -0,0 +1,14 @@ +// RUN: %clang_cc1 -verify %s + +void test1() +{ + #pragma clang __debug captured x // expected-warning {{extra tokens at end of #pragma clang __debug captured directive}} + { + } +} + +void test2() +{ + #pragma clang __debug captured + int x; // expected-error {{expected '{'}} +} diff --git a/clang/test/Preprocessor/pragma-captured.c b/clang/test/Preprocessor/pragma-captured.c new file mode 100644 index 000000000000..be2a62b5e475 --- /dev/null +++ b/clang/test/Preprocessor/pragma-captured.c @@ -0,0 +1,13 @@ +// RUN: %clang_cc1 -E %s | FileCheck %s + +// Test pragma clang __debug captured, for Captured Statements + +void test1() +{ + #pragma clang __debug captured + { + } +// CHECK: void test1() +// CHECK: { +// CHECK: #pragma clang __debug captured +}