maxjhandsome
/
llvm-project
forked from OSchip/llvm-project
1
0
Fork 0
Code Issues Pull Requests Packages Releases Wiki Activity
llvm-project/clang/lib/Parse/ParsePragma.cpp

2234 lines
75 KiB
C++
Raw Normal View History

Add Parser support for #pragma pack - Uses Action::ActOnPragmaPack - Test case is XFAIL pending verifier fixes. llvm-svn: 57066
2008-10-05 03:21:03 +08:00
//===--- ParsePragma.cpp - Language specific pragma parsing ---------------===//
//
// The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
//
// This file implements the language specific #pragma handlers.
//
//===----------------------------------------------------------------------===//
[MS-ABI] Add support for #pragma section and related pragmas This patch adds support for the msvc pragmas section, bss_seg, code_seg, const_seg and data_seg as well as support for __declspec(allocate()). Additionally it corrects semantics and adds diagnostics for __attribute__((section())) and the interaction between the attribute and the msvc pragmas and declspec. In general conflicts should now be well diganosed within and among these features. In supporting the pragmas new machinery for uniform lexing for msvc pragmas was introduced. The new machinery always lexes the entire pragma and stores it on an annotation token. The parser is responsible for parsing the pragma when the handling the annotation token. There is a known outstanding bug in this implementation in C mode. Because these attributes and pragmas apply _only_ to definitions, we process them at the time we detect a definition. Due to tentative definitions in C, we end up processing the definition late. This means that in C mode, everything that ends up in a BSS section will end up in the _last_ BSS section rather than the one that was live at the time of tentative definition, even if that turns out to be the point of actual definition. This issue is not known to impact anything as of yet because we are not aware of a clear use or use case for #pragma bss_seg but should be fixed at some point. Differential Revision=http://reviews.llvm.org/D3065#inline-16241 llvm-svn: 205810
2014-04-09 06:30:47 +08:00
#include "RAIIObjectsForParser.h"
MS Compat: mark globals emitted in read-only sections const They cannot be written to, so marking them const makes sense and may improve optimisation. As a side-effect, SectionInfos has to be moved from Sema to ASTContext. It also fixes this problem, that occurs when compiling ATL: warning LNK4254: section 'ATL' (C0000040) merged into '.rdata' (40000040) with different attributes The ATL headers are putting variables in a special section that's marked read-only. However, Clang currently can't model that read-onlyness in the IR. But, by making the variables const, the section does become read-only, and the linker warning is avoided. Differential Revision: http://reviews.llvm.org/D5812 llvm-svn: 219960
2014-10-17 04:52:46 +08:00
#include "clang/AST/ASTContext.h"
Serialize `#pragma comment`. `#pragma comment` was handled by Sema calling a function on ASTConsumer, and CodeGen then implementing this function and writing things to its output. Instead, introduce a PragmaCommentDecl AST node and hang one off the TranslationUnitDecl for every `#pragma comment` line, and then use the regular serialization machinery. (Since PragmaCommentDecl has codegen relevance, it's eagerly deserialized.) http://reviews.llvm.org/D17799 llvm-svn: 262493
2016-03-03 01:28:48 +08:00
#include "clang/Basic/PragmaKinds.h"
Parse: Don't attempt to act on #pragma init_seg when not targeting MSVC It doesn't really make sense to try and do stuff with #pragma init_seg when targeting non-Microsoft platforms; notions like library vs user initializers don't exist for other targets. This fixes PR20639. llvm-svn: 215618
2014-08-14 14:35:08 +08:00
#include "clang/Basic/TargetInfo.h"
Fix DOS-style newlines. A previous patch r210330 (and possibly another) introduced DOS-style newlines into a UNIX newline formatted file. Patch by Mark Heffernan (http://reviews.llvm.org/D4046) llvm-svn: 210369
2014-06-07 04:31:48 +08:00
#include "clang/Lex/Preprocessor.h"
#include "clang/Parse/ParseDiagnostic.h"
#include "clang/Parse/Parser.h"
#include "clang/Sema/LoopHint.h"
#include "clang/Sema/Scope.h"
#include "llvm/ADT/StringSwitch.h"
using namespace clang;
Add Parser support for #pragma pack - Uses Action::ActOnPragmaPack - Test case is XFAIL pending verifier fixes. llvm-svn: 57066
2008-10-05 03:21:03 +08:00
Hide pragma handler classes in ParsePragma.cpp This reduces the number of files we need to touch to add a new pragma, and reduces the number of externally visible symbols in clang. Make the handlers structs instead of classes because the vast majority have no private members. Reviewers: rsmith Differential Revision: http://llvm-reviews.chandlerc.com/D2834 llvm-svn: 201820
2014-02-21 06:52:09 +08:00
namespace {
struct PragmaAlignHandler : public PragmaHandler {
explicit PragmaAlignHandler() : PragmaHandler("align") {}
[C++11] Add 'override' keyword to virtual methods that override their base class. llvm-svn: 203641
2014-03-12 13:09:18 +08:00
void HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer,
Token &FirstToken) override;
Hide pragma handler classes in ParsePragma.cpp This reduces the number of files we need to touch to add a new pragma, and reduces the number of externally visible symbols in clang. Make the handlers structs instead of classes because the vast majority have no private members. Reviewers: rsmith Differential Revision: http://llvm-reviews.chandlerc.com/D2834 llvm-svn: 201820
2014-02-21 06:52:09 +08:00
};
struct PragmaGCCVisibilityHandler : public PragmaHandler {
explicit PragmaGCCVisibilityHandler() : PragmaHandler("visibility") {}
[C++11] Add 'override' keyword to virtual methods that override their base class. llvm-svn: 203641
2014-03-12 13:09:18 +08:00
void HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer,
Token &FirstToken) override;
Hide pragma handler classes in ParsePragma.cpp This reduces the number of files we need to touch to add a new pragma, and reduces the number of externally visible symbols in clang. Make the handlers structs instead of classes because the vast majority have no private members. Reviewers: rsmith Differential Revision: http://llvm-reviews.chandlerc.com/D2834 llvm-svn: 201820
2014-02-21 06:52:09 +08:00
};
struct PragmaOptionsHandler : public PragmaHandler {
explicit PragmaOptionsHandler() : PragmaHandler("options") {}
[C++11] Add 'override' keyword to virtual methods that override their base class. llvm-svn: 203641
2014-03-12 13:09:18 +08:00
void HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer,
Token &FirstToken) override;
Hide pragma handler classes in ParsePragma.cpp This reduces the number of files we need to touch to add a new pragma, and reduces the number of externally visible symbols in clang. Make the handlers structs instead of classes because the vast majority have no private members. Reviewers: rsmith Differential Revision: http://llvm-reviews.chandlerc.com/D2834 llvm-svn: 201820
2014-02-21 06:52:09 +08:00
};
struct PragmaPackHandler : public PragmaHandler {
explicit PragmaPackHandler() : PragmaHandler("pack") {}
[C++11] Add 'override' keyword to virtual methods that override their base class. llvm-svn: 203641
2014-03-12 13:09:18 +08:00
void HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer,
Token &FirstToken) override;
Hide pragma handler classes in ParsePragma.cpp This reduces the number of files we need to touch to add a new pragma, and reduces the number of externally visible symbols in clang. Make the handlers structs instead of classes because the vast majority have no private members. Reviewers: rsmith Differential Revision: http://llvm-reviews.chandlerc.com/D2834 llvm-svn: 201820
2014-02-21 06:52:09 +08:00
};
struct PragmaMSStructHandler : public PragmaHandler {
explicit PragmaMSStructHandler() : PragmaHandler("ms_struct") {}
[C++11] Add 'override' keyword to virtual methods that override their base class. llvm-svn: 203641
2014-03-12 13:09:18 +08:00
void HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer,
Token &FirstToken) override;
Hide pragma handler classes in ParsePragma.cpp This reduces the number of files we need to touch to add a new pragma, and reduces the number of externally visible symbols in clang. Make the handlers structs instead of classes because the vast majority have no private members. Reviewers: rsmith Differential Revision: http://llvm-reviews.chandlerc.com/D2834 llvm-svn: 201820
2014-02-21 06:52:09 +08:00
};
struct PragmaUnusedHandler : public PragmaHandler {
PragmaUnusedHandler() : PragmaHandler("unused") {}
[C++11] Add 'override' keyword to virtual methods that override their base class. llvm-svn: 203641
2014-03-12 13:09:18 +08:00
void HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer,
Token &FirstToken) override;
Hide pragma handler classes in ParsePragma.cpp This reduces the number of files we need to touch to add a new pragma, and reduces the number of externally visible symbols in clang. Make the handlers structs instead of classes because the vast majority have no private members. Reviewers: rsmith Differential Revision: http://llvm-reviews.chandlerc.com/D2834 llvm-svn: 201820
2014-02-21 06:52:09 +08:00
};
struct PragmaWeakHandler : public PragmaHandler {
explicit PragmaWeakHandler() : PragmaHandler("weak") {}
[C++11] Add 'override' keyword to virtual methods that override their base class. llvm-svn: 203641
2014-03-12 13:09:18 +08:00
void HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer,
Token &FirstToken) override;
Hide pragma handler classes in ParsePragma.cpp This reduces the number of files we need to touch to add a new pragma, and reduces the number of externally visible symbols in clang. Make the handlers structs instead of classes because the vast majority have no private members. Reviewers: rsmith Differential Revision: http://llvm-reviews.chandlerc.com/D2834 llvm-svn: 201820
2014-02-21 06:52:09 +08:00
};
struct PragmaRedefineExtnameHandler : public PragmaHandler {
explicit PragmaRedefineExtnameHandler() : PragmaHandler("redefine_extname") {}
[C++11] Add 'override' keyword to virtual methods that override their base class. llvm-svn: 203641
2014-03-12 13:09:18 +08:00
void HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer,
Token &FirstToken) override;
Hide pragma handler classes in ParsePragma.cpp This reduces the number of files we need to touch to add a new pragma, and reduces the number of externally visible symbols in clang. Make the handlers structs instead of classes because the vast majority have no private members. Reviewers: rsmith Differential Revision: http://llvm-reviews.chandlerc.com/D2834 llvm-svn: 201820
2014-02-21 06:52:09 +08:00
};
struct PragmaOpenCLExtensionHandler : public PragmaHandler {
PragmaOpenCLExtensionHandler() : PragmaHandler("EXTENSION") {}
[C++11] Add 'override' keyword to virtual methods that override their base class. llvm-svn: 203641
2014-03-12 13:09:18 +08:00
void HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer,
Token &FirstToken) override;
Hide pragma handler classes in ParsePragma.cpp This reduces the number of files we need to touch to add a new pragma, and reduces the number of externally visible symbols in clang. Make the handlers structs instead of classes because the vast majority have no private members. Reviewers: rsmith Differential Revision: http://llvm-reviews.chandlerc.com/D2834 llvm-svn: 201820
2014-02-21 06:52:09 +08:00
};
struct PragmaFPContractHandler : public PragmaHandler {
PragmaFPContractHandler() : PragmaHandler("FP_CONTRACT") {}
[C++11] Add 'override' keyword to virtual methods that override their base class. llvm-svn: 203641
2014-03-12 13:09:18 +08:00
void HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer,
Token &FirstToken) override;
Hide pragma handler classes in ParsePragma.cpp This reduces the number of files we need to touch to add a new pragma, and reduces the number of externally visible symbols in clang. Make the handlers structs instead of classes because the vast majority have no private members. Reviewers: rsmith Differential Revision: http://llvm-reviews.chandlerc.com/D2834 llvm-svn: 201820
2014-02-21 06:52:09 +08:00
};
struct PragmaNoOpenMPHandler : public PragmaHandler {
PragmaNoOpenMPHandler() : PragmaHandler("omp") { }
[C++11] Add 'override' keyword to virtual methods that override their base class. llvm-svn: 203641
2014-03-12 13:09:18 +08:00
void HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer,
Token &FirstToken) override;
Hide pragma handler classes in ParsePragma.cpp This reduces the number of files we need to touch to add a new pragma, and reduces the number of externally visible symbols in clang. Make the handlers structs instead of classes because the vast majority have no private members. Reviewers: rsmith Differential Revision: http://llvm-reviews.chandlerc.com/D2834 llvm-svn: 201820
2014-02-21 06:52:09 +08:00
};
struct PragmaOpenMPHandler : public PragmaHandler {
PragmaOpenMPHandler() : PragmaHandler("omp") { }
[C++11] Add 'override' keyword to virtual methods that override their base class. llvm-svn: 203641
2014-03-12 13:09:18 +08:00
void HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer,
Token &FirstToken) override;
Hide pragma handler classes in ParsePragma.cpp This reduces the number of files we need to touch to add a new pragma, and reduces the number of externally visible symbols in clang. Make the handlers structs instead of classes because the vast majority have no private members. Reviewers: rsmith Differential Revision: http://llvm-reviews.chandlerc.com/D2834 llvm-svn: 201820
2014-02-21 06:52:09 +08:00
};
/// PragmaCommentHandler - "\#pragma comment ...".
struct PragmaCommentHandler : public PragmaHandler {
PragmaCommentHandler(Sema &Actions)
: PragmaHandler("comment"), Actions(Actions) {}
[C++11] Add 'override' keyword to virtual methods that override their base class. llvm-svn: 203641
2014-03-12 13:09:18 +08:00
void HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer,
Token &FirstToken) override;
Hide pragma handler classes in ParsePragma.cpp This reduces the number of files we need to touch to add a new pragma, and reduces the number of externally visible symbols in clang. Make the handlers structs instead of classes because the vast majority have no private members. Reviewers: rsmith Differential Revision: http://llvm-reviews.chandlerc.com/D2834 llvm-svn: 201820
2014-02-21 06:52:09 +08:00
private:
Sema &Actions;
};
struct PragmaDetectMismatchHandler : public PragmaHandler {
PragmaDetectMismatchHandler(Sema &Actions)
: PragmaHandler("detect_mismatch"), Actions(Actions) {}
[C++11] Add 'override' keyword to virtual methods that override their base class. llvm-svn: 203641
2014-03-12 13:09:18 +08:00
void HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer,
Token &FirstToken) override;
Hide pragma handler classes in ParsePragma.cpp This reduces the number of files we need to touch to add a new pragma, and reduces the number of externally visible symbols in clang. Make the handlers structs instead of classes because the vast majority have no private members. Reviewers: rsmith Differential Revision: http://llvm-reviews.chandlerc.com/D2834 llvm-svn: 201820
2014-02-21 06:52:09 +08:00
private:
Sema &Actions;
};
struct PragmaMSPointersToMembers : public PragmaHandler {
explicit PragmaMSPointersToMembers() : PragmaHandler("pointers_to_members") {}
[C++11] Add 'override' keyword to virtual methods that override their base class. llvm-svn: 203641
2014-03-12 13:09:18 +08:00
void HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer,
Token &FirstToken) override;
Hide pragma handler classes in ParsePragma.cpp This reduces the number of files we need to touch to add a new pragma, and reduces the number of externally visible symbols in clang. Make the handlers structs instead of classes because the vast majority have no private members. Reviewers: rsmith Differential Revision: http://llvm-reviews.chandlerc.com/D2834 llvm-svn: 201820
2014-02-21 06:52:09 +08:00
};
struct PragmaMSVtorDisp : public PragmaHandler {
explicit PragmaMSVtorDisp() : PragmaHandler("vtordisp") {}
[C++11] Add 'override' keyword to virtual methods that override their base class. llvm-svn: 203641
2014-03-12 13:09:18 +08:00
void HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer,
Token &FirstToken) override;
Hide pragma handler classes in ParsePragma.cpp This reduces the number of files we need to touch to add a new pragma, and reduces the number of externally visible symbols in clang. Make the handlers structs instead of classes because the vast majority have no private members. Reviewers: rsmith Differential Revision: http://llvm-reviews.chandlerc.com/D2834 llvm-svn: 201820
2014-02-21 06:52:09 +08:00
};
[MS-ABI] Add support for #pragma section and related pragmas This patch adds support for the msvc pragmas section, bss_seg, code_seg, const_seg and data_seg as well as support for __declspec(allocate()). Additionally it corrects semantics and adds diagnostics for __attribute__((section())) and the interaction between the attribute and the msvc pragmas and declspec. In general conflicts should now be well diganosed within and among these features. In supporting the pragmas new machinery for uniform lexing for msvc pragmas was introduced. The new machinery always lexes the entire pragma and stores it on an annotation token. The parser is responsible for parsing the pragma when the handling the annotation token. There is a known outstanding bug in this implementation in C mode. Because these attributes and pragmas apply _only_ to definitions, we process them at the time we detect a definition. Due to tentative definitions in C, we end up processing the definition late. This means that in C mode, everything that ends up in a BSS section will end up in the _last_ BSS section rather than the one that was live at the time of tentative definition, even if that turns out to be the point of actual definition. This issue is not known to impact anything as of yet because we are not aware of a clear use or use case for #pragma bss_seg but should be fixed at some point. Differential Revision=http://reviews.llvm.org/D3065#inline-16241 llvm-svn: 205810
2014-04-09 06:30:47 +08:00
struct PragmaMSPragma : public PragmaHandler {
explicit PragmaMSPragma(const char *name) : PragmaHandler(name) {}
-fms-extensions: Error out on #pragma init_seg By ignoring this pragma with a warning, we're essentially miscompiling the user's program. WebKit / Blink use this pragma to disable dynamic initialization and finalization of some static data, and running the dtors crashes the program. Error out for now, so that /fallback compiles the TU correctly with MSVC. This pragma should be implemented some time this month, and we can remove this hack. llvm-svn: 205554
2014-04-04 03:04:24 +08:00
void HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer,
Token &FirstToken) override;
};
Implemented support for "pragma clang optimize on/off", based on attribute 'optnone'. This patch implements support for selectively disabling optimizations on a range of function definitions through a pragma. The implementation is that all function definitions in the range are decorated with attribute 'optnone'. #pragma clang optimize off // All function definitions in here are decorated with 'optnone'. #pragma clang optimize on // Compilation resumes as normal. llvm-svn: 209510
2014-05-23 20:13:25 +08:00
/// PragmaOptimizeHandler - "\#pragma clang optimize on/off".
struct PragmaOptimizeHandler : public PragmaHandler {
PragmaOptimizeHandler(Sema &S)
: PragmaHandler("optimize"), Actions(S) {}
void HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer,
Token &FirstToken) override;
private:
Fix DOS-style newlines. A previous patch r210330 (and possibly another) introduced DOS-style newlines into a UNIX newline formatted file. Patch by Mark Heffernan (http://reviews.llvm.org/D4046) llvm-svn: 210369
2014-06-07 04:31:48 +08:00
Sema &Actions;
};
struct PragmaLoopHintHandler : public PragmaHandler {
PragmaLoopHintHandler() : PragmaHandler("loop") {}
void HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer,
Token &FirstToken) override;
};
Add support for '#pragma unroll'. llvm-svn: 213574
2014-07-22 02:08:34 +08:00
struct PragmaUnrollHintHandler : public PragmaHandler {
PragmaUnrollHintHandler(const char *name) : PragmaHandler(name) {}
void HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer,
Token &FirstToken) override;
};
Parse and ignore #pragma runtime_checks in MS extensions mode (PR25138) We already silently ignore the /RTC, which controls the same functionality. llvm-svn: 250099
2015-10-13 04:47:58 +08:00
struct PragmaMSRuntimeChecksHandler : public EmptyPragmaHandler {
PragmaMSRuntimeChecksHandler() : EmptyPragmaHandler("runtime_checks") {}
};
Parsing MS pragma intrinsic Parse pragma intrinsic, display warning if the function isn't a builtin function in clang and suggest including intrin.h. Patch by Albert Gutowski! Reviewers: aaron.ballman, rnk Subscribers: aaron.ballman, cfe-commits Differential Revision: https://reviews.llvm.org/D23944 llvm-svn: 280825
2016-09-08 00:38:32 +08:00
struct PragmaMSIntrinsicHandler : public PragmaHandler {
PragmaMSIntrinsicHandler() : PragmaHandler("intrinsic") {}
void HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer,
Token &FirstToken) override;
};
[CUDA] Add #pragma clang force_cuda_host_device_{begin,end} pragmas. Summary: These cause us to consider all functions in-between to be __host__ __device__. You can nest these pragmas; you just can't have more 'end's than 'begin's. Reviewers: rsmith Subscribers: tra, jhen, cfe-commits Differential Revision: https://reviews.llvm.org/D24975 llvm-svn: 283677
2016-10-09 06:15:58 +08:00
struct PragmaForceCUDAHostDeviceHandler : public PragmaHandler {
PragmaForceCUDAHostDeviceHandler(Sema &Actions)
: PragmaHandler("force_cuda_host_device"), Actions(Actions) {}
void HandlePragma(Preprocessor &PP, PragmaIntroducerKind Introducer,
Token &FirstToken) override;
private:
Sema &Actions;
};
Fix DOS-style newlines. A previous patch r210330 (and possibly another) introduced DOS-style newlines into a UNIX newline formatted file. Patch by Mark Heffernan (http://reviews.llvm.org/D4046) llvm-svn: 210369
2014-06-07 04:31:48 +08:00
} // end namespace
void Parser::initializePragmaHandlers() {
Hide pragma handler classes in ParsePragma.cpp This reduces the number of files we need to touch to add a new pragma, and reduces the number of externally visible symbols in clang. Make the handlers structs instead of classes because the vast majority have no private members. Reviewers: rsmith Differential Revision: http://llvm-reviews.chandlerc.com/D2834 llvm-svn: 201820
2014-02-21 06:52:09 +08:00
AlignHandler.reset(new PragmaAlignHandler());
PP.AddPragmaHandler(AlignHandler.get());
GCCVisibilityHandler.reset(new PragmaGCCVisibilityHandler());
PP.AddPragmaHandler("GCC", GCCVisibilityHandler.get());
OptionsHandler.reset(new PragmaOptionsHandler());
PP.AddPragmaHandler(OptionsHandler.get());
PackHandler.reset(new PragmaPackHandler());
PP.AddPragmaHandler(PackHandler.get());
MSStructHandler.reset(new PragmaMSStructHandler());
PP.AddPragmaHandler(MSStructHandler.get());
UnusedHandler.reset(new PragmaUnusedHandler());
PP.AddPragmaHandler(UnusedHandler.get());
WeakHandler.reset(new PragmaWeakHandler());
PP.AddPragmaHandler(WeakHandler.get());
RedefineExtnameHandler.reset(new PragmaRedefineExtnameHandler());
PP.AddPragmaHandler(RedefineExtnameHandler.get());
FPContractHandler.reset(new PragmaFPContractHandler());
PP.AddPragmaHandler("STDC", FPContractHandler.get());
if (getLangOpts().OpenCL) {
OpenCLExtensionHandler.reset(new PragmaOpenCLExtensionHandler());
PP.AddPragmaHandler("OPENCL", OpenCLExtensionHandler.get());
PP.AddPragmaHandler("OPENCL", FPContractHandler.get());
}
if (getLangOpts().OpenMP)
OpenMPHandler.reset(new PragmaOpenMPHandler());
else
OpenMPHandler.reset(new PragmaNoOpenMPHandler());
PP.AddPragmaHandler(OpenMPHandler.get());
Adds a warning for unrecognized argument to #pragma comment() on PS4. PS4 target recognizes the #pragma comment() syntax as in -fms-extensions, but only handles the case of #pragma comment(lib). This patch adds a warning if any other arguments are encountered. This patch also refactors the code in ParsePragma.cpp a little bit to make it more obvious that some codes are being shared between -fms-extensions and PS4. llvm-svn: 233015
2015-03-24 04:41:42 +08:00
if (getLangOpts().MicrosoftExt || getTargetInfo().getTriple().isPS4()) {
Hide pragma handler classes in ParsePragma.cpp This reduces the number of files we need to touch to add a new pragma, and reduces the number of externally visible symbols in clang. Make the handlers structs instead of classes because the vast majority have no private members. Reviewers: rsmith Differential Revision: http://llvm-reviews.chandlerc.com/D2834 llvm-svn: 201820
2014-02-21 06:52:09 +08:00
MSCommentHandler.reset(new PragmaCommentHandler(Actions));
PP.AddPragmaHandler(MSCommentHandler.get());
Adds a warning for unrecognized argument to #pragma comment() on PS4. PS4 target recognizes the #pragma comment() syntax as in -fms-extensions, but only handles the case of #pragma comment(lib). This patch adds a warning if any other arguments are encountered. This patch also refactors the code in ParsePragma.cpp a little bit to make it more obvious that some codes are being shared between -fms-extensions and PS4. llvm-svn: 233015
2015-03-24 04:41:42 +08:00
}
if (getLangOpts().MicrosoftExt) {
Hide pragma handler classes in ParsePragma.cpp This reduces the number of files we need to touch to add a new pragma, and reduces the number of externally visible symbols in clang. Make the handlers structs instead of classes because the vast majority have no private members. Reviewers: rsmith Differential Revision: http://llvm-reviews.chandlerc.com/D2834 llvm-svn: 201820
2014-02-21 06:52:09 +08:00
MSDetectMismatchHandler.reset(new PragmaDetectMismatchHandler(Actions));
PP.AddPragmaHandler(MSDetectMismatchHandler.get());
MSPointersToMembers.reset(new PragmaMSPointersToMembers());
PP.AddPragmaHandler(MSPointersToMembers.get());
MSVtorDisp.reset(new PragmaMSVtorDisp());
PP.AddPragmaHandler(MSVtorDisp.get());
[MS-ABI] Add support for #pragma section and related pragmas This patch adds support for the msvc pragmas section, bss_seg, code_seg, const_seg and data_seg as well as support for __declspec(allocate()). Additionally it corrects semantics and adds diagnostics for __attribute__((section())) and the interaction between the attribute and the msvc pragmas and declspec. In general conflicts should now be well diganosed within and among these features. In supporting the pragmas new machinery for uniform lexing for msvc pragmas was introduced. The new machinery always lexes the entire pragma and stores it on an annotation token. The parser is responsible for parsing the pragma when the handling the annotation token. There is a known outstanding bug in this implementation in C mode. Because these attributes and pragmas apply _only_ to definitions, we process them at the time we detect a definition. Due to tentative definitions in C, we end up processing the definition late. This means that in C mode, everything that ends up in a BSS section will end up in the _last_ BSS section rather than the one that was live at the time of tentative definition, even if that turns out to be the point of actual definition. This issue is not known to impact anything as of yet because we are not aware of a clear use or use case for #pragma bss_seg but should be fixed at some point. Differential Revision=http://reviews.llvm.org/D3065#inline-16241 llvm-svn: 205810
2014-04-09 06:30:47 +08:00
MSInitSeg.reset(new PragmaMSPragma("init_seg"));
-fms-extensions: Error out on #pragma init_seg By ignoring this pragma with a warning, we're essentially miscompiling the user's program. WebKit / Blink use this pragma to disable dynamic initialization and finalization of some static data, and running the dtors crashes the program. Error out for now, so that /fallback compiles the TU correctly with MSVC. This pragma should be implemented some time this month, and we can remove this hack. llvm-svn: 205554
2014-04-04 03:04:24 +08:00
PP.AddPragmaHandler(MSInitSeg.get());
[MS-ABI] Add support for #pragma section and related pragmas This patch adds support for the msvc pragmas section, bss_seg, code_seg, const_seg and data_seg as well as support for __declspec(allocate()). Additionally it corrects semantics and adds diagnostics for __attribute__((section())) and the interaction between the attribute and the msvc pragmas and declspec. In general conflicts should now be well diganosed within and among these features. In supporting the pragmas new machinery for uniform lexing for msvc pragmas was introduced. The new machinery always lexes the entire pragma and stores it on an annotation token. The parser is responsible for parsing the pragma when the handling the annotation token. There is a known outstanding bug in this implementation in C mode. Because these attributes and pragmas apply _only_ to definitions, we process them at the time we detect a definition. Due to tentative definitions in C, we end up processing the definition late. This means that in C mode, everything that ends up in a BSS section will end up in the _last_ BSS section rather than the one that was live at the time of tentative definition, even if that turns out to be the point of actual definition. This issue is not known to impact anything as of yet because we are not aware of a clear use or use case for #pragma bss_seg but should be fixed at some point. Differential Revision=http://reviews.llvm.org/D3065#inline-16241 llvm-svn: 205810
2014-04-09 06:30:47 +08:00
MSDataSeg.reset(new PragmaMSPragma("data_seg"));
PP.AddPragmaHandler(MSDataSeg.get());
MSBSSSeg.reset(new PragmaMSPragma("bss_seg"));
PP.AddPragmaHandler(MSBSSSeg.get());
MSConstSeg.reset(new PragmaMSPragma("const_seg"));
PP.AddPragmaHandler(MSConstSeg.get());
MSCodeSeg.reset(new PragmaMSPragma("code_seg"));
PP.AddPragmaHandler(MSCodeSeg.get());
MSSection.reset(new PragmaMSPragma("section"));
PP.AddPragmaHandler(MSSection.get());
Parse and ignore #pragma runtime_checks in MS extensions mode (PR25138) We already silently ignore the /RTC, which controls the same functionality. llvm-svn: 250099
2015-10-13 04:47:58 +08:00
MSRuntimeChecks.reset(new PragmaMSRuntimeChecksHandler());
PP.AddPragmaHandler(MSRuntimeChecks.get());
Parsing MS pragma intrinsic Parse pragma intrinsic, display warning if the function isn't a builtin function in clang and suggest including intrin.h. Patch by Albert Gutowski! Reviewers: aaron.ballman, rnk Subscribers: aaron.ballman, cfe-commits Differential Revision: https://reviews.llvm.org/D23944 llvm-svn: 280825
2016-09-08 00:38:32 +08:00
MSIntrinsic.reset(new PragmaMSIntrinsicHandler());
PP.AddPragmaHandler(MSIntrinsic.get());
Hide pragma handler classes in ParsePragma.cpp This reduces the number of files we need to touch to add a new pragma, and reduces the number of externally visible symbols in clang. Make the handlers structs instead of classes because the vast majority have no private members. Reviewers: rsmith Differential Revision: http://llvm-reviews.chandlerc.com/D2834 llvm-svn: 201820
2014-02-21 06:52:09 +08:00
}
Fix DOS-style newlines. A previous patch r210330 (and possibly another) introduced DOS-style newlines into a UNIX newline formatted file. Patch by Mark Heffernan (http://reviews.llvm.org/D4046) llvm-svn: 210369
2014-06-07 04:31:48 +08:00
[CUDA] Add #pragma clang force_cuda_host_device_{begin,end} pragmas. Summary: These cause us to consider all functions in-between to be __host__ __device__. You can nest these pragmas; you just can't have more 'end's than 'begin's. Reviewers: rsmith Subscribers: tra, jhen, cfe-commits Differential Revision: https://reviews.llvm.org/D24975 llvm-svn: 283677
2016-10-09 06:15:58 +08:00
if (getLangOpts().CUDA) {
CUDAForceHostDeviceHandler.reset(
new PragmaForceCUDAHostDeviceHandler(Actions));
PP.AddPragmaHandler("clang", CUDAForceHostDeviceHandler.get());
}
Fix DOS-style newlines. A previous patch r210330 (and possibly another) introduced DOS-style newlines into a UNIX newline formatted file. Patch by Mark Heffernan (http://reviews.llvm.org/D4046) llvm-svn: 210369
2014-06-07 04:31:48 +08:00
OptimizeHandler.reset(new PragmaOptimizeHandler(Actions));
PP.AddPragmaHandler("clang", OptimizeHandler.get());
LoopHintHandler.reset(new PragmaLoopHintHandler());
PP.AddPragmaHandler("clang", LoopHintHandler.get());
Add support for '#pragma unroll'. llvm-svn: 213574
2014-07-22 02:08:34 +08:00
UnrollHintHandler.reset(new PragmaUnrollHintHandler("unroll"));
PP.AddPragmaHandler(UnrollHintHandler.get());
Add support for #pragma nounroll. llvm-svn: 213885
2014-07-25 02:09:38 +08:00
NoUnrollHintHandler.reset(new PragmaUnrollHintHandler("nounroll"));
PP.AddPragmaHandler(NoUnrollHintHandler.get());
Fix DOS-style newlines. A previous patch r210330 (and possibly another) introduced DOS-style newlines into a UNIX newline formatted file. Patch by Mark Heffernan (http://reviews.llvm.org/D4046) llvm-svn: 210369
2014-06-07 04:31:48 +08:00
}
void Parser::resetPragmaHandlers() {
Hide pragma handler classes in ParsePragma.cpp This reduces the number of files we need to touch to add a new pragma, and reduces the number of externally visible symbols in clang. Make the handlers structs instead of classes because the vast majority have no private members. Reviewers: rsmith Differential Revision: http://llvm-reviews.chandlerc.com/D2834 llvm-svn: 201820
2014-02-21 06:52:09 +08:00
// 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();
Adds a warning for unrecognized argument to #pragma comment() on PS4. PS4 target recognizes the #pragma comment() syntax as in -fms-extensions, but only handles the case of #pragma comment(lib). This patch adds a warning if any other arguments are encountered. This patch also refactors the code in ParsePragma.cpp a little bit to make it more obvious that some codes are being shared between -fms-extensions and PS4. llvm-svn: 233015
2015-03-24 04:41:42 +08:00
if (getLangOpts().MicrosoftExt || getTargetInfo().getTriple().isPS4()) {
Hide pragma handler classes in ParsePragma.cpp This reduces the number of files we need to touch to add a new pragma, and reduces the number of externally visible symbols in clang. Make the handlers structs instead of classes because the vast majority have no private members. Reviewers: rsmith Differential Revision: http://llvm-reviews.chandlerc.com/D2834 llvm-svn: 201820
2014-02-21 06:52:09 +08:00
PP.RemovePragmaHandler(MSCommentHandler.get());
MSCommentHandler.reset();
Adds a warning for unrecognized argument to #pragma comment() on PS4. PS4 target recognizes the #pragma comment() syntax as in -fms-extensions, but only handles the case of #pragma comment(lib). This patch adds a warning if any other arguments are encountered. This patch also refactors the code in ParsePragma.cpp a little bit to make it more obvious that some codes are being shared between -fms-extensions and PS4. llvm-svn: 233015
2015-03-24 04:41:42 +08:00
}
if (getLangOpts().MicrosoftExt) {
Hide pragma handler classes in ParsePragma.cpp This reduces the number of files we need to touch to add a new pragma, and reduces the number of externally visible symbols in clang. Make the handlers structs instead of classes because the vast majority have no private members. Reviewers: rsmith Differential Revision: http://llvm-reviews.chandlerc.com/D2834 llvm-svn: 201820
2014-02-21 06:52:09 +08:00
PP.RemovePragmaHandler(MSDetectMismatchHandler.get());
MSDetectMismatchHandler.reset();
PP.RemovePragmaHandler(MSPointersToMembers.get());
MSPointersToMembers.reset();
PP.RemovePragmaHandler(MSVtorDisp.get());
MSVtorDisp.reset();
-fms-extensions: Error out on #pragma init_seg By ignoring this pragma with a warning, we're essentially miscompiling the user's program. WebKit / Blink use this pragma to disable dynamic initialization and finalization of some static data, and running the dtors crashes the program. Error out for now, so that /fallback compiles the TU correctly with MSVC. This pragma should be implemented some time this month, and we can remove this hack. llvm-svn: 205554
2014-04-04 03:04:24 +08:00
PP.RemovePragmaHandler(MSInitSeg.get());
MSInitSeg.reset();
[MS-ABI] Add support for #pragma section and related pragmas This patch adds support for the msvc pragmas section, bss_seg, code_seg, const_seg and data_seg as well as support for __declspec(allocate()). Additionally it corrects semantics and adds diagnostics for __attribute__((section())) and the interaction between the attribute and the msvc pragmas and declspec. In general conflicts should now be well diganosed within and among these features. In supporting the pragmas new machinery for uniform lexing for msvc pragmas was introduced. The new machinery always lexes the entire pragma and stores it on an annotation token. The parser is responsible for parsing the pragma when the handling the annotation token. There is a known outstanding bug in this implementation in C mode. Because these attributes and pragmas apply _only_ to definitions, we process them at the time we detect a definition. Due to tentative definitions in C, we end up processing the definition late. This means that in C mode, everything that ends up in a BSS section will end up in the _last_ BSS section rather than the one that was live at the time of tentative definition, even if that turns out to be the point of actual definition. This issue is not known to impact anything as of yet because we are not aware of a clear use or use case for #pragma bss_seg but should be fixed at some point. Differential Revision=http://reviews.llvm.org/D3065#inline-16241 llvm-svn: 205810
2014-04-09 06:30:47 +08:00
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();
Parse and ignore #pragma runtime_checks in MS extensions mode (PR25138) We already silently ignore the /RTC, which controls the same functionality. llvm-svn: 250099
2015-10-13 04:47:58 +08:00
PP.RemovePragmaHandler(MSRuntimeChecks.get());
MSRuntimeChecks.reset();
Parsing MS pragma intrinsic Parse pragma intrinsic, display warning if the function isn't a builtin function in clang and suggest including intrin.h. Patch by Albert Gutowski! Reviewers: aaron.ballman, rnk Subscribers: aaron.ballman, cfe-commits Differential Revision: https://reviews.llvm.org/D23944 llvm-svn: 280825
2016-09-08 00:38:32 +08:00
PP.RemovePragmaHandler(MSIntrinsic.get());
MSIntrinsic.reset();
Hide pragma handler classes in ParsePragma.cpp This reduces the number of files we need to touch to add a new pragma, and reduces the number of externally visible symbols in clang. Make the handlers structs instead of classes because the vast majority have no private members. Reviewers: rsmith Differential Revision: http://llvm-reviews.chandlerc.com/D2834 llvm-svn: 201820
2014-02-21 06:52:09 +08:00
}
[CUDA] Add #pragma clang force_cuda_host_device_{begin,end} pragmas. Summary: These cause us to consider all functions in-between to be __host__ __device__. You can nest these pragmas; you just can't have more 'end's than 'begin's. Reviewers: rsmith Subscribers: tra, jhen, cfe-commits Differential Revision: https://reviews.llvm.org/D24975 llvm-svn: 283677
2016-10-09 06:15:58 +08:00
if (getLangOpts().CUDA) {
PP.RemovePragmaHandler("clang", CUDAForceHostDeviceHandler.get());
CUDAForceHostDeviceHandler.reset();
}
Hide pragma handler classes in ParsePragma.cpp This reduces the number of files we need to touch to add a new pragma, and reduces the number of externally visible symbols in clang. Make the handlers structs instead of classes because the vast majority have no private members. Reviewers: rsmith Differential Revision: http://llvm-reviews.chandlerc.com/D2834 llvm-svn: 201820
2014-02-21 06:52:09 +08:00
PP.RemovePragmaHandler("STDC", FPContractHandler.get());
FPContractHandler.reset();
Fix DOS-style newlines. A previous patch r210330 (and possibly another) introduced DOS-style newlines into a UNIX newline formatted file. Patch by Mark Heffernan (http://reviews.llvm.org/D4046) llvm-svn: 210369
2014-06-07 04:31:48 +08:00
PP.RemovePragmaHandler("clang", OptimizeHandler.get());
OptimizeHandler.reset();
PP.RemovePragmaHandler("clang", LoopHintHandler.get());
LoopHintHandler.reset();
Add support for '#pragma unroll'. llvm-svn: 213574
2014-07-22 02:08:34 +08:00
PP.RemovePragmaHandler(UnrollHintHandler.get());
UnrollHintHandler.reset();
Add support for #pragma nounroll. llvm-svn: 213885
2014-07-25 02:09:38 +08:00
PP.RemovePragmaHandler(NoUnrollHintHandler.get());
NoUnrollHintHandler.reset();
Fix DOS-style newlines. A previous patch r210330 (and possibly another) introduced DOS-style newlines into a UNIX newline formatted file. Patch by Mark Heffernan (http://reviews.llvm.org/D4046) llvm-svn: 210369
2014-06-07 04:31:48 +08:00
}
/// \brief Handle the annotation token produced for #pragma unused(...)
Convert "#pragma unused(...)" into tokens for the parser. This allows us to cache a "#pragma unused" that occurs inside an inline C++ member function. Fixes rdar://8829590&8770988. llvm-svn: 123666
2011-01-18 02:58:44 +08:00
///
/// Each annot_pragma_unused is followed by the argument token so e.g.
/// "#pragma unused(x,y)" becomes:
/// annot_pragma_unused 'x' annot_pragma_unused 'y'
void Parser::HandlePragmaUnused() {
assert(Tok.is(tok::annot_pragma_unused));
SourceLocation UnusedLoc = ConsumeToken();
Actions.ActOnPragmaUnused(Tok, getCurScope(), UnusedLoc);
ConsumeToken(); // The argument token.
}
Implement #pragma GCC visibility. llvm-svn: 110315
2010-08-05 14:57:20 +08:00
Fix our handling of #pragma GCC visibility. Now the lexer just produces a token and the parser is the one responsible for activating it. This fixes problem like the one pr11797 where the lexer and the parser were not in sync. This also let us be more strict on where in the file we accept these pragmas. llvm-svn: 149014
2012-01-26 10:02:57 +08:00
void Parser::HandlePragmaVisibility() {
assert(Tok.is(tok::annot_pragma_vis));
const IdentifierInfo *VisType =
static_cast<IdentifierInfo *>(Tok.getAnnotationValue());
SourceLocation VisLoc = ConsumeToken();
Actions.ActOnPragmaVisibility(VisType, VisLoc);
}
Put global classes into the appropriate namespace. Most of the cases belong into an anonymous namespace. No functionality change intended. llvm-svn: 251514
2015-10-28 21:54:16 +08:00
namespace {
Handle "#pragma GCC visibility" in a few more places. Switch over "#pragma pack" to use the same handling that gcc does. Fixes <rdar://problem/10871094> and <rdar://problem/10893316>. (Hopefully, common usage of these pragmas isn't irregular enough to break our current handling. Doug has ideas for a more crazy approach if necessary.) llvm-svn: 151307
2012-02-24 07:47:16 +08:00
struct PragmaPackInfo {
[MS] Make #pragma pack use PragmaStack<> class. Make implementation of #pragma pack consistent with other "stack" pragmas. Use PragmaStack<> class instead of old representation of internal stack. Don't change compiler's behavior. TODO: 1. Introduce diagnostics on popping named slots from pragma stacks. Reviewer: rnk Differential revision: http://reviews.llvm.org/D19727 llvm-svn: 268085
2016-04-30 02:17:40 +08:00
Sema::PragmaMsStackAction Action;
StringRef SlotLabel;
Permanently end the whole "pragma got handled by the parser too early" mess by handling all pragmas which the parser touches uniformly. <rdar://problem/12248901>, etc. llvm-svn: 165195
2012-10-04 10:36:51 +08:00
Token Alignment;
Handle "#pragma GCC visibility" in a few more places. Switch over "#pragma pack" to use the same handling that gcc does. Fixes <rdar://problem/10871094> and <rdar://problem/10893316>. (Hopefully, common usage of these pragmas isn't irregular enough to break our current handling. Doug has ideas for a more crazy approach if necessary.) llvm-svn: 151307
2012-02-24 07:47:16 +08:00
};
Put global classes into the appropriate namespace. Most of the cases belong into an anonymous namespace. No functionality change intended. llvm-svn: 251514
2015-10-28 21:54:16 +08:00
} // end anonymous namespace
Handle "#pragma GCC visibility" in a few more places. Switch over "#pragma pack" to use the same handling that gcc does. Fixes <rdar://problem/10871094> and <rdar://problem/10893316>. (Hopefully, common usage of these pragmas isn't irregular enough to break our current handling. Doug has ideas for a more crazy approach if necessary.) llvm-svn: 151307
2012-02-24 07:47:16 +08:00
void Parser::HandlePragmaPack() {
assert(Tok.is(tok::annot_pragma_pack));
PragmaPackInfo *Info =
static_cast<PragmaPackInfo *>(Tok.getAnnotationValue());
SourceLocation PragmaLoc = ConsumeToken();
Permanently end the whole "pragma got handled by the parser too early" mess by handling all pragmas which the parser touches uniformly. <rdar://problem/12248901>, etc. llvm-svn: 165195
2012-10-04 10:36:51 +08:00
ExprResult Alignment;
if (Info->Alignment.is(tok::numeric_constant)) {
Alignment = Actions.ActOnNumericConstant(Info->Alignment);
if (Alignment.isInvalid())
return;
}
[MS] Make #pragma pack use PragmaStack<> class. Make implementation of #pragma pack consistent with other "stack" pragmas. Use PragmaStack<> class instead of old representation of internal stack. Don't change compiler's behavior. TODO: 1. Introduce diagnostics on popping named slots from pragma stacks. Reviewer: rnk Differential revision: http://reviews.llvm.org/D19727 llvm-svn: 268085
2016-04-30 02:17:40 +08:00
Actions.ActOnPragmaPack(PragmaLoc, Info->Action, Info->SlotLabel,
Alignment.get());
Handle "#pragma GCC visibility" in a few more places. Switch over "#pragma pack" to use the same handling that gcc does. Fixes <rdar://problem/10871094> and <rdar://problem/10893316>. (Hopefully, common usage of these pragmas isn't irregular enough to break our current handling. Doug has ideas for a more crazy approach if necessary.) llvm-svn: 151307
2012-02-24 07:47:16 +08:00
}
Permanently end the whole "pragma got handled by the parser too early" mess by handling all pragmas which the parser touches uniformly. <rdar://problem/12248901>, etc. llvm-svn: 165195
2012-10-04 10:36:51 +08:00
void Parser::HandlePragmaMSStruct() {
assert(Tok.is(tok::annot_pragma_msstruct));
Serialize `pragma ms_struct` state. pragma ms_struct has an effect on struct decls, and the effect is serialized correctly already. But the "is ms_struct currently on" state wasn't before this change. This uses the same approach as `pragma clang optimize`: When writing a module, the state isn't serialized, only when writing a pch file. llvm-svn: 262539
2016-03-03 07:22:00 +08:00
PragmaMSStructKind Kind = static_cast<PragmaMSStructKind>(
reinterpret_cast<uintptr_t>(Tok.getAnnotationValue()));
Permanently end the whole "pragma got handled by the parser too early" mess by handling all pragmas which the parser touches uniformly. <rdar://problem/12248901>, etc. llvm-svn: 165195
2012-10-04 10:36:51 +08:00
Actions.ActOnPragmaMSStruct(Kind);
ConsumeToken(); // The annotation token.
}
void Parser::HandlePragmaAlign() {
assert(Tok.is(tok::annot_pragma_align));
Sema::PragmaOptionsAlignKind Kind =
static_cast<Sema::PragmaOptionsAlignKind>(
reinterpret_cast<uintptr_t>(Tok.getAnnotationValue()));
SourceLocation PragmaLoc = ConsumeToken();
Actions.ActOnPragmaOptionsAlign(Kind, PragmaLoc);
}
Improve AST dumping: 1) When dumping a declaration that declares a name for a type, also dump the named type. 2) Add a #pragma clang __debug dump X, that dumps the lookup results for X in the current context. llvm-svn: 257529
2016-01-13 05:59:26 +08:00
void Parser::HandlePragmaDump() {
assert(Tok.is(tok::annot_pragma_dump));
IdentifierInfo *II =
reinterpret_cast<IdentifierInfo *>(Tok.getAnnotationValue());
Actions.ActOnPragmaDump(getCurScope(), Tok.getLocation(), II);
ConsumeToken();
}
Permanently end the whole "pragma got handled by the parser too early" mess by handling all pragmas which the parser touches uniformly. <rdar://problem/12248901>, etc. llvm-svn: 165195
2012-10-04 10:36:51 +08:00
void Parser::HandlePragmaWeak() {
assert(Tok.is(tok::annot_pragma_weak));
SourceLocation PragmaLoc = ConsumeToken();
Actions.ActOnPragmaWeakID(Tok.getIdentifierInfo(), PragmaLoc,
Tok.getLocation());
ConsumeToken(); // The weak name.
}
void Parser::HandlePragmaWeakAlias() {
assert(Tok.is(tok::annot_pragma_weakalias));
SourceLocation PragmaLoc = ConsumeToken();
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);
}
void Parser::HandlePragmaRedefineExtname() {
assert(Tok.is(tok::annot_pragma_redefine_extname));
SourceLocation RedefLoc = ConsumeToken();
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);
}
void Parser::HandlePragmaFPContract() {
assert(Tok.is(tok::annot_pragma_fp_contract));
tok::OnOffSwitch OOS =
static_cast<tok::OnOffSwitch>(
reinterpret_cast<uintptr_t>(Tok.getAnnotationValue()));
Actions.ActOnPragmaFPContract(OOS);
ConsumeToken(); // The annotation token.
}
Parser support for #pragma clang __debug captured This patch implements parsing ‘#pragma clang __debug’ as a first step for implementing captured statements. Captured statements are a mechanism for doing outlining in the AST. see http://lists.cs.uiuc.edu/pipermail/cfe-dev/2013-January/027540.html. Currently returns StmtEmpty Author: Andy Zhang <andy.zhang@intel.com> Differential Revision: http://llvm-reviews.chandlerc.com/D369 llvm-svn: 179614
2013-04-17 02:41:26 +08:00
StmtResult Parser::HandlePragmaCaptured()
{
assert(Tok.is(tok::annot_pragma_captured));
ConsumeToken();
if (Tok.isNot(tok::l_brace)) {
Support and use token kinds as diagnostic arguments Introduce proper facilities to render token spellings using the diagnostic formatter. Replaces most of the hard-coded diagnostic messages related to expected tokens, which all shared the same semantics but had to be multiply defined due to variations in token order or quote marks. The associated parser changes are largely mechanical but they expose commonality in whole chunks of the parser that can now be factored away. This commit uses C++11 typed enums along with a speculative legacy fallback until the transition is complete. Requires corresponding changes in LLVM r197895. llvm-svn: 197972
2013-12-24 17:48:30 +08:00
PP.Diag(Tok, diag::err_expected) << tok::l_brace;
Parser support for #pragma clang __debug captured This patch implements parsing ‘#pragma clang __debug’ as a first step for implementing captured statements. Captured statements are a mechanism for doing outlining in the AST. see http://lists.cs.uiuc.edu/pipermail/cfe-dev/2013-January/027540.html. Currently returns StmtEmpty Author: Andy Zhang <andy.zhang@intel.com> Differential Revision: http://llvm-reviews.chandlerc.com/D369 llvm-svn: 179614
2013-04-17 02:41:26 +08:00
return StmtError();
}
Sema for Captured Statements Add CapturedDecl to be the DeclContext for CapturedStmt, and perform semantic analysis. Currently captures all variables by reference. TODO: templates Author: Ben Langmuir <ben.langmuir@intel.com> Differential Revision: http://llvm-reviews.chandlerc.com/D433 llvm-svn: 179618
2013-04-17 03:37:38 +08:00
SourceLocation Loc = Tok.getLocation();
ParseScope CapturedRegionScope(this, Scope::FnScope | Scope::DeclScope);
Move CapturedStmt parameters to CapturedDecl Move the creation of CapturedStmt parameters out of CodeGen and into Sema, making it easier to customize the outlined function. The ImplicitParamDecls are stored in the CapturedDecl using an ASTContext-allocated array. Differential Revision: http://llvm-reviews.chandlerc.com/D722 llvm-svn: 181043
2013-05-04 03:00:33 +08:00
Actions.ActOnCapturedRegionStart(Loc, getCurScope(), CR_Default,
/*NumParams=*/1);
Sema for Captured Statements Add CapturedDecl to be the DeclContext for CapturedStmt, and perform semantic analysis. Currently captures all variables by reference. TODO: templates Author: Ben Langmuir <ben.langmuir@intel.com> Differential Revision: http://llvm-reviews.chandlerc.com/D433 llvm-svn: 179618
2013-04-17 03:37:38 +08:00
StmtResult R = ParseCompoundStatement();
CapturedRegionScope.Exit();
if (R.isInvalid()) {
Actions.ActOnCapturedRegionError();
return StmtError();
}
return Actions.ActOnCapturedRegionEnd(R.get());
Parser support for #pragma clang __debug captured This patch implements parsing ‘#pragma clang __debug’ as a first step for implementing captured statements. Captured statements are a mechanism for doing outlining in the AST. see http://lists.cs.uiuc.edu/pipermail/cfe-dev/2013-January/027540.html. Currently returns StmtEmpty Author: Andy Zhang <andy.zhang@intel.com> Differential Revision: http://llvm-reviews.chandlerc.com/D369 llvm-svn: 179614
2013-04-17 02:41:26 +08:00
}
Permanently end the whole "pragma got handled by the parser too early" mess by handling all pragmas which the parser touches uniformly. <rdar://problem/12248901>, etc. llvm-svn: 165195
2012-10-04 10:36:51 +08:00
namespace {
typedef llvm::PointerIntPair<IdentifierInfo *, 1, bool> OpenCLExtData;
}
void Parser::HandlePragmaOpenCLExtension() {
assert(Tok.is(tok::annot_pragma_opencl_extension));
OpenCLExtData data =
OpenCLExtData::getFromOpaqueValue(Tok.getAnnotationValue());
unsigned state = data.getInt();
IdentifierInfo *ename = data.getPointer();
SourceLocation NameLoc = Tok.getLocation();
ConsumeToken(); // The annotation token.
OpenCLOptions &f = Actions.getOpenCLOptions();
[OpenCL] Add supported OpenCL extensions to target info. Add supported OpenCL extensions to target info. It serves as default values to save the users of the burden setting each supported extensions and optional core features in command line. Re-commit after fixing build error due to missing override attribute. Differential Revision: http://reviews.llvm.org/D19484 llvm-svn: 269670
2016-05-17 01:06:34 +08:00
auto CLVer = getLangOpts().OpenCLVersion;
auto &Supp = getTargetInfo().getSupportedOpenCLOpts();
Permanently end the whole "pragma got handled by the parser too early" mess by handling all pragmas which the parser touches uniformly. <rdar://problem/12248901>, etc. llvm-svn: 165195
2012-10-04 10:36:51 +08:00
// 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 (state == 0 && ename->isStr("all")) {
[OpenCL] Add supported OpenCL extensions to target info. Add supported OpenCL extensions to target info. It serves as default values to save the users of the burden setting each supported extensions and optional core features in command line. Re-commit after fixing build error due to missing override attribute. Differential Revision: http://reviews.llvm.org/D19484 llvm-svn: 269670
2016-05-17 01:06:34 +08:00
#define OPENCLEXT(nm) \
if (Supp.is_##nm##_supported_extension(CLVer)) \
f.nm = 0;
Permanently end the whole "pragma got handled by the parser too early" mess by handling all pragmas which the parser touches uniformly. <rdar://problem/12248901>, etc. llvm-svn: 165195
2012-10-04 10:36:51 +08:00
#include "clang/Basic/OpenCLExtensions.def"
}
[OpenCL] Add supported OpenCL extensions to target info. Add supported OpenCL extensions to target info. It serves as default values to save the users of the burden setting each supported extensions and optional core features in command line. Re-commit after fixing build error due to missing override attribute. Differential Revision: http://reviews.llvm.org/D19484 llvm-svn: 269670
2016-05-17 01:06:34 +08:00
#define OPENCLEXT(nm) else if (ename->isStr(#nm)) \
if (Supp.is_##nm##_supported_extension(CLVer)) \
f.nm = state; \
else if (Supp.is_##nm##_supported_core(CLVer)) \
PP.Diag(NameLoc, diag::warn_pragma_extension_is_core) << ename; \
else \
PP.Diag(NameLoc, diag::warn_pragma_unsupported_extension) << ename;
Permanently end the whole "pragma got handled by the parser too early" mess by handling all pragmas which the parser touches uniformly. <rdar://problem/12248901>, etc. llvm-svn: 165195
2012-10-04 10:36:51 +08:00
#include "clang/Basic/OpenCLExtensions.def"
else {
PP.Diag(NameLoc, diag::warn_pragma_unknown_extension) << ename;
return;
}
}
MS ABI: Add support for #pragma pointers_to_members Introduce a notion of a 'current representation method' for pointers-to-members. When starting out, this is set to 'best case' (representation method is chosen by examining the class, selecting the smallest representation that would work given the class definition or lack thereof). This pragma allows the translation unit to dictate exactly what representation to use, similar to how the inheritance model keywords operate. N.B. PCH support is forthcoming. Differential Revision: http://llvm-reviews.chandlerc.com/D2723 llvm-svn: 201105
2014-02-11 03:50:15 +08:00
void Parser::HandlePragmaMSPointersToMembers() {
assert(Tok.is(tok::annot_pragma_ms_pointers_to_members));
MS ABI: Add support for the -vm{b,g,s,m,v} flags These flags control the inheritance model initially used by the translation unit. Differential Revision: http://llvm-reviews.chandlerc.com/D2741 llvm-svn: 201175
2014-02-12 05:05:00 +08:00
LangOptions::PragmaMSPointersToMembersKind RepresentationMethod =
static_cast<LangOptions::PragmaMSPointersToMembersKind>(
MS ABI: Add support for #pragma pointers_to_members Introduce a notion of a 'current representation method' for pointers-to-members. When starting out, this is set to 'best case' (representation method is chosen by examining the class, selecting the smallest representation that would work given the class definition or lack thereof). This pragma allows the translation unit to dictate exactly what representation to use, similar to how the inheritance model keywords operate. N.B. PCH support is forthcoming. Differential Revision: http://llvm-reviews.chandlerc.com/D2723 llvm-svn: 201105
2014-02-11 03:50:15 +08:00
reinterpret_cast<uintptr_t>(Tok.getAnnotationValue()));
SourceLocation PragmaLoc = ConsumeToken(); // The annotation token.
Actions.ActOnPragmaMSPointersToMembers(RepresentationMethod, PragmaLoc);
}
Parser support for #pragma clang __debug captured This patch implements parsing ‘#pragma clang __debug’ as a first step for implementing captured statements. Captured statements are a mechanism for doing outlining in the AST. see http://lists.cs.uiuc.edu/pipermail/cfe-dev/2013-January/027540.html. Currently returns StmtEmpty Author: Andy Zhang <andy.zhang@intel.com> Differential Revision: http://llvm-reviews.chandlerc.com/D369 llvm-svn: 179614
2013-04-17 02:41:26 +08:00
MS ABI: Implement #pragma vtordisp() and clang-cl /vdN These features are new in VS 2013 and are necessary in order to layout std::ostream correctly. Currently we have an ABI incompatibility when self-hosting with the 2013 stdlib in our convertible_fwd_ostream wrapper in gtest. This change adds another implicit attribute, MSVtorDispAttr, because implicit attributes are currently the best way to make sure the information stays on class templates through instantiation. Reviewers: majnemer Differential Revision: http://llvm-reviews.chandlerc.com/D2746 llvm-svn: 201274
2014-02-13 07:50:26 +08:00
void Parser::HandlePragmaMSVtorDisp() {
assert(Tok.is(tok::annot_pragma_ms_vtordisp));
uintptr_t Value = reinterpret_cast<uintptr_t>(Tok.getAnnotationValue());
Recommit "[MS] Improved implementation of stack pragmas (vtordisp, *_seg)" Slightly updated version, double-checked build and tests. Improve implementation of MS pragmas that use stack + compatibility fixes. This patch: 1. Changes implementation of #pragma vtordisp to use PragmaStack class that other stack pragmas use; 2. Fixes "#pragma vtordisp()" behavior - it shouldn't affect the stack; 3. Supports "save-restore" of pragma stacks on enter / exit a C++ method body, as MSVC does. TODO: 1. Change implementation of #pragma pack to use the same approach; 2. Introduce diagnostics on popping named stack slots, as MSVC does. Reviewers: rnk, thakis Differential revision: http://reviews.llvm.org/D19361 llvm-svn: 268029
2016-04-29 19:27:00 +08:00
Sema::PragmaMsStackAction Action =
static_cast<Sema::PragmaMsStackAction>((Value >> 16) & 0xFFFF);
MS ABI: Implement #pragma vtordisp() and clang-cl /vdN These features are new in VS 2013 and are necessary in order to layout std::ostream correctly. Currently we have an ABI incompatibility when self-hosting with the 2013 stdlib in our convertible_fwd_ostream wrapper in gtest. This change adds another implicit attribute, MSVtorDispAttr, because implicit attributes are currently the best way to make sure the information stays on class templates through instantiation. Reviewers: majnemer Differential Revision: http://llvm-reviews.chandlerc.com/D2746 llvm-svn: 201274
2014-02-13 07:50:26 +08:00
MSVtorDispAttr::Mode Mode = MSVtorDispAttr::Mode(Value & 0xFFFF);
SourceLocation PragmaLoc = ConsumeToken(); // The annotation token.
Recommit "[MS] Improved implementation of stack pragmas (vtordisp, *_seg)" Slightly updated version, double-checked build and tests. Improve implementation of MS pragmas that use stack + compatibility fixes. This patch: 1. Changes implementation of #pragma vtordisp to use PragmaStack class that other stack pragmas use; 2. Fixes "#pragma vtordisp()" behavior - it shouldn't affect the stack; 3. Supports "save-restore" of pragma stacks on enter / exit a C++ method body, as MSVC does. TODO: 1. Change implementation of #pragma pack to use the same approach; 2. Introduce diagnostics on popping named stack slots, as MSVC does. Reviewers: rnk, thakis Differential revision: http://reviews.llvm.org/D19361 llvm-svn: 268029
2016-04-29 19:27:00 +08:00
Actions.ActOnPragmaMSVtorDisp(Action, PragmaLoc, Mode);
MS ABI: Implement #pragma vtordisp() and clang-cl /vdN These features are new in VS 2013 and are necessary in order to layout std::ostream correctly. Currently we have an ABI incompatibility when self-hosting with the 2013 stdlib in our convertible_fwd_ostream wrapper in gtest. This change adds another implicit attribute, MSVtorDispAttr, because implicit attributes are currently the best way to make sure the information stays on class templates through instantiation. Reviewers: majnemer Differential Revision: http://llvm-reviews.chandlerc.com/D2746 llvm-svn: 201274
2014-02-13 07:50:26 +08:00
}
Parser support for #pragma clang __debug captured This patch implements parsing ‘#pragma clang __debug’ as a first step for implementing captured statements. Captured statements are a mechanism for doing outlining in the AST. see http://lists.cs.uiuc.edu/pipermail/cfe-dev/2013-January/027540.html. Currently returns StmtEmpty Author: Andy Zhang <andy.zhang@intel.com> Differential Revision: http://llvm-reviews.chandlerc.com/D369 llvm-svn: 179614
2013-04-17 02:41:26 +08:00
[MS-ABI] Add support for #pragma section and related pragmas This patch adds support for the msvc pragmas section, bss_seg, code_seg, const_seg and data_seg as well as support for __declspec(allocate()). Additionally it corrects semantics and adds diagnostics for __attribute__((section())) and the interaction between the attribute and the msvc pragmas and declspec. In general conflicts should now be well diganosed within and among these features. In supporting the pragmas new machinery for uniform lexing for msvc pragmas was introduced. The new machinery always lexes the entire pragma and stores it on an annotation token. The parser is responsible for parsing the pragma when the handling the annotation token. There is a known outstanding bug in this implementation in C mode. Because these attributes and pragmas apply _only_ to definitions, we process them at the time we detect a definition. Due to tentative definitions in C, we end up processing the definition late. This means that in C mode, everything that ends up in a BSS section will end up in the _last_ BSS section rather than the one that was live at the time of tentative definition, even if that turns out to be the point of actual definition. This issue is not known to impact anything as of yet because we are not aware of a clear use or use case for #pragma bss_seg but should be fixed at some point. Differential Revision=http://reviews.llvm.org/D3065#inline-16241 llvm-svn: 205810
2014-04-09 06:30:47 +08:00
void Parser::HandlePragmaMSPragma() {
assert(Tok.is(tok::annot_pragma_ms_pragma));
// Grab the tokens out of the annotation and enter them into the stream.
Simplify EnterTokenStream API to make it more robust for memory management While this won't help fix things like the bug that r260219 addressed, it seems like good tidy up to have anyway. (it might be nice if "makeArrayRef" always produced a MutableArrayRef & let it decay to an ArrayRef when needed - then I'd use that for the MutableArrayRefs in this patch) If we had std::dynarray I'd use that instead of unique_ptr+size_t, ideally (but then it'd have to be threaded down through the Preprocessor all the way - no idea how painful that would be) llvm-svn: 260246
2016-02-10 02:52:09 +08:00
auto TheTokens =
(std::pair<std::unique_ptr<Token[]>, size_t> *)Tok.getAnnotationValue();
PP.EnterTokenStream(std::move(TheTokens->first), TheTokens->second, true);
[MS-ABI] Add support for #pragma section and related pragmas This patch adds support for the msvc pragmas section, bss_seg, code_seg, const_seg and data_seg as well as support for __declspec(allocate()). Additionally it corrects semantics and adds diagnostics for __attribute__((section())) and the interaction between the attribute and the msvc pragmas and declspec. In general conflicts should now be well diganosed within and among these features. In supporting the pragmas new machinery for uniform lexing for msvc pragmas was introduced. The new machinery always lexes the entire pragma and stores it on an annotation token. The parser is responsible for parsing the pragma when the handling the annotation token. There is a known outstanding bug in this implementation in C mode. Because these attributes and pragmas apply _only_ to definitions, we process them at the time we detect a definition. Due to tentative definitions in C, we end up processing the definition late. This means that in C mode, everything that ends up in a BSS section will end up in the _last_ BSS section rather than the one that was live at the time of tentative definition, even if that turns out to be the point of actual definition. This issue is not known to impact anything as of yet because we are not aware of a clear use or use case for #pragma bss_seg but should be fixed at some point. Differential Revision=http://reviews.llvm.org/D3065#inline-16241 llvm-svn: 205810
2014-04-09 06:30:47 +08:00
SourceLocation PragmaLocation = ConsumeToken(); // The annotation token.
assert(Tok.isAnyIdentifier());
Fix parsing certain kinds of strings in the MS section pragmas We were crashing on the relevant test case inputs. Also, refactor this code a bit so we can report failure and slurp the pragma tokens without returning a diagnostic id. This is more consistent with the rest of the parser and sema code. llvm-svn: 213337
2014-07-18 08:13:16 +08:00
StringRef PragmaName = Tok.getIdentifierInfo()->getName();
[MS-ABI] Add support for #pragma section and related pragmas This patch adds support for the msvc pragmas section, bss_seg, code_seg, const_seg and data_seg as well as support for __declspec(allocate()). Additionally it corrects semantics and adds diagnostics for __attribute__((section())) and the interaction between the attribute and the msvc pragmas and declspec. In general conflicts should now be well diganosed within and among these features. In supporting the pragmas new machinery for uniform lexing for msvc pragmas was introduced. The new machinery always lexes the entire pragma and stores it on an annotation token. The parser is responsible for parsing the pragma when the handling the annotation token. There is a known outstanding bug in this implementation in C mode. Because these attributes and pragmas apply _only_ to definitions, we process them at the time we detect a definition. Due to tentative definitions in C, we end up processing the definition late. This means that in C mode, everything that ends up in a BSS section will end up in the _last_ BSS section rather than the one that was live at the time of tentative definition, even if that turns out to be the point of actual definition. This issue is not known to impact anything as of yet because we are not aware of a clear use or use case for #pragma bss_seg but should be fixed at some point. Differential Revision=http://reviews.llvm.org/D3065#inline-16241 llvm-svn: 205810
2014-04-09 06:30:47 +08:00
PP.Lex(Tok); // pragma kind
Fix parsing certain kinds of strings in the MS section pragmas We were crashing on the relevant test case inputs. Also, refactor this code a bit so we can report failure and slurp the pragma tokens without returning a diagnostic id. This is more consistent with the rest of the parser and sema code. llvm-svn: 213337
2014-07-18 08:13:16 +08:00
[MS-ABI] Add support for #pragma section and related pragmas This patch adds support for the msvc pragmas section, bss_seg, code_seg, const_seg and data_seg as well as support for __declspec(allocate()). Additionally it corrects semantics and adds diagnostics for __attribute__((section())) and the interaction between the attribute and the msvc pragmas and declspec. In general conflicts should now be well diganosed within and among these features. In supporting the pragmas new machinery for uniform lexing for msvc pragmas was introduced. The new machinery always lexes the entire pragma and stores it on an annotation token. The parser is responsible for parsing the pragma when the handling the annotation token. There is a known outstanding bug in this implementation in C mode. Because these attributes and pragmas apply _only_ to definitions, we process them at the time we detect a definition. Due to tentative definitions in C, we end up processing the definition late. This means that in C mode, everything that ends up in a BSS section will end up in the _last_ BSS section rather than the one that was live at the time of tentative definition, even if that turns out to be the point of actual definition. This issue is not known to impact anything as of yet because we are not aware of a clear use or use case for #pragma bss_seg but should be fixed at some point. Differential Revision=http://reviews.llvm.org/D3065#inline-16241 llvm-svn: 205810
2014-04-09 06:30:47 +08:00
// Figure out which #pragma we're dealing with. The switch has no default
// because lex shouldn't emit the annotation token for unrecognized pragmas.
Fix parsing certain kinds of strings in the MS section pragmas We were crashing on the relevant test case inputs. Also, refactor this code a bit so we can report failure and slurp the pragma tokens without returning a diagnostic id. This is more consistent with the rest of the parser and sema code. llvm-svn: 213337
2014-07-18 08:13:16 +08:00
typedef bool (Parser::*PragmaHandler)(StringRef, SourceLocation);
[MS-ABI] Add support for #pragma section and related pragmas This patch adds support for the msvc pragmas section, bss_seg, code_seg, const_seg and data_seg as well as support for __declspec(allocate()). Additionally it corrects semantics and adds diagnostics for __attribute__((section())) and the interaction between the attribute and the msvc pragmas and declspec. In general conflicts should now be well diganosed within and among these features. In supporting the pragmas new machinery for uniform lexing for msvc pragmas was introduced. The new machinery always lexes the entire pragma and stores it on an annotation token. The parser is responsible for parsing the pragma when the handling the annotation token. There is a known outstanding bug in this implementation in C mode. Because these attributes and pragmas apply _only_ to definitions, we process them at the time we detect a definition. Due to tentative definitions in C, we end up processing the definition late. This means that in C mode, everything that ends up in a BSS section will end up in the _last_ BSS section rather than the one that was live at the time of tentative definition, even if that turns out to be the point of actual definition. This issue is not known to impact anything as of yet because we are not aware of a clear use or use case for #pragma bss_seg but should be fixed at some point. Differential Revision=http://reviews.llvm.org/D3065#inline-16241 llvm-svn: 205810
2014-04-09 06:30:47 +08:00
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);
Fix parsing certain kinds of strings in the MS section pragmas We were crashing on the relevant test case inputs. Also, refactor this code a bit so we can report failure and slurp the pragma tokens without returning a diagnostic id. This is more consistent with the rest of the parser and sema code. llvm-svn: 213337
2014-07-18 08:13:16 +08:00
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.
[MS-ABI] Add support for #pragma section and related pragmas This patch adds support for the msvc pragmas section, bss_seg, code_seg, const_seg and data_seg as well as support for __declspec(allocate()). Additionally it corrects semantics and adds diagnostics for __attribute__((section())) and the interaction between the attribute and the msvc pragmas and declspec. In general conflicts should now be well diganosed within and among these features. In supporting the pragmas new machinery for uniform lexing for msvc pragmas was introduced. The new machinery always lexes the entire pragma and stores it on an annotation token. The parser is responsible for parsing the pragma when the handling the annotation token. There is a known outstanding bug in this implementation in C mode. Because these attributes and pragmas apply _only_ to definitions, we process them at the time we detect a definition. Due to tentative definitions in C, we end up processing the definition late. This means that in C mode, everything that ends up in a BSS section will end up in the _last_ BSS section rather than the one that was live at the time of tentative definition, even if that turns out to be the point of actual definition. This issue is not known to impact anything as of yet because we are not aware of a clear use or use case for #pragma bss_seg but should be fixed at some point. Differential Revision=http://reviews.llvm.org/D3065#inline-16241 llvm-svn: 205810
2014-04-09 06:30:47 +08:00
while (Tok.isNot(tok::eof))
PP.Lex(Tok);
PP.Lex(Tok);
}
}
Fix parsing certain kinds of strings in the MS section pragmas We were crashing on the relevant test case inputs. Also, refactor this code a bit so we can report failure and slurp the pragma tokens without returning a diagnostic id. This is more consistent with the rest of the parser and sema code. llvm-svn: 213337
2014-07-18 08:13:16 +08:00
bool Parser::HandlePragmaMSSection(StringRef PragmaName,
SourceLocation PragmaLocation) {
if (Tok.isNot(tok::l_paren)) {
PP.Diag(PragmaLocation, diag::warn_pragma_expected_lparen) << PragmaName;
return false;
}
[MS-ABI] Add support for #pragma section and related pragmas This patch adds support for the msvc pragmas section, bss_seg, code_seg, const_seg and data_seg as well as support for __declspec(allocate()). Additionally it corrects semantics and adds diagnostics for __attribute__((section())) and the interaction between the attribute and the msvc pragmas and declspec. In general conflicts should now be well diganosed within and among these features. In supporting the pragmas new machinery for uniform lexing for msvc pragmas was introduced. The new machinery always lexes the entire pragma and stores it on an annotation token. The parser is responsible for parsing the pragma when the handling the annotation token. There is a known outstanding bug in this implementation in C mode. Because these attributes and pragmas apply _only_ to definitions, we process them at the time we detect a definition. Due to tentative definitions in C, we end up processing the definition late. This means that in C mode, everything that ends up in a BSS section will end up in the _last_ BSS section rather than the one that was live at the time of tentative definition, even if that turns out to be the point of actual definition. This issue is not known to impact anything as of yet because we are not aware of a clear use or use case for #pragma bss_seg but should be fixed at some point. Differential Revision=http://reviews.llvm.org/D3065#inline-16241 llvm-svn: 205810
2014-04-09 06:30:47 +08:00
PP.Lex(Tok); // (
// Parsing code for pragma section
Fix parsing certain kinds of strings in the MS section pragmas We were crashing on the relevant test case inputs. Also, refactor this code a bit so we can report failure and slurp the pragma tokens without returning a diagnostic id. This is more consistent with the rest of the parser and sema code. llvm-svn: 213337
2014-07-18 08:13:16 +08:00
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;
}
Parse: Ignore "long" and "short" in #pragma section This fixes PR21337. llvm-svn: 220429
2014-10-23 05:08:43 +08:00
int SectionFlags = ASTContext::PSF_Read;
bool SectionFlagsAreDefault = true;
[MS-ABI] Add support for #pragma section and related pragmas This patch adds support for the msvc pragmas section, bss_seg, code_seg, const_seg and data_seg as well as support for __declspec(allocate()). Additionally it corrects semantics and adds diagnostics for __attribute__((section())) and the interaction between the attribute and the msvc pragmas and declspec. In general conflicts should now be well diganosed within and among these features. In supporting the pragmas new machinery for uniform lexing for msvc pragmas was introduced. The new machinery always lexes the entire pragma and stores it on an annotation token. The parser is responsible for parsing the pragma when the handling the annotation token. There is a known outstanding bug in this implementation in C mode. Because these attributes and pragmas apply _only_ to definitions, we process them at the time we detect a definition. Due to tentative definitions in C, we end up processing the definition late. This means that in C mode, everything that ends up in a BSS section will end up in the _last_ BSS section rather than the one that was live at the time of tentative definition, even if that turns out to be the point of actual definition. This issue is not known to impact anything as of yet because we are not aware of a clear use or use case for #pragma bss_seg but should be fixed at some point. Differential Revision=http://reviews.llvm.org/D3065#inline-16241 llvm-svn: 205810
2014-04-09 06:30:47 +08:00
while (Tok.is(tok::comma)) {
PP.Lex(Tok); // ,
Parse: Ignore "long" and "short" in #pragma section This fixes PR21337. llvm-svn: 220429
2014-10-23 05:08:43 +08:00
// 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;
}
Fix parsing certain kinds of strings in the MS section pragmas We were crashing on the relevant test case inputs. Also, refactor this code a bit so we can report failure and slurp the pragma tokens without returning a diagnostic id. This is more consistent with the rest of the parser and sema code. llvm-svn: 213337
2014-07-18 08:13:16 +08:00
if (!Tok.isAnyIdentifier()) {
PP.Diag(PragmaLocation, diag::warn_pragma_expected_action_or_r_paren)
<< PragmaName;
return false;
}
MS Compat: mark globals emitted in read-only sections const They cannot be written to, so marking them const makes sense and may improve optimisation. As a side-effect, SectionInfos has to be moved from Sema to ASTContext. It also fixes this problem, that occurs when compiling ATL: warning LNK4254: section 'ATL' (C0000040) merged into '.rdata' (40000040) with different attributes The ATL headers are putting variables in a special section that's marked read-only. However, Clang currently can't model that read-onlyness in the IR. But, by making the variables const, the section does become read-only, and the linker warning is avoided. Differential Revision: http://reviews.llvm.org/D5812 llvm-svn: 219960
2014-10-17 04:52:46 +08:00
ASTContext::PragmaSectionFlag Flag =
llvm::StringSwitch<ASTContext::PragmaSectionFlag>(
[MS-ABI] Add support for #pragma section and related pragmas This patch adds support for the msvc pragmas section, bss_seg, code_seg, const_seg and data_seg as well as support for __declspec(allocate()). Additionally it corrects semantics and adds diagnostics for __attribute__((section())) and the interaction between the attribute and the msvc pragmas and declspec. In general conflicts should now be well diganosed within and among these features. In supporting the pragmas new machinery for uniform lexing for msvc pragmas was introduced. The new machinery always lexes the entire pragma and stores it on an annotation token. The parser is responsible for parsing the pragma when the handling the annotation token. There is a known outstanding bug in this implementation in C mode. Because these attributes and pragmas apply _only_ to definitions, we process them at the time we detect a definition. Due to tentative definitions in C, we end up processing the definition late. This means that in C mode, everything that ends up in a BSS section will end up in the _last_ BSS section rather than the one that was live at the time of tentative definition, even if that turns out to be the point of actual definition. This issue is not known to impact anything as of yet because we are not aware of a clear use or use case for #pragma bss_seg but should be fixed at some point. Differential Revision=http://reviews.llvm.org/D3065#inline-16241 llvm-svn: 205810
2014-04-09 06:30:47 +08:00
Tok.getIdentifierInfo()->getName())
MS Compat: mark globals emitted in read-only sections const They cannot be written to, so marking them const makes sense and may improve optimisation. As a side-effect, SectionInfos has to be moved from Sema to ASTContext. It also fixes this problem, that occurs when compiling ATL: warning LNK4254: section 'ATL' (C0000040) merged into '.rdata' (40000040) with different attributes The ATL headers are putting variables in a special section that's marked read-only. However, Clang currently can't model that read-onlyness in the IR. But, by making the variables const, the section does become read-only, and the linker warning is avoided. Differential Revision: http://reviews.llvm.org/D5812 llvm-svn: 219960
2014-10-17 04:52:46 +08:00
.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
Fix parsing certain kinds of strings in the MS section pragmas We were crashing on the relevant test case inputs. Also, refactor this code a bit so we can report failure and slurp the pragma tokens without returning a diagnostic id. This is more consistent with the rest of the parser and sema code. llvm-svn: 213337
2014-07-18 08:13:16 +08:00
? diag::warn_pragma_invalid_specific_action
: diag::warn_pragma_unsupported_action)
[MS-ABI] Add support for #pragma section and related pragmas This patch adds support for the msvc pragmas section, bss_seg, code_seg, const_seg and data_seg as well as support for __declspec(allocate()). Additionally it corrects semantics and adds diagnostics for __attribute__((section())) and the interaction between the attribute and the msvc pragmas and declspec. In general conflicts should now be well diganosed within and among these features. In supporting the pragmas new machinery for uniform lexing for msvc pragmas was introduced. The new machinery always lexes the entire pragma and stores it on an annotation token. The parser is responsible for parsing the pragma when the handling the annotation token. There is a known outstanding bug in this implementation in C mode. Because these attributes and pragmas apply _only_ to definitions, we process them at the time we detect a definition. Due to tentative definitions in C, we end up processing the definition late. This means that in C mode, everything that ends up in a BSS section will end up in the _last_ BSS section rather than the one that was live at the time of tentative definition, even if that turns out to be the point of actual definition. This issue is not known to impact anything as of yet because we are not aware of a clear use or use case for #pragma bss_seg but should be fixed at some point. Differential Revision=http://reviews.llvm.org/D3065#inline-16241 llvm-svn: 205810
2014-04-09 06:30:47 +08:00
<< PragmaName << Tok.getIdentifierInfo()->getName();
Fix parsing certain kinds of strings in the MS section pragmas We were crashing on the relevant test case inputs. Also, refactor this code a bit so we can report failure and slurp the pragma tokens without returning a diagnostic id. This is more consistent with the rest of the parser and sema code. llvm-svn: 213337
2014-07-18 08:13:16 +08:00
return false;
[MS-ABI] Add support for #pragma section and related pragmas This patch adds support for the msvc pragmas section, bss_seg, code_seg, const_seg and data_seg as well as support for __declspec(allocate()). Additionally it corrects semantics and adds diagnostics for __attribute__((section())) and the interaction between the attribute and the msvc pragmas and declspec. In general conflicts should now be well diganosed within and among these features. In supporting the pragmas new machinery for uniform lexing for msvc pragmas was introduced. The new machinery always lexes the entire pragma and stores it on an annotation token. The parser is responsible for parsing the pragma when the handling the annotation token. There is a known outstanding bug in this implementation in C mode. Because these attributes and pragmas apply _only_ to definitions, we process them at the time we detect a definition. Due to tentative definitions in C, we end up processing the definition late. This means that in C mode, everything that ends up in a BSS section will end up in the _last_ BSS section rather than the one that was live at the time of tentative definition, even if that turns out to be the point of actual definition. This issue is not known to impact anything as of yet because we are not aware of a clear use or use case for #pragma bss_seg but should be fixed at some point. Differential Revision=http://reviews.llvm.org/D3065#inline-16241 llvm-svn: 205810
2014-04-09 06:30:47 +08:00
}
SectionFlags |= Flag;
Parse: Ignore "long" and "short" in #pragma section This fixes PR21337. llvm-svn: 220429
2014-10-23 05:08:43 +08:00
SectionFlagsAreDefault = false;
[MS-ABI] Add support for #pragma section and related pragmas This patch adds support for the msvc pragmas section, bss_seg, code_seg, const_seg and data_seg as well as support for __declspec(allocate()). Additionally it corrects semantics and adds diagnostics for __attribute__((section())) and the interaction between the attribute and the msvc pragmas and declspec. In general conflicts should now be well diganosed within and among these features. In supporting the pragmas new machinery for uniform lexing for msvc pragmas was introduced. The new machinery always lexes the entire pragma and stores it on an annotation token. The parser is responsible for parsing the pragma when the handling the annotation token. There is a known outstanding bug in this implementation in C mode. Because these attributes and pragmas apply _only_ to definitions, we process them at the time we detect a definition. Due to tentative definitions in C, we end up processing the definition late. This means that in C mode, everything that ends up in a BSS section will end up in the _last_ BSS section rather than the one that was live at the time of tentative definition, even if that turns out to be the point of actual definition. This issue is not known to impact anything as of yet because we are not aware of a clear use or use case for #pragma bss_seg but should be fixed at some point. Differential Revision=http://reviews.llvm.org/D3065#inline-16241 llvm-svn: 205810
2014-04-09 06:30:47 +08:00
PP.Lex(Tok); // Identifier
}
Parse: Ignore "long" and "short" in #pragma section This fixes PR21337. llvm-svn: 220429
2014-10-23 05:08:43 +08:00
// If no section attributes are specified, the section will be marked as
// read/write.
if (SectionFlagsAreDefault)
SectionFlags |= ASTContext::PSF_Write;
Fix parsing certain kinds of strings in the MS section pragmas We were crashing on the relevant test case inputs. Also, refactor this code a bit so we can report failure and slurp the pragma tokens without returning a diagnostic id. This is more consistent with the rest of the parser and sema code. llvm-svn: 213337
2014-07-18 08:13:16 +08:00
if (Tok.isNot(tok::r_paren)) {
PP.Diag(PragmaLocation, diag::warn_pragma_expected_rparen) << PragmaName;
return false;
}
[MS-ABI] Add support for #pragma section and related pragmas This patch adds support for the msvc pragmas section, bss_seg, code_seg, const_seg and data_seg as well as support for __declspec(allocate()). Additionally it corrects semantics and adds diagnostics for __attribute__((section())) and the interaction between the attribute and the msvc pragmas and declspec. In general conflicts should now be well diganosed within and among these features. In supporting the pragmas new machinery for uniform lexing for msvc pragmas was introduced. The new machinery always lexes the entire pragma and stores it on an annotation token. The parser is responsible for parsing the pragma when the handling the annotation token. There is a known outstanding bug in this implementation in C mode. Because these attributes and pragmas apply _only_ to definitions, we process them at the time we detect a definition. Due to tentative definitions in C, we end up processing the definition late. This means that in C mode, everything that ends up in a BSS section will end up in the _last_ BSS section rather than the one that was live at the time of tentative definition, even if that turns out to be the point of actual definition. This issue is not known to impact anything as of yet because we are not aware of a clear use or use case for #pragma bss_seg but should be fixed at some point. Differential Revision=http://reviews.llvm.org/D3065#inline-16241 llvm-svn: 205810
2014-04-09 06:30:47 +08:00
PP.Lex(Tok); // )
Fix parsing certain kinds of strings in the MS section pragmas We were crashing on the relevant test case inputs. Also, refactor this code a bit so we can report failure and slurp the pragma tokens without returning a diagnostic id. This is more consistent with the rest of the parser and sema code. llvm-svn: 213337
2014-07-18 08:13:16 +08:00
if (Tok.isNot(tok::eof)) {
PP.Diag(PragmaLocation, diag::warn_pragma_extra_tokens_at_eol)
<< PragmaName;
return false;
}
[MS-ABI] Add support for #pragma section and related pragmas This patch adds support for the msvc pragmas section, bss_seg, code_seg, const_seg and data_seg as well as support for __declspec(allocate()). Additionally it corrects semantics and adds diagnostics for __attribute__((section())) and the interaction between the attribute and the msvc pragmas and declspec. In general conflicts should now be well diganosed within and among these features. In supporting the pragmas new machinery for uniform lexing for msvc pragmas was introduced. The new machinery always lexes the entire pragma and stores it on an annotation token. The parser is responsible for parsing the pragma when the handling the annotation token. There is a known outstanding bug in this implementation in C mode. Because these attributes and pragmas apply _only_ to definitions, we process them at the time we detect a definition. Due to tentative definitions in C, we end up processing the definition late. This means that in C mode, everything that ends up in a BSS section will end up in the _last_ BSS section rather than the one that was live at the time of tentative definition, even if that turns out to be the point of actual definition. This issue is not known to impact anything as of yet because we are not aware of a clear use or use case for #pragma bss_seg but should be fixed at some point. Differential Revision=http://reviews.llvm.org/D3065#inline-16241 llvm-svn: 205810
2014-04-09 06:30:47 +08:00
PP.Lex(Tok); // eof
Actions.ActOnPragmaMSSection(PragmaLocation, SectionFlags, SegmentName);
Fix parsing certain kinds of strings in the MS section pragmas We were crashing on the relevant test case inputs. Also, refactor this code a bit so we can report failure and slurp the pragma tokens without returning a diagnostic id. This is more consistent with the rest of the parser and sema code. llvm-svn: 213337
2014-07-18 08:13:16 +08:00
return true;
[MS-ABI] Add support for #pragma section and related pragmas This patch adds support for the msvc pragmas section, bss_seg, code_seg, const_seg and data_seg as well as support for __declspec(allocate()). Additionally it corrects semantics and adds diagnostics for __attribute__((section())) and the interaction between the attribute and the msvc pragmas and declspec. In general conflicts should now be well diganosed within and among these features. In supporting the pragmas new machinery for uniform lexing for msvc pragmas was introduced. The new machinery always lexes the entire pragma and stores it on an annotation token. The parser is responsible for parsing the pragma when the handling the annotation token. There is a known outstanding bug in this implementation in C mode. Because these attributes and pragmas apply _only_ to definitions, we process them at the time we detect a definition. Due to tentative definitions in C, we end up processing the definition late. This means that in C mode, everything that ends up in a BSS section will end up in the _last_ BSS section rather than the one that was live at the time of tentative definition, even if that turns out to be the point of actual definition. This issue is not known to impact anything as of yet because we are not aware of a clear use or use case for #pragma bss_seg but should be fixed at some point. Differential Revision=http://reviews.llvm.org/D3065#inline-16241 llvm-svn: 205810
2014-04-09 06:30:47 +08:00
}
Fix parsing certain kinds of strings in the MS section pragmas We were crashing on the relevant test case inputs. Also, refactor this code a bit so we can report failure and slurp the pragma tokens without returning a diagnostic id. This is more consistent with the rest of the parser and sema code. llvm-svn: 213337
2014-07-18 08:13:16 +08:00
bool Parser::HandlePragmaMSSegment(StringRef PragmaName,
SourceLocation PragmaLocation) {
if (Tok.isNot(tok::l_paren)) {
PP.Diag(PragmaLocation, diag::warn_pragma_expected_lparen) << PragmaName;
return false;
}
[MS-ABI] Add support for #pragma section and related pragmas This patch adds support for the msvc pragmas section, bss_seg, code_seg, const_seg and data_seg as well as support for __declspec(allocate()). Additionally it corrects semantics and adds diagnostics for __attribute__((section())) and the interaction between the attribute and the msvc pragmas and declspec. In general conflicts should now be well diganosed within and among these features. In supporting the pragmas new machinery for uniform lexing for msvc pragmas was introduced. The new machinery always lexes the entire pragma and stores it on an annotation token. The parser is responsible for parsing the pragma when the handling the annotation token. There is a known outstanding bug in this implementation in C mode. Because these attributes and pragmas apply _only_ to definitions, we process them at the time we detect a definition. Due to tentative definitions in C, we end up processing the definition late. This means that in C mode, everything that ends up in a BSS section will end up in the _last_ BSS section rather than the one that was live at the time of tentative definition, even if that turns out to be the point of actual definition. This issue is not known to impact anything as of yet because we are not aware of a clear use or use case for #pragma bss_seg but should be fixed at some point. Differential Revision=http://reviews.llvm.org/D3065#inline-16241 llvm-svn: 205810
2014-04-09 06:30:47 +08:00
PP.Lex(Tok); // (
Sema::PragmaMsStackAction Action = Sema::PSK_Reset;
Fix parsing certain kinds of strings in the MS section pragmas We were crashing on the relevant test case inputs. Also, refactor this code a bit so we can report failure and slurp the pragma tokens without returning a diagnostic id. This is more consistent with the rest of the parser and sema code. llvm-svn: 213337
2014-07-18 08:13:16 +08:00
StringRef SlotLabel;
[MS-ABI] Add support for #pragma section and related pragmas This patch adds support for the msvc pragmas section, bss_seg, code_seg, const_seg and data_seg as well as support for __declspec(allocate()). Additionally it corrects semantics and adds diagnostics for __attribute__((section())) and the interaction between the attribute and the msvc pragmas and declspec. In general conflicts should now be well diganosed within and among these features. In supporting the pragmas new machinery for uniform lexing for msvc pragmas was introduced. The new machinery always lexes the entire pragma and stores it on an annotation token. The parser is responsible for parsing the pragma when the handling the annotation token. There is a known outstanding bug in this implementation in C mode. Because these attributes and pragmas apply _only_ to definitions, we process them at the time we detect a definition. Due to tentative definitions in C, we end up processing the definition late. This means that in C mode, everything that ends up in a BSS section will end up in the _last_ BSS section rather than the one that was live at the time of tentative definition, even if that turns out to be the point of actual definition. This issue is not known to impact anything as of yet because we are not aware of a clear use or use case for #pragma bss_seg but should be fixed at some point. Differential Revision=http://reviews.llvm.org/D3065#inline-16241 llvm-svn: 205810
2014-04-09 06:30:47 +08:00
if (Tok.isAnyIdentifier()) {
Fix parsing certain kinds of strings in the MS section pragmas We were crashing on the relevant test case inputs. Also, refactor this code a bit so we can report failure and slurp the pragma tokens without returning a diagnostic id. This is more consistent with the rest of the parser and sema code. llvm-svn: 213337
2014-07-18 08:13:16 +08:00
StringRef PushPop = Tok.getIdentifierInfo()->getName();
[MS-ABI] Add support for #pragma section and related pragmas This patch adds support for the msvc pragmas section, bss_seg, code_seg, const_seg and data_seg as well as support for __declspec(allocate()). Additionally it corrects semantics and adds diagnostics for __attribute__((section())) and the interaction between the attribute and the msvc pragmas and declspec. In general conflicts should now be well diganosed within and among these features. In supporting the pragmas new machinery for uniform lexing for msvc pragmas was introduced. The new machinery always lexes the entire pragma and stores it on an annotation token. The parser is responsible for parsing the pragma when the handling the annotation token. There is a known outstanding bug in this implementation in C mode. Because these attributes and pragmas apply _only_ to definitions, we process them at the time we detect a definition. Due to tentative definitions in C, we end up processing the definition late. This means that in C mode, everything that ends up in a BSS section will end up in the _last_ BSS section rather than the one that was live at the time of tentative definition, even if that turns out to be the point of actual definition. This issue is not known to impact anything as of yet because we are not aware of a clear use or use case for #pragma bss_seg but should be fixed at some point. Differential Revision=http://reviews.llvm.org/D3065#inline-16241 llvm-svn: 205810
2014-04-09 06:30:47 +08:00
if (PushPop == "push")
Action = Sema::PSK_Push;
else if (PushPop == "pop")
Action = Sema::PSK_Pop;
Fix parsing certain kinds of strings in the MS section pragmas We were crashing on the relevant test case inputs. Also, refactor this code a bit so we can report failure and slurp the pragma tokens without returning a diagnostic id. This is more consistent with the rest of the parser and sema code. llvm-svn: 213337
2014-07-18 08:13:16 +08:00
else {
PP.Diag(PragmaLocation,
diag::warn_pragma_expected_section_push_pop_or_name)
<< PragmaName;
return false;
}
[MS-ABI] Add support for #pragma section and related pragmas This patch adds support for the msvc pragmas section, bss_seg, code_seg, const_seg and data_seg as well as support for __declspec(allocate()). Additionally it corrects semantics and adds diagnostics for __attribute__((section())) and the interaction between the attribute and the msvc pragmas and declspec. In general conflicts should now be well diganosed within and among these features. In supporting the pragmas new machinery for uniform lexing for msvc pragmas was introduced. The new machinery always lexes the entire pragma and stores it on an annotation token. The parser is responsible for parsing the pragma when the handling the annotation token. There is a known outstanding bug in this implementation in C mode. Because these attributes and pragmas apply _only_ to definitions, we process them at the time we detect a definition. Due to tentative definitions in C, we end up processing the definition late. This means that in C mode, everything that ends up in a BSS section will end up in the _last_ BSS section rather than the one that was live at the time of tentative definition, even if that turns out to be the point of actual definition. This issue is not known to impact anything as of yet because we are not aware of a clear use or use case for #pragma bss_seg but should be fixed at some point. Differential Revision=http://reviews.llvm.org/D3065#inline-16241 llvm-svn: 205810
2014-04-09 06:30:47 +08:00
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);
Fix parsing certain kinds of strings in the MS section pragmas We were crashing on the relevant test case inputs. Also, refactor this code a bit so we can report failure and slurp the pragma tokens without returning a diagnostic id. This is more consistent with the rest of the parser and sema code. llvm-svn: 213337
2014-07-18 08:13:16 +08:00
else if (Tok.isNot(tok::r_paren)) {
PP.Diag(PragmaLocation, diag::warn_pragma_expected_punc)
<< PragmaName;
return false;
}
[MS-ABI] Add support for #pragma section and related pragmas This patch adds support for the msvc pragmas section, bss_seg, code_seg, const_seg and data_seg as well as support for __declspec(allocate()). Additionally it corrects semantics and adds diagnostics for __attribute__((section())) and the interaction between the attribute and the msvc pragmas and declspec. In general conflicts should now be well diganosed within and among these features. In supporting the pragmas new machinery for uniform lexing for msvc pragmas was introduced. The new machinery always lexes the entire pragma and stores it on an annotation token. The parser is responsible for parsing the pragma when the handling the annotation token. There is a known outstanding bug in this implementation in C mode. Because these attributes and pragmas apply _only_ to definitions, we process them at the time we detect a definition. Due to tentative definitions in C, we end up processing the definition late. This means that in C mode, everything that ends up in a BSS section will end up in the _last_ BSS section rather than the one that was live at the time of tentative definition, even if that turns out to be the point of actual definition. This issue is not known to impact anything as of yet because we are not aware of a clear use or use case for #pragma bss_seg but should be fixed at some point. Differential Revision=http://reviews.llvm.org/D3065#inline-16241 llvm-svn: 205810
2014-04-09 06:30:47 +08:00
}
Fix parsing certain kinds of strings in the MS section pragmas We were crashing on the relevant test case inputs. Also, refactor this code a bit so we can report failure and slurp the pragma tokens without returning a diagnostic id. This is more consistent with the rest of the parser and sema code. llvm-svn: 213337
2014-07-18 08:13:16 +08:00
} else if (Tok.isNot(tok::r_paren)) {
PP.Diag(PragmaLocation, diag::warn_pragma_expected_punc) << PragmaName;
return false;
}
[MS-ABI] Add support for #pragma section and related pragmas This patch adds support for the msvc pragmas section, bss_seg, code_seg, const_seg and data_seg as well as support for __declspec(allocate()). Additionally it corrects semantics and adds diagnostics for __attribute__((section())) and the interaction between the attribute and the msvc pragmas and declspec. In general conflicts should now be well diganosed within and among these features. In supporting the pragmas new machinery for uniform lexing for msvc pragmas was introduced. The new machinery always lexes the entire pragma and stores it on an annotation token. The parser is responsible for parsing the pragma when the handling the annotation token. There is a known outstanding bug in this implementation in C mode. Because these attributes and pragmas apply _only_ to definitions, we process them at the time we detect a definition. Due to tentative definitions in C, we end up processing the definition late. This means that in C mode, everything that ends up in a BSS section will end up in the _last_ BSS section rather than the one that was live at the time of tentative definition, even if that turns out to be the point of actual definition. This issue is not known to impact anything as of yet because we are not aware of a clear use or use case for #pragma bss_seg but should be fixed at some point. Differential Revision=http://reviews.llvm.org/D3065#inline-16241 llvm-svn: 205810
2014-04-09 06:30:47 +08:00
}
}
// Grab the string literal for our section name.
StringLiteral *SegmentName = nullptr;
if (Tok.isNot(tok::r_paren)) {
Fix parsing certain kinds of strings in the MS section pragmas We were crashing on the relevant test case inputs. Also, refactor this code a bit so we can report failure and slurp the pragma tokens without returning a diagnostic id. This is more consistent with the rest of the parser and sema code. llvm-svn: 213337
2014-07-18 08:13:16 +08:00
if (Tok.isNot(tok::string_literal)) {
unsigned DiagID = Action != Sema::PSK_Reset ? !SlotLabel.empty() ?
[MS-ABI] Add support for #pragma section and related pragmas This patch adds support for the msvc pragmas section, bss_seg, code_seg, const_seg and data_seg as well as support for __declspec(allocate()). Additionally it corrects semantics and adds diagnostics for __attribute__((section())) and the interaction between the attribute and the msvc pragmas and declspec. In general conflicts should now be well diganosed within and among these features. In supporting the pragmas new machinery for uniform lexing for msvc pragmas was introduced. The new machinery always lexes the entire pragma and stores it on an annotation token. The parser is responsible for parsing the pragma when the handling the annotation token. There is a known outstanding bug in this implementation in C mode. Because these attributes and pragmas apply _only_ to definitions, we process them at the time we detect a definition. Due to tentative definitions in C, we end up processing the definition late. This means that in C mode, everything that ends up in a BSS section will end up in the _last_ BSS section rather than the one that was live at the time of tentative definition, even if that turns out to be the point of actual definition. This issue is not known to impact anything as of yet because we are not aware of a clear use or use case for #pragma bss_seg but should be fixed at some point. Differential Revision=http://reviews.llvm.org/D3065#inline-16241 llvm-svn: 205810
2014-04-09 06:30:47 +08:00
diag::warn_pragma_expected_section_name :
diag::warn_pragma_expected_section_label_or_name :
diag::warn_pragma_expected_section_push_pop_or_name;
Fix parsing certain kinds of strings in the MS section pragmas We were crashing on the relevant test case inputs. Also, refactor this code a bit so we can report failure and slurp the pragma tokens without returning a diagnostic id. This is more consistent with the rest of the parser and sema code. llvm-svn: 213337
2014-07-18 08:13:16 +08:00
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;
}
[MS-ABI] Add support for #pragma section and related pragmas This patch adds support for the msvc pragmas section, bss_seg, code_seg, const_seg and data_seg as well as support for __declspec(allocate()). Additionally it corrects semantics and adds diagnostics for __attribute__((section())) and the interaction between the attribute and the msvc pragmas and declspec. In general conflicts should now be well diganosed within and among these features. In supporting the pragmas new machinery for uniform lexing for msvc pragmas was introduced. The new machinery always lexes the entire pragma and stores it on an annotation token. The parser is responsible for parsing the pragma when the handling the annotation token. There is a known outstanding bug in this implementation in C mode. Because these attributes and pragmas apply _only_ to definitions, we process them at the time we detect a definition. Due to tentative definitions in C, we end up processing the definition late. This means that in C mode, everything that ends up in a BSS section will end up in the _last_ BSS section rather than the one that was live at the time of tentative definition, even if that turns out to be the point of actual definition. This issue is not known to impact anything as of yet because we are not aware of a clear use or use case for #pragma bss_seg but should be fixed at some point. Differential Revision=http://reviews.llvm.org/D3065#inline-16241 llvm-svn: 205810
2014-04-09 06:30:47 +08:00
// Setting section "" has no effect
if (SegmentName->getLength())
Action = (Sema::PragmaMsStackAction)(Action | Sema::PSK_Set);
}
Fix parsing certain kinds of strings in the MS section pragmas We were crashing on the relevant test case inputs. Also, refactor this code a bit so we can report failure and slurp the pragma tokens without returning a diagnostic id. This is more consistent with the rest of the parser and sema code. llvm-svn: 213337
2014-07-18 08:13:16 +08:00
if (Tok.isNot(tok::r_paren)) {
PP.Diag(PragmaLocation, diag::warn_pragma_expected_rparen) << PragmaName;
return false;
}
[MS-ABI] Add support for #pragma section and related pragmas This patch adds support for the msvc pragmas section, bss_seg, code_seg, const_seg and data_seg as well as support for __declspec(allocate()). Additionally it corrects semantics and adds diagnostics for __attribute__((section())) and the interaction between the attribute and the msvc pragmas and declspec. In general conflicts should now be well diganosed within and among these features. In supporting the pragmas new machinery for uniform lexing for msvc pragmas was introduced. The new machinery always lexes the entire pragma and stores it on an annotation token. The parser is responsible for parsing the pragma when the handling the annotation token. There is a known outstanding bug in this implementation in C mode. Because these attributes and pragmas apply _only_ to definitions, we process them at the time we detect a definition. Due to tentative definitions in C, we end up processing the definition late. This means that in C mode, everything that ends up in a BSS section will end up in the _last_ BSS section rather than the one that was live at the time of tentative definition, even if that turns out to be the point of actual definition. This issue is not known to impact anything as of yet because we are not aware of a clear use or use case for #pragma bss_seg but should be fixed at some point. Differential Revision=http://reviews.llvm.org/D3065#inline-16241 llvm-svn: 205810
2014-04-09 06:30:47 +08:00
PP.Lex(Tok); // )
Fix parsing certain kinds of strings in the MS section pragmas We were crashing on the relevant test case inputs. Also, refactor this code a bit so we can report failure and slurp the pragma tokens without returning a diagnostic id. This is more consistent with the rest of the parser and sema code. llvm-svn: 213337
2014-07-18 08:13:16 +08:00
if (Tok.isNot(tok::eof)) {
PP.Diag(PragmaLocation, diag::warn_pragma_extra_tokens_at_eol)
<< PragmaName;
return false;
}
[MS-ABI] Add support for #pragma section and related pragmas This patch adds support for the msvc pragmas section, bss_seg, code_seg, const_seg and data_seg as well as support for __declspec(allocate()). Additionally it corrects semantics and adds diagnostics for __attribute__((section())) and the interaction between the attribute and the msvc pragmas and declspec. In general conflicts should now be well diganosed within and among these features. In supporting the pragmas new machinery for uniform lexing for msvc pragmas was introduced. The new machinery always lexes the entire pragma and stores it on an annotation token. The parser is responsible for parsing the pragma when the handling the annotation token. There is a known outstanding bug in this implementation in C mode. Because these attributes and pragmas apply _only_ to definitions, we process them at the time we detect a definition. Due to tentative definitions in C, we end up processing the definition late. This means that in C mode, everything that ends up in a BSS section will end up in the _last_ BSS section rather than the one that was live at the time of tentative definition, even if that turns out to be the point of actual definition. This issue is not known to impact anything as of yet because we are not aware of a clear use or use case for #pragma bss_seg but should be fixed at some point. Differential Revision=http://reviews.llvm.org/D3065#inline-16241 llvm-svn: 205810
2014-04-09 06:30:47 +08:00
PP.Lex(Tok); // eof
Actions.ActOnPragmaMSSeg(PragmaLocation, Action, SlotLabel,
SegmentName, PragmaName);
Fix parsing certain kinds of strings in the MS section pragmas We were crashing on the relevant test case inputs. Also, refactor this code a bit so we can report failure and slurp the pragma tokens without returning a diagnostic id. This is more consistent with the rest of the parser and sema code. llvm-svn: 213337
2014-07-18 08:13:16 +08:00
return true;
[MS-ABI] Add support for #pragma section and related pragmas This patch adds support for the msvc pragmas section, bss_seg, code_seg, const_seg and data_seg as well as support for __declspec(allocate()). Additionally it corrects semantics and adds diagnostics for __attribute__((section())) and the interaction between the attribute and the msvc pragmas and declspec. In general conflicts should now be well diganosed within and among these features. In supporting the pragmas new machinery for uniform lexing for msvc pragmas was introduced. The new machinery always lexes the entire pragma and stores it on an annotation token. The parser is responsible for parsing the pragma when the handling the annotation token. There is a known outstanding bug in this implementation in C mode. Because these attributes and pragmas apply _only_ to definitions, we process them at the time we detect a definition. Due to tentative definitions in C, we end up processing the definition late. This means that in C mode, everything that ends up in a BSS section will end up in the _last_ BSS section rather than the one that was live at the time of tentative definition, even if that turns out to be the point of actual definition. This issue is not known to impact anything as of yet because we are not aware of a clear use or use case for #pragma bss_seg but should be fixed at some point. Differential Revision=http://reviews.llvm.org/D3065#inline-16241 llvm-svn: 205810
2014-04-09 06:30:47 +08:00
}
-fms-extensions: Implement half of #pragma init_seg Summary: This pragma is very rare. We could *hypothetically* lower some uses of it down to @llvm.global_ctors, but given that GlobalOpt isn't able to optimize prioritized global ctors today, there's really no point. If we wanted to do this in the future, I would check if the section used in the pragma started with ".CRT$XC" and had up to two characters after it. Those two characters could form the 16-bit initialization priority that we support in @llvm.global_ctors. We would have to teach LLVM to lower prioritized global ctors on COFF as well. This should let us compile some silly uses of this pragma in WebKit / Blink. Reviewers: rsmith, majnemer Subscribers: cfe-commits Differential Revision: http://reviews.llvm.org/D4549 llvm-svn: 213593
2014-07-22 08:53:05 +08:00
// #pragma init_seg({ compiler | lib | user | "section-name" [, func-name]} )
Fix parsing certain kinds of strings in the MS section pragmas We were crashing on the relevant test case inputs. Also, refactor this code a bit so we can report failure and slurp the pragma tokens without returning a diagnostic id. This is more consistent with the rest of the parser and sema code. llvm-svn: 213337
2014-07-18 08:13:16 +08:00
bool Parser::HandlePragmaMSInitSeg(StringRef PragmaName,
SourceLocation PragmaLocation) {
Parse: Don't attempt to act on #pragma init_seg when not targeting MSVC It doesn't really make sense to try and do stuff with #pragma init_seg when targeting non-Microsoft platforms; notions like library vs user initializers don't exist for other targets. This fixes PR20639. llvm-svn: 215618
2014-08-14 14:35:08 +08:00
if (getTargetInfo().getTriple().getEnvironment() != llvm::Triple::MSVC) {
PP.Diag(PragmaLocation, diag::warn_pragma_init_seg_unsupported_target);
return false;
}
-fms-extensions: Implement half of #pragma init_seg Summary: This pragma is very rare. We could *hypothetically* lower some uses of it down to @llvm.global_ctors, but given that GlobalOpt isn't able to optimize prioritized global ctors today, there's really no point. If we wanted to do this in the future, I would check if the section used in the pragma started with ".CRT$XC" and had up to two characters after it. Those two characters could form the 16-bit initialization priority that we support in @llvm.global_ctors. We would have to teach LLVM to lower prioritized global ctors on COFF as well. This should let us compile some silly uses of this pragma in WebKit / Blink. Reviewers: rsmith, majnemer Subscribers: cfe-commits Differential Revision: http://reviews.llvm.org/D4549 llvm-svn: 213593
2014-07-22 08:53:05 +08:00
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;
Fix DOS-style newlines. A previous patch r210330 (and possibly another) introduced DOS-style newlines into a UNIX newline formatted file. Patch by Mark Heffernan (http://reviews.llvm.org/D4046) llvm-svn: 210369
2014-06-07 04:31:48 +08:00
}
Put global classes into the appropriate namespace. Most of the cases belong into an anonymous namespace. No functionality change intended. llvm-svn: 251514
2015-10-28 21:54:16 +08:00
namespace {
Fix DOS-style newlines. A previous patch r210330 (and possibly another) introduced DOS-style newlines into a UNIX newline formatted file. Patch by Mark Heffernan (http://reviews.llvm.org/D4046) llvm-svn: 210369
2014-06-07 04:31:48 +08:00
struct PragmaLoopHintInfo {
Add support for '#pragma unroll'. llvm-svn: 213574
2014-07-22 02:08:34 +08:00
Token PragmaName;
Fix DOS-style newlines. A previous patch r210330 (and possibly another) introduced DOS-style newlines into a UNIX newline formatted file. Patch by Mark Heffernan (http://reviews.llvm.org/D4046) llvm-svn: 210369
2014-06-07 04:31:48 +08:00
Token Option;
[Parse] ArrayRefize PragmaLoopHintInfo. No functionality change. llvm-svn: 244024
2015-08-05 17:39:57 +08:00
ArrayRef<Token> Toks;
Fix DOS-style newlines. A previous patch r210330 (and possibly another) introduced DOS-style newlines into a UNIX newline formatted file. Patch by Mark Heffernan (http://reviews.llvm.org/D4046) llvm-svn: 210369
2014-06-07 04:31:48 +08:00
};
Put global classes into the appropriate namespace. Most of the cases belong into an anonymous namespace. No functionality change intended. llvm-svn: 251514
2015-10-28 21:54:16 +08:00
} // end anonymous namespace
Fix DOS-style newlines. A previous patch r210330 (and possibly another) introduced DOS-style newlines into a UNIX newline formatted file. Patch by Mark Heffernan (http://reviews.llvm.org/D4046) llvm-svn: 210369
2014-06-07 04:31:48 +08:00
Allow constant expressions in pragma loop hints. Previously loop hints such as #pragma loop vectorize_width(#) required a constant. This patch allows a constant expression to be used as well. Such as a non-type template parameter or an expression (2 * c + 1). Reviewed by Richard Smith llvm-svn: 219589
2014-10-13 04:46:07 +08:00
static std::string PragmaLoopHintString(Token PragmaName, Token Option) {
std::string PragmaString;
if (PragmaName.getIdentifierInfo()->getName() == "loop") {
PragmaString = "clang loop ";
PragmaString += Option.getIdentifierInfo()->getName();
} else {
assert(PragmaName.getIdentifierInfo()->getName() == "unroll" &&
"Unexpected pragma name");
PragmaString = "unroll";
}
return PragmaString;
}
Add a state variable to the loop hint attribute. This patch is necessary to support constant expressions which replaces the integer value in the loop hint attribute with an expression. The integer value was also storing the pragma’s state for options like vectorize(enable/disable) and the pragma unroll and nounroll directive. The state variable is introduced to hold the state of those options/pragmas. This moves the validation of the state (keywords) from SemaStmtAttr handler to the loop hint annotation token handler. Resubmit with changes to try to fix the build-bot issue. Reviewed by Aaron Ballman llvm-svn: 214432
2014-08-01 04:15:14 +08:00
bool Parser::HandlePragmaLoopHint(LoopHint &Hint) {
Fix DOS-style newlines. A previous patch r210330 (and possibly another) introduced DOS-style newlines into a UNIX newline formatted file. Patch by Mark Heffernan (http://reviews.llvm.org/D4046) llvm-svn: 210369
2014-06-07 04:31:48 +08:00
assert(Tok.is(tok::annot_pragma_loop_hint));
PragmaLoopHintInfo *Info =
static_cast<PragmaLoopHintInfo *>(Tok.getAnnotationValue());
Add a state variable to the loop hint attribute. This patch is necessary to support constant expressions which replaces the integer value in the loop hint attribute with an expression. The integer value was also storing the pragma’s state for options like vectorize(enable/disable) and the pragma unroll and nounroll directive. The state variable is introduced to hold the state of those options/pragmas. This moves the validation of the state (keywords) from SemaStmtAttr handler to the loop hint annotation token handler. Resubmit with changes to try to fix the build-bot issue. Reviewed by Aaron Ballman llvm-svn: 214432
2014-08-01 04:15:14 +08:00
IdentifierInfo *PragmaNameInfo = Info->PragmaName.getIdentifierInfo();
Hint.PragmaNameLoc = IdentifierLoc::create(
Actions.Context, Info->PragmaName.getLocation(), PragmaNameInfo);
Loop hint pragmas sometimes do not contain an identifier option (such as #pragma unroll(4)). Check explicitly that the token we stored was an identifier. Amends r214432 llvm-svn: 214446
2014-08-01 05:24:32 +08:00
// 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;
Add a state variable to the loop hint attribute. This patch is necessary to support constant expressions which replaces the integer value in the loop hint attribute with an expression. The integer value was also storing the pragma’s state for options like vectorize(enable/disable) and the pragma unroll and nounroll directive. The state variable is introduced to hold the state of those options/pragmas. This moves the validation of the state (keywords) from SemaStmtAttr handler to the loop hint annotation token handler. Resubmit with changes to try to fix the build-bot issue. Reviewed by Aaron Ballman llvm-svn: 214432
2014-08-01 04:15:14 +08:00
Hint.OptionLoc = IdentifierLoc::create(
Actions.Context, Info->Option.getLocation(), OptionInfo);
Simplify EnterTokenStream API to make it more robust for memory management While this won't help fix things like the bug that r260219 addressed, it seems like good tidy up to have anyway. (it might be nice if "makeArrayRef" always produced a MutableArrayRef & let it decay to an ArrayRef when needed - then I'd use that for the MutableArrayRefs in this patch) If we had std::dynarray I'd use that instead of unique_ptr+size_t, ideally (but then it'd have to be threaded down through the Preprocessor all the way - no idea how painful that would be) llvm-svn: 260246
2016-02-10 02:52:09 +08:00
llvm::ArrayRef<Token> Toks = Info->Toks;
Allow constant expressions in pragma loop hints. Previously loop hints such as #pragma loop vectorize_width(#) required a constant. This patch allows a constant expression to be used as well. Such as a non-type template parameter or an expression (2 * c + 1). Reviewed by Richard Smith llvm-svn: 219589
2014-10-13 04:46:07 +08:00
Add a state variable to the loop hint attribute. This patch is necessary to support constant expressions which replaces the integer value in the loop hint attribute with an expression. The integer value was also storing the pragma’s state for options like vectorize(enable/disable) and the pragma unroll and nounroll directive. The state variable is introduced to hold the state of those options/pragmas. This moves the validation of the state (keywords) from SemaStmtAttr handler to the loop hint annotation token handler. Resubmit with changes to try to fix the build-bot issue. Reviewed by Aaron Ballman llvm-svn: 214432
2014-08-01 04:15:14 +08:00
// Return a valid hint if pragma unroll or nounroll were specified
// without an argument.
bool PragmaUnroll = PragmaNameInfo->getName() == "unroll";
bool PragmaNoUnroll = PragmaNameInfo->getName() == "nounroll";
Simplify EnterTokenStream API to make it more robust for memory management While this won't help fix things like the bug that r260219 addressed, it seems like good tidy up to have anyway. (it might be nice if "makeArrayRef" always produced a MutableArrayRef & let it decay to an ArrayRef when needed - then I'd use that for the MutableArrayRefs in this patch) If we had std::dynarray I'd use that instead of unique_ptr+size_t, ideally (but then it'd have to be threaded down through the Preprocessor all the way - no idea how painful that would be) llvm-svn: 260246
2016-02-10 02:52:09 +08:00
if (Toks.empty() && (PragmaUnroll || PragmaNoUnroll)) {
Allow constant expressions in pragma loop hints. Previously loop hints such as #pragma loop vectorize_width(#) required a constant. This patch allows a constant expression to be used as well. Such as a non-type template parameter or an expression (2 * c + 1). Reviewed by Richard Smith llvm-svn: 219589
2014-10-13 04:46:07 +08:00
ConsumeToken(); // The annotation token.
Add a state variable to the loop hint attribute. This patch is necessary to support constant expressions which replaces the integer value in the loop hint attribute with an expression. The integer value was also storing the pragma’s state for options like vectorize(enable/disable) and the pragma unroll and nounroll directive. The state variable is introduced to hold the state of those options/pragmas. This moves the validation of the state (keywords) from SemaStmtAttr handler to the loop hint annotation token handler. Resubmit with changes to try to fix the build-bot issue. Reviewed by Aaron Ballman llvm-svn: 214432
2014-08-01 04:15:14 +08:00
Hint.Range = Info->PragmaName.getLocation();
return true;
}
Allow constant expressions in pragma loop hints. Previously loop hints such as #pragma loop vectorize_width(#) required a constant. This patch allows a constant expression to be used as well. Such as a non-type template parameter or an expression (2 * c + 1). Reviewed by Richard Smith llvm-svn: 219589
2014-10-13 04:46:07 +08:00
// The constant expression is always followed by an eof token, which increases
// the TokSize by 1.
Simplify EnterTokenStream API to make it more robust for memory management While this won't help fix things like the bug that r260219 addressed, it seems like good tidy up to have anyway. (it might be nice if "makeArrayRef" always produced a MutableArrayRef & let it decay to an ArrayRef when needed - then I'd use that for the MutableArrayRefs in this patch) If we had std::dynarray I'd use that instead of unique_ptr+size_t, ideally (but then it'd have to be threaded down through the Preprocessor all the way - no idea how painful that would be) llvm-svn: 260246
2016-02-10 02:52:09 +08:00
assert(!Toks.empty() &&
Allow constant expressions in pragma loop hints. Previously loop hints such as #pragma loop vectorize_width(#) required a constant. This patch allows a constant expression to be used as well. Such as a non-type template parameter or an expression (2 * c + 1). Reviewed by Richard Smith llvm-svn: 219589
2014-10-13 04:46:07 +08:00
"PragmaLoopHintInfo::Toks must contain at least one token.");
// If no option is specified the argument is assumed to be a constant expr.
Correct Loop Hint Diagnostic Message When pragma clang loop unroll() is specified without an argument the diagnostic message should inform that user that 'full' and 'disable' are valid arguments (not 'enable'). llvm-svn: 239363
2015-06-09 07:13:43 +08:00
bool OptionUnroll = false;
Add loop pragma for Loop Distribution Summary: This is similar to other loop pragmas like 'vectorize'. Currently it only has state values: distribute(enable) and distribute(disable). When one of these is specified the corresponding loop metadata is generated: !{!"llvm.loop.distribute.enable", i1 true/false} As a result, loop distribution will be attempted on the loop even if Loop Distribution in not enabled globally. Analogously, with 'disable' distribution can be turned off for an individual loop even when the pass is otherwise enabled. There are some slight differences compared to the existing loop pragmas. 1. There is no 'assume_safety' variant which makes its handling slightly different from 'vectorize'/'interleave'. 2. Unlike the existing loop pragmas, it does not have a corresponding numeric pragma like 'vectorize' -> 'vectorize_width'. So for the consistency checks in CheckForIncompatibleAttributes we don't need to check it against other pragmas. We just need to check for duplicates of the same pragma. Reviewers: rsmith, dexonsmith, aaron.ballman Subscribers: bob.wilson, cfe-commits, hfinkel Differential Revision: http://reviews.llvm.org/D19403 llvm-svn: 272656
2016-06-14 20:04:26 +08:00
bool OptionDistribute = false;
Add a state variable to the loop hint attribute. This patch is necessary to support constant expressions which replaces the integer value in the loop hint attribute with an expression. The integer value was also storing the pragma’s state for options like vectorize(enable/disable) and the pragma unroll and nounroll directive. The state variable is introduced to hold the state of those options/pragmas. This moves the validation of the state (keywords) from SemaStmtAttr handler to the loop hint annotation token handler. Resubmit with changes to try to fix the build-bot issue. Reviewed by Aaron Ballman llvm-svn: 214432
2014-08-01 04:15:14 +08:00
bool StateOption = false;
Correct Loop Hint Diagnostic Message When pragma clang loop unroll() is specified without an argument the diagnostic message should inform that user that 'full' and 'disable' are valid arguments (not 'enable'). llvm-svn: 239363
2015-06-09 07:13:43 +08:00
if (OptionInfo) { // Pragma Unroll does not specify an option.
OptionUnroll = OptionInfo->isStr("unroll");
Add loop pragma for Loop Distribution Summary: This is similar to other loop pragmas like 'vectorize'. Currently it only has state values: distribute(enable) and distribute(disable). When one of these is specified the corresponding loop metadata is generated: !{!"llvm.loop.distribute.enable", i1 true/false} As a result, loop distribution will be attempted on the loop even if Loop Distribution in not enabled globally. Analogously, with 'disable' distribution can be turned off for an individual loop even when the pass is otherwise enabled. There are some slight differences compared to the existing loop pragmas. 1. There is no 'assume_safety' variant which makes its handling slightly different from 'vectorize'/'interleave'. 2. Unlike the existing loop pragmas, it does not have a corresponding numeric pragma like 'vectorize' -> 'vectorize_width'. So for the consistency checks in CheckForIncompatibleAttributes we don't need to check it against other pragmas. We just need to check for duplicates of the same pragma. Reviewers: rsmith, dexonsmith, aaron.ballman Subscribers: bob.wilson, cfe-commits, hfinkel Differential Revision: http://reviews.llvm.org/D19403 llvm-svn: 272656
2016-06-14 20:04:26 +08:00
OptionDistribute = OptionInfo->isStr("distribute");
Add a state variable to the loop hint attribute. This patch is necessary to support constant expressions which replaces the integer value in the loop hint attribute with an expression. The integer value was also storing the pragma’s state for options like vectorize(enable/disable) and the pragma unroll and nounroll directive. The state variable is introduced to hold the state of those options/pragmas. This moves the validation of the state (keywords) from SemaStmtAttr handler to the loop hint annotation token handler. Resubmit with changes to try to fix the build-bot issue. Reviewed by Aaron Ballman llvm-svn: 214432
2014-08-01 04:15:14 +08:00
StateOption = llvm::StringSwitch<bool>(OptionInfo->getName())
.Case("vectorize", true)
.Case("interleave", true)
Add loop pragma for Loop Distribution Summary: This is similar to other loop pragmas like 'vectorize'. Currently it only has state values: distribute(enable) and distribute(disable). When one of these is specified the corresponding loop metadata is generated: !{!"llvm.loop.distribute.enable", i1 true/false} As a result, loop distribution will be attempted on the loop even if Loop Distribution in not enabled globally. Analogously, with 'disable' distribution can be turned off for an individual loop even when the pass is otherwise enabled. There are some slight differences compared to the existing loop pragmas. 1. There is no 'assume_safety' variant which makes its handling slightly different from 'vectorize'/'interleave'. 2. Unlike the existing loop pragmas, it does not have a corresponding numeric pragma like 'vectorize' -> 'vectorize_width'. So for the consistency checks in CheckForIncompatibleAttributes we don't need to check it against other pragmas. We just need to check for duplicates of the same pragma. Reviewers: rsmith, dexonsmith, aaron.ballman Subscribers: bob.wilson, cfe-commits, hfinkel Differential Revision: http://reviews.llvm.org/D19403 llvm-svn: 272656
2016-06-14 20:04:26 +08:00
.Default(false) ||
OptionUnroll || OptionDistribute;
Allow constant expressions in pragma loop hints. Previously loop hints such as #pragma loop vectorize_width(#) required a constant. This patch allows a constant expression to be used as well. Such as a non-type template parameter or an expression (2 * c + 1). Reviewed by Richard Smith llvm-svn: 219589
2014-10-13 04:46:07 +08:00
}
Add loop pragma for Loop Distribution Summary: This is similar to other loop pragmas like 'vectorize'. Currently it only has state values: distribute(enable) and distribute(disable). When one of these is specified the corresponding loop metadata is generated: !{!"llvm.loop.distribute.enable", i1 true/false} As a result, loop distribution will be attempted on the loop even if Loop Distribution in not enabled globally. Analogously, with 'disable' distribution can be turned off for an individual loop even when the pass is otherwise enabled. There are some slight differences compared to the existing loop pragmas. 1. There is no 'assume_safety' variant which makes its handling slightly different from 'vectorize'/'interleave'. 2. Unlike the existing loop pragmas, it does not have a corresponding numeric pragma like 'vectorize' -> 'vectorize_width'. So for the consistency checks in CheckForIncompatibleAttributes we don't need to check it against other pragmas. We just need to check for duplicates of the same pragma. Reviewers: rsmith, dexonsmith, aaron.ballman Subscribers: bob.wilson, cfe-commits, hfinkel Differential Revision: http://reviews.llvm.org/D19403 llvm-svn: 272656
2016-06-14 20:04:26 +08:00
bool AssumeSafetyArg = !OptionUnroll && !OptionDistribute;
Allow constant expressions in pragma loop hints. Previously loop hints such as #pragma loop vectorize_width(#) required a constant. This patch allows a constant expression to be used as well. Such as a non-type template parameter or an expression (2 * c + 1). Reviewed by Richard Smith llvm-svn: 219589
2014-10-13 04:46:07 +08:00
// Verify loop hint has an argument.
if (Toks[0].is(tok::eof)) {
ConsumeToken(); // The annotation token.
Diag(Toks[0].getLocation(), diag::err_pragma_loop_missing_argument)
Add loop pragma for Loop Distribution Summary: This is similar to other loop pragmas like 'vectorize'. Currently it only has state values: distribute(enable) and distribute(disable). When one of these is specified the corresponding loop metadata is generated: !{!"llvm.loop.distribute.enable", i1 true/false} As a result, loop distribution will be attempted on the loop even if Loop Distribution in not enabled globally. Analogously, with 'disable' distribution can be turned off for an individual loop even when the pass is otherwise enabled. There are some slight differences compared to the existing loop pragmas. 1. There is no 'assume_safety' variant which makes its handling slightly different from 'vectorize'/'interleave'. 2. Unlike the existing loop pragmas, it does not have a corresponding numeric pragma like 'vectorize' -> 'vectorize_width'. So for the consistency checks in CheckForIncompatibleAttributes we don't need to check it against other pragmas. We just need to check for duplicates of the same pragma. Reviewers: rsmith, dexonsmith, aaron.ballman Subscribers: bob.wilson, cfe-commits, hfinkel Differential Revision: http://reviews.llvm.org/D19403 llvm-svn: 272656
2016-06-14 20:04:26 +08:00
<< /*StateArgument=*/StateOption << /*FullKeyword=*/OptionUnroll
<< /*AssumeSafetyKeyword=*/AssumeSafetyArg;
Allow constant expressions in pragma loop hints. Previously loop hints such as #pragma loop vectorize_width(#) required a constant. This patch allows a constant expression to be used as well. Such as a non-type template parameter or an expression (2 * c + 1). Reviewed by Richard Smith llvm-svn: 219589
2014-10-13 04:46:07 +08:00
return false;
}
Add a state variable to the loop hint attribute. This patch is necessary to support constant expressions which replaces the integer value in the loop hint attribute with an expression. The integer value was also storing the pragma’s state for options like vectorize(enable/disable) and the pragma unroll and nounroll directive. The state variable is introduced to hold the state of those options/pragmas. This moves the validation of the state (keywords) from SemaStmtAttr handler to the loop hint annotation token handler. Resubmit with changes to try to fix the build-bot issue. Reviewed by Aaron Ballman llvm-svn: 214432
2014-08-01 04:15:14 +08:00
// Validate the argument.
if (StateOption) {
Allow constant expressions in pragma loop hints. Previously loop hints such as #pragma loop vectorize_width(#) required a constant. This patch allows a constant expression to be used as well. Such as a non-type template parameter or an expression (2 * c + 1). Reviewed by Richard Smith llvm-svn: 219589
2014-10-13 04:46:07 +08:00
ConsumeToken(); // The annotation token.
SourceLocation StateLoc = Toks[0].getLocation();
IdentifierInfo *StateInfo = Toks[0].getIdentifierInfo();
[Parse] Use StringSwitch to improve readability. NFC A subsequent patch will propose a "distribute" loop hint. Similarly to unroll, this does not have a "assume_safety" argument either so this condition will get more complex. llvm-svn: 266827
2016-04-20 06:17:45 +08:00
bool Valid = StateInfo &&
llvm::StringSwitch<bool>(StateInfo->getName())
.Cases("enable", "disable", true)
.Case("full", OptionUnroll)
Add loop pragma for Loop Distribution Summary: This is similar to other loop pragmas like 'vectorize'. Currently it only has state values: distribute(enable) and distribute(disable). When one of these is specified the corresponding loop metadata is generated: !{!"llvm.loop.distribute.enable", i1 true/false} As a result, loop distribution will be attempted on the loop even if Loop Distribution in not enabled globally. Analogously, with 'disable' distribution can be turned off for an individual loop even when the pass is otherwise enabled. There are some slight differences compared to the existing loop pragmas. 1. There is no 'assume_safety' variant which makes its handling slightly different from 'vectorize'/'interleave'. 2. Unlike the existing loop pragmas, it does not have a corresponding numeric pragma like 'vectorize' -> 'vectorize_width'. So for the consistency checks in CheckForIncompatibleAttributes we don't need to check it against other pragmas. We just need to check for duplicates of the same pragma. Reviewers: rsmith, dexonsmith, aaron.ballman Subscribers: bob.wilson, cfe-commits, hfinkel Differential Revision: http://reviews.llvm.org/D19403 llvm-svn: 272656
2016-06-14 20:04:26 +08:00
.Case("assume_safety", AssumeSafetyArg)
[Parse] Use StringSwitch to improve readability. NFC A subsequent patch will propose a "distribute" loop hint. Similarly to unroll, this does not have a "assume_safety" argument either so this condition will get more complex. llvm-svn: 266827
2016-04-20 06:17:45 +08:00
.Default(false);
if (!Valid) {
Allow constant expressions in pragma loop hints. Previously loop hints such as #pragma loop vectorize_width(#) required a constant. This patch allows a constant expression to be used as well. Such as a non-type template parameter or an expression (2 * c + 1). Reviewed by Richard Smith llvm-svn: 219589
2014-10-13 04:46:07 +08:00
Diag(Toks[0].getLocation(), diag::err_pragma_invalid_keyword)
Add loop pragma for Loop Distribution Summary: This is similar to other loop pragmas like 'vectorize'. Currently it only has state values: distribute(enable) and distribute(disable). When one of these is specified the corresponding loop metadata is generated: !{!"llvm.loop.distribute.enable", i1 true/false} As a result, loop distribution will be attempted on the loop even if Loop Distribution in not enabled globally. Analogously, with 'disable' distribution can be turned off for an individual loop even when the pass is otherwise enabled. There are some slight differences compared to the existing loop pragmas. 1. There is no 'assume_safety' variant which makes its handling slightly different from 'vectorize'/'interleave'. 2. Unlike the existing loop pragmas, it does not have a corresponding numeric pragma like 'vectorize' -> 'vectorize_width'. So for the consistency checks in CheckForIncompatibleAttributes we don't need to check it against other pragmas. We just need to check for duplicates of the same pragma. Reviewers: rsmith, dexonsmith, aaron.ballman Subscribers: bob.wilson, cfe-commits, hfinkel Differential Revision: http://reviews.llvm.org/D19403 llvm-svn: 272656
2016-06-14 20:04:26 +08:00
<< /*FullKeyword=*/OptionUnroll
<< /*AssumeSafetyKeyword=*/AssumeSafetyArg;
Add a state variable to the loop hint attribute. This patch is necessary to support constant expressions which replaces the integer value in the loop hint attribute with an expression. The integer value was also storing the pragma’s state for options like vectorize(enable/disable) and the pragma unroll and nounroll directive. The state variable is introduced to hold the state of those options/pragmas. This moves the validation of the state (keywords) from SemaStmtAttr handler to the loop hint annotation token handler. Resubmit with changes to try to fix the build-bot issue. Reviewed by Aaron Ballman llvm-svn: 214432
2014-08-01 04:15:14 +08:00
return false;
}
Simplify EnterTokenStream API to make it more robust for memory management While this won't help fix things like the bug that r260219 addressed, it seems like good tidy up to have anyway. (it might be nice if "makeArrayRef" always produced a MutableArrayRef & let it decay to an ArrayRef when needed - then I'd use that for the MutableArrayRefs in this patch) If we had std::dynarray I'd use that instead of unique_ptr+size_t, ideally (but then it'd have to be threaded down through the Preprocessor all the way - no idea how painful that would be) llvm-svn: 260246
2016-02-10 02:52:09 +08:00
if (Toks.size() > 2)
Allow constant expressions in pragma loop hints. Previously loop hints such as #pragma loop vectorize_width(#) required a constant. This patch allows a constant expression to be used as well. Such as a non-type template parameter or an expression (2 * c + 1). Reviewed by Richard Smith llvm-svn: 219589
2014-10-13 04:46:07 +08:00
Diag(Tok.getLocation(), diag::warn_pragma_extra_tokens_at_eol)
<< PragmaLoopHintString(Info->PragmaName, Info->Option);
Add a state variable to the loop hint attribute. This patch is necessary to support constant expressions which replaces the integer value in the loop hint attribute with an expression. The integer value was also storing the pragma’s state for options like vectorize(enable/disable) and the pragma unroll and nounroll directive. The state variable is introduced to hold the state of those options/pragmas. This moves the validation of the state (keywords) from SemaStmtAttr handler to the loop hint annotation token handler. Resubmit with changes to try to fix the build-bot issue. Reviewed by Aaron Ballman llvm-svn: 214432
2014-08-01 04:15:14 +08:00
Hint.StateLoc = IdentifierLoc::create(Actions.Context, StateLoc, StateInfo);
} else {
Allow constant expressions in pragma loop hints. Previously loop hints such as #pragma loop vectorize_width(#) required a constant. This patch allows a constant expression to be used as well. Such as a non-type template parameter or an expression (2 * c + 1). Reviewed by Richard Smith llvm-svn: 219589
2014-10-13 04:46:07 +08:00
// Enter constant expression including eof terminator into token stream.
Simplify EnterTokenStream API to make it more robust for memory management While this won't help fix things like the bug that r260219 addressed, it seems like good tidy up to have anyway. (it might be nice if "makeArrayRef" always produced a MutableArrayRef & let it decay to an ArrayRef when needed - then I'd use that for the MutableArrayRefs in this patch) If we had std::dynarray I'd use that instead of unique_ptr+size_t, ideally (but then it'd have to be threaded down through the Preprocessor all the way - no idea how painful that would be) llvm-svn: 260246
2016-02-10 02:52:09 +08:00
PP.EnterTokenStream(Toks, /*DisableMacroExpansion=*/false);
Allow constant expressions in pragma loop hints. Previously loop hints such as #pragma loop vectorize_width(#) required a constant. This patch allows a constant expression to be used as well. Such as a non-type template parameter or an expression (2 * c + 1). Reviewed by Richard Smith llvm-svn: 219589
2014-10-13 04:46:07 +08:00
ConsumeToken(); // The annotation token.
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();
Add a state variable to the loop hint attribute. This patch is necessary to support constant expressions which replaces the integer value in the loop hint attribute with an expression. The integer value was also storing the pragma’s state for options like vectorize(enable/disable) and the pragma unroll and nounroll directive. The state variable is introduced to hold the state of those options/pragmas. This moves the validation of the state (keywords) from SemaStmtAttr handler to the loop hint annotation token handler. Resubmit with changes to try to fix the build-bot issue. Reviewed by Aaron Ballman llvm-svn: 214432
2014-08-01 04:15:14 +08:00
}
Allow constant expressions in pragma loop hints. Previously loop hints such as #pragma loop vectorize_width(#) required a constant. This patch allows a constant expression to be used as well. Such as a non-type template parameter or an expression (2 * c + 1). Reviewed by Richard Smith llvm-svn: 219589
2014-10-13 04:46:07 +08:00
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();
Add support for '#pragma unroll'. llvm-svn: 213574
2014-07-22 02:08:34 +08:00
}
Fix DOS-style newlines. A previous patch r210330 (and possibly another) introduced DOS-style newlines into a UNIX newline formatted file. Patch by Mark Heffernan (http://reviews.llvm.org/D4046) llvm-svn: 210369
2014-06-07 04:31:48 +08:00
Allow constant expressions in pragma loop hints. Previously loop hints such as #pragma loop vectorize_width(#) required a constant. This patch allows a constant expression to be used as well. Such as a non-type template parameter or an expression (2 * c + 1). Reviewed by Richard Smith llvm-svn: 219589
2014-10-13 04:46:07 +08:00
Hint.Range = SourceRange(Info->PragmaName.getLocation(),
Simplify EnterTokenStream API to make it more robust for memory management While this won't help fix things like the bug that r260219 addressed, it seems like good tidy up to have anyway. (it might be nice if "makeArrayRef" always produced a MutableArrayRef & let it decay to an ArrayRef when needed - then I'd use that for the MutableArrayRefs in this patch) If we had std::dynarray I'd use that instead of unique_ptr+size_t, ideally (but then it'd have to be threaded down through the Preprocessor all the way - no idea how painful that would be) llvm-svn: 260246
2016-02-10 02:52:09 +08:00
Info->Toks.back().getLocation());
Add a state variable to the loop hint attribute. This patch is necessary to support constant expressions which replaces the integer value in the loop hint attribute with an expression. The integer value was also storing the pragma’s state for options like vectorize(enable/disable) and the pragma unroll and nounroll directive. The state variable is introduced to hold the state of those options/pragmas. This moves the validation of the state (keywords) from SemaStmtAttr handler to the loop hint annotation token handler. Resubmit with changes to try to fix the build-bot issue. Reviewed by Aaron Ballman llvm-svn: 214432
2014-08-01 04:15:14 +08:00
return true;
Fix DOS-style newlines. A previous patch r210330 (and possibly another) introduced DOS-style newlines into a UNIX newline formatted file. Patch by Mark Heffernan (http://reviews.llvm.org/D4046) llvm-svn: 210369
2014-06-07 04:31:48 +08:00
}
// #pragma GCC visibility comes in two variants:
// 'push' '(' [visibility] ')'
// 'pop'
When we parse a pragma, keep track of how that pragma was originally spelled (#pragma, _Pragma, __pragma). In -E mode, use that information to add appropriate newlines when translating _Pragma and __pragma into #pragma, like GCC does. Fixes <rdar://problem/8412013>. llvm-svn: 113553
2010-09-10 06:45:38 +08:00
void PragmaGCCVisibilityHandler::HandlePragma(Preprocessor &PP,
PragmaIntroducerKind Introducer,
Token &VisTok) {
Implement #pragma GCC visibility. llvm-svn: 110315
2010-08-05 14:57:20 +08:00
SourceLocation VisLoc = VisTok.getLocation();
Token Tok;
PR10392: "#pragma GCC visibility" must not expand macros in its arguments. llvm-svn: 135552
2011-07-20 09:03:50 +08:00
PP.LexUnexpandedToken(Tok);
Implement #pragma GCC visibility. llvm-svn: 110315
2010-08-05 14:57:20 +08:00
const IdentifierInfo *PushPop = Tok.getIdentifierInfo();
const IdentifierInfo *VisType;
if (PushPop && PushPop->isStr("pop")) {
[C++11] Use 'nullptr'. Parser edition. llvm-svn: 209275
2014-05-21 14:02:52 +08:00
VisType = nullptr;
Implement #pragma GCC visibility. llvm-svn: 110315
2010-08-05 14:57:20 +08:00
} else if (PushPop && PushPop->isStr("push")) {
PR10392: "#pragma GCC visibility" must not expand macros in its arguments. llvm-svn: 135552
2011-07-20 09:03:50 +08:00
PP.LexUnexpandedToken(Tok);
Implement #pragma GCC visibility. llvm-svn: 110315
2010-08-05 14:57:20 +08:00
if (Tok.isNot(tok::l_paren)) {
PP.Diag(Tok.getLocation(), diag::warn_pragma_expected_lparen)
<< "visibility";
return;
}
PR10392: "#pragma GCC visibility" must not expand macros in its arguments. llvm-svn: 135552
2011-07-20 09:03:50 +08:00
PP.LexUnexpandedToken(Tok);
Implement #pragma GCC visibility. llvm-svn: 110315
2010-08-05 14:57:20 +08:00
VisType = Tok.getIdentifierInfo();
if (!VisType) {
PP.Diag(Tok.getLocation(), diag::warn_pragma_expected_identifier)
<< "visibility";
return;
}
PR10392: "#pragma GCC visibility" must not expand macros in its arguments. llvm-svn: 135552
2011-07-20 09:03:50 +08:00
PP.LexUnexpandedToken(Tok);
Implement #pragma GCC visibility. llvm-svn: 110315
2010-08-05 14:57:20 +08:00
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;
}
Parse: Don't assume tokens have a length Don't crash if the last token in a bad inline method body is an annotation token. llvm-svn: 232694
2015-03-19 08:10:23 +08:00
SourceLocation EndLoc = Tok.getLocation();
PR10392: "#pragma GCC visibility" must not expand macros in its arguments. llvm-svn: 135552
2011-07-20 09:03:50 +08:00
PP.LexUnexpandedToken(Tok);
Rename tok::eom to tok::eod. The previous name was inaccurate as this token in fact appears at the end of every preprocessing directive, not just macro definitions. No functionality change, except for a diagnostic tweak. llvm-svn: 126631
2011-02-28 10:37:51 +08:00
if (Tok.isNot(tok::eod)) {
Implement #pragma GCC visibility. llvm-svn: 110315
2010-08-05 14:57:20 +08:00
PP.Diag(Tok.getLocation(), diag::warn_pragma_extra_tokens_at_eol)
<< "visibility";
return;
}
Simplify EnterTokenStream API to make it more robust for memory management While this won't help fix things like the bug that r260219 addressed, it seems like good tidy up to have anyway. (it might be nice if "makeArrayRef" always produced a MutableArrayRef & let it decay to an ArrayRef when needed - then I'd use that for the MutableArrayRefs in this patch) If we had std::dynarray I'd use that instead of unique_ptr+size_t, ideally (but then it'd have to be threaded down through the Preprocessor all the way - no idea how painful that would be) llvm-svn: 260246
2016-02-10 02:52:09 +08:00
auto Toks = llvm::make_unique<Token[]>(1);
Fix our handling of #pragma GCC visibility. Now the lexer just produces a token and the parser is the one responsible for activating it. This fixes problem like the one pr11797 where the lexer and the parser were not in sync. This also let us be more strict on where in the file we accept these pragmas. llvm-svn: 149014
2012-01-26 10:02:57 +08:00
Toks[0].startToken();
Toks[0].setKind(tok::annot_pragma_vis);
Toks[0].setLocation(VisLoc);
Parse: Don't assume tokens have a length Don't crash if the last token in a bad inline method body is an annotation token. llvm-svn: 232694
2015-03-19 08:10:23 +08:00
Toks[0].setAnnotationEndLoc(EndLoc);
Fix our handling of #pragma GCC visibility. Now the lexer just produces a token and the parser is the one responsible for activating it. This fixes problem like the one pr11797 where the lexer and the parser were not in sync. This also let us be more strict on where in the file we accept these pragmas. llvm-svn: 149014
2012-01-26 10:02:57 +08:00
Toks[0].setAnnotationValue(
const_cast<void*>(static_cast<const void*>(VisType)));
Simplify EnterTokenStream API to make it more robust for memory management While this won't help fix things like the bug that r260219 addressed, it seems like good tidy up to have anyway. (it might be nice if "makeArrayRef" always produced a MutableArrayRef & let it decay to an ArrayRef when needed - then I'd use that for the MutableArrayRefs in this patch) If we had std::dynarray I'd use that instead of unique_ptr+size_t, ideally (but then it'd have to be threaded down through the Preprocessor all the way - no idea how painful that would be) llvm-svn: 260246
2016-02-10 02:52:09 +08:00
PP.EnterTokenStream(std::move(Toks), 1, /*DisableMacroExpansion=*/true);
Implement #pragma GCC visibility. llvm-svn: 110315
2010-08-05 14:57:20 +08:00
}
Add Parser support for #pragma pack - Uses Action::ActOnPragmaPack - Test case is XFAIL pending verifier fixes. llvm-svn: 57066
2008-10-05 03:21:03 +08:00
// #pragma pack(...) comes in the following delicious flavors:
// pack '(' [integer] ')'
// pack '(' 'show' ')'
// pack '(' ('push' | 'pop') [',' identifier] [, integer] ')'
When we parse a pragma, keep track of how that pragma was originally spelled (#pragma, _Pragma, __pragma). In -E mode, use that information to add appropriate newlines when translating _Pragma and __pragma into #pragma, like GCC does. Fixes <rdar://problem/8412013>. llvm-svn: 113553
2010-09-10 06:45:38 +08:00
void PragmaPackHandler::HandlePragma(Preprocessor &PP,
PragmaIntroducerKind Introducer,
Token &PackTok) {
Add Parser support for #pragma pack - Uses Action::ActOnPragmaPack - Test case is XFAIL pending verifier fixes. llvm-svn: 57066
2008-10-05 03:21:03 +08:00
SourceLocation PackLoc = PackTok.getLocation();
Token Tok;
PP.Lex(Tok);
if (Tok.isNot(tok::l_paren)) {
Implement '#pragma unused'. llvm-svn: 67569
2009-03-24 06:28:25 +08:00
PP.Diag(Tok.getLocation(), diag::warn_pragma_expected_lparen) << "pack";
Add Parser support for #pragma pack - Uses Action::ActOnPragmaPack - Test case is XFAIL pending verifier fixes. llvm-svn: 57066
2008-10-05 03:21:03 +08:00
return;
}
[MS] Make #pragma pack use PragmaStack<> class. Make implementation of #pragma pack consistent with other "stack" pragmas. Use PragmaStack<> class instead of old representation of internal stack. Don't change compiler's behavior. TODO: 1. Introduce diagnostics on popping named slots from pragma stacks. Reviewer: rnk Differential revision: http://reviews.llvm.org/D19727 llvm-svn: 268085
2016-04-30 02:17:40 +08:00
Sema::PragmaMsStackAction Action = Sema::PSK_Reset;
StringRef SlotLabel;
Permanently end the whole "pragma got handled by the parser too early" mess by handling all pragmas which the parser touches uniformly. <rdar://problem/12248901>, etc. llvm-svn: 165195
2012-10-04 10:36:51 +08:00
Token Alignment;
Alignment.startToken();
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
PP.Lex(Tok);
Add Parser support for #pragma pack - Uses Action::ActOnPragmaPack - Test case is XFAIL pending verifier fixes. llvm-svn: 57066
2008-10-05 03:21:03 +08:00
if (Tok.is(tok::numeric_constant)) {
Permanently end the whole "pragma got handled by the parser too early" mess by handling all pragmas which the parser touches uniformly. <rdar://problem/12248901>, etc. llvm-svn: 165195
2012-10-04 10:36:51 +08:00
Alignment = Tok;
Add Parser support for #pragma pack - Uses Action::ActOnPragmaPack - Test case is XFAIL pending verifier fixes. llvm-svn: 57066
2008-10-05 03:21:03 +08:00
PP.Lex(Tok);
Add an option to emulate the strange Apple gcc behavior of #pragma pack. <rdar://problem/10374763> llvm-svn: 143527
2011-11-02 09:53:16 +08:00
// 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)
[MS] Make #pragma pack use PragmaStack<> class. Make implementation of #pragma pack consistent with other "stack" pragmas. Use PragmaStack<> class instead of old representation of internal stack. Don't change compiler's behavior. TODO: 1. Introduce diagnostics on popping named slots from pragma stacks. Reviewer: rnk Differential revision: http://reviews.llvm.org/D19727 llvm-svn: 268085
2016-04-30 02:17:40 +08:00
Action =
PP.getLangOpts().ApplePragmaPack ? Sema::PSK_Push_Set : Sema::PSK_Set;
Add Parser support for #pragma pack - Uses Action::ActOnPragmaPack - Test case is XFAIL pending verifier fixes. llvm-svn: 57066
2008-10-05 03:21:03 +08:00
} else if (Tok.is(tok::identifier)) {
const IdentifierInfo *II = Tok.getIdentifierInfo();
Convert IdentifierInfo's to be printed the same as DeclarationNames with implicit quotes around them. This has a bunch of follow-on effects and requires tweaking to a whole lot of code. This causes a regression in two tests (xfailed) by causing it to emit things like: Line 10: duplicate interface declaration for category 'MyClass1' ('Category1') instead of: Line 10: duplicate interface declaration for category 'MyClass1(Category1)' I will fix this in a follow-up commit. As part of this, I had to start switching stuff to use ->getDeclName() instead of Decl::getName() for consistency. This is good, but I was planning to do this as an independent patch. There will be several follow-on patches to clean up some of the mess, but this patch is already too big. llvm-svn: 59917
2008-11-24 05:45:46 +08:00
if (II->isStr("show")) {
[MS] Make #pragma pack use PragmaStack<> class. Make implementation of #pragma pack consistent with other "stack" pragmas. Use PragmaStack<> class instead of old representation of internal stack. Don't change compiler's behavior. TODO: 1. Introduce diagnostics on popping named slots from pragma stacks. Reviewer: rnk Differential revision: http://reviews.llvm.org/D19727 llvm-svn: 268085
2016-04-30 02:17:40 +08:00
Action = Sema::PSK_Show;
Add Parser support for #pragma pack - Uses Action::ActOnPragmaPack - Test case is XFAIL pending verifier fixes. llvm-svn: 57066
2008-10-05 03:21:03 +08:00
PP.Lex(Tok);
} else {
Convert IdentifierInfo's to be printed the same as DeclarationNames with implicit quotes around them. This has a bunch of follow-on effects and requires tweaking to a whole lot of code. This causes a regression in two tests (xfailed) by causing it to emit things like: Line 10: duplicate interface declaration for category 'MyClass1' ('Category1') instead of: Line 10: duplicate interface declaration for category 'MyClass1(Category1)' I will fix this in a follow-up commit. As part of this, I had to start switching stuff to use ->getDeclName() instead of Decl::getName() for consistency. This is good, but I was planning to do this as an independent patch. There will be several follow-on patches to clean up some of the mess, but this patch is already too big. llvm-svn: 59917
2008-11-24 05:45:46 +08:00
if (II->isStr("push")) {
[MS] Make #pragma pack use PragmaStack<> class. Make implementation of #pragma pack consistent with other "stack" pragmas. Use PragmaStack<> class instead of old representation of internal stack. Don't change compiler's behavior. TODO: 1. Introduce diagnostics on popping named slots from pragma stacks. Reviewer: rnk Differential revision: http://reviews.llvm.org/D19727 llvm-svn: 268085
2016-04-30 02:17:40 +08:00
Action = Sema::PSK_Push;
Convert IdentifierInfo's to be printed the same as DeclarationNames with implicit quotes around them. This has a bunch of follow-on effects and requires tweaking to a whole lot of code. This causes a regression in two tests (xfailed) by causing it to emit things like: Line 10: duplicate interface declaration for category 'MyClass1' ('Category1') instead of: Line 10: duplicate interface declaration for category 'MyClass1(Category1)' I will fix this in a follow-up commit. As part of this, I had to start switching stuff to use ->getDeclName() instead of Decl::getName() for consistency. This is good, but I was planning to do this as an independent patch. There will be several follow-on patches to clean up some of the mess, but this patch is already too big. llvm-svn: 59917
2008-11-24 05:45:46 +08:00
} else if (II->isStr("pop")) {
[MS] Make #pragma pack use PragmaStack<> class. Make implementation of #pragma pack consistent with other "stack" pragmas. Use PragmaStack<> class instead of old representation of internal stack. Don't change compiler's behavior. TODO: 1. Introduce diagnostics on popping named slots from pragma stacks. Reviewer: rnk Differential revision: http://reviews.llvm.org/D19727 llvm-svn: 268085
2016-04-30 02:17:40 +08:00
Action = Sema::PSK_Pop;
Add Parser support for #pragma pack - Uses Action::ActOnPragmaPack - Test case is XFAIL pending verifier fixes. llvm-svn: 57066
2008-10-05 03:21:03 +08:00
} else {
MS ABI: Implement #pragma vtordisp() and clang-cl /vdN These features are new in VS 2013 and are necessary in order to layout std::ostream correctly. Currently we have an ABI incompatibility when self-hosting with the 2013 stdlib in our convertible_fwd_ostream wrapper in gtest. This change adds another implicit attribute, MSVtorDispAttr, because implicit attributes are currently the best way to make sure the information stays on class templates through instantiation. Reviewers: majnemer Differential Revision: http://llvm-reviews.chandlerc.com/D2746 llvm-svn: 201274
2014-02-13 07:50:26 +08:00
PP.Diag(Tok.getLocation(), diag::warn_pragma_invalid_action) << "pack";
Add Parser support for #pragma pack - Uses Action::ActOnPragmaPack - Test case is XFAIL pending verifier fixes. llvm-svn: 57066
2008-10-05 03:21:03 +08:00
return;
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
}
Add Parser support for #pragma pack - Uses Action::ActOnPragmaPack - Test case is XFAIL pending verifier fixes. llvm-svn: 57066
2008-10-05 03:21:03 +08:00
PP.Lex(Tok);
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
Add Parser support for #pragma pack - Uses Action::ActOnPragmaPack - Test case is XFAIL pending verifier fixes. llvm-svn: 57066
2008-10-05 03:21:03 +08:00
if (Tok.is(tok::comma)) {
PP.Lex(Tok);
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
Add Parser support for #pragma pack - Uses Action::ActOnPragmaPack - Test case is XFAIL pending verifier fixes. llvm-svn: 57066
2008-10-05 03:21:03 +08:00
if (Tok.is(tok::numeric_constant)) {
[MS] Make #pragma pack use PragmaStack<> class. Make implementation of #pragma pack consistent with other "stack" pragmas. Use PragmaStack<> class instead of old representation of internal stack. Don't change compiler's behavior. TODO: 1. Introduce diagnostics on popping named slots from pragma stacks. Reviewer: rnk Differential revision: http://reviews.llvm.org/D19727 llvm-svn: 268085
2016-04-30 02:17:40 +08:00
Action = (Sema::PragmaMsStackAction)(Action | Sema::PSK_Set);
Permanently end the whole "pragma got handled by the parser too early" mess by handling all pragmas which the parser touches uniformly. <rdar://problem/12248901>, etc. llvm-svn: 165195
2012-10-04 10:36:51 +08:00
Alignment = Tok;
Add Parser support for #pragma pack - Uses Action::ActOnPragmaPack - Test case is XFAIL pending verifier fixes. llvm-svn: 57066
2008-10-05 03:21:03 +08:00
PP.Lex(Tok);
} else if (Tok.is(tok::identifier)) {
[MS] Make #pragma pack use PragmaStack<> class. Make implementation of #pragma pack consistent with other "stack" pragmas. Use PragmaStack<> class instead of old representation of internal stack. Don't change compiler's behavior. TODO: 1. Introduce diagnostics on popping named slots from pragma stacks. Reviewer: rnk Differential revision: http://reviews.llvm.org/D19727 llvm-svn: 268085
2016-04-30 02:17:40 +08:00
SlotLabel = Tok.getIdentifierInfo()->getName();
Add Parser support for #pragma pack - Uses Action::ActOnPragmaPack - Test case is XFAIL pending verifier fixes. llvm-svn: 57066
2008-10-05 03:21:03 +08:00
PP.Lex(Tok);
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
Add Parser support for #pragma pack - Uses Action::ActOnPragmaPack - Test case is XFAIL pending verifier fixes. llvm-svn: 57066
2008-10-05 03:21:03 +08:00
if (Tok.is(tok::comma)) {
PP.Lex(Tok);
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
Add Parser support for #pragma pack - Uses Action::ActOnPragmaPack - Test case is XFAIL pending verifier fixes. llvm-svn: 57066
2008-10-05 03:21:03 +08:00
if (Tok.isNot(tok::numeric_constant)) {
Convert IdentifierInfo's to be printed the same as DeclarationNames with implicit quotes around them. This has a bunch of follow-on effects and requires tweaking to a whole lot of code. This causes a regression in two tests (xfailed) by causing it to emit things like: Line 10: duplicate interface declaration for category 'MyClass1' ('Category1') instead of: Line 10: duplicate interface declaration for category 'MyClass1(Category1)' I will fix this in a follow-up commit. As part of this, I had to start switching stuff to use ->getDeclName() instead of Decl::getName() for consistency. This is good, but I was planning to do this as an independent patch. There will be several follow-on patches to clean up some of the mess, but this patch is already too big. llvm-svn: 59917
2008-11-24 05:45:46 +08:00
PP.Diag(Tok.getLocation(), diag::warn_pragma_pack_malformed);
Add Parser support for #pragma pack - Uses Action::ActOnPragmaPack - Test case is XFAIL pending verifier fixes. llvm-svn: 57066
2008-10-05 03:21:03 +08:00
return;
}
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
[MS] Make #pragma pack use PragmaStack<> class. Make implementation of #pragma pack consistent with other "stack" pragmas. Use PragmaStack<> class instead of old representation of internal stack. Don't change compiler's behavior. TODO: 1. Introduce diagnostics on popping named slots from pragma stacks. Reviewer: rnk Differential revision: http://reviews.llvm.org/D19727 llvm-svn: 268085
2016-04-30 02:17:40 +08:00
Action = (Sema::PragmaMsStackAction)(Action | Sema::PSK_Set);
Permanently end the whole "pragma got handled by the parser too early" mess by handling all pragmas which the parser touches uniformly. <rdar://problem/12248901>, etc. llvm-svn: 165195
2012-10-04 10:36:51 +08:00
Alignment = Tok;
Add Parser support for #pragma pack - Uses Action::ActOnPragmaPack - Test case is XFAIL pending verifier fixes. llvm-svn: 57066
2008-10-05 03:21:03 +08:00
PP.Lex(Tok);
}
} else {
Convert IdentifierInfo's to be printed the same as DeclarationNames with implicit quotes around them. This has a bunch of follow-on effects and requires tweaking to a whole lot of code. This causes a regression in two tests (xfailed) by causing it to emit things like: Line 10: duplicate interface declaration for category 'MyClass1' ('Category1') instead of: Line 10: duplicate interface declaration for category 'MyClass1(Category1)' I will fix this in a follow-up commit. As part of this, I had to start switching stuff to use ->getDeclName() instead of Decl::getName() for consistency. This is good, but I was planning to do this as an independent patch. There will be several follow-on patches to clean up some of the mess, but this patch is already too big. llvm-svn: 59917
2008-11-24 05:45:46 +08:00
PP.Diag(Tok.getLocation(), diag::warn_pragma_pack_malformed);
Add Parser support for #pragma pack - Uses Action::ActOnPragmaPack - Test case is XFAIL pending verifier fixes. llvm-svn: 57066
2008-10-05 03:21:03 +08:00
return;
}
}
}
Unify naming of LangOptions variable/get function across the Clang stack (Lex to AST). The member variable is always "LangOpts" and the member function is always "getLangOpts". Reviewed by Chris Lattner llvm-svn: 152536
2012-03-11 15:00:24 +08:00
} else if (PP.getLangOpts().ApplePragmaPack) {
Add an option to emulate the strange Apple gcc behavior of #pragma pack. <rdar://problem/10374763> llvm-svn: 143527
2011-11-02 09:53:16 +08:00
// 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).
[MS] Make #pragma pack use PragmaStack<> class. Make implementation of #pragma pack consistent with other "stack" pragmas. Use PragmaStack<> class instead of old representation of internal stack. Don't change compiler's behavior. TODO: 1. Introduce diagnostics on popping named slots from pragma stacks. Reviewer: rnk Differential revision: http://reviews.llvm.org/D19727 llvm-svn: 268085
2016-04-30 02:17:40 +08:00
Action = Sema::PSK_Pop;
Consistently use smart pointers for stmt and expr nodes in parser local variables. llvm-svn: 60761
2008-12-09 21:15:23 +08:00
}
Add Parser support for #pragma pack - Uses Action::ActOnPragmaPack - Test case is XFAIL pending verifier fixes. llvm-svn: 57066
2008-10-05 03:21:03 +08:00
if (Tok.isNot(tok::r_paren)) {
Implement '#pragma unused'. llvm-svn: 67569
2009-03-24 06:28:25 +08:00
PP.Diag(Tok.getLocation(), diag::warn_pragma_expected_rparen) << "pack";
Add Parser support for #pragma pack - Uses Action::ActOnPragmaPack - Test case is XFAIL pending verifier fixes. llvm-svn: 57066
2008-10-05 03:21:03 +08:00
return;
}
Parse: Add support for '#pragma options align'. Also, fix a source location bug with the rparen in #pragma pack. llvm-svn: 104784
2010-05-27 07:29:06 +08:00
SourceLocation RParenLoc = Tok.getLocation();
Add parser support for #pragma weak. llvm-svn: 72907
2009-06-05 08:49:58 +08:00
PP.Lex(Tok);
Rename tok::eom to tok::eod. The previous name was inaccurate as this token in fact appears at the end of every preprocessing directive, not just macro definitions. No functionality change, except for a diagnostic tweak. llvm-svn: 126631
2011-02-28 10:37:51 +08:00
if (Tok.isNot(tok::eod)) {
Add parser support for #pragma weak. llvm-svn: 72907
2009-06-05 08:49:58 +08:00
PP.Diag(Tok.getLocation(), diag::warn_pragma_extra_tokens_at_eol) << "pack";
return;
}
Simplify EnterTokenStream API to make it more robust for memory management While this won't help fix things like the bug that r260219 addressed, it seems like good tidy up to have anyway. (it might be nice if "makeArrayRef" always produced a MutableArrayRef & let it decay to an ArrayRef when needed - then I'd use that for the MutableArrayRefs in this patch) If we had std::dynarray I'd use that instead of unique_ptr+size_t, ideally (but then it'd have to be threaded down through the Preprocessor all the way - no idea how painful that would be) llvm-svn: 260246
2016-02-10 02:52:09 +08:00
PragmaPackInfo *Info =
PP.getPreprocessorAllocator().Allocate<PragmaPackInfo>(1);
[MS] Make #pragma pack use PragmaStack<> class. Make implementation of #pragma pack consistent with other "stack" pragmas. Use PragmaStack<> class instead of old representation of internal stack. Don't change compiler's behavior. TODO: 1. Introduce diagnostics on popping named slots from pragma stacks. Reviewer: rnk Differential revision: http://reviews.llvm.org/D19727 llvm-svn: 268085
2016-04-30 02:17:40 +08:00
Info->Action = Action;
Info->SlotLabel = SlotLabel;
Permanently end the whole "pragma got handled by the parser too early" mess by handling all pragmas which the parser touches uniformly. <rdar://problem/12248901>, etc. llvm-svn: 165195
2012-10-04 10:36:51 +08:00
Info->Alignment = Alignment;
Handle "#pragma GCC visibility" in a few more places. Switch over "#pragma pack" to use the same handling that gcc does. Fixes <rdar://problem/10871094> and <rdar://problem/10893316>. (Hopefully, common usage of these pragmas isn't irregular enough to break our current handling. Doug has ideas for a more crazy approach if necessary.) llvm-svn: 151307
2012-02-24 07:47:16 +08:00
Simplify EnterTokenStream API to make it more robust for memory management While this won't help fix things like the bug that r260219 addressed, it seems like good tidy up to have anyway. (it might be nice if "makeArrayRef" always produced a MutableArrayRef & let it decay to an ArrayRef when needed - then I'd use that for the MutableArrayRefs in this patch) If we had std::dynarray I'd use that instead of unique_ptr+size_t, ideally (but then it'd have to be threaded down through the Preprocessor all the way - no idea how painful that would be) llvm-svn: 260246
2016-02-10 02:52:09 +08:00
MutableArrayRef<Token> Toks(PP.getPreprocessorAllocator().Allocate<Token>(1),
1);
Handle "#pragma GCC visibility" in a few more places. Switch over "#pragma pack" to use the same handling that gcc does. Fixes <rdar://problem/10871094> and <rdar://problem/10893316>. (Hopefully, common usage of these pragmas isn't irregular enough to break our current handling. Doug has ideas for a more crazy approach if necessary.) llvm-svn: 151307
2012-02-24 07:47:16 +08:00
Toks[0].startToken();
Toks[0].setKind(tok::annot_pragma_pack);
Toks[0].setLocation(PackLoc);
Parse: Don't assume tokens have a length Don't crash if the last token in a bad inline method body is an annotation token. llvm-svn: 232694
2015-03-19 08:10:23 +08:00
Toks[0].setAnnotationEndLoc(RParenLoc);
Handle "#pragma GCC visibility" in a few more places. Switch over "#pragma pack" to use the same handling that gcc does. Fixes <rdar://problem/10871094> and <rdar://problem/10893316>. (Hopefully, common usage of these pragmas isn't irregular enough to break our current handling. Doug has ideas for a more crazy approach if necessary.) llvm-svn: 151307
2012-02-24 07:47:16 +08:00
Toks[0].setAnnotationValue(static_cast<void*>(Info));
Simplify EnterTokenStream API to make it more robust for memory management While this won't help fix things like the bug that r260219 addressed, it seems like good tidy up to have anyway. (it might be nice if "makeArrayRef" always produced a MutableArrayRef & let it decay to an ArrayRef when needed - then I'd use that for the MutableArrayRefs in this patch) If we had std::dynarray I'd use that instead of unique_ptr+size_t, ideally (but then it'd have to be threaded down through the Preprocessor all the way - no idea how painful that would be) llvm-svn: 260246
2016-02-10 02:52:09 +08:00
PP.EnterTokenStream(Toks, /*DisableMacroExpansion=*/true);
Add Parser support for #pragma pack - Uses Action::ActOnPragmaPack - Test case is XFAIL pending verifier fixes. llvm-svn: 57066
2008-10-05 03:21:03 +08:00
}
Recognize gcc's ms_struct pragma (and ignore for now). This is wip. llvm-svn: 130138
2011-04-26 02:49:15 +08:00
// #pragma ms_struct on
// #pragma ms_struct off
void PragmaMSStructHandler::HandlePragma(Preprocessor &PP,
PragmaIntroducerKind Introducer,
Token &MSStructTok) {
Serialize `pragma ms_struct` state. pragma ms_struct has an effect on struct decls, and the effect is serialized correctly already. But the "is ms_struct currently on" state wasn't before this change. This uses the same approach as `pragma clang optimize`: When writing a module, the state isn't serialized, only when writing a pch file. llvm-svn: 262539
2016-03-03 07:22:00 +08:00
PragmaMSStructKind Kind = PMSST_OFF;
Recognize gcc's ms_struct pragma (and ignore for now). This is wip. llvm-svn: 130138
2011-04-26 02:49:15 +08:00
Token Tok;
PP.Lex(Tok);
if (Tok.isNot(tok::identifier)) {
PP.Diag(Tok.getLocation(), diag::warn_pragma_ms_struct);
return;
}
Parse: Don't assume tokens have a length Don't crash if the last token in a bad inline method body is an annotation token. llvm-svn: 232694
2015-03-19 08:10:23 +08:00
SourceLocation EndLoc = Tok.getLocation();
Recognize gcc's ms_struct pragma (and ignore for now). This is wip. llvm-svn: 130138
2011-04-26 02:49:15 +08:00
const IdentifierInfo *II = Tok.getIdentifierInfo();
if (II->isStr("on")) {
Serialize `pragma ms_struct` state. pragma ms_struct has an effect on struct decls, and the effect is serialized correctly already. But the "is ms_struct currently on" state wasn't before this change. This uses the same approach as `pragma clang optimize`: When writing a module, the state isn't serialized, only when writing a pch file. llvm-svn: 262539
2016-03-03 07:22:00 +08:00
Kind = PMSST_ON;
Recognize gcc's ms_struct pragma (and ignore for now). This is wip. llvm-svn: 130138
2011-04-26 02:49:15 +08:00
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)) {
Parse: Change PragmaPackHandler to use the preprocessor allocator. llvm-svn: 151689
2012-02-29 09:38:22 +08:00
PP.Diag(Tok.getLocation(), diag::warn_pragma_extra_tokens_at_eol)
<< "ms_struct";
Recognize gcc's ms_struct pragma (and ignore for now). This is wip. llvm-svn: 130138
2011-04-26 02:49:15 +08:00
return;
}
Permanently end the whole "pragma got handled by the parser too early" mess by handling all pragmas which the parser touches uniformly. <rdar://problem/12248901>, etc. llvm-svn: 165195
2012-10-04 10:36:51 +08:00
Simplify EnterTokenStream API to make it more robust for memory management While this won't help fix things like the bug that r260219 addressed, it seems like good tidy up to have anyway. (it might be nice if "makeArrayRef" always produced a MutableArrayRef & let it decay to an ArrayRef when needed - then I'd use that for the MutableArrayRefs in this patch) If we had std::dynarray I'd use that instead of unique_ptr+size_t, ideally (but then it'd have to be threaded down through the Preprocessor all the way - no idea how painful that would be) llvm-svn: 260246
2016-02-10 02:52:09 +08:00
MutableArrayRef<Token> Toks(PP.getPreprocessorAllocator().Allocate<Token>(1),
1);
Permanently end the whole "pragma got handled by the parser too early" mess by handling all pragmas which the parser touches uniformly. <rdar://problem/12248901>, etc. llvm-svn: 165195
2012-10-04 10:36:51 +08:00
Toks[0].startToken();
Toks[0].setKind(tok::annot_pragma_msstruct);
Toks[0].setLocation(MSStructTok.getLocation());
Parse: Don't assume tokens have a length Don't crash if the last token in a bad inline method body is an annotation token. llvm-svn: 232694
2015-03-19 08:10:23 +08:00
Toks[0].setAnnotationEndLoc(EndLoc);
Permanently end the whole "pragma got handled by the parser too early" mess by handling all pragmas which the parser touches uniformly. <rdar://problem/12248901>, etc. llvm-svn: 165195
2012-10-04 10:36:51 +08:00
Toks[0].setAnnotationValue(reinterpret_cast<void*>(
static_cast<uintptr_t>(Kind)));
Simplify EnterTokenStream API to make it more robust for memory management While this won't help fix things like the bug that r260219 addressed, it seems like good tidy up to have anyway. (it might be nice if "makeArrayRef" always produced a MutableArrayRef & let it decay to an ArrayRef when needed - then I'd use that for the MutableArrayRefs in this patch) If we had std::dynarray I'd use that instead of unique_ptr+size_t, ideally (but then it'd have to be threaded down through the Preprocessor all the way - no idea how painful that would be) llvm-svn: 260246
2016-02-10 02:52:09 +08:00
PP.EnterTokenStream(Toks, /*DisableMacroExpansion=*/true);
Recognize gcc's ms_struct pragma (and ignore for now). This is wip. llvm-svn: 130138
2011-04-26 02:49:15 +08:00
}
Parser: Add support for #pragma align, which is just another spelling of #pragma options align. llvm-svn: 109952
2010-08-01 03:17:07 +08:00
// #pragma 'align' '=' {'native','natural','mac68k','power','reset'}
// #pragma 'options 'align' '=' {'native','natural','mac68k','power','reset'}
Permanently end the whole "pragma got handled by the parser too early" mess by handling all pragmas which the parser touches uniformly. <rdar://problem/12248901>, etc. llvm-svn: 165195
2012-10-04 10:36:51 +08:00
static void ParseAlignPragma(Preprocessor &PP, Token &FirstTok,
Parser: Add support for #pragma align, which is just another spelling of #pragma options align. llvm-svn: 109952
2010-08-01 03:17:07 +08:00
bool IsOptions) {
Parse: Add support for '#pragma options align'. Also, fix a source location bug with the rparen in #pragma pack. llvm-svn: 104784
2010-05-27 07:29:06 +08:00
Token Tok;
Parser: Add support for #pragma align, which is just another spelling of #pragma options align. llvm-svn: 109952
2010-08-01 03:17:07 +08:00
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;
}
Parse: Add support for '#pragma options align'. Also, fix a source location bug with the rparen in #pragma pack. llvm-svn: 104784
2010-05-27 07:29:06 +08:00
}
Parse/Sema: Add support for '#pragma options align=native'. llvm-svn: 104864
2010-05-28 02:42:09 +08:00
Parse: Add support for '#pragma options align'. Also, fix a source location bug with the rparen in #pragma pack. llvm-svn: 104784
2010-05-27 07:29:06 +08:00
PP.Lex(Tok);
if (Tok.isNot(tok::equal)) {
Parser: Add support for #pragma align, which is just another spelling of #pragma options align. llvm-svn: 109952
2010-08-01 03:17:07 +08:00
PP.Diag(Tok.getLocation(), diag::warn_pragma_align_expected_equal)
<< IsOptions;
Parse: Add support for '#pragma options align'. Also, fix a source location bug with the rparen in #pragma pack. llvm-svn: 104784
2010-05-27 07:29:06 +08:00
return;
}
PP.Lex(Tok);
if (Tok.isNot(tok::identifier)) {
PP.Diag(Tok.getLocation(), diag::warn_pragma_expected_identifier)
Parser: Add support for #pragma align, which is just another spelling of #pragma options align. llvm-svn: 109952
2010-08-01 03:17:07 +08:00
<< (IsOptions ? "options" : "align");
Parse: Add support for '#pragma options align'. Also, fix a source location bug with the rparen in #pragma pack. llvm-svn: 104784
2010-05-27 07:29:06 +08:00
return;
}
One who seeks knowledge learns something new every day. One who seeks the Tao unlearns something new every day. Less and less remains until you arrive at non-action. When you arrive at non-action, nothing will be left undone. llvm-svn: 112244
2010-08-27 07:41:50 +08:00
Sema::PragmaOptionsAlignKind Kind = Sema::POAK_Natural;
Parse: Add support for '#pragma options align'. Also, fix a source location bug with the rparen in #pragma pack. llvm-svn: 104784
2010-05-27 07:29:06 +08:00
const IdentifierInfo *II = Tok.getIdentifierInfo();
Parse/Sema: Add support for '#pragma options align=native'. llvm-svn: 104864
2010-05-28 02:42:09 +08:00
if (II->isStr("native"))
One who seeks knowledge learns something new every day. One who seeks the Tao unlearns something new every day. Less and less remains until you arrive at non-action. When you arrive at non-action, nothing will be left undone. llvm-svn: 112244
2010-08-27 07:41:50 +08:00
Kind = Sema::POAK_Native;
Parse/Sema: Add support for '#pragma options align=native'. llvm-svn: 104864
2010-05-28 02:42:09 +08:00
else if (II->isStr("natural"))
One who seeks knowledge learns something new every day. One who seeks the Tao unlearns something new every day. Less and less remains until you arrive at non-action. When you arrive at non-action, nothing will be left undone. llvm-svn: 112244
2010-08-27 07:41:50 +08:00
Kind = Sema::POAK_Natural;
Parse/Sema: Add support for '#pragma options align=packed', which, it should be noted, is not the same as __attribute__((packed)). That would be ridiculous! llvm-svn: 104865
2010-05-28 02:42:17 +08:00
else if (II->isStr("packed"))
One who seeks knowledge learns something new every day. One who seeks the Tao unlearns something new every day. Less and less remains until you arrive at non-action. When you arrive at non-action, nothing will be left undone. llvm-svn: 112244
2010-08-27 07:41:50 +08:00
Kind = Sema::POAK_Packed;
Parse: Add support for '#pragma options align'. Also, fix a source location bug with the rparen in #pragma pack. llvm-svn: 104784
2010-05-27 07:29:06 +08:00
else if (II->isStr("power"))
One who seeks knowledge learns something new every day. One who seeks the Tao unlearns something new every day. Less and less remains until you arrive at non-action. When you arrive at non-action, nothing will be left undone. llvm-svn: 112244
2010-08-27 07:41:50 +08:00
Kind = Sema::POAK_Power;
Parse: Add support for '#pragma options align'. Also, fix a source location bug with the rparen in #pragma pack. llvm-svn: 104784
2010-05-27 07:29:06 +08:00
else if (II->isStr("mac68k"))
One who seeks knowledge learns something new every day. One who seeks the Tao unlearns something new every day. Less and less remains until you arrive at non-action. When you arrive at non-action, nothing will be left undone. llvm-svn: 112244
2010-08-27 07:41:50 +08:00
Kind = Sema::POAK_Mac68k;
Parse: Add support for '#pragma options align'. Also, fix a source location bug with the rparen in #pragma pack. llvm-svn: 104784
2010-05-27 07:29:06 +08:00
else if (II->isStr("reset"))
One who seeks knowledge learns something new every day. One who seeks the Tao unlearns something new every day. Less and less remains until you arrive at non-action. When you arrive at non-action, nothing will be left undone. llvm-svn: 112244
2010-08-27 07:41:50 +08:00
Kind = Sema::POAK_Reset;
Parse: Add support for '#pragma options align'. Also, fix a source location bug with the rparen in #pragma pack. llvm-svn: 104784
2010-05-27 07:29:06 +08:00
else {
Parser: Add support for #pragma align, which is just another spelling of #pragma options align. llvm-svn: 109952
2010-08-01 03:17:07 +08:00
PP.Diag(Tok.getLocation(), diag::warn_pragma_align_invalid_option)
<< IsOptions;
Parse: Add support for '#pragma options align'. Also, fix a source location bug with the rparen in #pragma pack. llvm-svn: 104784
2010-05-27 07:29:06 +08:00
return;
}
Parse: Don't assume tokens have a length Don't crash if the last token in a bad inline method body is an annotation token. llvm-svn: 232694
2015-03-19 08:10:23 +08:00
SourceLocation EndLoc = Tok.getLocation();
Parse: Add support for '#pragma options align'. Also, fix a source location bug with the rparen in #pragma pack. llvm-svn: 104784
2010-05-27 07:29:06 +08:00
PP.Lex(Tok);
Rename tok::eom to tok::eod. The previous name was inaccurate as this token in fact appears at the end of every preprocessing directive, not just macro definitions. No functionality change, except for a diagnostic tweak. llvm-svn: 126631
2011-02-28 10:37:51 +08:00
if (Tok.isNot(tok::eod)) {
Parse: Add support for '#pragma options align'. Also, fix a source location bug with the rparen in #pragma pack. llvm-svn: 104784
2010-05-27 07:29:06 +08:00
PP.Diag(Tok.getLocation(), diag::warn_pragma_extra_tokens_at_eol)
Parser: Add support for #pragma align, which is just another spelling of #pragma options align. llvm-svn: 109952
2010-08-01 03:17:07 +08:00
<< (IsOptions ? "options" : "align");
Parse: Add support for '#pragma options align'. Also, fix a source location bug with the rparen in #pragma pack. llvm-svn: 104784
2010-05-27 07:29:06 +08:00
return;
}
Simplify EnterTokenStream API to make it more robust for memory management While this won't help fix things like the bug that r260219 addressed, it seems like good tidy up to have anyway. (it might be nice if "makeArrayRef" always produced a MutableArrayRef & let it decay to an ArrayRef when needed - then I'd use that for the MutableArrayRefs in this patch) If we had std::dynarray I'd use that instead of unique_ptr+size_t, ideally (but then it'd have to be threaded down through the Preprocessor all the way - no idea how painful that would be) llvm-svn: 260246
2016-02-10 02:52:09 +08:00
MutableArrayRef<Token> Toks(PP.getPreprocessorAllocator().Allocate<Token>(1),
1);
Permanently end the whole "pragma got handled by the parser too early" mess by handling all pragmas which the parser touches uniformly. <rdar://problem/12248901>, etc. llvm-svn: 165195
2012-10-04 10:36:51 +08:00
Toks[0].startToken();
Toks[0].setKind(tok::annot_pragma_align);
Toks[0].setLocation(FirstTok.getLocation());
Parse: Don't assume tokens have a length Don't crash if the last token in a bad inline method body is an annotation token. llvm-svn: 232694
2015-03-19 08:10:23 +08:00
Toks[0].setAnnotationEndLoc(EndLoc);
Permanently end the whole "pragma got handled by the parser too early" mess by handling all pragmas which the parser touches uniformly. <rdar://problem/12248901>, etc. llvm-svn: 165195
2012-10-04 10:36:51 +08:00
Toks[0].setAnnotationValue(reinterpret_cast<void*>(
static_cast<uintptr_t>(Kind)));
Simplify EnterTokenStream API to make it more robust for memory management While this won't help fix things like the bug that r260219 addressed, it seems like good tidy up to have anyway. (it might be nice if "makeArrayRef" always produced a MutableArrayRef & let it decay to an ArrayRef when needed - then I'd use that for the MutableArrayRefs in this patch) If we had std::dynarray I'd use that instead of unique_ptr+size_t, ideally (but then it'd have to be threaded down through the Preprocessor all the way - no idea how painful that would be) llvm-svn: 260246
2016-02-10 02:52:09 +08:00
PP.EnterTokenStream(Toks, /*DisableMacroExpansion=*/true);
Parser: Add support for #pragma align, which is just another spelling of #pragma options align. llvm-svn: 109952
2010-08-01 03:17:07 +08:00
}
When we parse a pragma, keep track of how that pragma was originally spelled (#pragma, _Pragma, __pragma). In -E mode, use that information to add appropriate newlines when translating _Pragma and __pragma into #pragma, like GCC does. Fixes <rdar://problem/8412013>. llvm-svn: 113553
2010-09-10 06:45:38 +08:00
void PragmaAlignHandler::HandlePragma(Preprocessor &PP,
PragmaIntroducerKind Introducer,
Token &AlignTok) {
Permanently end the whole "pragma got handled by the parser too early" mess by handling all pragmas which the parser touches uniformly. <rdar://problem/12248901>, etc. llvm-svn: 165195
2012-10-04 10:36:51 +08:00
ParseAlignPragma(PP, AlignTok, /*IsOptions=*/false);
Parser: Add support for #pragma align, which is just another spelling of #pragma options align. llvm-svn: 109952
2010-08-01 03:17:07 +08:00
}
When we parse a pragma, keep track of how that pragma was originally spelled (#pragma, _Pragma, __pragma). In -E mode, use that information to add appropriate newlines when translating _Pragma and __pragma into #pragma, like GCC does. Fixes <rdar://problem/8412013>. llvm-svn: 113553
2010-09-10 06:45:38 +08:00
void PragmaOptionsHandler::HandlePragma(Preprocessor &PP,
PragmaIntroducerKind Introducer,
Token &OptionsTok) {
Permanently end the whole "pragma got handled by the parser too early" mess by handling all pragmas which the parser touches uniformly. <rdar://problem/12248901>, etc. llvm-svn: 165195
2012-10-04 10:36:51 +08:00
ParseAlignPragma(PP, OptionsTok, /*IsOptions=*/true);
Parse: Add support for '#pragma options align'. Also, fix a source location bug with the rparen in #pragma pack. llvm-svn: 104784
2010-05-27 07:29:06 +08:00
}
Implement '#pragma unused'. llvm-svn: 67569
2009-03-24 06:28:25 +08:00
// #pragma unused(identifier)
When we parse a pragma, keep track of how that pragma was originally spelled (#pragma, _Pragma, __pragma). In -E mode, use that information to add appropriate newlines when translating _Pragma and __pragma into #pragma, like GCC does. Fixes <rdar://problem/8412013>. llvm-svn: 113553
2010-09-10 06:45:38 +08:00
void PragmaUnusedHandler::HandlePragma(Preprocessor &PP,
PragmaIntroducerKind Introducer,
Token &UnusedTok) {
Implement '#pragma unused'. llvm-svn: 67569
2009-03-24 06:28:25 +08:00
// FIXME: Should we be expanding macros here? My guess is no.
SourceLocation UnusedLoc = UnusedTok.getLocation();
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
Implement '#pragma unused'. llvm-svn: 67569
2009-03-24 06:28:25 +08:00
// 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;
}
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
Implement '#pragma unused'. llvm-svn: 67569
2009-03-24 06:28:25 +08:00
// Lex the declaration reference(s).
remove unneeded llvm:: namespace qualifiers on some core types now that LLVM.h imports them into the clang namespace. llvm-svn: 135852
2011-07-23 18:55:15 +08:00
SmallVector<Token, 5> Identifiers;
Implement '#pragma unused'. llvm-svn: 67569
2009-03-24 06:28:25 +08:00
SourceLocation RParenLoc;
bool LexID = true;
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
Implement '#pragma unused'. llvm-svn: 67569
2009-03-24 06:28:25 +08:00
while (true) {
PP.Lex(Tok);
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
Implement '#pragma unused'. llvm-svn: 67569
2009-03-24 06:28:25 +08:00
if (LexID) {
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
if (Tok.is(tok::identifier)) {
Per advice that Doug Gregor gave me several months ago, clean up the implementation of '#pragma unused' by not constructing intermediate DeclRefExprs, but instead do the name lookup directly. The implementation is greatly simplified. Along the way, degrade '#pragma unused(undeclaredvariable)' to a warning instead of being a hard error. This implements: <rdar://problem/6761874> [sema] allow #pragma unused to reference undefined variable (with warning) llvm-svn: 78019
2009-08-04 07:24:57 +08:00
Identifiers.push_back(Tok);
Implement '#pragma unused'. llvm-svn: 67569
2009-03-24 06:28:25 +08:00
LexID = false;
continue;
}
Per advice that Doug Gregor gave me several months ago, clean up the implementation of '#pragma unused' by not constructing intermediate DeclRefExprs, but instead do the name lookup directly. The implementation is greatly simplified. Along the way, degrade '#pragma unused(undeclaredvariable)' to a warning instead of being a hard error. This implements: <rdar://problem/6761874> [sema] allow #pragma unused to reference undefined variable (with warning) llvm-svn: 78019
2009-08-04 07:24:57 +08:00
// Illegal token!
Implement '#pragma unused'. llvm-svn: 67569
2009-03-24 06:28:25 +08:00
PP.Diag(Tok.getLocation(), diag::warn_pragma_unused_expected_var);
return;
}
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
Implement '#pragma unused'. llvm-svn: 67569
2009-03-24 06:28:25 +08:00
// We are execting a ')' or a ','.
if (Tok.is(tok::comma)) {
LexID = true;
continue;
}
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
Implement '#pragma unused'. llvm-svn: 67569
2009-03-24 06:28:25 +08:00
if (Tok.is(tok::r_paren)) {
RParenLoc = Tok.getLocation();
break;
}
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
Per advice that Doug Gregor gave me several months ago, clean up the implementation of '#pragma unused' by not constructing intermediate DeclRefExprs, but instead do the name lookup directly. The implementation is greatly simplified. Along the way, degrade '#pragma unused(undeclaredvariable)' to a warning instead of being a hard error. This implements: <rdar://problem/6761874> [sema] allow #pragma unused to reference undefined variable (with warning) llvm-svn: 78019
2009-08-04 07:24:57 +08:00
// Illegal token!
Basic: Clean up malformed pragma diagnostics Create a new diagnostic, -Wignored-pragmas and use it to handle any case where a pragma would have a side effect but is ignored. llvm-svn: 201102
2014-02-11 03:06:37 +08:00
PP.Diag(Tok.getLocation(), diag::warn_pragma_expected_punc) << "unused";
Implement '#pragma unused'. llvm-svn: 67569
2009-03-24 06:28:25 +08:00
return;
}
Add parser support for #pragma weak. llvm-svn: 72907
2009-06-05 08:49:58 +08:00
PP.Lex(Tok);
Rename tok::eom to tok::eod. The previous name was inaccurate as this token in fact appears at the end of every preprocessing directive, not just macro definitions. No functionality change, except for a diagnostic tweak. llvm-svn: 126631
2011-02-28 10:37:51 +08:00
if (Tok.isNot(tok::eod)) {
Add parser support for #pragma weak. llvm-svn: 72907
2009-06-05 08:49:58 +08:00
PP.Diag(Tok.getLocation(), diag::warn_pragma_extra_tokens_at_eol) <<
"unused";
return;
}
Implement '#pragma unused'. llvm-svn: 67569
2009-03-24 06:28:25 +08:00
// Verify that we have a location for the right parenthesis.
assert(RParenLoc.isValid() && "Valid '#pragma unused' must have ')'");
Per advice that Doug Gregor gave me several months ago, clean up the implementation of '#pragma unused' by not constructing intermediate DeclRefExprs, but instead do the name lookup directly. The implementation is greatly simplified. Along the way, degrade '#pragma unused(undeclaredvariable)' to a warning instead of being a hard error. This implements: <rdar://problem/6761874> [sema] allow #pragma unused to reference undefined variable (with warning) llvm-svn: 78019
2009-08-04 07:24:57 +08:00
assert(!Identifiers.empty() && "Valid '#pragma unused' must have arguments");
Implement '#pragma unused'. llvm-svn: 67569
2009-03-24 06:28:25 +08:00
Convert "#pragma unused(...)" into tokens for the parser. This allows us to cache a "#pragma unused" that occurs inside an inline C++ member function. Fixes rdar://8829590&8770988. llvm-svn: 123666
2011-01-18 02:58:44 +08:00
// 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.
Simplify EnterTokenStream API to make it more robust for memory management While this won't help fix things like the bug that r260219 addressed, it seems like good tidy up to have anyway. (it might be nice if "makeArrayRef" always produced a MutableArrayRef & let it decay to an ArrayRef when needed - then I'd use that for the MutableArrayRefs in this patch) If we had std::dynarray I'd use that instead of unique_ptr+size_t, ideally (but then it'd have to be threaded down through the Preprocessor all the way - no idea how painful that would be) llvm-svn: 260246
2016-02-10 02:52:09 +08:00
MutableArrayRef<Token> Toks(
PP.getPreprocessorAllocator().Allocate<Token>(2 * Identifiers.size()),
2 * Identifiers.size());
Convert "#pragma unused(...)" into tokens for the parser. This allows us to cache a "#pragma unused" that occurs inside an inline C++ member function. Fixes rdar://8829590&8770988. llvm-svn: 123666
2011-01-18 02:58:44 +08:00
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];
}
Simplify EnterTokenStream API to make it more robust for memory management While this won't help fix things like the bug that r260219 addressed, it seems like good tidy up to have anyway. (it might be nice if "makeArrayRef" always produced a MutableArrayRef & let it decay to an ArrayRef when needed - then I'd use that for the MutableArrayRefs in this patch) If we had std::dynarray I'd use that instead of unique_ptr+size_t, ideally (but then it'd have to be threaded down through the Preprocessor all the way - no idea how painful that would be) llvm-svn: 260246
2016-02-10 02:52:09 +08:00
PP.EnterTokenStream(Toks, /*DisableMacroExpansion=*/true);
Implement '#pragma unused'. llvm-svn: 67569
2009-03-24 06:28:25 +08:00
}
Add parser support for #pragma weak. llvm-svn: 72907
2009-06-05 08:49:58 +08:00
// #pragma weak identifier
// #pragma weak identifier '=' identifier
When we parse a pragma, keep track of how that pragma was originally spelled (#pragma, _Pragma, __pragma). In -E mode, use that information to add appropriate newlines when translating _Pragma and __pragma into #pragma, like GCC does. Fixes <rdar://problem/8412013>. llvm-svn: 113553
2010-09-10 06:45:38 +08:00
void PragmaWeakHandler::HandlePragma(Preprocessor &PP,
PragmaIntroducerKind Introducer,
Token &WeakTok) {
Add parser support for #pragma weak. llvm-svn: 72907
2009-06-05 08:49:58 +08:00
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;
}
Permanently end the whole "pragma got handled by the parser too early" mess by handling all pragmas which the parser touches uniformly. <rdar://problem/12248901>, etc. llvm-svn: 165195
2012-10-04 10:36:51 +08:00
Token WeakName = Tok;
bool HasAlias = false;
Token AliasName;
Add parser support for #pragma weak. llvm-svn: 72907
2009-06-05 08:49:58 +08:00
PP.Lex(Tok);
if (Tok.is(tok::equal)) {
Permanently end the whole "pragma got handled by the parser too early" mess by handling all pragmas which the parser touches uniformly. <rdar://problem/12248901>, etc. llvm-svn: 165195
2012-10-04 10:36:51 +08:00
HasAlias = true;
Add parser support for #pragma weak. llvm-svn: 72907
2009-06-05 08:49:58 +08:00
PP.Lex(Tok);
if (Tok.isNot(tok::identifier)) {
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
PP.Diag(Tok.getLocation(), diag::warn_pragma_expected_identifier)
Add parser support for #pragma weak. llvm-svn: 72907
2009-06-05 08:49:58 +08:00
<< "weak";
return;
}
Permanently end the whole "pragma got handled by the parser too early" mess by handling all pragmas which the parser touches uniformly. <rdar://problem/12248901>, etc. llvm-svn: 165195
2012-10-04 10:36:51 +08:00
AliasName = Tok;
Add parser support for #pragma weak. llvm-svn: 72907
2009-06-05 08:49:58 +08:00
PP.Lex(Tok);
}
Rename tok::eom to tok::eod. The previous name was inaccurate as this token in fact appears at the end of every preprocessing directive, not just macro definitions. No functionality change, except for a diagnostic tweak. llvm-svn: 126631
2011-02-28 10:37:51 +08:00
if (Tok.isNot(tok::eod)) {
Add parser support for #pragma weak. llvm-svn: 72907
2009-06-05 08:49:58 +08:00
PP.Diag(Tok.getLocation(), diag::warn_pragma_extra_tokens_at_eol) << "weak";
return;
}
Permanently end the whole "pragma got handled by the parser too early" mess by handling all pragmas which the parser touches uniformly. <rdar://problem/12248901>, etc. llvm-svn: 165195
2012-10-04 10:36:51 +08:00
if (HasAlias) {
Simplify EnterTokenStream API to make it more robust for memory management While this won't help fix things like the bug that r260219 addressed, it seems like good tidy up to have anyway. (it might be nice if "makeArrayRef" always produced a MutableArrayRef & let it decay to an ArrayRef when needed - then I'd use that for the MutableArrayRefs in this patch) If we had std::dynarray I'd use that instead of unique_ptr+size_t, ideally (but then it'd have to be threaded down through the Preprocessor all the way - no idea how painful that would be) llvm-svn: 260246
2016-02-10 02:52:09 +08:00
MutableArrayRef<Token> Toks(
PP.getPreprocessorAllocator().Allocate<Token>(3), 3);
Permanently end the whole "pragma got handled by the parser too early" mess by handling all pragmas which the parser touches uniformly. <rdar://problem/12248901>, etc. llvm-svn: 165195
2012-10-04 10:36:51 +08:00
Token &pragmaUnusedTok = Toks[0];
pragmaUnusedTok.startToken();
pragmaUnusedTok.setKind(tok::annot_pragma_weakalias);
pragmaUnusedTok.setLocation(WeakLoc);
Parse: Don't assume tokens have a length Don't crash if the last token in a bad inline method body is an annotation token. llvm-svn: 232694
2015-03-19 08:10:23 +08:00
pragmaUnusedTok.setAnnotationEndLoc(AliasName.getLocation());
Permanently end the whole "pragma got handled by the parser too early" mess by handling all pragmas which the parser touches uniformly. <rdar://problem/12248901>, etc. llvm-svn: 165195
2012-10-04 10:36:51 +08:00
Toks[1] = WeakName;
Toks[2] = AliasName;
Simplify EnterTokenStream API to make it more robust for memory management While this won't help fix things like the bug that r260219 addressed, it seems like good tidy up to have anyway. (it might be nice if "makeArrayRef" always produced a MutableArrayRef & let it decay to an ArrayRef when needed - then I'd use that for the MutableArrayRefs in this patch) If we had std::dynarray I'd use that instead of unique_ptr+size_t, ideally (but then it'd have to be threaded down through the Preprocessor all the way - no idea how painful that would be) llvm-svn: 260246
2016-02-10 02:52:09 +08:00
PP.EnterTokenStream(Toks, /*DisableMacroExpansion=*/true);
Add parser support for #pragma weak. llvm-svn: 72907
2009-06-05 08:49:58 +08:00
} else {
Simplify EnterTokenStream API to make it more robust for memory management While this won't help fix things like the bug that r260219 addressed, it seems like good tidy up to have anyway. (it might be nice if "makeArrayRef" always produced a MutableArrayRef & let it decay to an ArrayRef when needed - then I'd use that for the MutableArrayRefs in this patch) If we had std::dynarray I'd use that instead of unique_ptr+size_t, ideally (but then it'd have to be threaded down through the Preprocessor all the way - no idea how painful that would be) llvm-svn: 260246
2016-02-10 02:52:09 +08:00
MutableArrayRef<Token> Toks(
PP.getPreprocessorAllocator().Allocate<Token>(2), 2);
Permanently end the whole "pragma got handled by the parser too early" mess by handling all pragmas which the parser touches uniformly. <rdar://problem/12248901>, etc. llvm-svn: 165195
2012-10-04 10:36:51 +08:00
Token &pragmaUnusedTok = Toks[0];
pragmaUnusedTok.startToken();
pragmaUnusedTok.setKind(tok::annot_pragma_weak);
pragmaUnusedTok.setLocation(WeakLoc);
Parse: Don't assume tokens have a length Don't crash if the last token in a bad inline method body is an annotation token. llvm-svn: 232694
2015-03-19 08:10:23 +08:00
pragmaUnusedTok.setAnnotationEndLoc(WeakLoc);
Permanently end the whole "pragma got handled by the parser too early" mess by handling all pragmas which the parser touches uniformly. <rdar://problem/12248901>, etc. llvm-svn: 165195
2012-10-04 10:36:51 +08:00
Toks[1] = WeakName;
Simplify EnterTokenStream API to make it more robust for memory management While this won't help fix things like the bug that r260219 addressed, it seems like good tidy up to have anyway. (it might be nice if "makeArrayRef" always produced a MutableArrayRef & let it decay to an ArrayRef when needed - then I'd use that for the MutableArrayRefs in this patch) If we had std::dynarray I'd use that instead of unique_ptr+size_t, ideally (but then it'd have to be threaded down through the Preprocessor all the way - no idea how painful that would be) llvm-svn: 260246
2016-02-10 02:52:09 +08:00
PP.EnterTokenStream(Toks, /*DisableMacroExpansion=*/true);
Add parser support for #pragma weak. llvm-svn: 72907
2009-06-05 08:49:58 +08:00
}
}
Move support for "#pragma STDC FP_CONTRACT" to Parser; add Sema actions llvm-svn: 125474
2011-02-14 09:42:35 +08:00
Implement #pragma redefine_extname. This fixes PR5172 and allows clang to compile C++ programs on Solaris using the system headers. llvm-svn: 150881
2012-02-19 00:12:34 +08:00
// #pragma redefine_extname identifier identifier
void 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;
}
Permanently end the whole "pragma got handled by the parser too early" mess by handling all pragmas which the parser touches uniformly. <rdar://problem/12248901>, etc. llvm-svn: 165195
2012-10-04 10:36:51 +08:00
Token RedefName = Tok;
Implement #pragma redefine_extname. This fixes PR5172 and allows clang to compile C++ programs on Solaris using the system headers. llvm-svn: 150881
2012-02-19 00:12:34 +08:00
PP.Lex(Tok);
Permanently end the whole "pragma got handled by the parser too early" mess by handling all pragmas which the parser touches uniformly. <rdar://problem/12248901>, etc. llvm-svn: 165195
2012-10-04 10:36:51 +08:00
Implement #pragma redefine_extname. This fixes PR5172 and allows clang to compile C++ programs on Solaris using the system headers. llvm-svn: 150881
2012-02-19 00:12:34 +08:00
if (Tok.isNot(tok::identifier)) {
PP.Diag(Tok.getLocation(), diag::warn_pragma_expected_identifier)
<< "redefine_extname";
return;
}
Permanently end the whole "pragma got handled by the parser too early" mess by handling all pragmas which the parser touches uniformly. <rdar://problem/12248901>, etc. llvm-svn: 165195
2012-10-04 10:36:51 +08:00
Token AliasName = Tok;
Implement #pragma redefine_extname. This fixes PR5172 and allows clang to compile C++ programs on Solaris using the system headers. llvm-svn: 150881
2012-02-19 00:12:34 +08:00
PP.Lex(Tok);
if (Tok.isNot(tok::eod)) {
PP.Diag(Tok.getLocation(), diag::warn_pragma_extra_tokens_at_eol) <<
"redefine_extname";
return;
}
Simplify EnterTokenStream API to make it more robust for memory management While this won't help fix things like the bug that r260219 addressed, it seems like good tidy up to have anyway. (it might be nice if "makeArrayRef" always produced a MutableArrayRef & let it decay to an ArrayRef when needed - then I'd use that for the MutableArrayRefs in this patch) If we had std::dynarray I'd use that instead of unique_ptr+size_t, ideally (but then it'd have to be threaded down through the Preprocessor all the way - no idea how painful that would be) llvm-svn: 260246
2016-02-10 02:52:09 +08:00
MutableArrayRef<Token> Toks(PP.getPreprocessorAllocator().Allocate<Token>(3),
3);
Permanently end the whole "pragma got handled by the parser too early" mess by handling all pragmas which the parser touches uniformly. <rdar://problem/12248901>, etc. llvm-svn: 165195
2012-10-04 10:36:51 +08:00
Token &pragmaRedefTok = Toks[0];
pragmaRedefTok.startToken();
pragmaRedefTok.setKind(tok::annot_pragma_redefine_extname);
pragmaRedefTok.setLocation(RedefLoc);
Parse: Don't assume tokens have a length Don't crash if the last token in a bad inline method body is an annotation token. llvm-svn: 232694
2015-03-19 08:10:23 +08:00
pragmaRedefTok.setAnnotationEndLoc(AliasName.getLocation());
Permanently end the whole "pragma got handled by the parser too early" mess by handling all pragmas which the parser touches uniformly. <rdar://problem/12248901>, etc. llvm-svn: 165195
2012-10-04 10:36:51 +08:00
Toks[1] = RedefName;
Toks[2] = AliasName;
Simplify EnterTokenStream API to make it more robust for memory management While this won't help fix things like the bug that r260219 addressed, it seems like good tidy up to have anyway. (it might be nice if "makeArrayRef" always produced a MutableArrayRef & let it decay to an ArrayRef when needed - then I'd use that for the MutableArrayRefs in this patch) If we had std::dynarray I'd use that instead of unique_ptr+size_t, ideally (but then it'd have to be threaded down through the Preprocessor all the way - no idea how painful that would be) llvm-svn: 260246
2016-02-10 02:52:09 +08:00
PP.EnterTokenStream(Toks, /*DisableMacroExpansion=*/true);
Implement #pragma redefine_extname. This fixes PR5172 and allows clang to compile C++ programs on Solaris using the system headers. llvm-svn: 150881
2012-02-19 00:12:34 +08:00
}
Move support for "#pragma STDC FP_CONTRACT" to Parser; add Sema actions llvm-svn: 125474
2011-02-14 09:42:35 +08:00
void
PragmaFPContractHandler::HandlePragma(Preprocessor &PP,
PragmaIntroducerKind Introducer,
Token &Tok) {
tok::OnOffSwitch OOS;
if (PP.LexOnOffSwitch(OOS))
return;
Simplify EnterTokenStream API to make it more robust for memory management While this won't help fix things like the bug that r260219 addressed, it seems like good tidy up to have anyway. (it might be nice if "makeArrayRef" always produced a MutableArrayRef & let it decay to an ArrayRef when needed - then I'd use that for the MutableArrayRefs in this patch) If we had std::dynarray I'd use that instead of unique_ptr+size_t, ideally (but then it'd have to be threaded down through the Preprocessor all the way - no idea how painful that would be) llvm-svn: 260246
2016-02-10 02:52:09 +08:00
MutableArrayRef<Token> Toks(PP.getPreprocessorAllocator().Allocate<Token>(1),
1);
Permanently end the whole "pragma got handled by the parser too early" mess by handling all pragmas which the parser touches uniformly. <rdar://problem/12248901>, etc. llvm-svn: 165195
2012-10-04 10:36:51 +08:00
Toks[0].startToken();
Toks[0].setKind(tok::annot_pragma_fp_contract);
Toks[0].setLocation(Tok.getLocation());
Parse: Don't assume tokens have a length Don't crash if the last token in a bad inline method body is an annotation token. llvm-svn: 232694
2015-03-19 08:10:23 +08:00
Toks[0].setAnnotationEndLoc(Tok.getLocation());
Permanently end the whole "pragma got handled by the parser too early" mess by handling all pragmas which the parser touches uniformly. <rdar://problem/12248901>, etc. llvm-svn: 165195
2012-10-04 10:36:51 +08:00
Toks[0].setAnnotationValue(reinterpret_cast<void*>(
static_cast<uintptr_t>(OOS)));
Simplify EnterTokenStream API to make it more robust for memory management While this won't help fix things like the bug that r260219 addressed, it seems like good tidy up to have anyway. (it might be nice if "makeArrayRef" always produced a MutableArrayRef & let it decay to an ArrayRef when needed - then I'd use that for the MutableArrayRefs in this patch) If we had std::dynarray I'd use that instead of unique_ptr+size_t, ideally (but then it'd have to be threaded down through the Preprocessor all the way - no idea how painful that would be) llvm-svn: 260246
2016-02-10 02:52:09 +08:00
PP.EnterTokenStream(Toks, /*DisableMacroExpansion=*/true);
Move support for "#pragma STDC FP_CONTRACT" to Parser; add Sema actions llvm-svn: 125474
2011-02-14 09:42:35 +08:00
}
OpenCL: add support for __kernel, kernel keywords and EXTENSION, FP_CONTRACT pragmas. Patch originally by ARM. llvm-svn: 125475
2011-02-14 09:42:53 +08:00
void
PragmaOpenCLExtensionHandler::HandlePragma(Preprocessor &PP,
PragmaIntroducerKind Introducer,
Token &Tok) {
Do not expand the opencl pragma names. This is so you can also have a define named the samed as the pragma and they do not interfere (ie. cl_khr_fp64). llvm-svn: 129549
2011-04-15 07:35:31 +08:00
PP.LexUnexpandedToken(Tok);
OpenCL: add support for __kernel, kernel keywords and EXTENSION, FP_CONTRACT pragmas. Patch originally by ARM. llvm-svn: 125475
2011-02-14 09:42:53 +08:00
if (Tok.isNot(tok::identifier)) {
PP.Diag(Tok.getLocation(), diag::warn_pragma_expected_identifier) <<
"OPENCL";
return;
}
IdentifierInfo *ename = Tok.getIdentifierInfo();
SourceLocation NameLoc = Tok.getLocation();
PP.Lex(Tok);
if (Tok.isNot(tok::colon)) {
PP.Diag(Tok.getLocation(), diag::warn_pragma_expected_colon) << ename;
return;
}
PP.Lex(Tok);
if (Tok.isNot(tok::identifier)) {
PP.Diag(Tok.getLocation(), diag::warn_pragma_expected_enable_disable);
return;
}
IdentifierInfo *op = Tok.getIdentifierInfo();
unsigned state;
if (op->isStr("enable")) {
state = 1;
} else if (op->isStr("disable")) {
state = 0;
} else {
PP.Diag(Tok.getLocation(), diag::warn_pragma_expected_enable_disable);
return;
}
Callback support for OpenCL extension pragmas. Patch from Rami Ylimäki and Mikael Lepistö! llvm-svn: 192531
2013-10-12 17:29:48 +08:00
SourceLocation StateLoc = Tok.getLocation();
OpenCL: add support for __kernel, kernel keywords and EXTENSION, FP_CONTRACT pragmas. Patch originally by ARM. llvm-svn: 125475
2011-02-14 09:42:53 +08:00
Permanently end the whole "pragma got handled by the parser too early" mess by handling all pragmas which the parser touches uniformly. <rdar://problem/12248901>, etc. llvm-svn: 165195
2012-10-04 10:36:51 +08:00
PP.Lex(Tok);
if (Tok.isNot(tok::eod)) {
PP.Diag(Tok.getLocation(), diag::warn_pragma_extra_tokens_at_eol) <<
"OPENCL EXTENSION";
OpenCL: add support for __kernel, kernel keywords and EXTENSION, FP_CONTRACT pragmas. Patch originally by ARM. llvm-svn: 125475
2011-02-14 09:42:53 +08:00
return;
}
Permanently end the whole "pragma got handled by the parser too early" mess by handling all pragmas which the parser touches uniformly. <rdar://problem/12248901>, etc. llvm-svn: 165195
2012-10-04 10:36:51 +08:00
OpenCLExtData data(ename, state);
Simplify EnterTokenStream API to make it more robust for memory management While this won't help fix things like the bug that r260219 addressed, it seems like good tidy up to have anyway. (it might be nice if "makeArrayRef" always produced a MutableArrayRef & let it decay to an ArrayRef when needed - then I'd use that for the MutableArrayRefs in this patch) If we had std::dynarray I'd use that instead of unique_ptr+size_t, ideally (but then it'd have to be threaded down through the Preprocessor all the way - no idea how painful that would be) llvm-svn: 260246
2016-02-10 02:52:09 +08:00
MutableArrayRef<Token> Toks(PP.getPreprocessorAllocator().Allocate<Token>(1),
1);
Permanently end the whole "pragma got handled by the parser too early" mess by handling all pragmas which the parser touches uniformly. <rdar://problem/12248901>, etc. llvm-svn: 165195
2012-10-04 10:36:51 +08:00
Toks[0].startToken();
Toks[0].setKind(tok::annot_pragma_opencl_extension);
Toks[0].setLocation(NameLoc);
Toks[0].setAnnotationValue(data.getOpaqueValue());
Parse: Don't assume tokens have a length Don't crash if the last token in a bad inline method body is an annotation token. llvm-svn: 232694
2015-03-19 08:10:23 +08:00
Toks[0].setAnnotationEndLoc(StateLoc);
Simplify EnterTokenStream API to make it more robust for memory management While this won't help fix things like the bug that r260219 addressed, it seems like good tidy up to have anyway. (it might be nice if "makeArrayRef" always produced a MutableArrayRef & let it decay to an ArrayRef when needed - then I'd use that for the MutableArrayRefs in this patch) If we had std::dynarray I'd use that instead of unique_ptr+size_t, ideally (but then it'd have to be threaded down through the Preprocessor all the way - no idea how painful that would be) llvm-svn: 260246
2016-02-10 02:52:09 +08:00
PP.EnterTokenStream(Toks, /*DisableMacroExpansion=*/true);
Callback support for OpenCL extension pragmas. Patch from Rami Ylimäki and Mikael Lepistö! llvm-svn: 192531
2013-10-12 17:29:48 +08:00
if (PP.getPPCallbacks())
PP.getPPCallbacks()->PragmaOpenCLExtension(NameLoc, ename,
StateLoc, state);
OpenCL: add support for __kernel, kernel keywords and EXTENSION, FP_CONTRACT pragmas. Patch originally by ARM. llvm-svn: 125475
2011-02-14 09:42:53 +08:00
}
OpenMP threadprivate directive parsing and semantic analysis llvm-svn: 177705
2013-03-22 14:34:35 +08:00
/// \brief Handle '#pragma omp ...' when OpenMP is disabled.
///
void
PragmaNoOpenMPHandler::HandlePragma(Preprocessor &PP,
PragmaIntroducerKind Introducer,
Token &FirstTok) {
Hide the concept of diagnostic levels from lex, parse and sema The compilation pipeline doesn't actually need to know about the high-level concept of diagnostic mappings, and hiding the final computed level presents several simplifications and other potential benefits. The only exceptions are opportunistic checks to see whether expensive code paths can be avoided for diagnostics that are guaranteed to be ignored at a certain SourceLocation. This commit formalizes that invariant by introducing and using DiagnosticsEngine::isIgnored() in place of individual level checks throughout lex, parse and sema. llvm-svn: 211005
2014-06-16 07:30:39 +08:00
if (!PP.getDiagnostics().isIgnored(diag::warn_pragma_omp_ignored,
FirstTok.getLocation())) {
OpenMP threadprivate directive parsing and semantic analysis llvm-svn: 177705
2013-03-22 14:34:35 +08:00
PP.Diag(FirstTok, diag::warn_pragma_omp_ignored);
DiagnosticsEngine: update severity setters to new terminology llvm-svn: 210764
2014-06-12 19:13:52 +08:00
PP.getDiagnostics().setSeverity(diag::warn_pragma_omp_ignored,
diag::Severity::Ignored, SourceLocation());
OpenMP threadprivate directive parsing and semantic analysis llvm-svn: 177705
2013-03-22 14:34:35 +08:00
}
PP.DiscardUntilEndOfDirective();
}
/// \brief Handle '#pragma omp ...' when OpenMP is enabled.
///
void
PragmaOpenMPHandler::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)) {
Pragma.push_back(Tok);
PP.Lex(Tok);
}
SourceLocation EodLoc = Tok.getLocation();
Tok.startToken();
Tok.setKind(tok::annot_pragma_openmp_end);
Tok.setLocation(EodLoc);
Pragma.push_back(Tok);
Simplify EnterTokenStream API to make it more robust for memory management While this won't help fix things like the bug that r260219 addressed, it seems like good tidy up to have anyway. (it might be nice if "makeArrayRef" always produced a MutableArrayRef & let it decay to an ArrayRef when needed - then I'd use that for the MutableArrayRefs in this patch) If we had std::dynarray I'd use that instead of unique_ptr+size_t, ideally (but then it'd have to be threaded down through the Preprocessor all the way - no idea how painful that would be) llvm-svn: 260246
2016-02-10 02:52:09 +08:00
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);
OpenMP threadprivate directive parsing and semantic analysis llvm-svn: 177705
2013-03-22 14:34:35 +08:00
}
Move PragmaCommentHandler to lib/Parse in preparation for calling Sema Summary: No functionality change. The existing tests for this pragma only verify that we can preprocess it. Reviewers: rsmith CC: cfe-commits Differential Revision: http://llvm-reviews.chandlerc.com/D751 llvm-svn: 181246
2013-05-07 05:02:12 +08:00
MS ABI: Add support for #pragma pointers_to_members Introduce a notion of a 'current representation method' for pointers-to-members. When starting out, this is set to 'best case' (representation method is chosen by examining the class, selecting the smallest representation that would work given the class definition or lack thereof). This pragma allows the translation unit to dictate exactly what representation to use, similar to how the inheritance model keywords operate. N.B. PCH support is forthcoming. Differential Revision: http://llvm-reviews.chandlerc.com/D2723 llvm-svn: 201105
2014-02-11 03:50:15 +08:00
/// \brief Handle '#pragma pointers_to_members'
// The grammar for this pragma is as follows:
//
// <inheritance model> ::= ('single' | 'multiple' | 'virtual') '_inheritance'
//
// #pragma pointers_to_members '(' 'best_case' ')'
// #pragma pointers_to_members '(' 'full_generality' [',' inheritance-model] ')'
// #pragma pointers_to_members '(' inheritance-model ')'
void 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);
MS ABI: Add support for the -vm{b,g,s,m,v} flags These flags control the inheritance model initially used by the translation unit. Differential Revision: http://llvm-reviews.chandlerc.com/D2741 llvm-svn: 201175
2014-02-12 05:05:00 +08:00
LangOptions::PragmaMSPointersToMembersKind RepresentationMethod;
MS ABI: Add support for #pragma pointers_to_members Introduce a notion of a 'current representation method' for pointers-to-members. When starting out, this is set to 'best case' (representation method is chosen by examining the class, selecting the smallest representation that would work given the class definition or lack thereof). This pragma allows the translation unit to dictate exactly what representation to use, similar to how the inheritance model keywords operate. N.B. PCH support is forthcoming. Differential Revision: http://llvm-reviews.chandlerc.com/D2723 llvm-svn: 201105
2014-02-11 03:50:15 +08:00
if (Arg->isStr("best_case")) {
MS ABI: Add support for the -vm{b,g,s,m,v} flags These flags control the inheritance model initially used by the translation unit. Differential Revision: http://llvm-reviews.chandlerc.com/D2741 llvm-svn: 201175
2014-02-12 05:05:00 +08:00
RepresentationMethod = LangOptions::PPTMK_BestCase;
MS ABI: Add support for #pragma pointers_to_members Introduce a notion of a 'current representation method' for pointers-to-members. When starting out, this is set to 'best case' (representation method is chosen by examining the class, selecting the smallest representation that would work given the class definition or lack thereof). This pragma allows the translation unit to dictate exactly what representation to use, similar to how the inheritance model keywords operate. N.B. PCH support is forthcoming. Differential Revision: http://llvm-reviews.chandlerc.com/D2723 llvm-svn: 201105
2014-02-11 03:50:15 +08:00
} 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.
[C++11] Use 'nullptr'. Parser edition. llvm-svn: 209275
2014-05-21 14:02:52 +08:00
Arg = nullptr;
MS ABI: Add support for the -vm{b,g,s,m,v} flags These flags control the inheritance model initially used by the translation unit. Differential Revision: http://llvm-reviews.chandlerc.com/D2741 llvm-svn: 201175
2014-02-12 05:05:00 +08:00
RepresentationMethod = LangOptions::PPTMK_FullGeneralityVirtualInheritance;
MS ABI: Add support for #pragma pointers_to_members Introduce a notion of a 'current representation method' for pointers-to-members. When starting out, this is set to 'best case' (representation method is chosen by examining the class, selecting the smallest representation that would work given the class definition or lack thereof). This pragma allows the translation unit to dictate exactly what representation to use, similar to how the inheritance model keywords operate. N.B. PCH support is forthcoming. Differential Revision: http://llvm-reviews.chandlerc.com/D2723 llvm-svn: 201105
2014-02-11 03:50:15 +08:00
} else {
PP.Diag(Tok.getLocation(), diag::err_expected_punc)
<< "full_generality";
return;
}
}
if (Arg) {
if (Arg->isStr("single_inheritance")) {
MS ABI: Add support for the -vm{b,g,s,m,v} flags These flags control the inheritance model initially used by the translation unit. Differential Revision: http://llvm-reviews.chandlerc.com/D2741 llvm-svn: 201175
2014-02-12 05:05:00 +08:00
RepresentationMethod =
LangOptions::PPTMK_FullGeneralitySingleInheritance;
MS ABI: Add support for #pragma pointers_to_members Introduce a notion of a 'current representation method' for pointers-to-members. When starting out, this is set to 'best case' (representation method is chosen by examining the class, selecting the smallest representation that would work given the class definition or lack thereof). This pragma allows the translation unit to dictate exactly what representation to use, similar to how the inheritance model keywords operate. N.B. PCH support is forthcoming. Differential Revision: http://llvm-reviews.chandlerc.com/D2723 llvm-svn: 201105
2014-02-11 03:50:15 +08:00
} else if (Arg->isStr("multiple_inheritance")) {
MS ABI: Add support for the -vm{b,g,s,m,v} flags These flags control the inheritance model initially used by the translation unit. Differential Revision: http://llvm-reviews.chandlerc.com/D2741 llvm-svn: 201175
2014-02-12 05:05:00 +08:00
RepresentationMethod =
LangOptions::PPTMK_FullGeneralityMultipleInheritance;
MS ABI: Add support for #pragma pointers_to_members Introduce a notion of a 'current representation method' for pointers-to-members. When starting out, this is set to 'best case' (representation method is chosen by examining the class, selecting the smallest representation that would work given the class definition or lack thereof). This pragma allows the translation unit to dictate exactly what representation to use, similar to how the inheritance model keywords operate. N.B. PCH support is forthcoming. Differential Revision: http://llvm-reviews.chandlerc.com/D2723 llvm-svn: 201105
2014-02-11 03:50:15 +08:00
} else if (Arg->isStr("virtual_inheritance")) {
MS ABI: Add support for the -vm{b,g,s,m,v} flags These flags control the inheritance model initially used by the translation unit. Differential Revision: http://llvm-reviews.chandlerc.com/D2741 llvm-svn: 201175
2014-02-12 05:05:00 +08:00
RepresentationMethod =
LangOptions::PPTMK_FullGeneralityVirtualInheritance;
MS ABI: Add support for #pragma pointers_to_members Introduce a notion of a 'current representation method' for pointers-to-members. When starting out, this is set to 'best case' (representation method is chosen by examining the class, selecting the smallest representation that would work given the class definition or lack thereof). This pragma allows the translation unit to dictate exactly what representation to use, similar to how the inheritance model keywords operate. N.B. PCH support is forthcoming. Differential Revision: http://llvm-reviews.chandlerc.com/D2723 llvm-svn: 201105
2014-02-11 03:50:15 +08:00
} 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;
}
Parse: Don't assume tokens have a length Don't crash if the last token in a bad inline method body is an annotation token. llvm-svn: 232694
2015-03-19 08:10:23 +08:00
SourceLocation EndLoc = Tok.getLocation();
MS ABI: Add support for #pragma pointers_to_members Introduce a notion of a 'current representation method' for pointers-to-members. When starting out, this is set to 'best case' (representation method is chosen by examining the class, selecting the smallest representation that would work given the class definition or lack thereof). This pragma allows the translation unit to dictate exactly what representation to use, similar to how the inheritance model keywords operate. N.B. PCH support is forthcoming. Differential Revision: http://llvm-reviews.chandlerc.com/D2723 llvm-svn: 201105
2014-02-11 03:50:15 +08:00
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);
Parse: Don't assume tokens have a length Don't crash if the last token in a bad inline method body is an annotation token. llvm-svn: 232694
2015-03-19 08:10:23 +08:00
AnnotTok.setAnnotationEndLoc(EndLoc);
MS ABI: Add support for #pragma pointers_to_members Introduce a notion of a 'current representation method' for pointers-to-members. When starting out, this is set to 'best case' (representation method is chosen by examining the class, selecting the smallest representation that would work given the class definition or lack thereof). This pragma allows the translation unit to dictate exactly what representation to use, similar to how the inheritance model keywords operate. N.B. PCH support is forthcoming. Differential Revision: http://llvm-reviews.chandlerc.com/D2723 llvm-svn: 201105
2014-02-11 03:50:15 +08:00
AnnotTok.setAnnotationValue(
reinterpret_cast<void *>(static_cast<uintptr_t>(RepresentationMethod)));
PP.EnterToken(AnnotTok);
}
MS ABI: Implement #pragma vtordisp() and clang-cl /vdN These features are new in VS 2013 and are necessary in order to layout std::ostream correctly. Currently we have an ABI incompatibility when self-hosting with the 2013 stdlib in our convertible_fwd_ostream wrapper in gtest. This change adds another implicit attribute, MSVtorDispAttr, because implicit attributes are currently the best way to make sure the information stays on class templates through instantiation. Reviewers: majnemer Differential Revision: http://llvm-reviews.chandlerc.com/D2746 llvm-svn: 201274
2014-02-13 07:50:26 +08:00
/// \brief Handle '#pragma vtordisp'
// The grammar for this pragma is as follows:
//
// <vtordisp-mode> ::= ('off' | 'on' | '0' | '1' | '2' )
//
// #pragma vtordisp '(' ['push' ','] vtordisp-mode ')'
// #pragma vtordisp '(' 'pop' ')'
// #pragma vtordisp '(' ')'
void 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);
Recommit "[MS] Improved implementation of stack pragmas (vtordisp, *_seg)" Slightly updated version, double-checked build and tests. Improve implementation of MS pragmas that use stack + compatibility fixes. This patch: 1. Changes implementation of #pragma vtordisp to use PragmaStack class that other stack pragmas use; 2. Fixes "#pragma vtordisp()" behavior - it shouldn't affect the stack; 3. Supports "save-restore" of pragma stacks on enter / exit a C++ method body, as MSVC does. TODO: 1. Change implementation of #pragma pack to use the same approach; 2. Introduce diagnostics on popping named stack slots, as MSVC does. Reviewers: rnk, thakis Differential revision: http://reviews.llvm.org/D19361 llvm-svn: 268029
2016-04-29 19:27:00 +08:00
Sema::PragmaMsStackAction Action = Sema::PSK_Set;
MS ABI: Implement #pragma vtordisp() and clang-cl /vdN These features are new in VS 2013 and are necessary in order to layout std::ostream correctly. Currently we have an ABI incompatibility when self-hosting with the 2013 stdlib in our convertible_fwd_ostream wrapper in gtest. This change adds another implicit attribute, MSVtorDispAttr, because implicit attributes are currently the best way to make sure the information stays on class templates through instantiation. Reviewers: majnemer Differential Revision: http://llvm-reviews.chandlerc.com/D2746 llvm-svn: 201274
2014-02-13 07:50:26 +08:00
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);
Recommit "[MS] Improved implementation of stack pragmas (vtordisp, *_seg)" Slightly updated version, double-checked build and tests. Improve implementation of MS pragmas that use stack + compatibility fixes. This patch: 1. Changes implementation of #pragma vtordisp to use PragmaStack class that other stack pragmas use; 2. Fixes "#pragma vtordisp()" behavior - it shouldn't affect the stack; 3. Supports "save-restore" of pragma stacks on enter / exit a C++ method body, as MSVC does. TODO: 1. Change implementation of #pragma pack to use the same approach; 2. Introduce diagnostics on popping named stack slots, as MSVC does. Reviewers: rnk, thakis Differential revision: http://reviews.llvm.org/D19361 llvm-svn: 268029
2016-04-29 19:27:00 +08:00
Action = Sema::PSK_Push_Set;
MS ABI: Implement #pragma vtordisp() and clang-cl /vdN These features are new in VS 2013 and are necessary in order to layout std::ostream correctly. Currently we have an ABI incompatibility when self-hosting with the 2013 stdlib in our convertible_fwd_ostream wrapper in gtest. This change adds another implicit attribute, MSVtorDispAttr, because implicit attributes are currently the best way to make sure the information stays on class templates through instantiation. Reviewers: majnemer Differential Revision: http://llvm-reviews.chandlerc.com/D2746 llvm-svn: 201274
2014-02-13 07:50:26 +08:00
// not push, could be on/off
} else if (II->isStr("pop")) {
// #pragma vtordisp(pop)
PP.Lex(Tok);
Recommit "[MS] Improved implementation of stack pragmas (vtordisp, *_seg)" Slightly updated version, double-checked build and tests. Improve implementation of MS pragmas that use stack + compatibility fixes. This patch: 1. Changes implementation of #pragma vtordisp to use PragmaStack class that other stack pragmas use; 2. Fixes "#pragma vtordisp()" behavior - it shouldn't affect the stack; 3. Supports "save-restore" of pragma stacks on enter / exit a C++ method body, as MSVC does. TODO: 1. Change implementation of #pragma pack to use the same approach; 2. Introduce diagnostics on popping named stack slots, as MSVC does. Reviewers: rnk, thakis Differential revision: http://reviews.llvm.org/D19361 llvm-svn: 268029
2016-04-29 19:27:00 +08:00
Action = Sema::PSK_Pop;
MS ABI: Implement #pragma vtordisp() and clang-cl /vdN These features are new in VS 2013 and are necessary in order to layout std::ostream correctly. Currently we have an ABI incompatibility when self-hosting with the 2013 stdlib in our convertible_fwd_ostream wrapper in gtest. This change adds another implicit attribute, MSVtorDispAttr, because implicit attributes are currently the best way to make sure the information stays on class templates through instantiation. Reviewers: majnemer Differential Revision: http://llvm-reviews.chandlerc.com/D2746 llvm-svn: 201274
2014-02-13 07:50:26 +08:00
}
// not push or pop, could be on/off
} else {
if (Tok.is(tok::r_paren)) {
// #pragma vtordisp()
Recommit "[MS] Improved implementation of stack pragmas (vtordisp, *_seg)" Slightly updated version, double-checked build and tests. Improve implementation of MS pragmas that use stack + compatibility fixes. This patch: 1. Changes implementation of #pragma vtordisp to use PragmaStack class that other stack pragmas use; 2. Fixes "#pragma vtordisp()" behavior - it shouldn't affect the stack; 3. Supports "save-restore" of pragma stacks on enter / exit a C++ method body, as MSVC does. TODO: 1. Change implementation of #pragma pack to use the same approach; 2. Introduce diagnostics on popping named stack slots, as MSVC does. Reviewers: rnk, thakis Differential revision: http://reviews.llvm.org/D19361 llvm-svn: 268029
2016-04-29 19:27:00 +08:00
Action = Sema::PSK_Reset;
MS ABI: Implement #pragma vtordisp() and clang-cl /vdN These features are new in VS 2013 and are necessary in order to layout std::ostream correctly. Currently we have an ABI incompatibility when self-hosting with the 2013 stdlib in our convertible_fwd_ostream wrapper in gtest. This change adds another implicit attribute, MSVtorDispAttr, because implicit attributes are currently the best way to make sure the information stays on class templates through instantiation. Reviewers: majnemer Differential Revision: http://llvm-reviews.chandlerc.com/D2746 llvm-svn: 201274
2014-02-13 07:50:26 +08:00
}
}
Fix uninitialized read in vtordisp pragma code. llvm-svn: 201280
2014-02-13 08:44:34 +08:00
uint64_t Value = 0;
Recommit "[MS] Improved implementation of stack pragmas (vtordisp, *_seg)" Slightly updated version, double-checked build and tests. Improve implementation of MS pragmas that use stack + compatibility fixes. This patch: 1. Changes implementation of #pragma vtordisp to use PragmaStack class that other stack pragmas use; 2. Fixes "#pragma vtordisp()" behavior - it shouldn't affect the stack; 3. Supports "save-restore" of pragma stacks on enter / exit a C++ method body, as MSVC does. TODO: 1. Change implementation of #pragma pack to use the same approach; 2. Introduce diagnostics on popping named stack slots, as MSVC does. Reviewers: rnk, thakis Differential revision: http://reviews.llvm.org/D19361 llvm-svn: 268029
2016-04-29 19:27:00 +08:00
if (Action & Sema::PSK_Push || Action & Sema::PSK_Set) {
MS ABI: Implement #pragma vtordisp() and clang-cl /vdN These features are new in VS 2013 and are necessary in order to layout std::ostream correctly. Currently we have an ABI incompatibility when self-hosting with the 2013 stdlib in our convertible_fwd_ostream wrapper in gtest. This change adds another implicit attribute, MSVtorDispAttr, because implicit attributes are currently the best way to make sure the information stays on class templates through instantiation. Reviewers: majnemer Differential Revision: http://llvm-reviews.chandlerc.com/D2746 llvm-svn: 201274
2014-02-13 07:50:26 +08:00
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;
}
Parse: Don't assume tokens have a length Don't crash if the last token in a bad inline method body is an annotation token. llvm-svn: 232694
2015-03-19 08:10:23 +08:00
SourceLocation EndLoc = Tok.getLocation();
MS ABI: Implement #pragma vtordisp() and clang-cl /vdN These features are new in VS 2013 and are necessary in order to layout std::ostream correctly. Currently we have an ABI incompatibility when self-hosting with the 2013 stdlib in our convertible_fwd_ostream wrapper in gtest. This change adds another implicit attribute, MSVtorDispAttr, because implicit attributes are currently the best way to make sure the information stays on class templates through instantiation. Reviewers: majnemer Differential Revision: http://llvm-reviews.chandlerc.com/D2746 llvm-svn: 201274
2014-02-13 07:50:26 +08:00
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);
Parse: Don't assume tokens have a length Don't crash if the last token in a bad inline method body is an annotation token. llvm-svn: 232694
2015-03-19 08:10:23 +08:00
AnnotTok.setAnnotationEndLoc(EndLoc);
Fix uninitialized read in vtordisp pragma code. llvm-svn: 201280
2014-02-13 08:44:34 +08:00
AnnotTok.setAnnotationValue(reinterpret_cast<void *>(
Recommit "[MS] Improved implementation of stack pragmas (vtordisp, *_seg)" Slightly updated version, double-checked build and tests. Improve implementation of MS pragmas that use stack + compatibility fixes. This patch: 1. Changes implementation of #pragma vtordisp to use PragmaStack class that other stack pragmas use; 2. Fixes "#pragma vtordisp()" behavior - it shouldn't affect the stack; 3. Supports "save-restore" of pragma stacks on enter / exit a C++ method body, as MSVC does. TODO: 1. Change implementation of #pragma pack to use the same approach; 2. Introduce diagnostics on popping named stack slots, as MSVC does. Reviewers: rnk, thakis Differential revision: http://reviews.llvm.org/D19361 llvm-svn: 268029
2016-04-29 19:27:00 +08:00
static_cast<uintptr_t>((Action << 16) | (Value & 0xFFFF))));
MS ABI: Implement #pragma vtordisp() and clang-cl /vdN These features are new in VS 2013 and are necessary in order to layout std::ostream correctly. Currently we have an ABI incompatibility when self-hosting with the 2013 stdlib in our convertible_fwd_ostream wrapper in gtest. This change adds another implicit attribute, MSVtorDispAttr, because implicit attributes are currently the best way to make sure the information stays on class templates through instantiation. Reviewers: majnemer Differential Revision: http://llvm-reviews.chandlerc.com/D2746 llvm-svn: 201274
2014-02-13 07:50:26 +08:00
PP.EnterToken(AnnotTok);
}
[MS-ABI] Add support for #pragma section and related pragmas This patch adds support for the msvc pragmas section, bss_seg, code_seg, const_seg and data_seg as well as support for __declspec(allocate()). Additionally it corrects semantics and adds diagnostics for __attribute__((section())) and the interaction between the attribute and the msvc pragmas and declspec. In general conflicts should now be well diganosed within and among these features. In supporting the pragmas new machinery for uniform lexing for msvc pragmas was introduced. The new machinery always lexes the entire pragma and stores it on an annotation token. The parser is responsible for parsing the pragma when the handling the annotation token. There is a known outstanding bug in this implementation in C mode. Because these attributes and pragmas apply _only_ to definitions, we process them at the time we detect a definition. Due to tentative definitions in C, we end up processing the definition late. This means that in C mode, everything that ends up in a BSS section will end up in the _last_ BSS section rather than the one that was live at the time of tentative definition, even if that turns out to be the point of actual definition. This issue is not known to impact anything as of yet because we are not aware of a clear use or use case for #pragma bss_seg but should be fixed at some point. Differential Revision=http://reviews.llvm.org/D3065#inline-16241 llvm-svn: 205810
2014-04-09 06:30:47 +08:00
/// \brief Handle all MS pragmas. Simply forwards the tokens after inserting
/// an annotation token.
void 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());
Parse: Don't assume tokens have a length Don't crash if the last token in a bad inline method body is an annotation token. llvm-svn: 232694
2015-03-19 08:10:23 +08:00
AnnotTok.setAnnotationEndLoc(Tok.getLocation());
[MS-ABI] Add support for #pragma section and related pragmas This patch adds support for the msvc pragmas section, bss_seg, code_seg, const_seg and data_seg as well as support for __declspec(allocate()). Additionally it corrects semantics and adds diagnostics for __attribute__((section())) and the interaction between the attribute and the msvc pragmas and declspec. In general conflicts should now be well diganosed within and among these features. In supporting the pragmas new machinery for uniform lexing for msvc pragmas was introduced. The new machinery always lexes the entire pragma and stores it on an annotation token. The parser is responsible for parsing the pragma when the handling the annotation token. There is a known outstanding bug in this implementation in C mode. Because these attributes and pragmas apply _only_ to definitions, we process them at the time we detect a definition. Due to tentative definitions in C, we end up processing the definition late. This means that in C mode, everything that ends up in a BSS section will end up in the _last_ BSS section rather than the one that was live at the time of tentative definition, even if that turns out to be the point of actual definition. This issue is not known to impact anything as of yet because we are not aware of a clear use or use case for #pragma bss_seg but should be fixed at some point. Differential Revision=http://reviews.llvm.org/D3065#inline-16241 llvm-svn: 205810
2014-04-09 06:30:47 +08:00
SmallVector<Token, 8> TokenVector;
// Suck up all of the tokens before the eod.
Parse: Don't assume tokens have a length Don't crash if the last token in a bad inline method body is an annotation token. llvm-svn: 232694
2015-03-19 08:10:23 +08:00
for (; Tok.isNot(tok::eod); PP.Lex(Tok)) {
[MS-ABI] Add support for #pragma section and related pragmas This patch adds support for the msvc pragmas section, bss_seg, code_seg, const_seg and data_seg as well as support for __declspec(allocate()). Additionally it corrects semantics and adds diagnostics for __attribute__((section())) and the interaction between the attribute and the msvc pragmas and declspec. In general conflicts should now be well diganosed within and among these features. In supporting the pragmas new machinery for uniform lexing for msvc pragmas was introduced. The new machinery always lexes the entire pragma and stores it on an annotation token. The parser is responsible for parsing the pragma when the handling the annotation token. There is a known outstanding bug in this implementation in C mode. Because these attributes and pragmas apply _only_ to definitions, we process them at the time we detect a definition. Due to tentative definitions in C, we end up processing the definition late. This means that in C mode, everything that ends up in a BSS section will end up in the _last_ BSS section rather than the one that was live at the time of tentative definition, even if that turns out to be the point of actual definition. This issue is not known to impact anything as of yet because we are not aware of a clear use or use case for #pragma bss_seg but should be fixed at some point. Differential Revision=http://reviews.llvm.org/D3065#inline-16241 llvm-svn: 205810
2014-04-09 06:30:47 +08:00
TokenVector.push_back(Tok);
Parse: Don't assume tokens have a length Don't crash if the last token in a bad inline method body is an annotation token. llvm-svn: 232694
2015-03-19 08:10:23 +08:00
AnnotTok.setAnnotationEndLoc(Tok.getLocation());
}
[MS-ABI] Add support for #pragma section and related pragmas This patch adds support for the msvc pragmas section, bss_seg, code_seg, const_seg and data_seg as well as support for __declspec(allocate()). Additionally it corrects semantics and adds diagnostics for __attribute__((section())) and the interaction between the attribute and the msvc pragmas and declspec. In general conflicts should now be well diganosed within and among these features. In supporting the pragmas new machinery for uniform lexing for msvc pragmas was introduced. The new machinery always lexes the entire pragma and stores it on an annotation token. The parser is responsible for parsing the pragma when the handling the annotation token. There is a known outstanding bug in this implementation in C mode. Because these attributes and pragmas apply _only_ to definitions, we process them at the time we detect a definition. Due to tentative definitions in C, we end up processing the definition late. This means that in C mode, everything that ends up in a BSS section will end up in the _last_ BSS section rather than the one that was live at the time of tentative definition, even if that turns out to be the point of actual definition. This issue is not known to impact anything as of yet because we are not aware of a clear use or use case for #pragma bss_seg but should be fixed at some point. Differential Revision=http://reviews.llvm.org/D3065#inline-16241 llvm-svn: 205810
2014-04-09 06:30:47 +08:00
// Add a sentinal 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.
Simplify EnterTokenStream API to make it more robust for memory management While this won't help fix things like the bug that r260219 addressed, it seems like good tidy up to have anyway. (it might be nice if "makeArrayRef" always produced a MutableArrayRef & let it decay to an ArrayRef when needed - then I'd use that for the MutableArrayRefs in this patch) If we had std::dynarray I'd use that instead of unique_ptr+size_t, ideally (but then it'd have to be threaded down through the Preprocessor all the way - no idea how painful that would be) llvm-svn: 260246
2016-02-10 02:52:09 +08:00
auto TokenArray = llvm::make_unique<Token[]>(TokenVector.size());
std::copy(TokenVector.begin(), TokenVector.end(), TokenArray.get());
[MS-ABI] Add support for #pragma section and related pragmas This patch adds support for the msvc pragmas section, bss_seg, code_seg, const_seg and data_seg as well as support for __declspec(allocate()). Additionally it corrects semantics and adds diagnostics for __attribute__((section())) and the interaction between the attribute and the msvc pragmas and declspec. In general conflicts should now be well diganosed within and among these features. In supporting the pragmas new machinery for uniform lexing for msvc pragmas was introduced. The new machinery always lexes the entire pragma and stores it on an annotation token. The parser is responsible for parsing the pragma when the handling the annotation token. There is a known outstanding bug in this implementation in C mode. Because these attributes and pragmas apply _only_ to definitions, we process them at the time we detect a definition. Due to tentative definitions in C, we end up processing the definition late. This means that in C mode, everything that ends up in a BSS section will end up in the _last_ BSS section rather than the one that was live at the time of tentative definition, even if that turns out to be the point of actual definition. This issue is not known to impact anything as of yet because we are not aware of a clear use or use case for #pragma bss_seg but should be fixed at some point. Differential Revision=http://reviews.llvm.org/D3065#inline-16241 llvm-svn: 205810
2014-04-09 06:30:47 +08:00
auto Value = new (PP.getPreprocessorAllocator())
Simplify EnterTokenStream API to make it more robust for memory management While this won't help fix things like the bug that r260219 addressed, it seems like good tidy up to have anyway. (it might be nice if "makeArrayRef" always produced a MutableArrayRef & let it decay to an ArrayRef when needed - then I'd use that for the MutableArrayRefs in this patch) If we had std::dynarray I'd use that instead of unique_ptr+size_t, ideally (but then it'd have to be threaded down through the Preprocessor all the way - no idea how painful that would be) llvm-svn: 260246
2016-02-10 02:52:09 +08:00
std::pair<std::unique_ptr<Token[]>, size_t>(std::move(TokenArray),
TokenVector.size());
[MS-ABI] Add support for #pragma section and related pragmas This patch adds support for the msvc pragmas section, bss_seg, code_seg, const_seg and data_seg as well as support for __declspec(allocate()). Additionally it corrects semantics and adds diagnostics for __attribute__((section())) and the interaction between the attribute and the msvc pragmas and declspec. In general conflicts should now be well diganosed within and among these features. In supporting the pragmas new machinery for uniform lexing for msvc pragmas was introduced. The new machinery always lexes the entire pragma and stores it on an annotation token. The parser is responsible for parsing the pragma when the handling the annotation token. There is a known outstanding bug in this implementation in C mode. Because these attributes and pragmas apply _only_ to definitions, we process them at the time we detect a definition. Due to tentative definitions in C, we end up processing the definition late. This means that in C mode, everything that ends up in a BSS section will end up in the _last_ BSS section rather than the one that was live at the time of tentative definition, even if that turns out to be the point of actual definition. This issue is not known to impact anything as of yet because we are not aware of a clear use or use case for #pragma bss_seg but should be fixed at some point. Differential Revision=http://reviews.llvm.org/D3065#inline-16241 llvm-svn: 205810
2014-04-09 06:30:47 +08:00
AnnotTok.setAnnotationValue(Value);
PP.EnterToken(AnnotTok);
-fms-extensions: Error out on #pragma init_seg By ignoring this pragma with a warning, we're essentially miscompiling the user's program. WebKit / Blink use this pragma to disable dynamic initialization and finalization of some static data, and running the dtors crashes the program. Error out for now, so that /fallback compiles the TU correctly with MSVC. This pragma should be implemented some time this month, and we can remove this hack. llvm-svn: 205554
2014-04-04 03:04:24 +08:00
}
Adding support for MSVC #pragma detect_mismatch functionality by emitting a FAILIFMISMATCH linker command into the object file. llvm-svn: 183178
2013-06-04 10:07:14 +08:00
/// \brief Handle the Microsoft \#pragma detect_mismatch extension.
///
/// The syntax is:
/// \code
/// #pragma detect_mismatch("name", "value")
/// \endcode
/// Where 'name' and 'value' are quoted strings. The values are embedded in
/// the object file and passed along to the linker. If the linker detects a
/// mismatch in the object file's values for the given name, a LNK2038 error
/// is emitted. See MSDN for more details.
void PragmaDetectMismatchHandler::HandlePragma(Preprocessor &PP,
PragmaIntroducerKind Introducer,
Token &Tok) {
Serialize `#pragma detect_mismatch`. This is like r262493, but for pragma detect_mismatch instead of pragma comment. The two pragmas have similar behavior, so use the same approach for both. llvm-svn: 262506
2016-03-03 03:28:54 +08:00
SourceLocation DetectMismatchLoc = Tok.getLocation();
Adding support for MSVC #pragma detect_mismatch functionality by emitting a FAILIFMISMATCH linker command into the object file. llvm-svn: 183178
2013-06-04 10:07:14 +08:00
PP.Lex(Tok);
if (Tok.isNot(tok::l_paren)) {
Serialize `#pragma detect_mismatch`. This is like r262493, but for pragma detect_mismatch instead of pragma comment. The two pragmas have similar behavior, so use the same approach for both. llvm-svn: 262506
2016-03-03 03:28:54 +08:00
PP.Diag(DetectMismatchLoc, diag::err_expected) << tok::l_paren;
Adding support for MSVC #pragma detect_mismatch functionality by emitting a FAILIFMISMATCH linker command into the object file. llvm-svn: 183178
2013-06-04 10:07:14 +08:00
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)) {
Support and use token kinds as diagnostic arguments Introduce proper facilities to render token spellings using the diagnostic formatter. Replaces most of the hard-coded diagnostic messages related to expected tokens, which all shared the same semantics but had to be multiply defined due to variations in token order or quote marks. The associated parser changes are largely mechanical but they expose commonality in whole chunks of the parser that can now be factored away. This commit uses C++11 typed enums along with a speculative legacy fallback until the transition is complete. Requires corresponding changes in LLVM r197895. llvm-svn: 197972
2013-12-24 17:48:30 +08:00
PP.Diag(Tok.getLocation(), diag::err_expected) << tok::r_paren;
Adding support for MSVC #pragma detect_mismatch functionality by emitting a FAILIFMISMATCH linker command into the object file. llvm-svn: 183178
2013-06-04 10:07:14 +08:00
return;
}
PP.Lex(Tok); // Eat the r_paren.
if (Tok.isNot(tok::eod)) {
PP.Diag(Tok.getLocation(), diag::err_pragma_detect_mismatch_malformed);
return;
}
Revert the removal of PPCallbacks::PragmaComment() in r201821 The pp-trace clang tool was using it successfully. We can still delete the callbacks in Frontend/PrintPreprocessedOutput.cpp because they were effectively dead. llvm-svn: 201825
2014-02-21 07:37:45 +08:00
// If the pragma is lexically sound, notify any interested PPCallbacks.
if (PP.getPPCallbacks())
Serialize `#pragma detect_mismatch`. This is like r262493, but for pragma detect_mismatch instead of pragma comment. The two pragmas have similar behavior, so use the same approach for both. llvm-svn: 262506
2016-03-03 03:28:54 +08:00
PP.getPPCallbacks()->PragmaDetectMismatch(DetectMismatchLoc, NameString,
Revert the removal of PPCallbacks::PragmaComment() in r201821 The pp-trace clang tool was using it successfully. We can still delete the callbacks in Frontend/PrintPreprocessedOutput.cpp because they were effectively dead. llvm-svn: 201825
2014-02-21 07:37:45 +08:00
ValueString);
Serialize `#pragma detect_mismatch`. This is like r262493, but for pragma detect_mismatch instead of pragma comment. The two pragmas have similar behavior, so use the same approach for both. llvm-svn: 262506
2016-03-03 03:28:54 +08:00
Actions.ActOnPragmaDetectMismatch(DetectMismatchLoc, NameString, ValueString);
Adding support for MSVC #pragma detect_mismatch functionality by emitting a FAILIFMISMATCH linker command into the object file. llvm-svn: 183178
2013-06-04 10:07:14 +08:00
}
Move PragmaCommentHandler to lib/Parse in preparation for calling Sema Summary: No functionality change. The existing tests for this pragma only verify that we can preprocess it. Reviewers: rsmith CC: cfe-commits Differential Revision: http://llvm-reviews.chandlerc.com/D751 llvm-svn: 181246
2013-05-07 05:02:12 +08:00
/// \brief Handle the microsoft \#pragma comment extension.
///
/// The syntax is:
/// \code
/// #pragma comment(linker, "foo")
/// \endcode
/// 'linker' is one of five identifiers: compiler, exestr, lib, linker, user.
/// "foo" is a string, which is fully macro expanded, and permits string
/// concatenation, embedded escape characters etc. See MSDN for more details.
void 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.
Forward #pragma comment(lib/linker) through as flags metadata Summary: Most of this change is wiring the pragma all the way through from the lexer, parser, and sema to codegen. I considered adding a Decl AST node for this, but it seemed too heavyweight. Mach-O already uses a metadata flag called "Linker Options" to do this kind of auto-linking. This change follows that pattern. LLVM knows how to forward the "Linker Options" metadata into the COFF .drectve section where these flags belong. ELF support is not implemented, but possible. This is related to auto-linking, which is http://llvm.org/PR13016. CC: cfe-commits Differential Revision: http://llvm-reviews.chandlerc.com/D723 llvm-svn: 181426
2013-05-08 21:44:39 +08:00
IdentifierInfo *II = Tok.getIdentifierInfo();
Serialize `#pragma comment`. `#pragma comment` was handled by Sema calling a function on ASTConsumer, and CodeGen then implementing this function and writing things to its output. Instead, introduce a PragmaCommentDecl AST node and hang one off the TranslationUnitDecl for every `#pragma comment` line, and then use the regular serialization machinery. (Since PragmaCommentDecl has codegen relevance, it's eagerly deserialized.) http://reviews.llvm.org/D17799 llvm-svn: 262493
2016-03-03 01:28:48 +08:00
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) {
Move PragmaCommentHandler to lib/Parse in preparation for calling Sema Summary: No functionality change. The existing tests for this pragma only verify that we can preprocess it. Reviewers: rsmith CC: cfe-commits Differential Revision: http://llvm-reviews.chandlerc.com/D751 llvm-svn: 181246
2013-05-07 05:02:12 +08:00
PP.Diag(Tok.getLocation(), diag::err_pragma_comment_unknown_kind);
return;
}
Adds a warning for unrecognized argument to #pragma comment() on PS4. PS4 target recognizes the #pragma comment() syntax as in -fms-extensions, but only handles the case of #pragma comment(lib). This patch adds a warning if any other arguments are encountered. This patch also refactors the code in ParsePragma.cpp a little bit to make it more obvious that some codes are being shared between -fms-extensions and PS4. llvm-svn: 233015
2015-03-24 04:41:42 +08:00
// On PS4, issue a warning about any pragma comments other than
// #pragma comment lib.
Serialize `#pragma comment`. `#pragma comment` was handled by Sema calling a function on ASTConsumer, and CodeGen then implementing this function and writing things to its output. Instead, introduce a PragmaCommentDecl AST node and hang one off the TranslationUnitDecl for every `#pragma comment` line, and then use the regular serialization machinery. (Since PragmaCommentDecl has codegen relevance, it's eagerly deserialized.) http://reviews.llvm.org/D17799 llvm-svn: 262493
2016-03-03 01:28:48 +08:00
if (PP.getTargetInfo().getTriple().isPS4() && Kind != PCK_Lib) {
Adds a warning for unrecognized argument to #pragma comment() on PS4. PS4 target recognizes the #pragma comment() syntax as in -fms-extensions, but only handles the case of #pragma comment(lib). This patch adds a warning if any other arguments are encountered. This patch also refactors the code in ParsePragma.cpp a little bit to make it more obvious that some codes are being shared between -fms-extensions and PS4. llvm-svn: 233015
2015-03-24 04:41:42 +08:00
PP.Diag(Tok.getLocation(), diag::warn_pragma_comment_ignored)
<< II->getName();
return;
}
Move PragmaCommentHandler to lib/Parse in preparation for calling Sema Summary: No functionality change. The existing tests for this pragma only verify that we can preprocess it. Reviewers: rsmith CC: cfe-commits Differential Revision: http://llvm-reviews.chandlerc.com/D751 llvm-svn: 181246
2013-05-07 05:02:12 +08:00
// 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;
Forward #pragma comment(lib/linker) through as flags metadata Summary: Most of this change is wiring the pragma all the way through from the lexer, parser, and sema to codegen. I considered adding a Decl AST node for this, but it seemed too heavyweight. Mach-O already uses a metadata flag called "Linker Options" to do this kind of auto-linking. This change follows that pattern. LLVM knows how to forward the "Linker Options" metadata into the COFF .drectve section where these flags belong. ELF support is not implemented, but possible. This is related to auto-linking, which is http://llvm.org/PR13016. CC: cfe-commits Differential Revision: http://llvm-reviews.chandlerc.com/D723 llvm-svn: 181426
2013-05-08 21:44:39 +08:00
// FIXME: warn that 'exestr' is deprecated.
Move PragmaCommentHandler to lib/Parse in preparation for calling Sema Summary: No functionality change. The existing tests for this pragma only verify that we can preprocess it. Reviewers: rsmith CC: cfe-commits Differential Revision: http://llvm-reviews.chandlerc.com/D751 llvm-svn: 181246
2013-05-07 05:02:12 +08:00
// FIXME: If the kind is "compiler" warn if the string is present (it is
// ignored).
Forward #pragma comment(lib/linker) through as flags metadata Summary: Most of this change is wiring the pragma all the way through from the lexer, parser, and sema to codegen. I considered adding a Decl AST node for this, but it seemed too heavyweight. Mach-O already uses a metadata flag called "Linker Options" to do this kind of auto-linking. This change follows that pattern. LLVM knows how to forward the "Linker Options" metadata into the COFF .drectve section where these flags belong. ELF support is not implemented, but possible. This is related to auto-linking, which is http://llvm.org/PR13016. CC: cfe-commits Differential Revision: http://llvm-reviews.chandlerc.com/D723 llvm-svn: 181426
2013-05-08 21:44:39 +08:00
// 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.
Move PragmaCommentHandler to lib/Parse in preparation for calling Sema Summary: No functionality change. The existing tests for this pragma only verify that we can preprocess it. Reviewers: rsmith CC: cfe-commits Differential Revision: http://llvm-reviews.chandlerc.com/D751 llvm-svn: 181246
2013-05-07 05:02:12 +08:00
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;
}
Revert the removal of PPCallbacks::PragmaComment() in r201821 The pp-trace clang tool was using it successfully. We can still delete the callbacks in Frontend/PrintPreprocessedOutput.cpp because they were effectively dead. llvm-svn: 201825
2014-02-21 07:37:45 +08:00
// If the pragma is lexically sound, notify any interested PPCallbacks.
if (PP.getPPCallbacks())
PP.getPPCallbacks()->PragmaComment(CommentLoc, II, ArgumentString);
Serialize `#pragma comment`. `#pragma comment` was handled by Sema calling a function on ASTConsumer, and CodeGen then implementing this function and writing things to its output. Instead, introduce a PragmaCommentDecl AST node and hang one off the TranslationUnitDecl for every `#pragma comment` line, and then use the regular serialization machinery. (Since PragmaCommentDecl has codegen relevance, it's eagerly deserialized.) http://reviews.llvm.org/D17799 llvm-svn: 262493
2016-03-03 01:28:48 +08:00
Actions.ActOnPragmaMSComment(CommentLoc, Kind, ArgumentString);
Move PragmaCommentHandler to lib/Parse in preparation for calling Sema Summary: No functionality change. The existing tests for this pragma only verify that we can preprocess it. Reviewers: rsmith CC: cfe-commits Differential Revision: http://llvm-reviews.chandlerc.com/D751 llvm-svn: 181246
2013-05-07 05:02:12 +08:00
}
Implemented support for "pragma clang optimize on/off", based on attribute 'optnone'. This patch implements support for selectively disabling optimizations on a range of function definitions through a pragma. The implementation is that all function definitions in the range are decorated with attribute 'optnone'. #pragma clang optimize off // All function definitions in here are decorated with 'optnone'. #pragma clang optimize on // Compilation resumes as normal. llvm-svn: 209510
2014-05-23 20:13:25 +08:00
// #pragma clang optimize off
// #pragma clang optimize on
void PragmaOptimizeHandler::HandlePragma(Preprocessor &PP,
PragmaIntroducerKind Introducer,
Token &FirstToken) {
Token Tok;
PP.Lex(Tok);
if (Tok.is(tok::eod)) {
Add support for '#pragma unroll'. llvm-svn: 213574
2014-07-22 02:08:34 +08:00
PP.Diag(Tok.getLocation(), diag::err_pragma_missing_argument)
In unroll pragma syntax and loop hint metadata, change "enable" forms to a new form using the string "full". llvm-svn: 213771
2014-07-24 01:31:31 +08:00
<< "clang optimize" << /*Expected=*/true << "'on' or 'off'";
Implemented support for "pragma clang optimize on/off", based on attribute 'optnone'. This patch implements support for selectively disabling optimizations on a range of function definitions through a pragma. The implementation is that all function definitions in the range are decorated with attribute 'optnone'. #pragma clang optimize off // All function definitions in here are decorated with 'optnone'. #pragma clang optimize on // Compilation resumes as normal. llvm-svn: 209510
2014-05-23 20:13:25 +08:00
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;
}
Fix DOS-style newlines. A previous patch r210330 (and possibly another) introduced DOS-style newlines into a UNIX newline formatted file. Patch by Mark Heffernan (http://reviews.llvm.org/D4046) llvm-svn: 210369
2014-06-07 04:31:48 +08:00
Actions.ActOnPragmaOptimize(IsOn, FirstToken.getLocation());
}
Add support for '#pragma unroll'. llvm-svn: 213574
2014-07-22 02:08:34 +08:00
/// \brief Parses loop or unroll pragma hint value and fills in Info.
Add a state variable to the loop hint attribute. This patch is necessary to support constant expressions which replaces the integer value in the loop hint attribute with an expression. The integer value was also storing the pragma’s state for options like vectorize(enable/disable) and the pragma unroll and nounroll directive. The state variable is introduced to hold the state of those options/pragmas. This moves the validation of the state (keywords) from SemaStmtAttr handler to the loop hint annotation token handler. Resubmit with changes to try to fix the build-bot issue. Reviewed by Aaron Ballman llvm-svn: 214432
2014-08-01 04:15:14 +08:00
static bool ParseLoopHintValue(Preprocessor &PP, Token &Tok, Token PragmaName,
Token Option, bool ValueInParens,
Add support for '#pragma unroll'. llvm-svn: 213574
2014-07-22 02:08:34 +08:00
PragmaLoopHintInfo &Info) {
Allow constant expressions in pragma loop hints. Previously loop hints such as #pragma loop vectorize_width(#) required a constant. This patch allows a constant expression to be used as well. Such as a non-type template parameter or an expression (2 * c + 1). Reviewed by Richard Smith llvm-svn: 219589
2014-10-13 04:46:07 +08:00
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;
Add support for '#pragma unroll'. llvm-svn: 213574
2014-07-22 02:08:34 +08:00
}
Allow constant expressions in pragma loop hints. Previously loop hints such as #pragma loop vectorize_width(#) required a constant. This patch allows a constant expression to be used as well. Such as a non-type template parameter or an expression (2 * c + 1). Reviewed by Richard Smith llvm-svn: 219589
2014-10-13 04:46:07 +08:00
ValueList.push_back(Tok);
PP.Lex(Tok);
}
Add support for '#pragma unroll'. llvm-svn: 213574
2014-07-22 02:08:34 +08:00
if (ValueInParens) {
Add a state variable to the loop hint attribute. This patch is necessary to support constant expressions which replaces the integer value in the loop hint attribute with an expression. The integer value was also storing the pragma’s state for options like vectorize(enable/disable) and the pragma unroll and nounroll directive. The state variable is introduced to hold the state of those options/pragmas. This moves the validation of the state (keywords) from SemaStmtAttr handler to the loop hint annotation token handler. Resubmit with changes to try to fix the build-bot issue. Reviewed by Aaron Ballman llvm-svn: 214432
2014-08-01 04:15:14 +08:00
// Read ')'
Add support for '#pragma unroll'. llvm-svn: 213574
2014-07-22 02:08:34 +08:00
if (Tok.isNot(tok::r_paren)) {
PP.Diag(Tok.getLocation(), diag::err_expected) << tok::r_paren;
return true;
}
Add a state variable to the loop hint attribute. This patch is necessary to support constant expressions which replaces the integer value in the loop hint attribute with an expression. The integer value was also storing the pragma’s state for options like vectorize(enable/disable) and the pragma unroll and nounroll directive. The state variable is introduced to hold the state of those options/pragmas. This moves the validation of the state (keywords) from SemaStmtAttr handler to the loop hint annotation token handler. Resubmit with changes to try to fix the build-bot issue. Reviewed by Aaron Ballman llvm-svn: 214432
2014-08-01 04:15:14 +08:00
PP.Lex(Tok);
Add support for '#pragma unroll'. llvm-svn: 213574
2014-07-22 02:08:34 +08:00
}
Allow constant expressions in pragma loop hints. Previously loop hints such as #pragma loop vectorize_width(#) required a constant. This patch allows a constant expression to be used as well. Such as a non-type template parameter or an expression (2 * c + 1). Reviewed by Richard Smith llvm-svn: 219589
2014-10-13 04:46:07 +08:00
Token EOFTok;
EOFTok.startToken();
EOFTok.setKind(tok::eof);
EOFTok.setLocation(Tok.getLocation());
ValueList.push_back(EOFTok); // Terminates expression for parsing.
[Parse] ArrayRefize PragmaLoopHintInfo. No functionality change. llvm-svn: 244024
2015-08-05 17:39:57 +08:00
Info.Toks = llvm::makeArrayRef(ValueList).copy(PP.getPreprocessorAllocator());
Allow constant expressions in pragma loop hints. Previously loop hints such as #pragma loop vectorize_width(#) required a constant. This patch allows a constant expression to be used as well. Such as a non-type template parameter or an expression (2 * c + 1). Reviewed by Richard Smith llvm-svn: 219589
2014-10-13 04:46:07 +08:00
Add support for '#pragma unroll'. llvm-svn: 213574
2014-07-22 02:08:34 +08:00
Info.PragmaName = PragmaName;
Info.Option = Option;
return false;
}
Fix DOS-style newlines. A previous patch r210330 (and possibly another) introduced DOS-style newlines into a UNIX newline formatted file. Patch by Mark Heffernan (http://reviews.llvm.org/D4046) llvm-svn: 210369
2014-06-07 04:31:48 +08:00
/// \brief Handle the \#pragma clang loop directive.
/// #pragma clang 'loop' loop-hints
///
/// loop-hints:
/// loop-hint loop-hints[opt]
///
/// loop-hint:
/// 'vectorize' '(' loop-hint-keyword ')'
/// 'interleave' '(' loop-hint-keyword ')'
In unroll pragma syntax and loop hint metadata, change "enable" forms to a new form using the string "full". llvm-svn: 213771
2014-07-24 01:31:31 +08:00
/// 'unroll' '(' unroll-hint-keyword ')'
Fix DOS-style newlines. A previous patch r210330 (and possibly another) introduced DOS-style newlines into a UNIX newline formatted file. Patch by Mark Heffernan (http://reviews.llvm.org/D4046) llvm-svn: 210369
2014-06-07 04:31:48 +08:00
/// 'vectorize_width' '(' loop-hint-value ')'
/// 'interleave_count' '(' loop-hint-value ')'
Add loop unroll pragma support http://reviews.llvm.org/D4089 Patch by Mark Heffernan. llvm-svn: 210667
2014-06-12 01:56:26 +08:00
/// 'unroll_count' '(' loop-hint-value ')'
Fix DOS-style newlines. A previous patch r210330 (and possibly another) introduced DOS-style newlines into a UNIX newline formatted file. Patch by Mark Heffernan (http://reviews.llvm.org/D4046) llvm-svn: 210369
2014-06-07 04:31:48 +08:00
///
/// loop-hint-keyword:
/// 'enable'
/// 'disable'
Add assume_safety option for pragma loop vectorize and interleave. Specifying #pragma clang loop vectorize(assume_safety) on a loop adds the mem.parallel_loop_access metadata to each load/store operation in the loop. This metadata tells loop access analysis (LAA) to skip memory dependency checking. llvm-svn: 239572
2015-06-12 07:23:17 +08:00
/// 'assume_safety'
Fix DOS-style newlines. A previous patch r210330 (and possibly another) introduced DOS-style newlines into a UNIX newline formatted file. Patch by Mark Heffernan (http://reviews.llvm.org/D4046) llvm-svn: 210369
2014-06-07 04:31:48 +08:00
///
In unroll pragma syntax and loop hint metadata, change "enable" forms to a new form using the string "full". llvm-svn: 213771
2014-07-24 01:31:31 +08:00
/// unroll-hint-keyword:
Add new llvm.loop.unroll.enable metadata for use with "#pragma unroll". This change adds the new unroll metadata "llvm.loop.unroll.enable" which directs the optimizer to unroll a loop fully if the trip count is known at compile time, and unroll partially if the trip count is not known at compile time. This differs from "llvm.loop.unroll.full" which explicitly does not unroll a loop if the trip count is not known at compile time With this change "#pragma unroll" generates "llvm.loop.unroll.enable" rather than "llvm.loop.unroll.full" metadata. This changes the semantics of "#pragma unroll" slightly to mean "unroll aggressively (fully or partially)" rather than "unroll fully or not at all". The motivating example for this change was some internal code with a loop marked with "#pragma unroll" which only sometimes had a compile-time trip count depending on template magic. When the trip count was a compile-time constant, everything works as expected and the loop is fully unrolled. However, when the trip count was not a compile-time constant the "#pragma unroll" explicitly disabled unrolling of the loop(!). Removing "#pragma unroll" caused the loop to be unrolled partially which was desirable from a performance perspective. llvm-svn: 244467
2015-08-11 01:29:39 +08:00
/// 'enable'
In unroll pragma syntax and loop hint metadata, change "enable" forms to a new form using the string "full". llvm-svn: 213771
2014-07-24 01:31:31 +08:00
/// 'disable'
Add new llvm.loop.unroll.enable metadata for use with "#pragma unroll". This change adds the new unroll metadata "llvm.loop.unroll.enable" which directs the optimizer to unroll a loop fully if the trip count is known at compile time, and unroll partially if the trip count is not known at compile time. This differs from "llvm.loop.unroll.full" which explicitly does not unroll a loop if the trip count is not known at compile time With this change "#pragma unroll" generates "llvm.loop.unroll.enable" rather than "llvm.loop.unroll.full" metadata. This changes the semantics of "#pragma unroll" slightly to mean "unroll aggressively (fully or partially)" rather than "unroll fully or not at all". The motivating example for this change was some internal code with a loop marked with "#pragma unroll" which only sometimes had a compile-time trip count depending on template magic. When the trip count was a compile-time constant, everything works as expected and the loop is fully unrolled. However, when the trip count was not a compile-time constant the "#pragma unroll" explicitly disabled unrolling of the loop(!). Removing "#pragma unroll" caused the loop to be unrolled partially which was desirable from a performance perspective. llvm-svn: 244467
2015-08-11 01:29:39 +08:00
/// 'full'
In unroll pragma syntax and loop hint metadata, change "enable" forms to a new form using the string "full". llvm-svn: 213771
2014-07-24 01:31:31 +08:00
///
Fix DOS-style newlines. A previous patch r210330 (and possibly another) introduced DOS-style newlines into a UNIX newline formatted file. Patch by Mark Heffernan (http://reviews.llvm.org/D4046) llvm-svn: 210369
2014-06-07 04:31:48 +08:00
/// loop-hint-value:
/// constant-expression
///
/// Specifying vectorize(enable) or vectorize_width(_value_) instructs llvm to
/// try vectorizing the instructions of the loop it precedes. Specifying
/// interleave(enable) or interleave_count(_value_) instructs llvm to try
/// interleaving multiple iterations of the loop it precedes. The width of the
/// vector instructions is specified by vectorize_width() and the number of
/// interleaved loop iterations is specified by interleave_count(). Specifying a
/// value of 1 effectively disables vectorization/interleaving, even if it is
/// possible and profitable, and 0 is invalid. The loop vectorizer currently
/// only works on inner loops.
///
Add loop unroll pragma support http://reviews.llvm.org/D4089 Patch by Mark Heffernan. llvm-svn: 210667
2014-06-12 01:56:26 +08:00
/// The unroll and unroll_count directives control the concatenation
Add new llvm.loop.unroll.enable metadata for use with "#pragma unroll". This change adds the new unroll metadata "llvm.loop.unroll.enable" which directs the optimizer to unroll a loop fully if the trip count is known at compile time, and unroll partially if the trip count is not known at compile time. This differs from "llvm.loop.unroll.full" which explicitly does not unroll a loop if the trip count is not known at compile time With this change "#pragma unroll" generates "llvm.loop.unroll.enable" rather than "llvm.loop.unroll.full" metadata. This changes the semantics of "#pragma unroll" slightly to mean "unroll aggressively (fully or partially)" rather than "unroll fully or not at all". The motivating example for this change was some internal code with a loop marked with "#pragma unroll" which only sometimes had a compile-time trip count depending on template magic. When the trip count was a compile-time constant, everything works as expected and the loop is fully unrolled. However, when the trip count was not a compile-time constant the "#pragma unroll" explicitly disabled unrolling of the loop(!). Removing "#pragma unroll" caused the loop to be unrolled partially which was desirable from a performance perspective. llvm-svn: 244467
2015-08-11 01:29:39 +08:00
/// unroller. Specifying unroll(enable) instructs llvm to unroll the loop
/// completely if the trip count is known at compile time and unroll partially
/// if the trip count is not known. Specifying unroll(full) is similar to
/// unroll(enable) but will unroll the loop only if the trip count is known at
/// compile time. Specifying unroll(disable) disables unrolling for the
/// loop. Specifying unroll_count(_value_) instructs llvm to try to unroll the
/// loop the number of times indicated by the value.
Fix DOS-style newlines. A previous patch r210330 (and possibly another) introduced DOS-style newlines into a UNIX newline formatted file. Patch by Mark Heffernan (http://reviews.llvm.org/D4046) llvm-svn: 210369
2014-06-07 04:31:48 +08:00
void PragmaLoopHintHandler::HandlePragma(Preprocessor &PP,
PragmaIntroducerKind Introducer,
Token &Tok) {
Add support for '#pragma unroll'. llvm-svn: 213574
2014-07-22 02:08:34 +08:00
// Incoming token is "loop" from "#pragma clang loop".
Token PragmaName = Tok;
Fix DOS-style newlines. A previous patch r210330 (and possibly another) introduced DOS-style newlines into a UNIX newline formatted file. Patch by Mark Heffernan (http://reviews.llvm.org/D4046) llvm-svn: 210369
2014-06-07 04:31:48 +08:00
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();
Add loop unroll pragma support http://reviews.llvm.org/D4089 Patch by Mark Heffernan. llvm-svn: 210667
2014-06-12 01:56:26 +08:00
bool OptionValid = llvm::StringSwitch<bool>(OptionInfo->getName())
Add support for '#pragma unroll'. llvm-svn: 213574
2014-07-22 02:08:34 +08:00
.Case("vectorize", true)
.Case("interleave", true)
.Case("unroll", true)
Add loop pragma for Loop Distribution Summary: This is similar to other loop pragmas like 'vectorize'. Currently it only has state values: distribute(enable) and distribute(disable). When one of these is specified the corresponding loop metadata is generated: !{!"llvm.loop.distribute.enable", i1 true/false} As a result, loop distribution will be attempted on the loop even if Loop Distribution in not enabled globally. Analogously, with 'disable' distribution can be turned off for an individual loop even when the pass is otherwise enabled. There are some slight differences compared to the existing loop pragmas. 1. There is no 'assume_safety' variant which makes its handling slightly different from 'vectorize'/'interleave'. 2. Unlike the existing loop pragmas, it does not have a corresponding numeric pragma like 'vectorize' -> 'vectorize_width'. So for the consistency checks in CheckForIncompatibleAttributes we don't need to check it against other pragmas. We just need to check for duplicates of the same pragma. Reviewers: rsmith, dexonsmith, aaron.ballman Subscribers: bob.wilson, cfe-commits, hfinkel Differential Revision: http://reviews.llvm.org/D19403 llvm-svn: 272656
2016-06-14 20:04:26 +08:00
.Case("distribute", true)
Add support for '#pragma unroll'. llvm-svn: 213574
2014-07-22 02:08:34 +08:00
.Case("vectorize_width", true)
.Case("interleave_count", true)
.Case("unroll_count", true)
.Default(false);
Add loop unroll pragma support http://reviews.llvm.org/D4089 Patch by Mark Heffernan. llvm-svn: 210667
2014-06-12 01:56:26 +08:00
if (!OptionValid) {
Fix DOS-style newlines. A previous patch r210330 (and possibly another) introduced DOS-style newlines into a UNIX newline formatted file. Patch by Mark Heffernan (http://reviews.llvm.org/D4046) llvm-svn: 210369
2014-06-07 04:31:48 +08:00
PP.Diag(Tok.getLocation(), diag::err_pragma_loop_invalid_option)
<< /*MissingOption=*/false << OptionInfo;
return;
}
Add a state variable to the loop hint attribute. This patch is necessary to support constant expressions which replaces the integer value in the loop hint attribute with an expression. The integer value was also storing the pragma’s state for options like vectorize(enable/disable) and the pragma unroll and nounroll directive. The state variable is introduced to hold the state of those options/pragmas. This moves the validation of the state (keywords) from SemaStmtAttr handler to the loop hint annotation token handler. Reviewed by Aaron Ballman llvm-svn: 214333
2014-07-31 04:54:33 +08:00
PP.Lex(Tok);
Add a state variable to the loop hint attribute. This patch is necessary to support constant expressions which replaces the integer value in the loop hint attribute with an expression. The integer value was also storing the pragma’s state for options like vectorize(enable/disable) and the pragma unroll and nounroll directive. The state variable is introduced to hold the state of those options/pragmas. This moves the validation of the state (keywords) from SemaStmtAttr handler to the loop hint annotation token handler. Resubmit with changes to try to fix the build-bot issue. Reviewed by Aaron Ballman llvm-svn: 214432
2014-08-01 04:15:14 +08:00
// Read '('
if (Tok.isNot(tok::l_paren)) {
PP.Diag(Tok.getLocation(), diag::err_expected) << tok::l_paren;
Add a state variable to the loop hint attribute. This patch is necessary to support constant expressions which replaces the integer value in the loop hint attribute with an expression. The integer value was also storing the pragma’s state for options like vectorize(enable/disable) and the pragma unroll and nounroll directive. The state variable is introduced to hold the state of those options/pragmas. This moves the validation of the state (keywords) from SemaStmtAttr handler to the loop hint annotation token handler. Reviewed by Aaron Ballman llvm-svn: 214333
2014-07-31 04:54:33 +08:00
return;
Revert r214333, "Add a state variable to the loop hint attribute." It brought undefined behavior. llvm-svn: 214376
2014-07-31 09:52:33 +08:00
}
Add a state variable to the loop hint attribute. This patch is necessary to support constant expressions which replaces the integer value in the loop hint attribute with an expression. The integer value was also storing the pragma’s state for options like vectorize(enable/disable) and the pragma unroll and nounroll directive. The state variable is introduced to hold the state of those options/pragmas. This moves the validation of the state (keywords) from SemaStmtAttr handler to the loop hint annotation token handler. Resubmit with changes to try to fix the build-bot issue. Reviewed by Aaron Ballman llvm-svn: 214432
2014-08-01 04:15:14 +08:00
PP.Lex(Tok);
auto *Info = new (PP.getPreprocessorAllocator()) PragmaLoopHintInfo;
if (ParseLoopHintValue(PP, Tok, PragmaName, Option, /*ValueInParens=*/true,
*Info))
return;
Fix DOS-style newlines. A previous patch r210330 (and possibly another) introduced DOS-style newlines into a UNIX newline formatted file. Patch by Mark Heffernan (http://reviews.llvm.org/D4046) llvm-svn: 210369
2014-06-07 04:31:48 +08:00
Add support for '#pragma unroll'. llvm-svn: 213574
2014-07-22 02:08:34 +08:00
// Generate the loop hint token.
Fix DOS-style newlines. A previous patch r210330 (and possibly another) introduced DOS-style newlines into a UNIX newline formatted file. Patch by Mark Heffernan (http://reviews.llvm.org/D4046) llvm-svn: 210369
2014-06-07 04:31:48 +08:00
Token LoopHintTok;
LoopHintTok.startToken();
LoopHintTok.setKind(tok::annot_pragma_loop_hint);
Add support for '#pragma unroll'. llvm-svn: 213574
2014-07-22 02:08:34 +08:00
LoopHintTok.setLocation(PragmaName.getLocation());
Parse: Don't assume tokens have a length Don't crash if the last token in a bad inline method body is an annotation token. llvm-svn: 232694
2015-03-19 08:10:23 +08:00
LoopHintTok.setAnnotationEndLoc(PragmaName.getLocation());
Fix DOS-style newlines. A previous patch r210330 (and possibly another) introduced DOS-style newlines into a UNIX newline formatted file. Patch by Mark Heffernan (http://reviews.llvm.org/D4046) llvm-svn: 210369
2014-06-07 04:31:48 +08:00
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;
}
Simplify EnterTokenStream API to make it more robust for memory management While this won't help fix things like the bug that r260219 addressed, it seems like good tidy up to have anyway. (it might be nice if "makeArrayRef" always produced a MutableArrayRef & let it decay to an ArrayRef when needed - then I'd use that for the MutableArrayRefs in this patch) If we had std::dynarray I'd use that instead of unique_ptr+size_t, ideally (but then it'd have to be threaded down through the Preprocessor all the way - no idea how painful that would be) llvm-svn: 260246
2016-02-10 02:52:09 +08:00
auto TokenArray = llvm::make_unique<Token[]>(TokenList.size());
std::copy(TokenList.begin(), TokenList.end(), TokenArray.get());
Fix DOS-style newlines. A previous patch r210330 (and possibly another) introduced DOS-style newlines into a UNIX newline formatted file. Patch by Mark Heffernan (http://reviews.llvm.org/D4046) llvm-svn: 210369
2014-06-07 04:31:48 +08:00
Simplify EnterTokenStream API to make it more robust for memory management While this won't help fix things like the bug that r260219 addressed, it seems like good tidy up to have anyway. (it might be nice if "makeArrayRef" always produced a MutableArrayRef & let it decay to an ArrayRef when needed - then I'd use that for the MutableArrayRefs in this patch) If we had std::dynarray I'd use that instead of unique_ptr+size_t, ideally (but then it'd have to be threaded down through the Preprocessor all the way - no idea how painful that would be) llvm-svn: 260246
2016-02-10 02:52:09 +08:00
PP.EnterTokenStream(std::move(TokenArray), TokenList.size(),
/*DisableMacroExpansion=*/false);
Fix DOS-style newlines. A previous patch r210330 (and possibly another) introduced DOS-style newlines into a UNIX newline formatted file. Patch by Mark Heffernan (http://reviews.llvm.org/D4046) llvm-svn: 210369
2014-06-07 04:31:48 +08:00
}
Add support for '#pragma unroll'. llvm-svn: 213574
2014-07-22 02:08:34 +08:00
/// \brief Handle the loop unroll optimization pragmas.
/// #pragma unroll
/// #pragma unroll unroll-hint-value
/// #pragma unroll '(' unroll-hint-value ')'
Add support for #pragma nounroll. llvm-svn: 213885
2014-07-25 02:09:38 +08:00
/// #pragma nounroll
Add support for '#pragma unroll'. llvm-svn: 213574
2014-07-22 02:08:34 +08:00
///
/// unroll-hint-value:
/// constant-expression
///
Add support for #pragma nounroll. llvm-svn: 213885
2014-07-25 02:09:38 +08:00
/// Loop unrolling hints can be specified with '#pragma unroll' or
/// '#pragma nounroll'. '#pragma unroll' can take a numeric argument optionally
/// contained in parentheses. With no argument the directive instructs llvm to
/// try to unroll the loop completely. A positive integer argument can be
/// specified to indicate the number of times the loop should be unrolled. To
/// maximize compatibility with other compilers the unroll count argument can be
/// specified with or without parentheses. Specifying, '#pragma nounroll'
/// disables unrolling of the loop.
Add support for '#pragma unroll'. llvm-svn: 213574
2014-07-22 02:08:34 +08:00
void PragmaUnrollHintHandler::HandlePragma(Preprocessor &PP,
PragmaIntroducerKind Introducer,
Token &Tok) {
Add support for #pragma nounroll. llvm-svn: 213885
2014-07-25 02:09:38 +08:00
// Incoming token is "unroll" for "#pragma unroll", or "nounroll" for
// "#pragma nounroll".
Add support for '#pragma unroll'. llvm-svn: 213574
2014-07-22 02:08:34 +08:00
Token PragmaName = Tok;
PP.Lex(Tok);
auto *Info = new (PP.getPreprocessorAllocator()) PragmaLoopHintInfo;
if (Tok.is(tok::eod)) {
Add support for #pragma nounroll. llvm-svn: 213885
2014-07-25 02:09:38 +08:00
// nounroll or unroll pragma without an argument.
Add support for '#pragma unroll'. llvm-svn: 213574
2014-07-22 02:08:34 +08:00
Info->PragmaName = PragmaName;
Initializing the loop hint option token again. llvm-svn: 214504
2014-08-01 20:41:37 +08:00
Info->Option.startToken();
Add support for #pragma nounroll. llvm-svn: 213885
2014-07-25 02:09:38 +08:00
} else if (PragmaName.getIdentifierInfo()->getName() == "nounroll") {
PP.Diag(Tok.getLocation(), diag::warn_pragma_extra_tokens_at_eol)
<< "nounroll";
return;
Add support for '#pragma unroll'. llvm-svn: 213574
2014-07-22 02:08:34 +08:00
} else {
// Unroll pragma with an argument: "#pragma unroll N" or
// "#pragma unroll(N)".
Add a state variable to the loop hint attribute. This patch is necessary to support constant expressions which replaces the integer value in the loop hint attribute with an expression. The integer value was also storing the pragma’s state for options like vectorize(enable/disable) and the pragma unroll and nounroll directive. The state variable is introduced to hold the state of those options/pragmas. This moves the validation of the state (keywords) from SemaStmtAttr handler to the loop hint annotation token handler. Resubmit with changes to try to fix the build-bot issue. Reviewed by Aaron Ballman llvm-svn: 214432
2014-08-01 04:15:14 +08:00
// Read '(' if it exists.
bool ValueInParens = Tok.is(tok::l_paren);
if (ValueInParens)
PP.Lex(Tok);
Initializing the loop hint option token. llvm-svn: 214502
2014-08-01 20:20:20 +08:00
Token Option;
Option.startToken();
if (ParseLoopHintValue(PP, Tok, PragmaName, Option, ValueInParens, *Info))
Add support for '#pragma unroll'. llvm-svn: 213574
2014-07-22 02:08:34 +08:00
return;
// In CUDA, the argument to '#pragma unroll' should not be contained in
// parentheses.
if (PP.getLangOpts().CUDA && ValueInParens)
Allow constant expressions in pragma loop hints. Previously loop hints such as #pragma loop vectorize_width(#) required a constant. This patch allows a constant expression to be used as well. Such as a non-type template parameter or an expression (2 * c + 1). Reviewed by Richard Smith llvm-svn: 219589
2014-10-13 04:46:07 +08:00
PP.Diag(Info->Toks[0].getLocation(),
Add support for '#pragma unroll'. llvm-svn: 213574
2014-07-22 02:08:34 +08:00
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.
Simplify EnterTokenStream API to make it more robust for memory management While this won't help fix things like the bug that r260219 addressed, it seems like good tidy up to have anyway. (it might be nice if "makeArrayRef" always produced a MutableArrayRef & let it decay to an ArrayRef when needed - then I'd use that for the MutableArrayRefs in this patch) If we had std::dynarray I'd use that instead of unique_ptr+size_t, ideally (but then it'd have to be threaded down through the Preprocessor all the way - no idea how painful that would be) llvm-svn: 260246
2016-02-10 02:52:09 +08:00
auto TokenArray = llvm::make_unique<Token[]>(1);
Add support for '#pragma unroll'. llvm-svn: 213574
2014-07-22 02:08:34 +08:00
TokenArray[0].startToken();
TokenArray[0].setKind(tok::annot_pragma_loop_hint);
TokenArray[0].setLocation(PragmaName.getLocation());
Parse: Don't assume tokens have a length Don't crash if the last token in a bad inline method body is an annotation token. llvm-svn: 232694
2015-03-19 08:10:23 +08:00
TokenArray[0].setAnnotationEndLoc(PragmaName.getLocation());
Add support for '#pragma unroll'. llvm-svn: 213574
2014-07-22 02:08:34 +08:00
TokenArray[0].setAnnotationValue(static_cast<void *>(Info));
Simplify EnterTokenStream API to make it more robust for memory management While this won't help fix things like the bug that r260219 addressed, it seems like good tidy up to have anyway. (it might be nice if "makeArrayRef" always produced a MutableArrayRef & let it decay to an ArrayRef when needed - then I'd use that for the MutableArrayRefs in this patch) If we had std::dynarray I'd use that instead of unique_ptr+size_t, ideally (but then it'd have to be threaded down through the Preprocessor all the way - no idea how painful that would be) llvm-svn: 260246
2016-02-10 02:52:09 +08:00
PP.EnterTokenStream(std::move(TokenArray), 1,
/*DisableMacroExpansion=*/false);
Add support for '#pragma unroll'. llvm-svn: 213574
2014-07-22 02:08:34 +08:00
}
Parsing MS pragma intrinsic Parse pragma intrinsic, display warning if the function isn't a builtin function in clang and suggest including intrin.h. Patch by Albert Gutowski! Reviewers: aaron.ballman, rnk Subscribers: aaron.ballman, cfe-commits Differential Revision: https://reviews.llvm.org/D23944 llvm-svn: 280825
2016-09-08 00:38:32 +08:00
/// \brief Handle the Microsoft \#pragma intrinsic extension.
///
/// The syntax is:
/// \code
/// #pragma intrinsic(memset)
/// #pragma intrinsic(strlen, memcpy)
/// \endcode
///
/// Pragma intrisic tells the compiler to use a builtin version of the
/// function. Clang does it anyway, so the pragma doesn't really do anything.
/// Anyway, we emit a warning if the function specified in \#pragma intrinsic
/// isn't an intrinsic in clang and suggest to include intrin.h.
void 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";
}
[CUDA] Add #pragma clang force_cuda_host_device_{begin,end} pragmas. Summary: These cause us to consider all functions in-between to be __host__ __device__. You can nest these pragmas; you just can't have more 'end's than 'begin's. Reviewers: rsmith Subscribers: tra, jhen, cfe-commits Differential Revision: https://reviews.llvm.org/D24975 llvm-svn: 283677
2016-10-09 06:15:58 +08:00
void 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);
}