/build/llvm-toolchain-snapshot-8~svn350071/tools/clang/lib/Parse/ParsePragma.cpp

Bug Summary

File:	tools/clang/lib/Parse/ParsePragma.cpp
Warning:	line 3188, column 20 Access to field 'Action' results in a dereference of a null pointer (loaded from variable 'Info')
Annotated Source Code

Press '?' to see keyboard shortcuts
Show analyzer invocation
clang -cc1 -triple x86_64-pc-linux-gnu -analyze -disable-free -disable-llvm-verifier -discard-value-names -main-file-name ParsePragma.cpp -analyzer-store=region -analyzer-opt-analyze-nested-blocks -analyzer-checker=core -analyzer-checker=apiModeling -analyzer-checker=unix -analyzer-checker=deadcode -analyzer-checker=cplusplus -analyzer-checker=security.insecureAPI.UncheckedReturn -analyzer-checker=security.insecureAPI.getpw -analyzer-checker=security.insecureAPI.gets -analyzer-checker=security.insecureAPI.mktemp -analyzer-checker=security.insecureAPI.mkstemp -analyzer-checker=security.insecureAPI.vfork -analyzer-checker=nullability.NullPassedToNonnull -analyzer-checker=nullability.NullReturnedFromNonnull -analyzer-output plist -w -analyzer-config-compatibility-mode=true -mrelocation-model pic -pic-level 2 -mthread-model posix -relaxed-aliasing -fmath-errno -masm-verbose -mconstructor-aliases -munwind-tables -fuse-init-array -target-cpu x86-64 -dwarf-column-info -debugger-tuning=gdb -momit-leaf-frame-pointer -ffunction-sections -fdata-sections -resource-dir /usr/lib/llvm-8/lib/clang/8.0.0 -D CLANG_VENDOR="Debian " -D _DEBUG -D _GNU_SOURCE -D __STDC_CONSTANT_MACROS -D __STDC_FORMAT_MACROS -D __STDC_LIMIT_MACROS -I /build/llvm-toolchain-snapshot-8~svn350071/build-llvm/tools/clang/lib/Parse -I /build/llvm-toolchain-snapshot-8~svn350071/tools/clang/lib/Parse -I /build/llvm-toolchain-snapshot-8~svn350071/tools/clang/include -I /build/llvm-toolchain-snapshot-8~svn350071/build-llvm/tools/clang/include -I /build/llvm-toolchain-snapshot-8~svn350071/build-llvm/include -I /build/llvm-toolchain-snapshot-8~svn350071/include -U NDEBUG -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/6.3.0/../../../../include/c++/6.3.0 -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/6.3.0/../../../../include/x86_64-linux-gnu/c++/6.3.0 -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/6.3.0/../../../../include/x86_64-linux-gnu/c++/6.3.0 -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/6.3.0/../../../../include/c++/6.3.0/backward -internal-isystem /usr/include/clang/8.0.0/include/ -internal-isystem /usr/local/include -internal-isystem /usr/lib/llvm-8/lib/clang/8.0.0/include -internal-externc-isystem /usr/include/x86_64-linux-gnu -internal-externc-isystem /include -internal-externc-isystem /usr/include -O2 -Wno-unused-parameter -Wwrite-strings -Wno-missing-field-initializers -Wno-long-long -Wno-maybe-uninitialized -Wno-comment -std=c++11 -fdeprecated-macro -fdebug-compilation-dir /build/llvm-toolchain-snapshot-8~svn350071/build-llvm/tools/clang/lib/Parse -fdebug-prefix-map=/build/llvm-toolchain-snapshot-8~svn350071=. -ferror-limit 19 -fmessage-length 0 -fvisibility-inlines-hidden -stack-protector 2 -fobjc-runtime=gcc -fno-common -fdiagnostics-show-option -vectorize-loops -vectorize-slp -analyzer-output=html -analyzer-config stable-report-filename=true -o /tmp/scan-build-2018-12-27-042839-1215-1 -x c++ /build/llvm-toolchain-snapshot-8~svn350071/tools/clang/lib/Parse/ParsePragma.cpp -faddrsig
1//===--- ParsePragma.cpp - Language specific pragma parsing ---------------===//
2//
3//                     The LLVM Compiler Infrastructure
4//
5// This file is distributed under the University of Illinois Open Source
6// License. See LICENSE.TXT for details.
7//
8//===----------------------------------------------------------------------===//
9//
10// This file implements the language specific #pragma handlers.
11//
12//===----------------------------------------------------------------------===//

14#include "clang/AST/ASTContext.h"
15#include "clang/Basic/PragmaKinds.h"
16#include "clang/Basic/TargetInfo.h"
17#include "clang/Lex/Preprocessor.h"
18#include "clang/Parse/LoopHint.h"
19#include "clang/Parse/ParseDiagnostic.h"
20#include "clang/Parse/Parser.h"
21#include "clang/Parse/RAIIObjectsForParser.h"
22#include "clang/Sema/Scope.h"
23#include "llvm/ADT/StringSwitch.h"
24using namespace clang;

26namespace {

28struct PragmaAlignHandler : public PragmaHandler {
explicit PragmaAlignHandler() : PragmaHandler("align") {}
void HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer,
                  Token &FirstToken) override;
32};

34struct PragmaGCCVisibilityHandler : public PragmaHandler {
explicit PragmaGCCVisibilityHandler() : PragmaHandler("visibility") {}
void HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer,
                  Token &FirstToken) override;
38};

40struct PragmaOptionsHandler : public PragmaHandler {
explicit PragmaOptionsHandler() : PragmaHandler("options") {}
void HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer,
                  Token &FirstToken) override;
44};

46struct PragmaPackHandler : public PragmaHandler {
explicit PragmaPackHandler() : PragmaHandler("pack") {}
void HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer,
                  Token &FirstToken) override;
50};

52struct PragmaClangSectionHandler : public PragmaHandler {
explicit PragmaClangSectionHandler(Sema &S)
           : PragmaHandler("section"), Actions(S) {}
void HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer,
                  Token &FirstToken) override;
57private:
Sema &Actions;
59};

61struct PragmaMSStructHandler : public PragmaHandler {
explicit PragmaMSStructHandler() : PragmaHandler("ms_struct") {}
void HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer,
                  Token &FirstToken) override;
65};

67struct PragmaUnusedHandler : public PragmaHandler {
PragmaUnusedHandler() : PragmaHandler("unused") {}
void HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer,
                  Token &FirstToken) override;
71};

73struct PragmaWeakHandler : public PragmaHandler {
explicit PragmaWeakHandler() : PragmaHandler("weak") {}
void HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer,
                  Token &FirstToken) override;
77};

79struct PragmaRedefineExtnameHandler : public PragmaHandler {
explicit PragmaRedefineExtnameHandler() : PragmaHandler("redefine_extname") {}
void HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer,
                  Token &FirstToken) override;
83};

85struct PragmaOpenCLExtensionHandler : public PragmaHandler {
PragmaOpenCLExtensionHandler() : PragmaHandler("EXTENSION") {}
void HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer,
                  Token &FirstToken) override;
89};


92struct PragmaFPContractHandler : public PragmaHandler {
PragmaFPContractHandler() : PragmaHandler("FP_CONTRACT") {}
void HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer,
                  Token &FirstToken) override;
96};

98// Pragma STDC implementations.

100/// PragmaSTDC_FENV_ACCESSHandler - "\#pragma STDC FENV_ACCESS ...".
101struct PragmaSTDC_FENV_ACCESSHandler : public PragmaHandler {
PragmaSTDC_FENV_ACCESSHandler() : PragmaHandler("FENV_ACCESS") {}

void HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer,
                  Token &Tok) override {
  tok::OnOffSwitch OOS;
  if (PP.LexOnOffSwitch(OOS))
   return;
  if (OOS == tok::OOS_ON) {
    PP.Diag(Tok, diag::warn_stdc_fenv_access_not_supported);
  }

  MutableArrayRef<Token> Toks(PP.getPreprocessorAllocator().Allocate<Token>(1),
                              1);
  Toks[0].startToken();
  Toks[0].setKind(tok::annot_pragma_fenv_access);
  Toks[0].setLocation(Tok.getLocation());
  Toks[0].setAnnotationEndLoc(Tok.getLocation());
  Toks[0].setAnnotationValue(reinterpret_cast<void*>(
                             static_cast<uintptr_t>(OOS)));
  PP.EnterTokenStream(Toks, /*DisableMacroExpansion=*/true);
}
123};

125/// PragmaSTDC_CX_LIMITED_RANGEHandler - "\#pragma STDC CX_LIMITED_RANGE ...".
126struct PragmaSTDC_CX_LIMITED_RANGEHandler : public PragmaHandler {
PragmaSTDC_CX_LIMITED_RANGEHandler() : PragmaHandler("CX_LIMITED_RANGE") {}

void HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer,
                  Token &Tok) override {
  tok::OnOffSwitch OOS;
  PP.LexOnOffSwitch(OOS);
}
134};

136/// PragmaSTDC_UnknownHandler - "\#pragma STDC ...".
137struct PragmaSTDC_UnknownHandler : public PragmaHandler {
PragmaSTDC_UnknownHandler() = default;

void HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer,
                  Token &UnknownTok) override {
  // C99 6.10.6p2, unknown forms are not allowed.
  PP.Diag(UnknownTok, diag::ext_stdc_pragma_ignored);
}
145};

147struct PragmaFPHandler : public PragmaHandler {
PragmaFPHandler() : PragmaHandler("fp") {}
void HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer,
                  Token &FirstToken) override;
151};

153struct PragmaNoOpenMPHandler : public PragmaHandler {
PragmaNoOpenMPHandler() : PragmaHandler("omp") { }
void HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer,
                  Token &FirstToken) override;
157};

159struct PragmaOpenMPHandler : public PragmaHandler {
PragmaOpenMPHandler() : PragmaHandler("omp") { }
void HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer,
                  Token &FirstToken) override;
163};

165/// PragmaCommentHandler - "\#pragma comment ...".
166struct PragmaCommentHandler : public PragmaHandler {
PragmaCommentHandler(Sema &Actions)
  : PragmaHandler("comment"), Actions(Actions) {}
void HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer,
                  Token &FirstToken) override;
171private:
Sema &Actions;
173};

175struct PragmaDetectMismatchHandler : public PragmaHandler {
PragmaDetectMismatchHandler(Sema &Actions)
  : PragmaHandler("detect_mismatch"), Actions(Actions) {}
void HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer,
                  Token &FirstToken) override;
180private:
Sema &Actions;
182};

184struct PragmaMSPointersToMembers : public PragmaHandler {
explicit PragmaMSPointersToMembers() : PragmaHandler("pointers_to_members") {}
void HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer,
                  Token &FirstToken) override;
188};

190struct PragmaMSVtorDisp : public PragmaHandler {
explicit PragmaMSVtorDisp() : PragmaHandler("vtordisp") {}
void HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer,
                  Token &FirstToken) override;
194};

196struct PragmaMSPragma : public PragmaHandler {
explicit PragmaMSPragma(const char *name) : PragmaHandler(name) {}
void HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer,
                  Token &FirstToken) override;
200};

202/// PragmaOptimizeHandler - "\#pragma clang optimize on/off".
203struct PragmaOptimizeHandler : public PragmaHandler {
PragmaOptimizeHandler(Sema &S)
  : PragmaHandler("optimize"), Actions(S) {}
void HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer,
                  Token &FirstToken) override;
208private:
Sema &Actions;
210};

212struct PragmaLoopHintHandler : public PragmaHandler {
PragmaLoopHintHandler() : PragmaHandler("loop") {}
void HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer,
                  Token &FirstToken) override;
216};

218struct PragmaUnrollHintHandler : public PragmaHandler {
PragmaUnrollHintHandler(const char *name) : PragmaHandler(name) {}
void HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer,
                  Token &FirstToken) override;
222};

224struct PragmaMSRuntimeChecksHandler : public EmptyPragmaHandler {
PragmaMSRuntimeChecksHandler() : EmptyPragmaHandler("runtime_checks") {}
226};

228struct PragmaMSIntrinsicHandler : public PragmaHandler {
PragmaMSIntrinsicHandler() : PragmaHandler("intrinsic") {}
void HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer,
                  Token &FirstToken) override;
232};

234struct PragmaMSOptimizeHandler : public PragmaHandler {
PragmaMSOptimizeHandler() : PragmaHandler("optimize") {}
void HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer,
                  Token &FirstToken) override;
238};

240struct PragmaForceCUDAHostDeviceHandler : public PragmaHandler {
PragmaForceCUDAHostDeviceHandler(Sema &Actions)
    : PragmaHandler("force_cuda_host_device"), Actions(Actions) {}
void HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer,
                  Token &FirstToken) override;

246private:
Sema &Actions;
248};

250/// PragmaAttributeHandler - "\#pragma clang attribute ...".
251struct PragmaAttributeHandler : public PragmaHandler {
PragmaAttributeHandler(AttributeFactory &AttrFactory)
    : PragmaHandler("attribute"), AttributesForPragmaAttribute(AttrFactory) {}
void HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer,
                  Token &FirstToken) override;

/// A pool of attributes that were parsed in \#pragma clang attribute.
ParsedAttributes AttributesForPragmaAttribute;
259};

261}  // end namespace

263void Parser::initializePragmaHandlers() {
AlignHandler = llvm::make_unique<PragmaAlignHandler>();
PP.AddPragmaHandler(AlignHandler.get());

GCCVisibilityHandler = llvm::make_unique<PragmaGCCVisibilityHandler>();
PP.AddPragmaHandler("GCC", GCCVisibilityHandler.get());

OptionsHandler = llvm::make_unique<PragmaOptionsHandler>();
PP.AddPragmaHandler(OptionsHandler.get());

PackHandler = llvm::make_unique<PragmaPackHandler>();
PP.AddPragmaHandler(PackHandler.get());

MSStructHandler = llvm::make_unique<PragmaMSStructHandler>();
PP.AddPragmaHandler(MSStructHandler.get());

UnusedHandler = llvm::make_unique<PragmaUnusedHandler>();
PP.AddPragmaHandler(UnusedHandler.get());

WeakHandler = llvm::make_unique<PragmaWeakHandler>();
PP.AddPragmaHandler(WeakHandler.get());

RedefineExtnameHandler = llvm::make_unique<PragmaRedefineExtnameHandler>();
PP.AddPragmaHandler(RedefineExtnameHandler.get());

FPContractHandler = llvm::make_unique<PragmaFPContractHandler>();
PP.AddPragmaHandler("STDC", FPContractHandler.get());

STDCFENVHandler = llvm::make_unique<PragmaSTDC_FENV_ACCESSHandler>();
PP.AddPragmaHandler("STDC", STDCFENVHandler.get());

STDCCXLIMITHandler = llvm::make_unique<PragmaSTDC_CX_LIMITED_RANGEHandler>();
PP.AddPragmaHandler("STDC", STDCCXLIMITHandler.get());

STDCUnknownHandler = llvm::make_unique<PragmaSTDC_UnknownHandler>();
PP.AddPragmaHandler("STDC", STDCUnknownHandler.get());

PCSectionHandler = llvm::make_unique<PragmaClangSectionHandler>(Actions);
PP.AddPragmaHandler("clang", PCSectionHandler.get());

if (getLangOpts().OpenCL) {
  OpenCLExtensionHandler = llvm::make_unique<PragmaOpenCLExtensionHandler>();
  PP.AddPragmaHandler("OPENCL", OpenCLExtensionHandler.get());

  PP.AddPragmaHandler("OPENCL", FPContractHandler.get());
}
if (getLangOpts().OpenMP)
  OpenMPHandler = llvm::make_unique<PragmaOpenMPHandler>();
else
  OpenMPHandler = llvm::make_unique<PragmaNoOpenMPHandler>();
PP.AddPragmaHandler(OpenMPHandler.get());

if (getLangOpts().MicrosoftExt ||
    getTargetInfo().getTriple().isOSBinFormatELF()) {
  MSCommentHandler = llvm::make_unique<PragmaCommentHandler>(Actions);
  PP.AddPragmaHandler(MSCommentHandler.get());
}

if (getLangOpts().MicrosoftExt) {
  MSDetectMismatchHandler =
      llvm::make_unique<PragmaDetectMismatchHandler>(Actions);
  PP.AddPragmaHandler(MSDetectMismatchHandler.get());
  MSPointersToMembers = llvm::make_unique<PragmaMSPointersToMembers>();
  PP.AddPragmaHandler(MSPointersToMembers.get());
  MSVtorDisp = llvm::make_unique<PragmaMSVtorDisp>();
  PP.AddPragmaHandler(MSVtorDisp.get());
  MSInitSeg = llvm::make_unique<PragmaMSPragma>("init_seg");
  PP.AddPragmaHandler(MSInitSeg.get());
  MSDataSeg = llvm::make_unique<PragmaMSPragma>("data_seg");
  PP.AddPragmaHandler(MSDataSeg.get());
  MSBSSSeg = llvm::make_unique<PragmaMSPragma>("bss_seg");
  PP.AddPragmaHandler(MSBSSSeg.get());
  MSConstSeg = llvm::make_unique<PragmaMSPragma>("const_seg");
  PP.AddPragmaHandler(MSConstSeg.get());
  MSCodeSeg = llvm::make_unique<PragmaMSPragma>("code_seg");
  PP.AddPragmaHandler(MSCodeSeg.get());
  MSSection = llvm::make_unique<PragmaMSPragma>("section");
  PP.AddPragmaHandler(MSSection.get());
  MSRuntimeChecks = llvm::make_unique<PragmaMSRuntimeChecksHandler>();
  PP.AddPragmaHandler(MSRuntimeChecks.get());
  MSIntrinsic = llvm::make_unique<PragmaMSIntrinsicHandler>();
  PP.AddPragmaHandler(MSIntrinsic.get());
  MSOptimize = llvm::make_unique<PragmaMSOptimizeHandler>();
  PP.AddPragmaHandler(MSOptimize.get());
}

if (getLangOpts().CUDA) {
  CUDAForceHostDeviceHandler =
      llvm::make_unique<PragmaForceCUDAHostDeviceHandler>(Actions);
  PP.AddPragmaHandler("clang", CUDAForceHostDeviceHandler.get());
}

OptimizeHandler = llvm::make_unique<PragmaOptimizeHandler>(Actions);
PP.AddPragmaHandler("clang", OptimizeHandler.get());

LoopHintHandler = llvm::make_unique<PragmaLoopHintHandler>();
PP.AddPragmaHandler("clang", LoopHintHandler.get());

UnrollHintHandler = llvm::make_unique<PragmaUnrollHintHandler>("unroll");
PP.AddPragmaHandler(UnrollHintHandler.get());

NoUnrollHintHandler = llvm::make_unique<PragmaUnrollHintHandler>("nounroll");
PP.AddPragmaHandler(NoUnrollHintHandler.get());

UnrollAndJamHintHandler =
    llvm::make_unique<PragmaUnrollHintHandler>("unroll_and_jam");
PP.AddPragmaHandler(UnrollAndJamHintHandler.get());

NoUnrollAndJamHintHandler =
    llvm::make_unique<PragmaUnrollHintHandler>("nounroll_and_jam");
PP.AddPragmaHandler(NoUnrollAndJamHintHandler.get());

FPHandler = llvm::make_unique<PragmaFPHandler>();
PP.AddPragmaHandler("clang", FPHandler.get());

AttributePragmaHandler =
    llvm::make_unique<PragmaAttributeHandler>(AttrFactory);
PP.AddPragmaHandler("clang", AttributePragmaHandler.get());
381}

383void Parser::resetPragmaHandlers() {
// Remove the pragma handlers we installed.
PP.RemovePragmaHandler(AlignHandler.get());
AlignHandler.reset();
PP.RemovePragmaHandler("GCC", GCCVisibilityHandler.get());
GCCVisibilityHandler.reset();
PP.RemovePragmaHandler(OptionsHandler.get());
OptionsHandler.reset();
PP.RemovePragmaHandler(PackHandler.get());
PackHandler.reset();
PP.RemovePragmaHandler(MSStructHandler.get());
MSStructHandler.reset();
PP.RemovePragmaHandler(UnusedHandler.get());
UnusedHandler.reset();
PP.RemovePragmaHandler(WeakHandler.get());
WeakHandler.reset();
PP.RemovePragmaHandler(RedefineExtnameHandler.get());
RedefineExtnameHandler.reset();

if (getLangOpts().OpenCL) {
  PP.RemovePragmaHandler("OPENCL", OpenCLExtensionHandler.get());
  OpenCLExtensionHandler.reset();
  PP.RemovePragmaHandler("OPENCL", FPContractHandler.get());
}
PP.RemovePragmaHandler(OpenMPHandler.get());
OpenMPHandler.reset();

if (getLangOpts().MicrosoftExt ||
    getTargetInfo().getTriple().isOSBinFormatELF()) {
  PP.RemovePragmaHandler(MSCommentHandler.get());
  MSCommentHandler.reset();
}

PP.RemovePragmaHandler("clang", PCSectionHandler.get());
PCSectionHandler.reset();

if (getLangOpts().MicrosoftExt) {
  PP.RemovePragmaHandler(MSDetectMismatchHandler.get());
  MSDetectMismatchHandler.reset();
  PP.RemovePragmaHandler(MSPointersToMembers.get());
  MSPointersToMembers.reset();
  PP.RemovePragmaHandler(MSVtorDisp.get());
  MSVtorDisp.reset();
  PP.RemovePragmaHandler(MSInitSeg.get());
  MSInitSeg.reset();
  PP.RemovePragmaHandler(MSDataSeg.get());
  MSDataSeg.reset();
  PP.RemovePragmaHandler(MSBSSSeg.get());
  MSBSSSeg.reset();
  PP.RemovePragmaHandler(MSConstSeg.get());
  MSConstSeg.reset();
  PP.RemovePragmaHandler(MSCodeSeg.get());
  MSCodeSeg.reset();
  PP.RemovePragmaHandler(MSSection.get());
  MSSection.reset();
  PP.RemovePragmaHandler(MSRuntimeChecks.get());
  MSRuntimeChecks.reset();
  PP.RemovePragmaHandler(MSIntrinsic.get());
  MSIntrinsic.reset();
  PP.RemovePragmaHandler(MSOptimize.get());
  MSOptimize.reset();
}

if (getLangOpts().CUDA) {
  PP.RemovePragmaHandler("clang", CUDAForceHostDeviceHandler.get());
  CUDAForceHostDeviceHandler.reset();
}

PP.RemovePragmaHandler("STDC", FPContractHandler.get());
FPContractHandler.reset();

PP.RemovePragmaHandler("STDC", STDCFENVHandler.get());
STDCFENVHandler.reset();

PP.RemovePragmaHandler("STDC", STDCCXLIMITHandler.get());
STDCCXLIMITHandler.reset();

PP.RemovePragmaHandler("STDC", STDCUnknownHandler.get());
STDCUnknownHandler.reset();

PP.RemovePragmaHandler("clang", OptimizeHandler.get());
OptimizeHandler.reset();

PP.RemovePragmaHandler("clang", LoopHintHandler.get());
LoopHintHandler.reset();

PP.RemovePragmaHandler(UnrollHintHandler.get());
UnrollHintHandler.reset();

PP.RemovePragmaHandler(NoUnrollHintHandler.get());
NoUnrollHintHandler.reset();

PP.RemovePragmaHandler(UnrollAndJamHintHandler.get());
UnrollAndJamHintHandler.reset();

PP.RemovePragmaHandler(NoUnrollAndJamHintHandler.get());
NoUnrollAndJamHintHandler.reset();

PP.RemovePragmaHandler("clang", FPHandler.get());
FPHandler.reset();

PP.RemovePragmaHandler("clang", AttributePragmaHandler.get());
AttributePragmaHandler.reset();
486}

488/// Handle the annotation token produced for #pragma unused(...)
489///
490/// Each annot_pragma_unused is followed by the argument token so e.g.
491/// "#pragma unused(x,y)" becomes:
492/// annot_pragma_unused 'x' annot_pragma_unused 'y'
493void Parser::HandlePragmaUnused() {
assert(Tok.is(tok::annot_pragma_unused))((Tok.is(tok::annot_pragma_unused)) ? static_cast<void>
 (0) : __assert_fail ("Tok.is(tok::annot_pragma_unused)", "/build/llvm-toolchain-snapshot-8~svn350071/tools/clang/lib/Parse/ParsePragma.cpp"
, 494, __PRETTY_FUNCTION__));
SourceLocation UnusedLoc = ConsumeAnnotationToken();
Actions.ActOnPragmaUnused(Tok, getCurScope(), UnusedLoc);
ConsumeToken(); // The argument token.
498}

500void Parser::HandlePragmaVisibility() {
assert(Tok.is(tok::annot_pragma_vis))((Tok.is(tok::annot_pragma_vis)) ? static_cast<void> (0
) : __assert_fail ("Tok.is(tok::annot_pragma_vis)", "/build/llvm-toolchain-snapshot-8~svn350071/tools/clang/lib/Parse/ParsePragma.cpp"
, 501, __PRETTY_FUNCTION__));
const IdentifierInfo *VisType =
  static_cast<IdentifierInfo *>(Tok.getAnnotationValue());
SourceLocation VisLoc = ConsumeAnnotationToken();
Actions.ActOnPragmaVisibility(VisType, VisLoc);
506}

508namespace {
509struct PragmaPackInfo {
Sema::PragmaMsStackAction Action;
StringRef SlotLabel;
Token Alignment;
513};
514} // end anonymous namespace

516void Parser::HandlePragmaPack() {
assert(Tok.is(tok::annot_pragma_pack))((Tok.is(tok::annot_pragma_pack)) ? static_cast<void> (
0) : __assert_fail ("Tok.is(tok::annot_pragma_pack)", "/build/llvm-toolchain-snapshot-8~svn350071/tools/clang/lib/Parse/ParsePragma.cpp"
, 517, __PRETTY_FUNCTION__));
PragmaPackInfo *Info =
  static_cast<PragmaPackInfo *>(Tok.getAnnotationValue());
SourceLocation PragmaLoc = Tok.getLocation();
ExprResult Alignment;
if (Info->Alignment.is(tok::numeric_constant)) {
  Alignment = Actions.ActOnNumericConstant(Info->Alignment);
  if (Alignment.isInvalid()) {
    ConsumeAnnotationToken();
    return;
  }
}
Actions.ActOnPragmaPack(PragmaLoc, Info->Action, Info->SlotLabel,
                        Alignment.get());
// Consume the token after processing the pragma to enable pragma-specific
// #include warnings.
ConsumeAnnotationToken();
534}

536void Parser::HandlePragmaMSStruct() {
assert(Tok.is(tok::annot_pragma_msstruct))((Tok.is(tok::annot_pragma_msstruct)) ? static_cast<void>
 (0) : __assert_fail ("Tok.is(tok::annot_pragma_msstruct)", "/build/llvm-toolchain-snapshot-8~svn350071/tools/clang/lib/Parse/ParsePragma.cpp"
, 537, __PRETTY_FUNCTION__));
PragmaMSStructKind Kind = static_cast<PragmaMSStructKind>(
    reinterpret_cast<uintptr_t>(Tok.getAnnotationValue()));
Actions.ActOnPragmaMSStruct(Kind);
ConsumeAnnotationToken();
542}

544void Parser::HandlePragmaAlign() {
assert(Tok.is(tok::annot_pragma_align))((Tok.is(tok::annot_pragma_align)) ? static_cast<void> (
0) : __assert_fail ("Tok.is(tok::annot_pragma_align)", "/build/llvm-toolchain-snapshot-8~svn350071/tools/clang/lib/Parse/ParsePragma.cpp"
, 545, __PRETTY_FUNCTION__));
Sema::PragmaOptionsAlignKind Kind =
  static_cast<Sema::PragmaOptionsAlignKind>(
  reinterpret_cast<uintptr_t>(Tok.getAnnotationValue()));
Actions.ActOnPragmaOptionsAlign(Kind, Tok.getLocation());
// Consume the token after processing the pragma to enable pragma-specific
// #include warnings.
ConsumeAnnotationToken();
553}

555void Parser::HandlePragmaDump() {
assert(Tok.is(tok::annot_pragma_dump))((Tok.is(tok::annot_pragma_dump)) ? static_cast<void> (
0) : __assert_fail ("Tok.is(tok::annot_pragma_dump)", "/build/llvm-toolchain-snapshot-8~svn350071/tools/clang/lib/Parse/ParsePragma.cpp"
, 556, __PRETTY_FUNCTION__));
IdentifierInfo *II =
    reinterpret_cast<IdentifierInfo *>(Tok.getAnnotationValue());
Actions.ActOnPragmaDump(getCurScope(), Tok.getLocation(), II);
ConsumeAnnotationToken();
561}

563void Parser::HandlePragmaWeak() {
assert(Tok.is(tok::annot_pragma_weak))((Tok.is(tok::annot_pragma_weak)) ? static_cast<void> (
0) : __assert_fail ("Tok.is(tok::annot_pragma_weak)", "/build/llvm-toolchain-snapshot-8~svn350071/tools/clang/lib/Parse/ParsePragma.cpp"
, 564, __PRETTY_FUNCTION__));
SourceLocation PragmaLoc = ConsumeAnnotationToken();
Actions.ActOnPragmaWeakID(Tok.getIdentifierInfo(), PragmaLoc,
                          Tok.getLocation());
ConsumeToken(); // The weak name.
569}

571void Parser::HandlePragmaWeakAlias() {
assert(Tok.is(tok::annot_pragma_weakalias))((Tok.is(tok::annot_pragma_weakalias)) ? static_cast<void>
 (0) : __assert_fail ("Tok.is(tok::annot_pragma_weakalias)", "/build/llvm-toolchain-snapshot-8~svn350071/tools/clang/lib/Parse/ParsePragma.cpp"
, 572, __PRETTY_FUNCTION__));
SourceLocation PragmaLoc = ConsumeAnnotationToken();
IdentifierInfo *WeakName = Tok.getIdentifierInfo();
SourceLocation WeakNameLoc = Tok.getLocation();
ConsumeToken();
IdentifierInfo *AliasName = Tok.getIdentifierInfo();
SourceLocation AliasNameLoc = Tok.getLocation();
ConsumeToken();
Actions.ActOnPragmaWeakAlias(WeakName, AliasName, PragmaLoc,
                             WeakNameLoc, AliasNameLoc);

583}

585void Parser::HandlePragmaRedefineExtname() {
assert(Tok.is(tok::annot_pragma_redefine_extname))((Tok.is(tok::annot_pragma_redefine_extname)) ? static_cast<
void> (0) : __assert_fail ("Tok.is(tok::annot_pragma_redefine_extname)"
, "/build/llvm-toolchain-snapshot-8~svn350071/tools/clang/lib/Parse/ParsePragma.cpp"
, 586, __PRETTY_FUNCTION__));
SourceLocation RedefLoc = ConsumeAnnotationToken();
IdentifierInfo *RedefName = Tok.getIdentifierInfo();
SourceLocation RedefNameLoc = Tok.getLocation();
ConsumeToken();
IdentifierInfo *AliasName = Tok.getIdentifierInfo();
SourceLocation AliasNameLoc = Tok.getLocation();
ConsumeToken();
Actions.ActOnPragmaRedefineExtname(RedefName, AliasName, RedefLoc,
                                   RedefNameLoc, AliasNameLoc);
596}

598void Parser::HandlePragmaFPContract() {
assert(Tok.is(tok::annot_pragma_fp_contract))((Tok.is(tok::annot_pragma_fp_contract)) ? static_cast<void
> (0) : __assert_fail ("Tok.is(tok::annot_pragma_fp_contract)"
, "/build/llvm-toolchain-snapshot-8~svn350071/tools/clang/lib/Parse/ParsePragma.cpp"
, 599, __PRETTY_FUNCTION__));
tok::OnOffSwitch OOS =
  static_cast<tok::OnOffSwitch>(
  reinterpret_cast<uintptr_t>(Tok.getAnnotationValue()));

LangOptions::FPContractModeKind FPC;
switch (OOS) {
case tok::OOS_ON:
  FPC = LangOptions::FPC_On;
  break;
case tok::OOS_OFF:
  FPC = LangOptions::FPC_Off;
  break;
case tok::OOS_DEFAULT:
  FPC = getLangOpts().getDefaultFPContractMode();
  break;
}

Actions.ActOnPragmaFPContract(FPC);
ConsumeAnnotationToken();
619}

621void Parser::HandlePragmaFEnvAccess() {
assert(Tok.is(tok::annot_pragma_fenv_access))((Tok.is(tok::annot_pragma_fenv_access)) ? static_cast<void
> (0) : __assert_fail ("Tok.is(tok::annot_pragma_fenv_access)"
, "/build/llvm-toolchain-snapshot-8~svn350071/tools/clang/lib/Parse/ParsePragma.cpp"
, 622, __PRETTY_FUNCTION__));
tok::OnOffSwitch OOS =
  static_cast<tok::OnOffSwitch>(
  reinterpret_cast<uintptr_t>(Tok.getAnnotationValue()));

LangOptions::FEnvAccessModeKind FPC;
switch (OOS) {
case tok::OOS_ON:
  FPC = LangOptions::FEA_On;
  break;
case tok::OOS_OFF:
  FPC = LangOptions::FEA_Off;
  break;
case tok::OOS_DEFAULT: // FIXME: Add this cli option when it makes sense.
  FPC = LangOptions::FEA_Off;
  break;
}

Actions.ActOnPragmaFEnvAccess(FPC);
ConsumeAnnotationToken();
642}


645StmtResult Parser::HandlePragmaCaptured()
646{
assert(Tok.is(tok::annot_pragma_captured))((Tok.is(tok::annot_pragma_captured)) ? static_cast<void>
 (0) : __assert_fail ("Tok.is(tok::annot_pragma_captured)", "/build/llvm-toolchain-snapshot-8~svn350071/tools/clang/lib/Parse/ParsePragma.cpp"
, 647, __PRETTY_FUNCTION__));
ConsumeAnnotationToken();

if (Tok.isNot(tok::l_brace)) {
  PP.Diag(Tok, diag::err_expected) << tok::l_brace;
  return StmtError();
}

SourceLocation Loc = Tok.getLocation();

ParseScope CapturedRegionScope(this, Scope::FnScope | Scope::DeclScope |
                                         Scope::CompoundStmtScope);
Actions.ActOnCapturedRegionStart(Loc, getCurScope(), CR_Default,
                                 /*NumParams=*/1);

StmtResult R = ParseCompoundStatement();
CapturedRegionScope.Exit();

if (R.isInvalid()) {
  Actions.ActOnCapturedRegionError();
  return StmtError();
}

return Actions.ActOnCapturedRegionEnd(R.get());
671}

673namespace {
enum OpenCLExtState : char {
  Disable, Enable, Begin, End
};
typedef std::pair<const IdentifierInfo *, OpenCLExtState> OpenCLExtData;
678}

680void Parser::HandlePragmaOpenCLExtension() {
assert(Tok.is(tok::annot_pragma_opencl_extension))((Tok.is(tok::annot_pragma_opencl_extension)) ? static_cast<
void> (0) : __assert_fail ("Tok.is(tok::annot_pragma_opencl_extension)"
, "/build/llvm-toolchain-snapshot-8~svn350071/tools/clang/lib/Parse/ParsePragma.cpp"
, 681, __PRETTY_FUNCTION__));
OpenCLExtData *Data = static_cast<OpenCLExtData*>(Tok.getAnnotationValue());
auto State = Data->second;
auto Ident = Data->first;
SourceLocation NameLoc = Tok.getLocation();
ConsumeAnnotationToken();

auto &Opt = Actions.getOpenCLOptions();
auto Name = Ident->getName();
// OpenCL 1.1 9.1: "The all variant sets the behavior for all extensions,
// overriding all previously issued extension directives, but only if the
// behavior is set to disable."
if (Name == "all") {
  if (State == Disable) {
    Opt.disableAll();
    Opt.enableSupportedCore(getLangOpts().OpenCLVersion);
  } else {
    PP.Diag(NameLoc, diag::warn_pragma_expected_predicate) << 1;
  }
} else if (State == Begin) {
  if (!Opt.isKnown(Name) ||
      !Opt.isSupported(Name, getLangOpts().OpenCLVersion)) {
    Opt.support(Name);
  }
  Actions.setCurrentOpenCLExtension(Name);
} else if (State == End) {
  if (Name != Actions.getCurrentOpenCLExtension())
    PP.Diag(NameLoc, diag::warn_pragma_begin_end_mismatch);
  Actions.setCurrentOpenCLExtension("");
} else if (!Opt.isKnown(Name))
  PP.Diag(NameLoc, diag::warn_pragma_unknown_extension) << Ident;
else if (Opt.isSupportedExtension(Name, getLangOpts().OpenCLVersion))
  Opt.enable(Name, State == Enable);
else if (Opt.isSupportedCore(Name, getLangOpts().OpenCLVersion))
  PP.Diag(NameLoc, diag::warn_pragma_extension_is_core) << Ident;
else
  PP.Diag(NameLoc, diag::warn_pragma_unsupported_extension) << Ident;
718}

720void Parser::HandlePragmaMSPointersToMembers() {
assert(Tok.is(tok::annot_pragma_ms_pointers_to_members))((Tok.is(tok::annot_pragma_ms_pointers_to_members)) ? static_cast
<void> (0) : __assert_fail ("Tok.is(tok::annot_pragma_ms_pointers_to_members)"
, "/build/llvm-toolchain-snapshot-8~svn350071/tools/clang/lib/Parse/ParsePragma.cpp"
, 721, __PRETTY_FUNCTION__));
LangOptions::PragmaMSPointersToMembersKind RepresentationMethod =
    static_cast<LangOptions::PragmaMSPointersToMembersKind>(
        reinterpret_cast<uintptr_t>(Tok.getAnnotationValue()));
SourceLocation PragmaLoc = ConsumeAnnotationToken();
Actions.ActOnPragmaMSPointersToMembers(RepresentationMethod, PragmaLoc);
727}

729void Parser::HandlePragmaMSVtorDisp() {
assert(Tok.is(tok::annot_pragma_ms_vtordisp))((Tok.is(tok::annot_pragma_ms_vtordisp)) ? static_cast<void
> (0) : __assert_fail ("Tok.is(tok::annot_pragma_ms_vtordisp)"
, "/build/llvm-toolchain-snapshot-8~svn350071/tools/clang/lib/Parse/ParsePragma.cpp"
, 730, __PRETTY_FUNCTION__));
uintptr_t Value = reinterpret_cast<uintptr_t>(Tok.getAnnotationValue());
Sema::PragmaMsStackAction Action =
    static_cast<Sema::PragmaMsStackAction>((Value >> 16) & 0xFFFF);
MSVtorDispAttr::Mode Mode = MSVtorDispAttr::Mode(Value & 0xFFFF);
SourceLocation PragmaLoc = ConsumeAnnotationToken();
Actions.ActOnPragmaMSVtorDisp(Action, PragmaLoc, Mode);
737}

739void Parser::HandlePragmaMSPragma() {
assert(Tok.is(tok::annot_pragma_ms_pragma))((Tok.is(tok::annot_pragma_ms_pragma)) ? static_cast<void>
 (0) : __assert_fail ("Tok.is(tok::annot_pragma_ms_pragma)", "/build/llvm-toolchain-snapshot-8~svn350071/tools/clang/lib/Parse/ParsePragma.cpp"
, 740, __PRETTY_FUNCTION__));
// Grab the tokens out of the annotation and enter them into the stream.
auto TheTokens =
    (std::pair<std::unique_ptr<Token[]>, size_t> *)Tok.getAnnotationValue();
PP.EnterTokenStream(std::move(TheTokens->first), TheTokens->second, true);
SourceLocation PragmaLocation = ConsumeAnnotationToken();
assert(Tok.isAnyIdentifier())((Tok.isAnyIdentifier()) ? static_cast<void> (0) : __assert_fail
 ("Tok.isAnyIdentifier()", "/build/llvm-toolchain-snapshot-8~svn350071/tools/clang/lib/Parse/ParsePragma.cpp"
, 746, __PRETTY_FUNCTION__));
StringRef PragmaName = Tok.getIdentifierInfo()->getName();
PP.Lex(Tok); // pragma kind

// Figure out which #pragma we're dealing with.  The switch has no default
// because lex shouldn't emit the annotation token for unrecognized pragmas.
typedef bool (Parser::*PragmaHandler)(StringRef, SourceLocation);
PragmaHandler Handler = llvm::StringSwitch<PragmaHandler>(PragmaName)
  .Case("data_seg", &Parser::HandlePragmaMSSegment)
  .Case("bss_seg", &Parser::HandlePragmaMSSegment)
  .Case("const_seg", &Parser::HandlePragmaMSSegment)
  .Case("code_seg", &Parser::HandlePragmaMSSegment)
  .Case("section", &Parser::HandlePragmaMSSection)
  .Case("init_seg", &Parser::HandlePragmaMSInitSeg);

if (!(this->*Handler)(PragmaName, PragmaLocation)) {
  // Pragma handling failed, and has been diagnosed.  Slurp up the tokens
  // until eof (really end of line) to prevent follow-on errors.
  while (Tok.isNot(tok::eof))
    PP.Lex(Tok);
  PP.Lex(Tok);
}
768}

770bool Parser::HandlePragmaMSSection(StringRef PragmaName,
                                 SourceLocation PragmaLocation) {
if (Tok.isNot(tok::l_paren)) {
  PP.Diag(PragmaLocation, diag::warn_pragma_expected_lparen) << PragmaName;
  return false;
}
PP.Lex(Tok); // (
// Parsing code for pragma section
if (Tok.isNot(tok::string_literal)) {
  PP.Diag(PragmaLocation, diag::warn_pragma_expected_section_name)
      << PragmaName;
  return false;
}
ExprResult StringResult = ParseStringLiteralExpression();
if (StringResult.isInvalid())
  return false; // Already diagnosed.
StringLiteral *SegmentName = cast<StringLiteral>(StringResult.get());
if (SegmentName->getCharByteWidth() != 1) {
  PP.Diag(PragmaLocation, diag::warn_pragma_expected_non_wide_string)
      << PragmaName;
  return false;
}
int SectionFlags = ASTContext::PSF_Read;
bool SectionFlagsAreDefault = true;
while (Tok.is(tok::comma)) {
  PP.Lex(Tok); // ,
  // Ignore "long" and "short".
  // They are undocumented, but widely used, section attributes which appear
  // to do nothing.
  if (Tok.is(tok::kw_long) || Tok.is(tok::kw_short)) {
    PP.Lex(Tok); // long/short
    continue;
  }

  if (!Tok.isAnyIdentifier()) {
    PP.Diag(PragmaLocation, diag::warn_pragma_expected_action_or_r_paren)
        << PragmaName;
    return false;
  }
  ASTContext::PragmaSectionFlag Flag =
    llvm::StringSwitch<ASTContext::PragmaSectionFlag>(
    Tok.getIdentifierInfo()->getName())
    .Case("read", ASTContext::PSF_Read)
    .Case("write", ASTContext::PSF_Write)
    .Case("execute", ASTContext::PSF_Execute)
    .Case("shared", ASTContext::PSF_Invalid)
    .Case("nopage", ASTContext::PSF_Invalid)
    .Case("nocache", ASTContext::PSF_Invalid)
    .Case("discard", ASTContext::PSF_Invalid)
    .Case("remove", ASTContext::PSF_Invalid)
    .Default(ASTContext::PSF_None);
  if (Flag == ASTContext::PSF_None || Flag == ASTContext::PSF_Invalid) {
    PP.Diag(PragmaLocation, Flag == ASTContext::PSF_None
                                ? diag::warn_pragma_invalid_specific_action
                                : diag::warn_pragma_unsupported_action)
        << PragmaName << Tok.getIdentifierInfo()->getName();
    return false;
  }
  SectionFlags |= Flag;
  SectionFlagsAreDefault = false;
  PP.Lex(Tok); // Identifier
}
// If no section attributes are specified, the section will be marked as
// read/write.
if (SectionFlagsAreDefault)
  SectionFlags |= ASTContext::PSF_Write;
if (Tok.isNot(tok::r_paren)) {
  PP.Diag(PragmaLocation, diag::warn_pragma_expected_rparen) << PragmaName;
  return false;
}
PP.Lex(Tok); // )
if (Tok.isNot(tok::eof)) {
  PP.Diag(PragmaLocation, diag::warn_pragma_extra_tokens_at_eol)
      << PragmaName;
  return false;
}
PP.Lex(Tok); // eof
Actions.ActOnPragmaMSSection(PragmaLocation, SectionFlags, SegmentName);
return true;
849}

851bool Parser::HandlePragmaMSSegment(StringRef PragmaName,
                                 SourceLocation PragmaLocation) {
if (Tok.isNot(tok::l_paren)) {
  PP.Diag(PragmaLocation, diag::warn_pragma_expected_lparen) << PragmaName;
  return false;
}
PP.Lex(Tok); // (
Sema::PragmaMsStackAction Action = Sema::PSK_Reset;
StringRef SlotLabel;
if (Tok.isAnyIdentifier()) {
  StringRef PushPop = Tok.getIdentifierInfo()->getName();
  if (PushPop == "push")
    Action = Sema::PSK_Push;
  else if (PushPop == "pop")
    Action = Sema::PSK_Pop;
  else {
    PP.Diag(PragmaLocation,
            diag::warn_pragma_expected_section_push_pop_or_name)
        << PragmaName;
    return false;
  }
  if (Action != Sema::PSK_Reset) {
    PP.Lex(Tok); // push | pop
    if (Tok.is(tok::comma)) {
      PP.Lex(Tok); // ,
      // If we've got a comma, we either need a label or a string.
      if (Tok.isAnyIdentifier()) {
        SlotLabel = Tok.getIdentifierInfo()->getName();
        PP.Lex(Tok); // identifier
        if (Tok.is(tok::comma))
          PP.Lex(Tok);
        else if (Tok.isNot(tok::r_paren)) {
          PP.Diag(PragmaLocation, diag::warn_pragma_expected_punc)
              << PragmaName;
          return false;
        }
      }
    } else if (Tok.isNot(tok::r_paren)) {
      PP.Diag(PragmaLocation, diag::warn_pragma_expected_punc) << PragmaName;
      return false;
    }
  }
}
// Grab the string literal for our section name.
StringLiteral *SegmentName = nullptr;
if (Tok.isNot(tok::r_paren)) {
  if (Tok.isNot(tok::string_literal)) {
    unsigned DiagID = Action != Sema::PSK_Reset ? !SlotLabel.empty() ?
        diag::warn_pragma_expected_section_name :
        diag::warn_pragma_expected_section_label_or_name :
        diag::warn_pragma_expected_section_push_pop_or_name;
    PP.Diag(PragmaLocation, DiagID) << PragmaName;
    return false;
  }
  ExprResult StringResult = ParseStringLiteralExpression();
  if (StringResult.isInvalid())
    return false; // Already diagnosed.
  SegmentName = cast<StringLiteral>(StringResult.get());
  if (SegmentName->getCharByteWidth() != 1) {
    PP.Diag(PragmaLocation, diag::warn_pragma_expected_non_wide_string)
        << PragmaName;
    return false;
  }
  // Setting section "" has no effect
  if (SegmentName->getLength())
    Action = (Sema::PragmaMsStackAction)(Action | Sema::PSK_Set);
}
if (Tok.isNot(tok::r_paren)) {
  PP.Diag(PragmaLocation, diag::warn_pragma_expected_rparen) << PragmaName;
  return false;
}
PP.Lex(Tok); // )
if (Tok.isNot(tok::eof)) {
  PP.Diag(PragmaLocation, diag::warn_pragma_extra_tokens_at_eol)
      << PragmaName;
  return false;
}
PP.Lex(Tok); // eof
Actions.ActOnPragmaMSSeg(PragmaLocation, Action, SlotLabel,
                         SegmentName, PragmaName);
return true;
932}

934// #pragma init_seg({ compiler | lib | user | "section-name" [, func-name]} )
935bool Parser::HandlePragmaMSInitSeg(StringRef PragmaName,
                                 SourceLocation PragmaLocation) {
if (getTargetInfo().getTriple().getEnvironment() != llvm::Triple::MSVC) {
  PP.Diag(PragmaLocation, diag::warn_pragma_init_seg_unsupported_target);
  return false;
}

if (ExpectAndConsume(tok::l_paren, diag::warn_pragma_expected_lparen,
                     PragmaName))
  return false;

// Parse either the known section names or the string section name.
StringLiteral *SegmentName = nullptr;
if (Tok.isAnyIdentifier()) {
  auto *II = Tok.getIdentifierInfo();
  StringRef Section = llvm::StringSwitch<StringRef>(II->getName())
                          .Case("compiler", "\".CRT$XCC\"")
                          .Case("lib", "\".CRT$XCL\"")
                          .Case("user", "\".CRT$XCU\"")
                          .Default("");

  if (!Section.empty()) {
    // Pretend the user wrote the appropriate string literal here.
    Token Toks[1];
    Toks[0].startToken();
    Toks[0].setKind(tok::string_literal);
    Toks[0].setLocation(Tok.getLocation());
    Toks[0].setLiteralData(Section.data());
    Toks[0].setLength(Section.size());
    SegmentName =
        cast<StringLiteral>(Actions.ActOnStringLiteral(Toks, nullptr).get());
    PP.Lex(Tok);
  }
} else if (Tok.is(tok::string_literal)) {
  ExprResult StringResult = ParseStringLiteralExpression();
  if (StringResult.isInvalid())
    return false;
  SegmentName = cast<StringLiteral>(StringResult.get());
  if (SegmentName->getCharByteWidth() != 1) {
    PP.Diag(PragmaLocation, diag::warn_pragma_expected_non_wide_string)
        << PragmaName;
    return false;
  }
  // FIXME: Add support for the '[, func-name]' part of the pragma.
}

if (!SegmentName) {
  PP.Diag(PragmaLocation, diag::warn_pragma_expected_init_seg) << PragmaName;
  return false;
}

if (ExpectAndConsume(tok::r_paren, diag::warn_pragma_expected_rparen,
                     PragmaName) ||
    ExpectAndConsume(tok::eof, diag::warn_pragma_extra_tokens_at_eol,
                     PragmaName))
  return false;

Actions.ActOnPragmaMSInitSeg(PragmaLocation, SegmentName);
return true;
994}

996namespace {
997struct PragmaLoopHintInfo {
Token PragmaName;
Token Option;
ArrayRef<Token> Toks;
1001};
1002} // end anonymous namespace

1004static std::string PragmaLoopHintString(Token PragmaName, Token Option) {
std::string PragmaString;
if (PragmaName.getIdentifierInfo()->getName() == "loop") {
  PragmaString = "clang loop ";
  PragmaString += Option.getIdentifierInfo()->getName();
} else if (PragmaName.getIdentifierInfo()->getName() == "unroll_and_jam") {
  PragmaString = "unroll_and_jam";
} else {
  assert(PragmaName.getIdentifierInfo()->getName() == "unroll" &&((PragmaName.getIdentifierInfo()->getName() == "unroll" &&
 "Unexpected pragma name") ? static_cast<void> (0) : __assert_fail
 ("PragmaName.getIdentifierInfo()->getName() == \"unroll\" && \"Unexpected pragma name\""
, "/build/llvm-toolchain-snapshot-8~svn350071/tools/clang/lib/Parse/ParsePragma.cpp"
, 1013, __PRETTY_FUNCTION__))
         "Unexpected pragma name")((PragmaName.getIdentifierInfo()->getName() == "unroll" &&
 "Unexpected pragma name") ? static_cast<void> (0) : __assert_fail
 ("PragmaName.getIdentifierInfo()->getName() == \"unroll\" && \"Unexpected pragma name\""
, "/build/llvm-toolchain-snapshot-8~svn350071/tools/clang/lib/Parse/ParsePragma.cpp"
, 1013, __PRETTY_FUNCTION__));
  PragmaString = "unroll";
}
return PragmaString;
1017}

1019bool Parser::HandlePragmaLoopHint(LoopHint &Hint) {
assert(Tok.is(tok::annot_pragma_loop_hint))((Tok.is(tok::annot_pragma_loop_hint)) ? static_cast<void>
 (0) : __assert_fail ("Tok.is(tok::annot_pragma_loop_hint)", "/build/llvm-toolchain-snapshot-8~svn350071/tools/clang/lib/Parse/ParsePragma.cpp"
, 1020, __PRETTY_FUNCTION__));
PragmaLoopHintInfo *Info =
    static_cast<PragmaLoopHintInfo *>(Tok.getAnnotationValue());

IdentifierInfo *PragmaNameInfo = Info->PragmaName.getIdentifierInfo();
Hint.PragmaNameLoc = IdentifierLoc::create(
    Actions.Context, Info->PragmaName.getLocation(), PragmaNameInfo);

// It is possible that the loop hint has no option identifier, such as
// #pragma unroll(4).
IdentifierInfo *OptionInfo = Info->Option.is(tok::identifier)
                                 ? Info->Option.getIdentifierInfo()
                                 : nullptr;
Hint.OptionLoc = IdentifierLoc::create(
    Actions.Context, Info->Option.getLocation(), OptionInfo);

llvm::ArrayRef<Token> Toks = Info->Toks;

// Return a valid hint if pragma unroll or nounroll were specified
// without an argument.
bool PragmaUnroll = PragmaNameInfo->getName() == "unroll";
bool PragmaNoUnroll = PragmaNameInfo->getName() == "nounroll";
bool PragmaUnrollAndJam = PragmaNameInfo->getName() == "unroll_and_jam";
bool PragmaNoUnrollAndJam = PragmaNameInfo->getName() == "nounroll_and_jam";
if (Toks.empty() && (PragmaUnroll || PragmaNoUnroll || PragmaUnrollAndJam ||
                     PragmaNoUnrollAndJam)) {
  ConsumeAnnotationToken();
  Hint.Range = Info->PragmaName.getLocation();
  return true;
}

// The constant expression is always followed by an eof token, which increases
// the TokSize by 1.
assert(!Toks.empty() &&((!Toks.empty() && "PragmaLoopHintInfo::Toks must contain at least one token."
) ? static_cast<void> (0) : __assert_fail ("!Toks.empty() && \"PragmaLoopHintInfo::Toks must contain at least one token.\""
, "/build/llvm-toolchain-snapshot-8~svn350071/tools/clang/lib/Parse/ParsePragma.cpp"
, 1054, __PRETTY_FUNCTION__))
       "PragmaLoopHintInfo::Toks must contain at least one token.")((!Toks.empty() && "PragmaLoopHintInfo::Toks must contain at least one token."
) ? static_cast<void> (0) : __assert_fail ("!Toks.empty() && \"PragmaLoopHintInfo::Toks must contain at least one token.\""
, "/build/llvm-toolchain-snapshot-8~svn350071/tools/clang/lib/Parse/ParsePragma.cpp"
, 1054, __PRETTY_FUNCTION__));

// If no option is specified the argument is assumed to be a constant expr.
bool OptionUnroll = false;
bool OptionUnrollAndJam = false;
bool OptionDistribute = false;
bool StateOption = false;
if (OptionInfo) { // Pragma Unroll does not specify an option.
  OptionUnroll = OptionInfo->isStr("unroll");
  OptionUnrollAndJam = OptionInfo->isStr("unroll_and_jam");
  OptionDistribute = OptionInfo->isStr("distribute");
  StateOption = llvm::StringSwitch<bool>(OptionInfo->getName())
                    .Case("vectorize", true)
                    .Case("interleave", true)
                    .Default(false) ||
                OptionUnroll || OptionUnrollAndJam || OptionDistribute;
}

bool AssumeSafetyArg =
    !OptionUnroll && !OptionUnrollAndJam && !OptionDistribute;
// Verify loop hint has an argument.
if (Toks[0].is(tok::eof)) {
  ConsumeAnnotationToken();
  Diag(Toks[0].getLocation(), diag::err_pragma_loop_missing_argument)
      << /*StateArgument=*/StateOption
      << /*FullKeyword=*/(OptionUnroll || OptionUnrollAndJam)
      << /*AssumeSafetyKeyword=*/AssumeSafetyArg;
  return false;
}

// Validate the argument.
if (StateOption) {
  ConsumeAnnotationToken();
  SourceLocation StateLoc = Toks[0].getLocation();
  IdentifierInfo *StateInfo = Toks[0].getIdentifierInfo();

  bool Valid =
      StateInfo && llvm::StringSwitch<bool>(StateInfo->getName())
                       .Cases("enable", "disable", true)
                       .Case("full", OptionUnroll || OptionUnrollAndJam)
                       .Case("assume_safety", AssumeSafetyArg)
                       .Default(false);
  if (!Valid) {
    Diag(Toks[0].getLocation(), diag::err_pragma_invalid_keyword)
        << /*FullKeyword=*/(OptionUnroll || OptionUnrollAndJam)
        << /*AssumeSafetyKeyword=*/AssumeSafetyArg;
    return false;
  }
  if (Toks.size() > 2)
    Diag(Tok.getLocation(), diag::warn_pragma_extra_tokens_at_eol)
        << PragmaLoopHintString(Info->PragmaName, Info->Option);
  Hint.StateLoc = IdentifierLoc::create(Actions.Context, StateLoc, StateInfo);
} else {
  // Enter constant expression including eof terminator into token stream.
  PP.EnterTokenStream(Toks, /*DisableMacroExpansion=*/false);
  ConsumeAnnotationToken();

  ExprResult R = ParseConstantExpression();

  // Tokens following an error in an ill-formed constant expression will
  // remain in the token stream and must be removed.
  if (Tok.isNot(tok::eof)) {
    Diag(Tok.getLocation(), diag::warn_pragma_extra_tokens_at_eol)
        << PragmaLoopHintString(Info->PragmaName, Info->Option);
    while (Tok.isNot(tok::eof))
      ConsumeAnyToken();
  }

  ConsumeToken(); // Consume the constant expression eof terminator.

  if (R.isInvalid() ||
      Actions.CheckLoopHintExpr(R.get(), Toks[0].getLocation()))
    return false;

  // Argument is a constant expression with an integer type.
  Hint.ValueExpr = R.get();
}

Hint.Range = SourceRange(Info->PragmaName.getLocation(),
                         Info->Toks.back().getLocation());
return true;
1135}

1137namespace {
1138struct PragmaAttributeInfo {
enum ActionType { Push, Pop, Attribute };
ParsedAttributes &Attributes;
ActionType Action;
const IdentifierInfo *Namespace = nullptr;
ArrayRef<Token> Tokens;

PragmaAttributeInfo(ParsedAttributes &Attributes) : Attributes(Attributes) {}
1146};

1148#include "clang/Parse/AttrSubMatchRulesParserStringSwitches.inc"

1150} // end anonymous namespace

1152static StringRef getIdentifier(const Token &Tok) {
if (Tok.is(tok::identifier))
  return Tok.getIdentifierInfo()->getName();
const char *S = tok::getKeywordSpelling(Tok.getKind());
if (!S)
  return "";
return S;
1159}

1161static bool isAbstractAttrMatcherRule(attr::SubjectMatchRule Rule) {
using namespace attr;
switch (Rule) {
1164#define ATTR_MATCH_RULE(Value, Spelling, IsAbstract)                           \
case Value:                                                                  \
  return IsAbstract;
1167#include "clang/Basic/AttrSubMatchRulesList.inc"
}
llvm_unreachable("Invalid attribute subject match rule")::llvm::llvm_unreachable_internal("Invalid attribute subject match rule"
, "/build/llvm-toolchain-snapshot-8~svn350071/tools/clang/lib/Parse/ParsePragma.cpp"
, 1169);
return false;
1171}

1173static void diagnoseExpectedAttributeSubjectSubRule(
  Parser &PRef, attr::SubjectMatchRule PrimaryRule, StringRef PrimaryRuleName,
  SourceLocation SubRuleLoc) {
auto Diagnostic =
    PRef.Diag(SubRuleLoc,
              diag::err_pragma_attribute_expected_subject_sub_identifier)
    << PrimaryRuleName;
if (const char *SubRules = validAttributeSubjectMatchSubRules(PrimaryRule))
  Diagnostic << /*SubRulesSupported=*/1 << SubRules;
else
  Diagnostic << /*SubRulesSupported=*/0;
1184}

1186static void diagnoseUnknownAttributeSubjectSubRule(
  Parser &PRef, attr::SubjectMatchRule PrimaryRule, StringRef PrimaryRuleName,
  StringRef SubRuleName, SourceLocation SubRuleLoc) {

auto Diagnostic =
    PRef.Diag(SubRuleLoc, diag::err_pragma_attribute_unknown_subject_sub_rule)
    << SubRuleName << PrimaryRuleName;
if (const char *SubRules = validAttributeSubjectMatchSubRules(PrimaryRule))
  Diagnostic << /*SubRulesSupported=*/1 << SubRules;
else
  Diagnostic << /*SubRulesSupported=*/0;
1197}

1199bool Parser::ParsePragmaAttributeSubjectMatchRuleSet(
  attr::ParsedSubjectMatchRuleSet &SubjectMatchRules, SourceLocation &AnyLoc,
  SourceLocation &LastMatchRuleEndLoc) {
bool IsAny = false;
BalancedDelimiterTracker AnyParens(*this, tok::l_paren);
if (getIdentifier(Tok) == "any") {
  AnyLoc = ConsumeToken();
  IsAny = true;
  if (AnyParens.expectAndConsume())
    return true;
}

do {
  // Parse the subject matcher rule.
  StringRef Name = getIdentifier(Tok);
  if (Name.empty()) {
    Diag(Tok, diag::err_pragma_attribute_expected_subject_identifier);
    return true;
  }
  std::pair<Optional<attr::SubjectMatchRule>,
            Optional<attr::SubjectMatchRule> (*)(StringRef, bool)>
      Rule = isAttributeSubjectMatchRule(Name);
  if (!Rule.first) {
    Diag(Tok, diag::err_pragma_attribute_unknown_subject_rule) << Name;
    return true;
  }
  attr::SubjectMatchRule PrimaryRule = *Rule.first;
  SourceLocation RuleLoc = ConsumeToken();

  BalancedDelimiterTracker Parens(*this, tok::l_paren);
  if (isAbstractAttrMatcherRule(PrimaryRule)) {
    if (Parens.expectAndConsume())
      return true;
  } else if (Parens.consumeOpen()) {
    if (!SubjectMatchRules
             .insert(
                 std::make_pair(PrimaryRule, SourceRange(RuleLoc, RuleLoc)))
             .second)
      Diag(RuleLoc, diag::err_pragma_attribute_duplicate_subject)
          << Name
          << FixItHint::CreateRemoval(SourceRange(
                 RuleLoc, Tok.is(tok::comma) ? Tok.getLocation() : RuleLoc));
    LastMatchRuleEndLoc = RuleLoc;
    continue;
  }

  // Parse the sub-rules.
  StringRef SubRuleName = getIdentifier(Tok);
  if (SubRuleName.empty()) {
    diagnoseExpectedAttributeSubjectSubRule(*this, PrimaryRule, Name,
                                            Tok.getLocation());
    return true;
  }
  attr::SubjectMatchRule SubRule;
  if (SubRuleName == "unless") {
    SourceLocation SubRuleLoc = ConsumeToken();
    BalancedDelimiterTracker Parens(*this, tok::l_paren);
    if (Parens.expectAndConsume())
      return true;
    SubRuleName = getIdentifier(Tok);
    if (SubRuleName.empty()) {
      diagnoseExpectedAttributeSubjectSubRule(*this, PrimaryRule, Name,
                                              SubRuleLoc);
      return true;
    }
    auto SubRuleOrNone = Rule.second(SubRuleName, /*IsUnless=*/true);
    if (!SubRuleOrNone) {
      std::string SubRuleUnlessName = "unless(" + SubRuleName.str() + ")";
      diagnoseUnknownAttributeSubjectSubRule(*this, PrimaryRule, Name,
                                             SubRuleUnlessName, SubRuleLoc);
      return true;
    }
    SubRule = *SubRuleOrNone;
    ConsumeToken();
    if (Parens.consumeClose())
      return true;
  } else {
    auto SubRuleOrNone = Rule.second(SubRuleName, /*IsUnless=*/false);
    if (!SubRuleOrNone) {
      diagnoseUnknownAttributeSubjectSubRule(*this, PrimaryRule, Name,
                                             SubRuleName, Tok.getLocation());
      return true;
    }
    SubRule = *SubRuleOrNone;
    ConsumeToken();
  }
  SourceLocation RuleEndLoc = Tok.getLocation();
  LastMatchRuleEndLoc = RuleEndLoc;
  if (Parens.consumeClose())
    return true;
  if (!SubjectMatchRules
           .insert(std::make_pair(SubRule, SourceRange(RuleLoc, RuleEndLoc)))
           .second) {
    Diag(RuleLoc, diag::err_pragma_attribute_duplicate_subject)
        << attr::getSubjectMatchRuleSpelling(SubRule)
        << FixItHint::CreateRemoval(SourceRange(
               RuleLoc, Tok.is(tok::comma) ? Tok.getLocation() : RuleEndLoc));
    continue;
  }
} while (IsAny && TryConsumeToken(tok::comma));

if (IsAny)
  if (AnyParens.consumeClose())
    return true;

return false;
1305}

1307namespace {

1309/// Describes the stage at which attribute subject rule parsing was interrupted.
1310enum class MissingAttributeSubjectRulesRecoveryPoint {
Comma,
ApplyTo,
Equals,
Any,
None,
1316};

1318MissingAttributeSubjectRulesRecoveryPoint
1319getAttributeSubjectRulesRecoveryPointForToken(const Token &Tok) {
if (const auto *II = Tok.getIdentifierInfo()) {
  if (II->isStr("apply_to"))
    return MissingAttributeSubjectRulesRecoveryPoint::ApplyTo;
  if (II->isStr("any"))
    return MissingAttributeSubjectRulesRecoveryPoint::Any;
}
if (Tok.is(tok::equal))
  return MissingAttributeSubjectRulesRecoveryPoint::Equals;
return MissingAttributeSubjectRulesRecoveryPoint::None;
1329}

1331/// Creates a diagnostic for the attribute subject rule parsing diagnostic that
1332/// suggests the possible attribute subject rules in a fix-it together with
1333/// any other missing tokens.
1334DiagnosticBuilder createExpectedAttributeSubjectRulesTokenDiagnostic(
  unsigned DiagID, ParsedAttr &Attribute,
  MissingAttributeSubjectRulesRecoveryPoint Point, Parser &PRef) {
SourceLocation Loc = PRef.getEndOfPreviousToken();
if (Loc.isInvalid())
  Loc = PRef.getCurToken().getLocation();
auto Diagnostic = PRef.Diag(Loc, DiagID);
std::string FixIt;
MissingAttributeSubjectRulesRecoveryPoint EndPoint =
    getAttributeSubjectRulesRecoveryPointForToken(PRef.getCurToken());
if (Point == MissingAttributeSubjectRulesRecoveryPoint::Comma)
  FixIt = ", ";
if (Point <= MissingAttributeSubjectRulesRecoveryPoint::ApplyTo &&
    EndPoint > MissingAttributeSubjectRulesRecoveryPoint::ApplyTo)
  FixIt += "apply_to";
if (Point <= MissingAttributeSubjectRulesRecoveryPoint::Equals &&
    EndPoint > MissingAttributeSubjectRulesRecoveryPoint::Equals)
  FixIt += " = ";
SourceRange FixItRange(Loc);
if (EndPoint == MissingAttributeSubjectRulesRecoveryPoint::None) {
  // Gather the subject match rules that are supported by the attribute.
  SmallVector<std::pair<attr::SubjectMatchRule, bool>, 4> SubjectMatchRuleSet;
  Attribute.getMatchRules(PRef.getLangOpts(), SubjectMatchRuleSet);
  if (SubjectMatchRuleSet.empty()) {
    // FIXME: We can emit a "fix-it" with a subject list placeholder when
    // placeholders will be supported by the fix-its.
    return Diagnostic;
  }
  FixIt += "any(";
  bool NeedsComma = false;
  for (const auto &I : SubjectMatchRuleSet) {
    // Ensure that the missing rule is reported in the fix-it only when it's
    // supported in the current language mode.
    if (!I.second)
      continue;
    if (NeedsComma)
      FixIt += ", ";
    else
      NeedsComma = true;
    FixIt += attr::getSubjectMatchRuleSpelling(I.first);
  }
  FixIt += ")";
  // Check if we need to remove the range
  PRef.SkipUntil(tok::eof, Parser::StopBeforeMatch);
  FixItRange.setEnd(PRef.getCurToken().getLocation());
}
if (FixItRange.getBegin() == FixItRange.getEnd())
  Diagnostic << FixItHint::CreateInsertion(FixItRange.getBegin(), FixIt);
else
  Diagnostic << FixItHint::CreateReplacement(
      CharSourceRange::getCharRange(FixItRange), FixIt);
return Diagnostic;
1386}

1388} // end anonymous namespace

1390void Parser::HandlePragmaAttribute() {
assert(Tok.is(tok::annot_pragma_attribute) &&((Tok.is(tok::annot_pragma_attribute) && "Expected #pragma attribute annotation token"
) ? static_cast<void> (0) : __assert_fail ("Tok.is(tok::annot_pragma_attribute) && \"Expected #pragma attribute annotation token\""
, "/build/llvm-toolchain-snapshot-8~svn350071/tools/clang/lib/Parse/ParsePragma.cpp"
, 1392, __PRETTY_FUNCTION__))
       "Expected #pragma attribute annotation token")((Tok.is(tok::annot_pragma_attribute) && "Expected #pragma attribute annotation token"
) ? static_cast<void> (0) : __assert_fail ("Tok.is(tok::annot_pragma_attribute) && \"Expected #pragma attribute annotation token\""
, "/build/llvm-toolchain-snapshot-8~svn350071/tools/clang/lib/Parse/ParsePragma.cpp"
, 1392, __PRETTY_FUNCTION__));
SourceLocation PragmaLoc = Tok.getLocation();
auto *Info = static_cast<PragmaAttributeInfo *>(Tok.getAnnotationValue());
if (Info->Action == PragmaAttributeInfo::Pop) {
  ConsumeAnnotationToken();
  Actions.ActOnPragmaAttributePop(PragmaLoc, Info->Namespace);
  return;
}
// Parse the actual attribute with its arguments.
assert((Info->Action == PragmaAttributeInfo::Push ||(((Info->Action == PragmaAttributeInfo::Push || Info->Action
 == PragmaAttributeInfo::Attribute) && "Unexpected #pragma attribute command"
) ? static_cast<void> (0) : __assert_fail ("(Info->Action == PragmaAttributeInfo::Push || Info->Action == PragmaAttributeInfo::Attribute) && \"Unexpected #pragma attribute command\""
, "/build/llvm-toolchain-snapshot-8~svn350071/tools/clang/lib/Parse/ParsePragma.cpp"
, 1403, __PRETTY_FUNCTION__))
        Info->Action == PragmaAttributeInfo::Attribute) &&(((Info->Action == PragmaAttributeInfo::Push || Info->Action
 == PragmaAttributeInfo::Attribute) && "Unexpected #pragma attribute command"
) ? static_cast<void> (0) : __assert_fail ("(Info->Action == PragmaAttributeInfo::Push || Info->Action == PragmaAttributeInfo::Attribute) && \"Unexpected #pragma attribute command\""
, "/build/llvm-toolchain-snapshot-8~svn350071/tools/clang/lib/Parse/ParsePragma.cpp"
, 1403, __PRETTY_FUNCTION__))
       "Unexpected #pragma attribute command")(((Info->Action == PragmaAttributeInfo::Push || Info->Action
 == PragmaAttributeInfo::Attribute) && "Unexpected #pragma attribute command"
) ? static_cast<void> (0) : __assert_fail ("(Info->Action == PragmaAttributeInfo::Push || Info->Action == PragmaAttributeInfo::Attribute) && \"Unexpected #pragma attribute command\""
, "/build/llvm-toolchain-snapshot-8~svn350071/tools/clang/lib/Parse/ParsePragma.cpp"
, 1403, __PRETTY_FUNCTION__));

if (Info->Action == PragmaAttributeInfo::Push && Info->Tokens.empty()) {
  ConsumeAnnotationToken();
  Actions.ActOnPragmaAttributeEmptyPush(PragmaLoc, Info->Namespace);
  return;
}

PP.EnterTokenStream(Info->Tokens, /*DisableMacroExpansion=*/false);
ConsumeAnnotationToken();

ParsedAttributes &Attrs = Info->Attributes;
Attrs.clearListOnly();

auto SkipToEnd = [this]() {
  SkipUntil(tok::eof, StopBeforeMatch);
  ConsumeToken();
};

if (Tok.is(tok::l_square) && NextToken().is(tok::l_square)) {
  // Parse the CXX11 style attribute.
  ParseCXX11AttributeSpecifier(Attrs);
} else if (Tok.is(tok::kw___attribute)) {
  ConsumeToken();
  if (ExpectAndConsume(tok::l_paren, diag::err_expected_lparen_after,
                       "attribute"))
    return SkipToEnd();
  if (ExpectAndConsume(tok::l_paren, diag::err_expected_lparen_after, "("))
    return SkipToEnd();

  if (Tok.isNot(tok::identifier)) {
    Diag(Tok, diag::err_pragma_attribute_expected_attribute_name);
    SkipToEnd();
    return;
  }
  IdentifierInfo *AttrName = Tok.getIdentifierInfo();
  SourceLocation AttrNameLoc = ConsumeToken();

  if (Tok.isNot(tok::l_paren))
    Attrs.addNew(AttrName, AttrNameLoc, nullptr, AttrNameLoc, nullptr, 0,
                 ParsedAttr::AS_GNU);
  else
    ParseGNUAttributeArgs(AttrName, AttrNameLoc, Attrs, /*EndLoc=*/nullptr,
                          /*ScopeName=*/nullptr,
                          /*ScopeLoc=*/SourceLocation(), ParsedAttr::AS_GNU,
                          /*Declarator=*/nullptr);

  if (ExpectAndConsume(tok::r_paren))
    return SkipToEnd();
  if (ExpectAndConsume(tok::r_paren))
    return SkipToEnd();
} else if (Tok.is(tok::kw___declspec)) {
  ParseMicrosoftDeclSpecs(Attrs);
} else {
  Diag(Tok, diag::err_pragma_attribute_expected_attribute_syntax);
  if (Tok.getIdentifierInfo()) {
    // If we suspect that this is an attribute suggest the use of
    // '__attribute__'.
    if (ParsedAttr::getKind(Tok.getIdentifierInfo(), /*ScopeName=*/nullptr,
                            ParsedAttr::AS_GNU) !=
        ParsedAttr::UnknownAttribute) {
      SourceLocation InsertStartLoc = Tok.getLocation();
      ConsumeToken();
      if (Tok.is(tok::l_paren)) {
        ConsumeAnyToken();
        SkipUntil(tok::r_paren, StopBeforeMatch);
        if (Tok.isNot(tok::r_paren))
          return SkipToEnd();
      }
      Diag(Tok, diag::note_pragma_attribute_use_attribute_kw)
          << FixItHint::CreateInsertion(InsertStartLoc, "__attribute__((")
          << FixItHint::CreateInsertion(Tok.getEndLoc(), "))");
    }
  }
  SkipToEnd();
  return;
}

if (Attrs.empty() || Attrs.begin()->isInvalid()) {
  SkipToEnd();
  return;
}

// Ensure that we don't have more than one attribute.
if (Attrs.size() > 1) {
  SourceLocation Loc = Attrs[1].getLoc();
  Diag(Loc, diag::err_pragma_attribute_multiple_attributes);
  SkipToEnd();
  return;
}

ParsedAttr &Attribute = *Attrs.begin();
if (!Attribute.isSupportedByPragmaAttribute()) {
  Diag(PragmaLoc, diag::err_pragma_attribute_unsupported_attribute)
      << Attribute.getName();
  SkipToEnd();
  return;
}

// Parse the subject-list.
if (!TryConsumeToken(tok::comma)) {
  createExpectedAttributeSubjectRulesTokenDiagnostic(
      diag::err_expected, Attribute,
      MissingAttributeSubjectRulesRecoveryPoint::Comma, *this)
      << tok::comma;
  SkipToEnd();
  return;
}

if (Tok.isNot(tok::identifier)) {
  createExpectedAttributeSubjectRulesTokenDiagnostic(
      diag::err_pragma_attribute_invalid_subject_set_specifier, Attribute,
      MissingAttributeSubjectRulesRecoveryPoint::ApplyTo, *this);
  SkipToEnd();
  return;
}
const IdentifierInfo *II = Tok.getIdentifierInfo();
if (!II->isStr("apply_to")) {
  createExpectedAttributeSubjectRulesTokenDiagnostic(
      diag::err_pragma_attribute_invalid_subject_set_specifier, Attribute,
      MissingAttributeSubjectRulesRecoveryPoint::ApplyTo, *this);
  SkipToEnd();
  return;
}
ConsumeToken();

if (!TryConsumeToken(tok::equal)) {
  createExpectedAttributeSubjectRulesTokenDiagnostic(
      diag::err_expected, Attribute,
      MissingAttributeSubjectRulesRecoveryPoint::Equals, *this)
      << tok::equal;
  SkipToEnd();
  return;
}

attr::ParsedSubjectMatchRuleSet SubjectMatchRules;
SourceLocation AnyLoc, LastMatchRuleEndLoc;
if (ParsePragmaAttributeSubjectMatchRuleSet(SubjectMatchRules, AnyLoc,
                                            LastMatchRuleEndLoc)) {
  SkipToEnd();
  return;
}

// Tokens following an ill-formed attribute will remain in the token stream
// and must be removed.
if (Tok.isNot(tok::eof)) {
  Diag(Tok, diag::err_pragma_attribute_extra_tokens_after_attribute);
  SkipToEnd();
  return;
}

// Consume the eof terminator token.
ConsumeToken();

// Handle a mixed push/attribute by desurging to a push, then an attribute.
if (Info->Action == PragmaAttributeInfo::Push)
  Actions.ActOnPragmaAttributeEmptyPush(PragmaLoc, Info->Namespace);

Actions.ActOnPragmaAttributeAttribute(Attribute, PragmaLoc,
                                      std::move(SubjectMatchRules));
1563}

1565// #pragma GCC visibility comes in two variants:
1566//   'push' '(' [visibility] ')'
1567//   'pop'
1568void PragmaGCCVisibilityHandler::HandlePragma(Preprocessor &PP,
                                            PragmaIntroducerKind Introducer,
                                            Token &VisTok) {
SourceLocation VisLoc = VisTok.getLocation();

Token Tok;
PP.LexUnexpandedToken(Tok);

const IdentifierInfo *PushPop = Tok.getIdentifierInfo();

const IdentifierInfo *VisType;
if (PushPop && PushPop->isStr("pop")) {
  VisType = nullptr;
} else if (PushPop && PushPop->isStr("push")) {
  PP.LexUnexpandedToken(Tok);
  if (Tok.isNot(tok::l_paren)) {
    PP.Diag(Tok.getLocation(), diag::warn_pragma_expected_lparen)
      << "visibility";
    return;
  }
  PP.LexUnexpandedToken(Tok);
  VisType = Tok.getIdentifierInfo();
  if (!VisType) {
    PP.Diag(Tok.getLocation(), diag::warn_pragma_expected_identifier)
      << "visibility";
    return;
  }
  PP.LexUnexpandedToken(Tok);
  if (Tok.isNot(tok::r_paren)) {
    PP.Diag(Tok.getLocation(), diag::warn_pragma_expected_rparen)
      << "visibility";
    return;
  }
} else {
  PP.Diag(Tok.getLocation(), diag::warn_pragma_expected_identifier)
    << "visibility";
  return;
}
SourceLocation EndLoc = Tok.getLocation();
PP.LexUnexpandedToken(Tok);
if (Tok.isNot(tok::eod)) {
  PP.Diag(Tok.getLocation(), diag::warn_pragma_extra_tokens_at_eol)
    << "visibility";
  return;
}

auto Toks = llvm::make_unique<Token[]>(1);
Toks[0].startToken();
Toks[0].setKind(tok::annot_pragma_vis);
Toks[0].setLocation(VisLoc);
Toks[0].setAnnotationEndLoc(EndLoc);
Toks[0].setAnnotationValue(
                        const_cast<void*>(static_cast<const void*>(VisType)));
PP.EnterTokenStream(std::move(Toks), 1, /*DisableMacroExpansion=*/true);
1622}

1624// #pragma pack(...) comes in the following delicious flavors:
1625//   pack '(' [integer] ')'
1626//   pack '(' 'show' ')'
1627//   pack '(' ('push' | 'pop') [',' identifier] [, integer] ')'
1628void PragmaPackHandler::HandlePragma(Preprocessor &PP,
                                   PragmaIntroducerKind Introducer,
                                   Token &PackTok) {
SourceLocation PackLoc = PackTok.getLocation();

Token Tok;
PP.Lex(Tok);
if (Tok.isNot(tok::l_paren)) {
  PP.Diag(Tok.getLocation(), diag::warn_pragma_expected_lparen) << "pack";
  return;
}

Sema::PragmaMsStackAction Action = Sema::PSK_Reset;
StringRef SlotLabel;
Token Alignment;
Alignment.startToken();
PP.Lex(Tok);
if (Tok.is(tok::numeric_constant)) {
  Alignment = Tok;

  PP.Lex(Tok);

  // In MSVC/gcc, #pragma pack(4) sets the alignment without affecting
  // the push/pop stack.
  // In Apple gcc, #pragma pack(4) is equivalent to #pragma pack(push, 4)
  Action =
      PP.getLangOpts().ApplePragmaPack ? Sema::PSK_Push_Set : Sema::PSK_Set;
} else if (Tok.is(tok::identifier)) {
  const IdentifierInfo *II = Tok.getIdentifierInfo();
  if (II->isStr("show")) {
    Action = Sema::PSK_Show;
    PP.Lex(Tok);
  } else {
    if (II->isStr("push")) {
      Action = Sema::PSK_Push;
    } else if (II->isStr("pop")) {
      Action = Sema::PSK_Pop;
    } else {
      PP.Diag(Tok.getLocation(), diag::warn_pragma_invalid_action) << "pack";
      return;
    }
    PP.Lex(Tok);

    if (Tok.is(tok::comma)) {
      PP.Lex(Tok);

      if (Tok.is(tok::numeric_constant)) {
        Action = (Sema::PragmaMsStackAction)(Action | Sema::PSK_Set);
        Alignment = Tok;

        PP.Lex(Tok);
      } else if (Tok.is(tok::identifier)) {
        SlotLabel = Tok.getIdentifierInfo()->getName();
        PP.Lex(Tok);

        if (Tok.is(tok::comma)) {
          PP.Lex(Tok);

          if (Tok.isNot(tok::numeric_constant)) {
            PP.Diag(Tok.getLocation(), diag::warn_pragma_pack_malformed);
            return;
          }

          Action = (Sema::PragmaMsStackAction)(Action | Sema::PSK_Set);
          Alignment = Tok;

          PP.Lex(Tok);
        }
      } else {
        PP.Diag(Tok.getLocation(), diag::warn_pragma_pack_malformed);
        return;
      }
    }
  }
} else if (PP.getLangOpts().ApplePragmaPack) {
  // In MSVC/gcc, #pragma pack() resets the alignment without affecting
  // the push/pop stack.
  // In Apple gcc #pragma pack() is equivalent to #pragma pack(pop).
  Action = Sema::PSK_Pop;
}

if (Tok.isNot(tok::r_paren)) {
  PP.Diag(Tok.getLocation(), diag::warn_pragma_expected_rparen) << "pack";
  return;
}

SourceLocation RParenLoc = Tok.getLocation();
PP.Lex(Tok);
if (Tok.isNot(tok::eod)) {
  PP.Diag(Tok.getLocation(), diag::warn_pragma_extra_tokens_at_eol) << "pack";
  return;
}

PragmaPackInfo *Info =
    PP.getPreprocessorAllocator().Allocate<PragmaPackInfo>(1);
Info->Action = Action;
Info->SlotLabel = SlotLabel;
Info->Alignment = Alignment;

MutableArrayRef<Token> Toks(PP.getPreprocessorAllocator().Allocate<Token>(1),
                            1);
Toks[0].startToken();
Toks[0].setKind(tok::annot_pragma_pack);
Toks[0].setLocation(PackLoc);
Toks[0].setAnnotationEndLoc(RParenLoc);
Toks[0].setAnnotationValue(static_cast<void*>(Info));
PP.EnterTokenStream(Toks, /*DisableMacroExpansion=*/true);
1735}

1737// #pragma ms_struct on
1738// #pragma ms_struct off
1739void PragmaMSStructHandler::HandlePragma(Preprocessor &PP,
                                       PragmaIntroducerKind Introducer,
                                       Token &MSStructTok) {
PragmaMSStructKind Kind = PMSST_OFF;

Token Tok;
PP.Lex(Tok);
if (Tok.isNot(tok::identifier)) {
  PP.Diag(Tok.getLocation(), diag::warn_pragma_ms_struct);
  return;
}
SourceLocation EndLoc = Tok.getLocation();
const IdentifierInfo *II = Tok.getIdentifierInfo();
if (II->isStr("on")) {
  Kind = PMSST_ON;
  PP.Lex(Tok);
}
else if (II->isStr("off") || II->isStr("reset"))
  PP.Lex(Tok);
else {
  PP.Diag(Tok.getLocation(), diag::warn_pragma_ms_struct);
  return;
}

if (Tok.isNot(tok::eod)) {
  PP.Diag(Tok.getLocation(), diag::warn_pragma_extra_tokens_at_eol)
    << "ms_struct";
  return;
}

MutableArrayRef<Token> Toks(PP.getPreprocessorAllocator().Allocate<Token>(1),
                            1);
Toks[0].startToken();
Toks[0].setKind(tok::annot_pragma_msstruct);
Toks[0].setLocation(MSStructTok.getLocation());
Toks[0].setAnnotationEndLoc(EndLoc);
Toks[0].setAnnotationValue(reinterpret_cast<void*>(
                           static_cast<uintptr_t>(Kind)));
PP.EnterTokenStream(Toks, /*DisableMacroExpansion=*/true);
1778}

1780// #pragma clang section bss="abc" data="" rodata="def" text=""
1781void PragmaClangSectionHandler::HandlePragma(Preprocessor &PP,
           PragmaIntroducerKind Introducer, Token &FirstToken) {

Token Tok;
auto SecKind = Sema::PragmaClangSectionKind::PCSK_Invalid;

PP.Lex(Tok); // eat 'section'
while (Tok.isNot(tok::eod)) {
  if (Tok.isNot(tok::identifier)) {
    PP.Diag(Tok.getLocation(), diag::err_pragma_expected_clang_section_name) << "clang section";
    return;
  }

  const IdentifierInfo *SecType = Tok.getIdentifierInfo();
  if (SecType->isStr("bss"))
    SecKind = Sema::PragmaClangSectionKind::PCSK_BSS;
  else if (SecType->isStr("data"))
    SecKind = Sema::PragmaClangSectionKind::PCSK_Data;
  else if (SecType->isStr("rodata"))
    SecKind = Sema::PragmaClangSectionKind::PCSK_Rodata;
  else if (SecType->isStr("text"))
    SecKind = Sema::PragmaClangSectionKind::PCSK_Text;
  else {
    PP.Diag(Tok.getLocation(), diag::err_pragma_expected_clang_section_name) << "clang section";
    return;
  }

  PP.Lex(Tok); // eat ['bss'|'data'|'rodata'|'text']
  if (Tok.isNot(tok::equal)) {
    PP.Diag(Tok.getLocation(), diag::err_pragma_clang_section_expected_equal) << SecKind;
    return;
  }

  std::string SecName;
  if (!PP.LexStringLiteral(Tok, SecName, "pragma clang section", false))
    return;

  Actions.ActOnPragmaClangSection(Tok.getLocation(),
    (SecName.size()? Sema::PragmaClangSectionAction::PCSA_Set :
                     Sema::PragmaClangSectionAction::PCSA_Clear),
     SecKind, SecName);
}
1823}

1825// #pragma 'align' '=' {'native','natural','mac68k','power','reset'}
1826// #pragma 'options 'align' '=' {'native','natural','mac68k','power','reset'}
1827static void ParseAlignPragma(Preprocessor &PP, Token &FirstTok,
                           bool IsOptions) {
Token Tok;

if (IsOptions) {
  PP.Lex(Tok);
  if (Tok.isNot(tok::identifier) ||
      !Tok.getIdentifierInfo()->isStr("align")) {
    PP.Diag(Tok.getLocation(), diag::warn_pragma_options_expected_align);
    return;
  }
}

PP.Lex(Tok);
if (Tok.isNot(tok::equal)) {
  PP.Diag(Tok.getLocation(), diag::warn_pragma_align_expected_equal)
    << IsOptions;
  return;
}

PP.Lex(Tok);
if (Tok.isNot(tok::identifier)) {
  PP.Diag(Tok.getLocation(), diag::warn_pragma_expected_identifier)
    << (IsOptions ? "options" : "align");
  return;
}

Sema::PragmaOptionsAlignKind Kind = Sema::POAK_Natural;
const IdentifierInfo *II = Tok.getIdentifierInfo();
if (II->isStr("native"))
  Kind = Sema::POAK_Native;
else if (II->isStr("natural"))
  Kind = Sema::POAK_Natural;
else if (II->isStr("packed"))
  Kind = Sema::POAK_Packed;
else if (II->isStr("power"))
  Kind = Sema::POAK_Power;
else if (II->isStr("mac68k"))
  Kind = Sema::POAK_Mac68k;
else if (II->isStr("reset"))
  Kind = Sema::POAK_Reset;
else {
  PP.Diag(Tok.getLocation(), diag::warn_pragma_align_invalid_option)
    << IsOptions;
  return;
}

SourceLocation EndLoc = Tok.getLocation();
PP.Lex(Tok);
if (Tok.isNot(tok::eod)) {
  PP.Diag(Tok.getLocation(), diag::warn_pragma_extra_tokens_at_eol)
    << (IsOptions ? "options" : "align");
  return;
}

MutableArrayRef<Token> Toks(PP.getPreprocessorAllocator().Allocate<Token>(1),
                            1);
Toks[0].startToken();
Toks[0].setKind(tok::annot_pragma_align);
Toks[0].setLocation(FirstTok.getLocation());
Toks[0].setAnnotationEndLoc(EndLoc);
Toks[0].setAnnotationValue(reinterpret_cast<void*>(
                           static_cast<uintptr_t>(Kind)));
PP.EnterTokenStream(Toks, /*DisableMacroExpansion=*/true);
1891}

1893void PragmaAlignHandler::HandlePragma(Preprocessor &PP,
                                    PragmaIntroducerKind Introducer,
                                    Token &AlignTok) {
ParseAlignPragma(PP, AlignTok, /*IsOptions=*/false);
1897}

1899void PragmaOptionsHandler::HandlePragma(Preprocessor &PP,
                                      PragmaIntroducerKind Introducer,
                                      Token &OptionsTok) {
ParseAlignPragma(PP, OptionsTok, /*IsOptions=*/true);
1903}

1905// #pragma unused(identifier)
1906void PragmaUnusedHandler::HandlePragma(Preprocessor &PP,
                                     PragmaIntroducerKind Introducer,
                                     Token &UnusedTok) {
// FIXME: Should we be expanding macros here? My guess is no.
SourceLocation UnusedLoc = UnusedTok.getLocation();

// Lex the left '('.
Token Tok;
PP.Lex(Tok);
if (Tok.isNot(tok::l_paren)) {
  PP.Diag(Tok.getLocation(), diag::warn_pragma_expected_lparen) << "unused";
  return;
}

// Lex the declaration reference(s).
SmallVector<Token, 5> Identifiers;
SourceLocation RParenLoc;
bool LexID = true;

while (true) {
  PP.Lex(Tok);

  if (LexID) {
    if (Tok.is(tok::identifier)) {
      Identifiers.push_back(Tok);
      LexID = false;
      continue;
    }

    // Illegal token!
    PP.Diag(Tok.getLocation(), diag::warn_pragma_unused_expected_var);
    return;
  }

  // We are execting a ')' or a ','.
  if (Tok.is(tok::comma)) {
    LexID = true;
    continue;
  }

  if (Tok.is(tok::r_paren)) {
    RParenLoc = Tok.getLocation();
    break;
  }

  // Illegal token!
  PP.Diag(Tok.getLocation(), diag::warn_pragma_expected_punc) << "unused";
  return;
}

PP.Lex(Tok);
if (Tok.isNot(tok::eod)) {
  PP.Diag(Tok.getLocation(), diag::warn_pragma_extra_tokens_at_eol) <<
      "unused";
  return;
}

// Verify that we have a location for the right parenthesis.
assert(RParenLoc.isValid() && "Valid '#pragma unused' must have ')'")((RParenLoc.isValid() && "Valid '#pragma unused' must have ')'"
) ? static_cast<void> (0) : __assert_fail ("RParenLoc.isValid() && \"Valid '#pragma unused' must have ')'\""
, "/build/llvm-toolchain-snapshot-8~svn350071/tools/clang/lib/Parse/ParsePragma.cpp"
, 1964, __PRETTY_FUNCTION__));
assert(!Identifiers.empty() && "Valid '#pragma unused' must have arguments")((!Identifiers.empty() && "Valid '#pragma unused' must have arguments"
) ? static_cast<void> (0) : __assert_fail ("!Identifiers.empty() && \"Valid '#pragma unused' must have arguments\""
, "/build/llvm-toolchain-snapshot-8~svn350071/tools/clang/lib/Parse/ParsePragma.cpp"
, 1965, __PRETTY_FUNCTION__));

// For each identifier token, insert into the token stream a
// annot_pragma_unused token followed by the identifier token.
// This allows us to cache a "#pragma unused" that occurs inside an inline
// C++ member function.

MutableArrayRef<Token> Toks(
    PP.getPreprocessorAllocator().Allocate<Token>(2 * Identifiers.size()),
    2 * Identifiers.size());
for (unsigned i=0; i != Identifiers.size(); i++) {
  Token &pragmaUnusedTok = Toks[2*i], &idTok = Toks[2*i+1];
  pragmaUnusedTok.startToken();
  pragmaUnusedTok.setKind(tok::annot_pragma_unused);
  pragmaUnusedTok.setLocation(UnusedLoc);
  idTok = Identifiers[i];
}
PP.EnterTokenStream(Toks, /*DisableMacroExpansion=*/true);
1983}

1985// #pragma weak identifier
1986// #pragma weak identifier '=' identifier
1987void PragmaWeakHandler::HandlePragma(Preprocessor &PP,
                                   PragmaIntroducerKind Introducer,
                                   Token &WeakTok) {
SourceLocation WeakLoc = WeakTok.getLocation();

Token Tok;
PP.Lex(Tok);
if (Tok.isNot(tok::identifier)) {
  PP.Diag(Tok.getLocation(), diag::warn_pragma_expected_identifier) << "weak";
  return;
}

Token WeakName = Tok;
bool HasAlias = false;
Token AliasName;

PP.Lex(Tok);
if (Tok.is(tok::equal)) {
  HasAlias = true;
  PP.Lex(Tok);
  if (Tok.isNot(tok::identifier)) {
    PP.Diag(Tok.getLocation(), diag::warn_pragma_expected_identifier)
        << "weak";
    return;
  }
  AliasName = Tok;
  PP.Lex(Tok);
}

if (Tok.isNot(tok::eod)) {
  PP.Diag(Tok.getLocation(), diag::warn_pragma_extra_tokens_at_eol) << "weak";
  return;
}

if (HasAlias) {
  MutableArrayRef<Token> Toks(
      PP.getPreprocessorAllocator().Allocate<Token>(3), 3);
  Token &pragmaUnusedTok = Toks[0];
  pragmaUnusedTok.startToken();
  pragmaUnusedTok.setKind(tok::annot_pragma_weakalias);
  pragmaUnusedTok.setLocation(WeakLoc);
  pragmaUnusedTok.setAnnotationEndLoc(AliasName.getLocation());
  Toks[1] = WeakName;
  Toks[2] = AliasName;
  PP.EnterTokenStream(Toks, /*DisableMacroExpansion=*/true);
} else {
  MutableArrayRef<Token> Toks(
      PP.getPreprocessorAllocator().Allocate<Token>(2), 2);
  Token &pragmaUnusedTok = Toks[0];
  pragmaUnusedTok.startToken();
  pragmaUnusedTok.setKind(tok::annot_pragma_weak);
  pragmaUnusedTok.setLocation(WeakLoc);
  pragmaUnusedTok.setAnnotationEndLoc(WeakLoc);
  Toks[1] = WeakName;
  PP.EnterTokenStream(Toks, /*DisableMacroExpansion=*/true);
}
2043}

2045// #pragma redefine_extname identifier identifier
2046void PragmaRedefineExtnameHandler::HandlePragma(Preprocessor &PP,
                                             PragmaIntroducerKind Introducer,
                                              Token &RedefToken) {
SourceLocation RedefLoc = RedefToken.getLocation();

Token Tok;
PP.Lex(Tok);
if (Tok.isNot(tok::identifier)) {
  PP.Diag(Tok.getLocation(), diag::warn_pragma_expected_identifier) <<
    "redefine_extname";
  return;
}

Token RedefName = Tok;
PP.Lex(Tok);

if (Tok.isNot(tok::identifier)) {
  PP.Diag(Tok.getLocation(), diag::warn_pragma_expected_identifier)
      << "redefine_extname";
  return;
}

Token AliasName = Tok;
PP.Lex(Tok);

if (Tok.isNot(tok::eod)) {
  PP.Diag(Tok.getLocation(), diag::warn_pragma_extra_tokens_at_eol) <<
    "redefine_extname";
  return;
}

MutableArrayRef<Token> Toks(PP.getPreprocessorAllocator().Allocate<Token>(3),
                            3);
Token &pragmaRedefTok = Toks[0];
pragmaRedefTok.startToken();
pragmaRedefTok.setKind(tok::annot_pragma_redefine_extname);
pragmaRedefTok.setLocation(RedefLoc);
pragmaRedefTok.setAnnotationEndLoc(AliasName.getLocation());
Toks[1] = RedefName;
Toks[2] = AliasName;
PP.EnterTokenStream(Toks, /*DisableMacroExpansion=*/true);
2087}


2090void
2091PragmaFPContractHandler::HandlePragma(Preprocessor &PP,
                                    PragmaIntroducerKind Introducer,
                                    Token &Tok) {
tok::OnOffSwitch OOS;
if (PP.LexOnOffSwitch(OOS))
  return;

MutableArrayRef<Token> Toks(PP.getPreprocessorAllocator().Allocate<Token>(1),
                            1);
Toks[0].startToken();
Toks[0].setKind(tok::annot_pragma_fp_contract);
Toks[0].setLocation(Tok.getLocation());
Toks[0].setAnnotationEndLoc(Tok.getLocation());
Toks[0].setAnnotationValue(reinterpret_cast<void*>(
                           static_cast<uintptr_t>(OOS)));
PP.EnterTokenStream(Toks, /*DisableMacroExpansion=*/true);
2107}

2109void
2110PragmaOpenCLExtensionHandler::HandlePragma(Preprocessor &PP,
                                         PragmaIntroducerKind Introducer,
                                         Token &Tok) {
PP.LexUnexpandedToken(Tok);
if (Tok.isNot(tok::identifier)) {
  PP.Diag(Tok.getLocation(), diag::warn_pragma_expected_identifier) <<
    "OPENCL";
  return;
}
IdentifierInfo *Ext = Tok.getIdentifierInfo();
SourceLocation NameLoc = Tok.getLocation();

PP.Lex(Tok);
if (Tok.isNot(tok::colon)) {
  PP.Diag(Tok.getLocation(), diag::warn_pragma_expected_colon) << Ext;
  return;
}

PP.Lex(Tok);
if (Tok.isNot(tok::identifier)) {
  PP.Diag(Tok.getLocation(), diag::warn_pragma_expected_predicate) << 0;
  return;
}
IdentifierInfo *Pred = Tok.getIdentifierInfo();

OpenCLExtState State;
if (Pred->isStr("enable")) {
  State = Enable;
} else if (Pred->isStr("disable")) {
  State = Disable;
} else if (Pred->isStr("begin"))
  State = Begin;
else if (Pred->isStr("end"))
  State = End;
else {
  PP.Diag(Tok.getLocation(), diag::warn_pragma_expected_predicate)
    << Ext->isStr("all");
  return;
}
SourceLocation StateLoc = Tok.getLocation();

PP.Lex(Tok);
if (Tok.isNot(tok::eod)) {
  PP.Diag(Tok.getLocation(), diag::warn_pragma_extra_tokens_at_eol) <<
    "OPENCL EXTENSION";
  return;
}

auto Info = PP.getPreprocessorAllocator().Allocate<OpenCLExtData>(1);
Info->first = Ext;
Info->second = State;
MutableArrayRef<Token> Toks(PP.getPreprocessorAllocator().Allocate<Token>(1),
                            1);
Toks[0].startToken();
Toks[0].setKind(tok::annot_pragma_opencl_extension);
Toks[0].setLocation(NameLoc);
Toks[0].setAnnotationValue(static_cast<void*>(Info));
Toks[0].setAnnotationEndLoc(StateLoc);
PP.EnterTokenStream(Toks, /*DisableMacroExpansion=*/true);

if (PP.getPPCallbacks())
  PP.getPPCallbacks()->PragmaOpenCLExtension(NameLoc, Ext,
                                             StateLoc, State);
2173}

2175/// Handle '#pragma omp ...' when OpenMP is disabled.
2176///
2177void
2178PragmaNoOpenMPHandler::HandlePragma(Preprocessor &PP,
                                  PragmaIntroducerKind Introducer,
                                  Token &FirstTok) {
if (!PP.getDiagnostics().isIgnored(diag::warn_pragma_omp_ignored,
                                   FirstTok.getLocation())) {
  PP.Diag(FirstTok, diag::warn_pragma_omp_ignored);
  PP.getDiagnostics().setSeverity(diag::warn_pragma_omp_ignored,
                                  diag::Severity::Ignored, SourceLocation());
}
PP.DiscardUntilEndOfDirective();
2188}

2190/// Handle '#pragma omp ...' when OpenMP is enabled.
2191///
2192void
2193PragmaOpenMPHandler::HandlePragma(Preprocessor &PP,
                                PragmaIntroducerKind Introducer,
                                Token &FirstTok) {
SmallVector<Token, 16> Pragma;
Token Tok;
Tok.startToken();
Tok.setKind(tok::annot_pragma_openmp);
Tok.setLocation(FirstTok.getLocation());

while (Tok.isNot(tok::eod) && Tok.isNot(tok::eof)) {
  Pragma.push_back(Tok);
  PP.Lex(Tok);
  if (Tok.is(tok::annot_pragma_openmp)) {
    PP.Diag(Tok, diag::err_omp_unexpected_directive) << 0;
    unsigned InnerPragmaCnt = 1;
    while (InnerPragmaCnt != 0) {
      PP.Lex(Tok);
      if (Tok.is(tok::annot_pragma_openmp))
        ++InnerPragmaCnt;
      else if (Tok.is(tok::annot_pragma_openmp_end))
        --InnerPragmaCnt;
    }
    PP.Lex(Tok);
  }
}
SourceLocation EodLoc = Tok.getLocation();
Tok.startToken();
Tok.setKind(tok::annot_pragma_openmp_end);
Tok.setLocation(EodLoc);
Pragma.push_back(Tok);

auto Toks = llvm::make_unique<Token[]>(Pragma.size());
std::copy(Pragma.begin(), Pragma.end(), Toks.get());
PP.EnterTokenStream(std::move(Toks), Pragma.size(),
                    /*DisableMacroExpansion=*/false);
2228}

2230/// Handle '#pragma pointers_to_members'
2231// The grammar for this pragma is as follows:
2232//
2233// <inheritance model> ::= ('single' | 'multiple' | 'virtual') '_inheritance'
2234//
2235// #pragma pointers_to_members '(' 'best_case' ')'
2236// #pragma pointers_to_members '(' 'full_generality' [',' inheritance-model] ')'
2237// #pragma pointers_to_members '(' inheritance-model ')'
2238void PragmaMSPointersToMembers::HandlePragma(Preprocessor &PP,
                                           PragmaIntroducerKind Introducer,
                                           Token &Tok) {
SourceLocation PointersToMembersLoc = Tok.getLocation();
PP.Lex(Tok);
if (Tok.isNot(tok::l_paren)) {
  PP.Diag(PointersToMembersLoc, diag::warn_pragma_expected_lparen)
    << "pointers_to_members";
  return;
}
PP.Lex(Tok);
const IdentifierInfo *Arg = Tok.getIdentifierInfo();
if (!Arg) {
  PP.Diag(Tok.getLocation(), diag::warn_pragma_expected_identifier)
    << "pointers_to_members";
  return;
}
PP.Lex(Tok);

LangOptions::PragmaMSPointersToMembersKind RepresentationMethod;
if (Arg->isStr("best_case")) {
  RepresentationMethod = LangOptions::PPTMK_BestCase;
} else {
  if (Arg->isStr("full_generality")) {
    if (Tok.is(tok::comma)) {
      PP.Lex(Tok);

      Arg = Tok.getIdentifierInfo();
      if (!Arg) {
        PP.Diag(Tok.getLocation(),
                diag::err_pragma_pointers_to_members_unknown_kind)
            << Tok.getKind() << /*OnlyInheritanceModels*/ 0;
        return;
      }
      PP.Lex(Tok);
    } else if (Tok.is(tok::r_paren)) {
      // #pragma pointers_to_members(full_generality) implicitly specifies
      // virtual_inheritance.
      Arg = nullptr;
      RepresentationMethod = LangOptions::PPTMK_FullGeneralityVirtualInheritance;
    } else {
      PP.Diag(Tok.getLocation(), diag::err_expected_punc)
          << "full_generality";
      return;
    }
  }

  if (Arg) {
    if (Arg->isStr("single_inheritance")) {
      RepresentationMethod =
          LangOptions::PPTMK_FullGeneralitySingleInheritance;
    } else if (Arg->isStr("multiple_inheritance")) {
      RepresentationMethod =
          LangOptions::PPTMK_FullGeneralityMultipleInheritance;
    } else if (Arg->isStr("virtual_inheritance")) {
      RepresentationMethod =
          LangOptions::PPTMK_FullGeneralityVirtualInheritance;
    } else {
      PP.Diag(Tok.getLocation(),
              diag::err_pragma_pointers_to_members_unknown_kind)
          << Arg << /*HasPointerDeclaration*/ 1;
      return;
    }
  }
}

if (Tok.isNot(tok::r_paren)) {
  PP.Diag(Tok.getLocation(), diag::err_expected_rparen_after)
      << (Arg ? Arg->getName() : "full_generality");
  return;
}

SourceLocation EndLoc = Tok.getLocation();
PP.Lex(Tok);
if (Tok.isNot(tok::eod)) {
  PP.Diag(Tok.getLocation(), diag::warn_pragma_extra_tokens_at_eol)
    << "pointers_to_members";
  return;
}

Token AnnotTok;
AnnotTok.startToken();
AnnotTok.setKind(tok::annot_pragma_ms_pointers_to_members);
AnnotTok.setLocation(PointersToMembersLoc);
AnnotTok.setAnnotationEndLoc(EndLoc);
AnnotTok.setAnnotationValue(
    reinterpret_cast<void *>(static_cast<uintptr_t>(RepresentationMethod)));
PP.EnterToken(AnnotTok);
2326}

2328/// Handle '#pragma vtordisp'
2329// The grammar for this pragma is as follows:
2330//
2331// <vtordisp-mode> ::= ('off' | 'on' | '0' | '1' | '2' )
2332//
2333// #pragma vtordisp '(' ['push' ','] vtordisp-mode ')'
2334// #pragma vtordisp '(' 'pop' ')'
2335// #pragma vtordisp '(' ')'
2336void PragmaMSVtorDisp::HandlePragma(Preprocessor &PP,
                                  PragmaIntroducerKind Introducer,
                                  Token &Tok) {
SourceLocation VtorDispLoc = Tok.getLocation();
PP.Lex(Tok);
if (Tok.isNot(tok::l_paren)) {
  PP.Diag(VtorDispLoc, diag::warn_pragma_expected_lparen) << "vtordisp";
  return;
}
PP.Lex(Tok);

Sema::PragmaMsStackAction Action = Sema::PSK_Set;
const IdentifierInfo *II = Tok.getIdentifierInfo();
if (II) {
  if (II->isStr("push")) {
    // #pragma vtordisp(push, mode)
    PP.Lex(Tok);
    if (Tok.isNot(tok::comma)) {
      PP.Diag(VtorDispLoc, diag::warn_pragma_expected_punc) << "vtordisp";
      return;
    }
    PP.Lex(Tok);
    Action = Sema::PSK_Push_Set;
    // not push, could be on/off
  } else if (II->isStr("pop")) {
    // #pragma vtordisp(pop)
    PP.Lex(Tok);
    Action = Sema::PSK_Pop;
  }
  // not push or pop, could be on/off
} else {
  if (Tok.is(tok::r_paren)) {
    // #pragma vtordisp()
    Action = Sema::PSK_Reset;
  }
}


uint64_t Value = 0;
if (Action & Sema::PSK_Push || Action & Sema::PSK_Set) {
  const IdentifierInfo *II = Tok.getIdentifierInfo();
  if (II && II->isStr("off")) {
    PP.Lex(Tok);
    Value = 0;
  } else if (II && II->isStr("on")) {
    PP.Lex(Tok);
    Value = 1;
  } else if (Tok.is(tok::numeric_constant) &&
             PP.parseSimpleIntegerLiteral(Tok, Value)) {
    if (Value > 2) {
      PP.Diag(Tok.getLocation(), diag::warn_pragma_expected_integer)
          << 0 << 2 << "vtordisp";
      return;
    }
  } else {
    PP.Diag(Tok.getLocation(), diag::warn_pragma_invalid_action)
        << "vtordisp";
    return;
  }
}

// Finish the pragma: ')' $
if (Tok.isNot(tok::r_paren)) {
  PP.Diag(VtorDispLoc, diag::warn_pragma_expected_rparen) << "vtordisp";
  return;
}
SourceLocation EndLoc = Tok.getLocation();
PP.Lex(Tok);
if (Tok.isNot(tok::eod)) {
  PP.Diag(Tok.getLocation(), diag::warn_pragma_extra_tokens_at_eol)
      << "vtordisp";
  return;
}

// Enter the annotation.
Token AnnotTok;
AnnotTok.startToken();
AnnotTok.setKind(tok::annot_pragma_ms_vtordisp);
AnnotTok.setLocation(VtorDispLoc);
AnnotTok.setAnnotationEndLoc(EndLoc);
AnnotTok.setAnnotationValue(reinterpret_cast<void *>(
    static_cast<uintptr_t>((Action << 16) | (Value & 0xFFFF))));
PP.EnterToken(AnnotTok);
2419}

2421/// Handle all MS pragmas.  Simply forwards the tokens after inserting
2422/// an annotation token.
2423void PragmaMSPragma::HandlePragma(Preprocessor &PP,
                                PragmaIntroducerKind Introducer,
                                Token &Tok) {
Token EoF, AnnotTok;
EoF.startToken();
EoF.setKind(tok::eof);
AnnotTok.startToken();
AnnotTok.setKind(tok::annot_pragma_ms_pragma);
AnnotTok.setLocation(Tok.getLocation());
AnnotTok.setAnnotationEndLoc(Tok.getLocation());
SmallVector<Token, 8> TokenVector;
// Suck up all of the tokens before the eod.
for (; Tok.isNot(tok::eod); PP.Lex(Tok)) {
  TokenVector.push_back(Tok);
  AnnotTok.setAnnotationEndLoc(Tok.getLocation());
}
// Add a sentinel EoF token to the end of the list.
TokenVector.push_back(EoF);
// We must allocate this array with new because EnterTokenStream is going to
// delete it later.
auto TokenArray = llvm::make_unique<Token[]>(TokenVector.size());
std::copy(TokenVector.begin(), TokenVector.end(), TokenArray.get());
auto Value = new (PP.getPreprocessorAllocator())
    std::pair<std::unique_ptr<Token[]>, size_t>(std::move(TokenArray),
                                                TokenVector.size());
AnnotTok.setAnnotationValue(Value);
PP.EnterToken(AnnotTok);
2450}

2452/// Handle the Microsoft \#pragma detect_mismatch extension.
2453///
2454/// The syntax is:
2455/// \code
2456///   #pragma detect_mismatch("name", "value")
2457/// \endcode
2458/// Where 'name' and 'value' are quoted strings.  The values are embedded in
2459/// the object file and passed along to the linker.  If the linker detects a
2460/// mismatch in the object file's values for the given name, a LNK2038 error
2461/// is emitted.  See MSDN for more details.
2462void PragmaDetectMismatchHandler::HandlePragma(Preprocessor &PP,
                                             PragmaIntroducerKind Introducer,
                                             Token &Tok) {
SourceLocation DetectMismatchLoc = Tok.getLocation();
PP.Lex(Tok);
if (Tok.isNot(tok::l_paren)) {
  PP.Diag(DetectMismatchLoc, diag::err_expected) << tok::l_paren;
  return;
}

// Read the name to embed, which must be a string literal.
std::string NameString;
if (!PP.LexStringLiteral(Tok, NameString,
                         "pragma detect_mismatch",
                         /*MacroExpansion=*/true))
  return;

// Read the comma followed by a second string literal.
std::string ValueString;
if (Tok.isNot(tok::comma)) {
  PP.Diag(Tok.getLocation(), diag::err_pragma_detect_mismatch_malformed);
  return;
}

if (!PP.LexStringLiteral(Tok, ValueString, "pragma detect_mismatch",
                         /*MacroExpansion=*/true))
  return;

if (Tok.isNot(tok::r_paren)) {
  PP.Diag(Tok.getLocation(), diag::err_expected) << tok::r_paren;
  return;
}
PP.Lex(Tok);  // Eat the r_paren.

if (Tok.isNot(tok::eod)) {
  PP.Diag(Tok.getLocation(), diag::err_pragma_detect_mismatch_malformed);
  return;
}

// If the pragma is lexically sound, notify any interested PPCallbacks.
if (PP.getPPCallbacks())
  PP.getPPCallbacks()->PragmaDetectMismatch(DetectMismatchLoc, NameString,
                                            ValueString);

Actions.ActOnPragmaDetectMismatch(DetectMismatchLoc, NameString, ValueString);
2507}

2509/// Handle the microsoft \#pragma comment extension.
2510///
2511/// The syntax is:
2512/// \code
2513///   #pragma comment(linker, "foo")
2514/// \endcode
2515/// 'linker' is one of five identifiers: compiler, exestr, lib, linker, user.
2516/// "foo" is a string, which is fully macro expanded, and permits string
2517/// concatenation, embedded escape characters etc.  See MSDN for more details.
2518void PragmaCommentHandler::HandlePragma(Preprocessor &PP,
                                      PragmaIntroducerKind Introducer,
                                      Token &Tok) {
SourceLocation CommentLoc = Tok.getLocation();
PP.Lex(Tok);
if (Tok.isNot(tok::l_paren)) {
  PP.Diag(CommentLoc, diag::err_pragma_comment_malformed);
  return;
}

// Read the identifier.
PP.Lex(Tok);
if (Tok.isNot(tok::identifier)) {
  PP.Diag(CommentLoc, diag::err_pragma_comment_malformed);
  return;
}

// Verify that this is one of the 5 whitelisted options.
IdentifierInfo *II = Tok.getIdentifierInfo();
PragmaMSCommentKind Kind =
  llvm::StringSwitch<PragmaMSCommentKind>(II->getName())
  .Case("linker",   PCK_Linker)
  .Case("lib",      PCK_Lib)
  .Case("compiler", PCK_Compiler)
  .Case("exestr",   PCK_ExeStr)
  .Case("user",     PCK_User)
  .Default(PCK_Unknown);
if (Kind == PCK_Unknown) {
  PP.Diag(Tok.getLocation(), diag::err_pragma_comment_unknown_kind);
  return;
}

if (PP.getTargetInfo().getTriple().isOSBinFormatELF() && Kind != PCK_Lib) {
  PP.Diag(Tok.getLocation(), diag::warn_pragma_comment_ignored)
      << II->getName();
  return;
}

// On PS4, issue a warning about any pragma comments other than
// #pragma comment lib.
if (PP.getTargetInfo().getTriple().isPS4() && Kind != PCK_Lib) {
  PP.Diag(Tok.getLocation(), diag::warn_pragma_comment_ignored)
    << II->getName();
  return;
}

// Read the optional string if present.
PP.Lex(Tok);
std::string ArgumentString;
if (Tok.is(tok::comma) && !PP.LexStringLiteral(Tok, ArgumentString,
                                               "pragma comment",
                                               /*MacroExpansion=*/true))
  return;

// FIXME: warn that 'exestr' is deprecated.
// FIXME: If the kind is "compiler" warn if the string is present (it is
// ignored).
// The MSDN docs say that "lib" and "linker" require a string and have a short
// whitelist of linker options they support, but in practice MSVC doesn't
// issue a diagnostic.  Therefore neither does clang.

if (Tok.isNot(tok::r_paren)) {
  PP.Diag(Tok.getLocation(), diag::err_pragma_comment_malformed);
  return;
}
PP.Lex(Tok);  // eat the r_paren.

if (Tok.isNot(tok::eod)) {
  PP.Diag(Tok.getLocation(), diag::err_pragma_comment_malformed);
  return;
}

// If the pragma is lexically sound, notify any interested PPCallbacks.
if (PP.getPPCallbacks())
  PP.getPPCallbacks()->PragmaComment(CommentLoc, II, ArgumentString);

Actions.ActOnPragmaMSComment(CommentLoc, Kind, ArgumentString);
2595}

2597// #pragma clang optimize off
2598// #pragma clang optimize on
2599void PragmaOptimizeHandler::HandlePragma(Preprocessor &PP,
                                      PragmaIntroducerKind Introducer,
                                      Token &FirstToken) {
Token Tok;
PP.Lex(Tok);
if (Tok.is(tok::eod)) {
  PP.Diag(Tok.getLocation(), diag::err_pragma_missing_argument)
      << "clang optimize" << /*Expected=*/true << "'on' or 'off'";
  return;
}
if (Tok.isNot(tok::identifier)) {
  PP.Diag(Tok.getLocation(), diag::err_pragma_optimize_invalid_argument)
    << PP.getSpelling(Tok);
  return;
}
const IdentifierInfo *II = Tok.getIdentifierInfo();
// The only accepted values are 'on' or 'off'.
bool IsOn = false;
if (II->isStr("on")) {
  IsOn = true;
} else if (!II->isStr("off")) {
  PP.Diag(Tok.getLocation(), diag::err_pragma_optimize_invalid_argument)
    << PP.getSpelling(Tok);
  return;
}
PP.Lex(Tok);

if (Tok.isNot(tok::eod)) {
  PP.Diag(Tok.getLocation(), diag::err_pragma_optimize_extra_argument)
    << PP.getSpelling(Tok);
  return;
}

Actions.ActOnPragmaOptimize(IsOn, FirstToken.getLocation());
2633}

2635namespace {
2636/// Used as the annotation value for tok::annot_pragma_fp.
2637struct TokFPAnnotValue {
enum FlagKinds { Contract };
enum FlagValues { On, Off, Fast };

FlagKinds FlagKind;
FlagValues FlagValue;
2643};
2644} // end anonymous namespace

2646void PragmaFPHandler::HandlePragma(Preprocessor &PP,
                                 PragmaIntroducerKind Introducer,
                                 Token &Tok) {
// fp
Token PragmaName = Tok;
SmallVector<Token, 1> TokenList;

PP.Lex(Tok);
if (Tok.isNot(tok::identifier)) {
  PP.Diag(Tok.getLocation(), diag::err_pragma_fp_invalid_option)
      << /*MissingOption=*/true << "";
  return;
}

while (Tok.is(tok::identifier)) {
  IdentifierInfo *OptionInfo = Tok.getIdentifierInfo();

  auto FlagKind =
      llvm::StringSwitch<llvm::Optional<TokFPAnnotValue::FlagKinds>>(
          OptionInfo->getName())
          .Case("contract", TokFPAnnotValue::Contract)
          .Default(None);
  if (!FlagKind) {
    PP.Diag(Tok.getLocation(), diag::err_pragma_fp_invalid_option)
        << /*MissingOption=*/false << OptionInfo;
    return;
  }
  PP.Lex(Tok);

  // Read '('
  if (Tok.isNot(tok::l_paren)) {
    PP.Diag(Tok.getLocation(), diag::err_expected) << tok::l_paren;
    return;
  }
  PP.Lex(Tok);

  if (Tok.isNot(tok::identifier)) {
    PP.Diag(Tok.getLocation(), diag::err_pragma_fp_invalid_argument)
        << PP.getSpelling(Tok) << OptionInfo->getName();
    return;
  }
  const IdentifierInfo *II = Tok.getIdentifierInfo();

  auto FlagValue =
      llvm::StringSwitch<llvm::Optional<TokFPAnnotValue::FlagValues>>(
          II->getName())
          .Case("on", TokFPAnnotValue::On)
          .Case("off", TokFPAnnotValue::Off)
          .Case("fast", TokFPAnnotValue::Fast)
          .Default(llvm::None);

  if (!FlagValue) {
    PP.Diag(Tok.getLocation(), diag::err_pragma_fp_invalid_argument)
        << PP.getSpelling(Tok) << OptionInfo->getName();
    return;
  }
  PP.Lex(Tok);

  // Read ')'
  if (Tok.isNot(tok::r_paren)) {
    PP.Diag(Tok.getLocation(), diag::err_expected) << tok::r_paren;
    return;
  }
  PP.Lex(Tok);

  auto *AnnotValue = new (PP.getPreprocessorAllocator())
      TokFPAnnotValue{*FlagKind, *FlagValue};
  // Generate the loop hint token.
  Token FPTok;
  FPTok.startToken();
  FPTok.setKind(tok::annot_pragma_fp);
  FPTok.setLocation(PragmaName.getLocation());
  FPTok.setAnnotationEndLoc(PragmaName.getLocation());
  FPTok.setAnnotationValue(reinterpret_cast<void *>(AnnotValue));
  TokenList.push_back(FPTok);
}

if (Tok.isNot(tok::eod)) {
  PP.Diag(Tok.getLocation(), diag::warn_pragma_extra_tokens_at_eol)
      << "clang fp";
  return;
}

auto TokenArray = llvm::make_unique<Token[]>(TokenList.size());
std::copy(TokenList.begin(), TokenList.end(), TokenArray.get());

PP.EnterTokenStream(std::move(TokenArray), TokenList.size(),
                    /*DisableMacroExpansion=*/false);
2734}

2736void Parser::HandlePragmaFP() {
assert(Tok.is(tok::annot_pragma_fp))((Tok.is(tok::annot_pragma_fp)) ? static_cast<void> (0)
 : __assert_fail ("Tok.is(tok::annot_pragma_fp)", "/build/llvm-toolchain-snapshot-8~svn350071/tools/clang/lib/Parse/ParsePragma.cpp"
, 2737, __PRETTY_FUNCTION__));
auto *AnnotValue =
    reinterpret_cast<TokFPAnnotValue *>(Tok.getAnnotationValue());

LangOptions::FPContractModeKind FPC;
switch (AnnotValue->FlagValue) {
case TokFPAnnotValue::On:
  FPC = LangOptions::FPC_On;
  break;
case TokFPAnnotValue::Fast:
  FPC = LangOptions::FPC_Fast;
  break;
case TokFPAnnotValue::Off:
  FPC = LangOptions::FPC_Off;
  break;
}

Actions.ActOnPragmaFPContract(FPC);
ConsumeAnnotationToken();
2756}

2758/// Parses loop or unroll pragma hint value and fills in Info.
2759static bool ParseLoopHintValue(Preprocessor &PP, Token &Tok, Token PragmaName,
                             Token Option, bool ValueInParens,
                             PragmaLoopHintInfo &Info) {
SmallVector<Token, 1> ValueList;
int OpenParens = ValueInParens ? 1 : 0;
// Read constant expression.
while (Tok.isNot(tok::eod)) {
  if (Tok.is(tok::l_paren))
    OpenParens++;
  else if (Tok.is(tok::r_paren)) {
    OpenParens--;
    if (OpenParens == 0 && ValueInParens)
      break;
  }

  ValueList.push_back(Tok);
  PP.Lex(Tok);
}

if (ValueInParens) {
  // Read ')'
  if (Tok.isNot(tok::r_paren)) {
    PP.Diag(Tok.getLocation(), diag::err_expected) << tok::r_paren;
    return true;
  }
  PP.Lex(Tok);
}

Token EOFTok;
EOFTok.startToken();
EOFTok.setKind(tok::eof);
EOFTok.setLocation(Tok.getLocation());
ValueList.push_back(EOFTok); // Terminates expression for parsing.

Info.Toks = llvm::makeArrayRef(ValueList).copy(PP.getPreprocessorAllocator());

Info.PragmaName = PragmaName;
Info.Option = Option;
return false;
2798}

2800/// Handle the \#pragma clang loop directive.
2801///  #pragma clang 'loop' loop-hints
2802///
2803///  loop-hints:
2804///    loop-hint loop-hints[opt]
2805///
2806///  loop-hint:
2807///    'vectorize' '(' loop-hint-keyword ')'
2808///    'interleave' '(' loop-hint-keyword ')'
2809///    'unroll' '(' unroll-hint-keyword ')'
2810///    'vectorize_width' '(' loop-hint-value ')'
2811///    'interleave_count' '(' loop-hint-value ')'
2812///    'unroll_count' '(' loop-hint-value ')'
2813///
2814///  loop-hint-keyword:
2815///    'enable'
2816///    'disable'
2817///    'assume_safety'
2818///
2819///  unroll-hint-keyword:
2820///    'enable'
2821///    'disable'
2822///    'full'
2823///
2824///  loop-hint-value:
2825///    constant-expression
2826///
2827/// Specifying vectorize(enable) or vectorize_width(_value_) instructs llvm to
2828/// try vectorizing the instructions of the loop it precedes. Specifying
2829/// interleave(enable) or interleave_count(_value_) instructs llvm to try
2830/// interleaving multiple iterations of the loop it precedes. The width of the
2831/// vector instructions is specified by vectorize_width() and the number of
2832/// interleaved loop iterations is specified by interleave_count(). Specifying a
2833/// value of 1 effectively disables vectorization/interleaving, even if it is
2834/// possible and profitable, and 0 is invalid. The loop vectorizer currently
2835/// only works on inner loops.
2836///
2837/// The unroll and unroll_count directives control the concatenation
2838/// unroller. Specifying unroll(enable) instructs llvm to unroll the loop
2839/// completely if the trip count is known at compile time and unroll partially
2840/// if the trip count is not known.  Specifying unroll(full) is similar to
2841/// unroll(enable) but will unroll the loop only if the trip count is known at
2842/// compile time.  Specifying unroll(disable) disables unrolling for the
2843/// loop. Specifying unroll_count(_value_) instructs llvm to try to unroll the
2844/// loop the number of times indicated by the value.
2845void PragmaLoopHintHandler::HandlePragma(Preprocessor &PP,
                                       PragmaIntroducerKind Introducer,
                                       Token &Tok) {
// Incoming token is "loop" from "#pragma clang loop".
Token PragmaName = Tok;
SmallVector<Token, 1> TokenList;

// Lex the optimization option and verify it is an identifier.
PP.Lex(Tok);
if (Tok.isNot(tok::identifier)) {
  PP.Diag(Tok.getLocation(), diag::err_pragma_loop_invalid_option)
      << /*MissingOption=*/true << "";
  return;
}

while (Tok.is(tok::identifier)) {
  Token Option = Tok;
  IdentifierInfo *OptionInfo = Tok.getIdentifierInfo();

  bool OptionValid = llvm::StringSwitch<bool>(OptionInfo->getName())
                         .Case("vectorize", true)
                         .Case("interleave", true)
                         .Case("unroll", true)
                         .Case("distribute", true)
                         .Case("vectorize_width", true)
                         .Case("interleave_count", true)
                         .Case("unroll_count", true)
                         .Default(false);
  if (!OptionValid) {
    PP.Diag(Tok.getLocation(), diag::err_pragma_loop_invalid_option)
        << /*MissingOption=*/false << OptionInfo;
    return;
  }
  PP.Lex(Tok);

  // Read '('
  if (Tok.isNot(tok::l_paren)) {
    PP.Diag(Tok.getLocation(), diag::err_expected) << tok::l_paren;
    return;
  }
  PP.Lex(Tok);

  auto *Info = new (PP.getPreprocessorAllocator()) PragmaLoopHintInfo;
  if (ParseLoopHintValue(PP, Tok, PragmaName, Option, /*ValueInParens=*/true,
                         *Info))
    return;

  // Generate the loop hint token.
  Token LoopHintTok;
  LoopHintTok.startToken();
  LoopHintTok.setKind(tok::annot_pragma_loop_hint);
  LoopHintTok.setLocation(PragmaName.getLocation());
  LoopHintTok.setAnnotationEndLoc(PragmaName.getLocation());
  LoopHintTok.setAnnotationValue(static_cast<void *>(Info));
  TokenList.push_back(LoopHintTok);
}

if (Tok.isNot(tok::eod)) {
  PP.Diag(Tok.getLocation(), diag::warn_pragma_extra_tokens_at_eol)
      << "clang loop";
  return;
}

auto TokenArray = llvm::make_unique<Token[]>(TokenList.size());
std::copy(TokenList.begin(), TokenList.end(), TokenArray.get());

PP.EnterTokenStream(std::move(TokenArray), TokenList.size(),
                    /*DisableMacroExpansion=*/false);
2913}

2915/// Handle the loop unroll optimization pragmas.
2916///  #pragma unroll
2917///  #pragma unroll unroll-hint-value
2918///  #pragma unroll '(' unroll-hint-value ')'
2919///  #pragma nounroll
2920///  #pragma unroll_and_jam
2921///  #pragma unroll_and_jam unroll-hint-value
2922///  #pragma unroll_and_jam '(' unroll-hint-value ')'
2923///  #pragma nounroll_and_jam
2924///
2925///  unroll-hint-value:
2926///    constant-expression
2927///
2928/// Loop unrolling hints can be specified with '#pragma unroll' or
2929/// '#pragma nounroll'. '#pragma unroll' can take a numeric argument optionally
2930/// contained in parentheses. With no argument the directive instructs llvm to
2931/// try to unroll the loop completely. A positive integer argument can be
2932/// specified to indicate the number of times the loop should be unrolled.  To
2933/// maximize compatibility with other compilers the unroll count argument can be
2934/// specified with or without parentheses.  Specifying, '#pragma nounroll'
2935/// disables unrolling of the loop.
2936void PragmaUnrollHintHandler::HandlePragma(Preprocessor &PP,
                                         PragmaIntroducerKind Introducer,
                                         Token &Tok) {
// Incoming token is "unroll" for "#pragma unroll", or "nounroll" for
// "#pragma nounroll".
Token PragmaName = Tok;
PP.Lex(Tok);
auto *Info = new (PP.getPreprocessorAllocator()) PragmaLoopHintInfo;
if (Tok.is(tok::eod)) {
  // nounroll or unroll pragma without an argument.
  Info->PragmaName = PragmaName;
  Info->Option.startToken();
} else if (PragmaName.getIdentifierInfo()->getName() == "nounroll" ||
           PragmaName.getIdentifierInfo()->getName() == "nounroll_and_jam") {
  PP.Diag(Tok.getLocation(), diag::warn_pragma_extra_tokens_at_eol)
      << PragmaName.getIdentifierInfo()->getName();
  return;
} else {
  // Unroll pragma with an argument: "#pragma unroll N" or
  // "#pragma unroll(N)".
  // Read '(' if it exists.
  bool ValueInParens = Tok.is(tok::l_paren);
  if (ValueInParens)
    PP.Lex(Tok);

  Token Option;
  Option.startToken();
  if (ParseLoopHintValue(PP, Tok, PragmaName, Option, ValueInParens, *Info))
    return;

  // In CUDA, the argument to '#pragma unroll' should not be contained in
  // parentheses.
  if (PP.getLangOpts().CUDA && ValueInParens)
    PP.Diag(Info->Toks[0].getLocation(),
            diag::warn_pragma_unroll_cuda_value_in_parens);

  if (Tok.isNot(tok::eod)) {
    PP.Diag(Tok.getLocation(), diag::warn_pragma_extra_tokens_at_eol)
        << "unroll";
    return;
  }
}

// Generate the hint token.
auto TokenArray = llvm::make_unique<Token[]>(1);
TokenArray[0].startToken();
TokenArray[0].setKind(tok::annot_pragma_loop_hint);
TokenArray[0].setLocation(PragmaName.getLocation());
TokenArray[0].setAnnotationEndLoc(PragmaName.getLocation());
TokenArray[0].setAnnotationValue(static_cast<void *>(Info));
PP.EnterTokenStream(std::move(TokenArray), 1,
                    /*DisableMacroExpansion=*/false);
2988}

2990/// Handle the Microsoft \#pragma intrinsic extension.
2991///
2992/// The syntax is:
2993/// \code
2994///  #pragma intrinsic(memset)
2995///  #pragma intrinsic(strlen, memcpy)
2996/// \endcode
2997///
2998/// Pragma intrisic tells the compiler to use a builtin version of the
2999/// function. Clang does it anyway, so the pragma doesn't really do anything.
3000/// Anyway, we emit a warning if the function specified in \#pragma intrinsic
3001/// isn't an intrinsic in clang and suggest to include intrin.h.
3002void PragmaMSIntrinsicHandler::HandlePragma(Preprocessor &PP,
                                          PragmaIntroducerKind Introducer,
                                          Token &Tok) {
PP.Lex(Tok);

if (Tok.isNot(tok::l_paren)) {
  PP.Diag(Tok.getLocation(), diag::warn_pragma_expected_lparen)
      << "intrinsic";
  return;
}
PP.Lex(Tok);

bool SuggestIntrinH = !PP.isMacroDefined("__INTRIN_H");

while (Tok.is(tok::identifier)) {
  IdentifierInfo *II = Tok.getIdentifierInfo();
  if (!II->getBuiltinID())
    PP.Diag(Tok.getLocation(), diag::warn_pragma_intrinsic_builtin)
        << II << SuggestIntrinH;

  PP.Lex(Tok);
  if (Tok.isNot(tok::comma))
    break;
  PP.Lex(Tok);
}

if (Tok.isNot(tok::r_paren)) {
  PP.Diag(Tok.getLocation(), diag::warn_pragma_expected_rparen)
      << "intrinsic";
  return;
}
PP.Lex(Tok);

if (Tok.isNot(tok::eod))
  PP.Diag(Tok.getLocation(), diag::warn_pragma_extra_tokens_at_eol)
      << "intrinsic";
3038}

3040// #pragma optimize("gsty", on|off)
3041void PragmaMSOptimizeHandler::HandlePragma(Preprocessor &PP,
                                         PragmaIntroducerKind Introducer,
                                         Token &Tok) {
SourceLocation StartLoc = Tok.getLocation();
PP.Lex(Tok);

if (Tok.isNot(tok::l_paren)) {
  PP.Diag(Tok.getLocation(), diag::warn_pragma_expected_lparen) << "optimize";
  return;
}
PP.Lex(Tok);

if (Tok.isNot(tok::string_literal)) {
  PP.Diag(Tok.getLocation(), diag::warn_pragma_expected_string) << "optimize";
  return;
}
// We could syntax check the string but it's probably not worth the effort.
PP.Lex(Tok);

if (Tok.isNot(tok::comma)) {
  PP.Diag(Tok.getLocation(), diag::warn_pragma_expected_comma) << "optimize";
  return;
}
PP.Lex(Tok);

if (Tok.is(tok::eod) || Tok.is(tok::r_paren)) {
  PP.Diag(Tok.getLocation(), diag::warn_pragma_missing_argument)
      << "optimize" << /*Expected=*/true << "'on' or 'off'";
  return;
}
IdentifierInfo *II = Tok.getIdentifierInfo();
if (!II || (!II->isStr("on") && !II->isStr("off"))) {
  PP.Diag(Tok.getLocation(), diag::warn_pragma_invalid_argument)
      << PP.getSpelling(Tok) << "optimize" << /*Expected=*/true
      << "'on' or 'off'";
  return;
}
PP.Lex(Tok);

if (Tok.isNot(tok::r_paren)) {
  PP.Diag(Tok.getLocation(), diag::warn_pragma_expected_rparen) << "optimize";
  return;
}
PP.Lex(Tok);

if (Tok.isNot(tok::eod)) {
  PP.Diag(Tok.getLocation(), diag::warn_pragma_extra_tokens_at_eol)
      << "optimize";
  return;
}
PP.Diag(StartLoc, diag::warn_pragma_optimize);
3092}

3094void PragmaForceCUDAHostDeviceHandler::HandlePragma(
  Preprocessor &PP, PragmaIntroducerKind Introducer, Token &Tok) {
Token FirstTok = Tok;

PP.Lex(Tok);
IdentifierInfo *Info = Tok.getIdentifierInfo();
if (!Info || (!Info->isStr("begin") && !Info->isStr("end"))) {
  PP.Diag(FirstTok.getLocation(),
          diag::warn_pragma_force_cuda_host_device_bad_arg);
  return;
}

if (Info->isStr("begin"))
  Actions.PushForceCUDAHostDevice();
else if (!Actions.PopForceCUDAHostDevice())
  PP.Diag(FirstTok.getLocation(),
          diag::err_pragma_cannot_end_force_cuda_host_device);

PP.Lex(Tok);
if (!Tok.is(tok::eod))
  PP.Diag(FirstTok.getLocation(),
          diag::warn_pragma_force_cuda_host_device_bad_arg);
3116}

3118/// Handle the #pragma clang attribute directive.
3119///
3120/// The syntax is:
3121/// \code
3122///  #pragma clang attribute push (attribute, subject-set)
3123///  #pragma clang attribute push
3124///  #pragma clang attribute (attribute, subject-set)
3125///  #pragma clang attribute pop
3126/// \endcode
3127///
3128/// There are also 'namespace' variants of push and pop directives. The bare
3129/// '#pragma clang attribute (attribute, subject-set)' version doesn't require a
3130/// namespace, since it always applies attributes to the most recently pushed
3131/// group, regardless of namespace.
3132/// \code
3133///  #pragma clang attribute namespace.push (attribute, subject-set)
3134///  #pragma clang attribute namespace.push
3135///  #pragma clang attribute namespace.pop
3136/// \endcode
3137///
3138/// The subject-set clause defines the set of declarations which receive the
3139/// attribute. Its exact syntax is described in the LanguageExtensions document
3140/// in Clang's documentation.
3141///
3142/// This directive instructs the compiler to begin/finish applying the specified
3143/// attribute to the set of attribute-specific declarations in the active range
3144/// of the pragma.
3145void PragmaAttributeHandler::HandlePragma(Preprocessor &PP,
                                        PragmaIntroducerKind Introducer,
                                        Token &FirstToken) {
Token Tok;
PP.Lex(Tok);
auto *Info = new (PP.getPreprocessorAllocator())
1
'Info' initialized to a null pointer value→
    PragmaAttributeInfo(AttributesForPragmaAttribute);

// Parse the optional namespace followed by a period.
if (Tok.is(tok::identifier)) {
2
←
Taking true branch→
  IdentifierInfo *II = Tok.getIdentifierInfo();
  if (!II->isStr("push") && !II->isStr("pop")) {
    Info->Namespace = II;
    PP.Lex(Tok);

    if (!Tok.is(tok::period)) {
      PP.Diag(Tok.getLocation(), diag::err_pragma_attribute_expected_period)
          << II;
      return;
    }
    PP.Lex(Tok);
  }
}

if (!Tok.isOneOf(tok::identifier, tok::l_paren)) {
3
←
Taking false branch→
  PP.Diag(Tok.getLocation(),
          diag::err_pragma_attribute_expected_push_pop_paren);
  return;
}

// Determine what action this pragma clang attribute represents.
if (Tok.is(tok::l_paren)) {
4
←
Taking false branch→
  if (Info->Namespace) {
    PP.Diag(Tok.getLocation(),
            diag::err_pragma_attribute_namespace_on_attribute);
    PP.Diag(Tok.getLocation(),
            diag::note_pragma_attribute_namespace_on_attribute);
    return;
  }
  Info->Action = PragmaAttributeInfo::Attribute;
} else {
  const IdentifierInfo *II = Tok.getIdentifierInfo();
  if (II->isStr("push"))
5
←
Taking true branch→
    Info->Action = PragmaAttributeInfo::Push;
6
←
Access to field 'Action' results in a dereference of a null pointer (loaded from variable 'Info')
  else if (II->isStr("pop"))
    Info->Action = PragmaAttributeInfo::Pop;
  else {
    PP.Diag(Tok.getLocation(), diag::err_pragma_attribute_invalid_argument)
        << PP.getSpelling(Tok);
    return;
  }

  PP.Lex(Tok);
}

// Parse the actual attribute.
if ((Info->Action == PragmaAttributeInfo::Push && Tok.isNot(tok::eod)) ||
    Info->Action == PragmaAttributeInfo::Attribute) {
  if (Tok.isNot(tok::l_paren)) {
    PP.Diag(Tok.getLocation(), diag::err_expected) << tok::l_paren;
    return;
  }
  PP.Lex(Tok);

  // Lex the attribute tokens.
  SmallVector<Token, 16> AttributeTokens;
  int OpenParens = 1;
  while (Tok.isNot(tok::eod)) {
    if (Tok.is(tok::l_paren))
      OpenParens++;
    else if (Tok.is(tok::r_paren)) {
      OpenParens--;
      if (OpenParens == 0)
        break;
    }

    AttributeTokens.push_back(Tok);
    PP.Lex(Tok);
  }

  if (AttributeTokens.empty()) {
    PP.Diag(Tok.getLocation(), diag::err_pragma_attribute_expected_attribute);
    return;
  }
  if (Tok.isNot(tok::r_paren)) {
    PP.Diag(Tok.getLocation(), diag::err_expected) << tok::r_paren;
    return;
  }
  SourceLocation EndLoc = Tok.getLocation();
  PP.Lex(Tok);

  // Terminate the attribute for parsing.
  Token EOFTok;
  EOFTok.startToken();
  EOFTok.setKind(tok::eof);
  EOFTok.setLocation(EndLoc);
  AttributeTokens.push_back(EOFTok);

  Info->Tokens =
      llvm::makeArrayRef(AttributeTokens).copy(PP.getPreprocessorAllocator());
}

if (Tok.isNot(tok::eod))
  PP.Diag(Tok.getLocation(), diag::warn_pragma_extra_tokens_at_eol)
      << "clang attribute";

// Generate the annotated pragma token.
auto TokenArray = llvm::make_unique<Token[]>(1);
TokenArray[0].startToken();
TokenArray[0].setKind(tok::annot_pragma_attribute);
TokenArray[0].setLocation(FirstToken.getLocation());
TokenArray[0].setAnnotationEndLoc(FirstToken.getLocation());
TokenArray[0].setAnnotationValue(static_cast<void *>(Info));
PP.EnterTokenStream(std::move(TokenArray), 1,
                    /*DisableMacroExpansion=*/false);
3260}