blob: 94812fc93de97ef543e85bfa5e85fcc223e2991c [file] [log] [blame]
Argyrios Kyrtzidis2edbc862012-11-01 17:52:58 +00001//===- unittests/Lex/PPCallbacksTest.cpp - PPCallbacks tests ------===//
2//
3// The LLVM Compiler Infrastructure
4//
5// This file is distributed under the University of Illinois Open Source
6// License. See LICENSE.TXT for details.
7//
8//===--------------------------------------------------------------===//
9
Chandler Carruth320d9662012-12-04 09:45:34 +000010#include "clang/Lex/Preprocessor.h"
Chandler Carruth5553d0d2014-01-07 11:51:46 +000011#include "clang/AST/ASTConsumer.h"
12#include "clang/AST/ASTContext.h"
Argyrios Kyrtzidis2edbc862012-11-01 17:52:58 +000013#include "clang/Basic/Diagnostic.h"
Benjamin Kramerf3ca26982014-05-10 16:31:55 +000014#include "clang/Basic/DiagnosticOptions.h"
Argyrios Kyrtzidis2edbc862012-11-01 17:52:58 +000015#include "clang/Basic/FileManager.h"
16#include "clang/Basic/LangOptions.h"
17#include "clang/Basic/SourceManager.h"
18#include "clang/Basic/TargetInfo.h"
19#include "clang/Basic/TargetOptions.h"
20#include "clang/Lex/HeaderSearch.h"
21#include "clang/Lex/HeaderSearchOptions.h"
22#include "clang/Lex/ModuleLoader.h"
Argyrios Kyrtzidis2edbc862012-11-01 17:52:58 +000023#include "clang/Lex/PreprocessorOptions.h"
Pekka Jaaskelainen1db1da22013-10-12 09:29:48 +000024#include "clang/Parse/Parser.h"
25#include "clang/Sema/Sema.h"
Argyrios Kyrtzidis2edbc862012-11-01 17:52:58 +000026#include "llvm/ADT/SmallString.h"
Rafael Espindola552c1692013-06-11 22:15:02 +000027#include "llvm/Support/Path.h"
Argyrios Kyrtzidis2edbc862012-11-01 17:52:58 +000028#include "gtest/gtest.h"
29
Argyrios Kyrtzidis2edbc862012-11-01 17:52:58 +000030using namespace clang;
31
32namespace {
33
34// Stub out module loading.
35class VoidModuleLoader : public ModuleLoader {
John Thompson2d94bbb2014-04-23 19:04:32 +000036 ModuleLoadResult loadModule(SourceLocation ImportLoc,
37 ModuleIdPath Path,
38 Module::NameVisibilityKind Visibility,
39 bool IsInclusionDirective) override {
Douglas Gregor8c058932012-11-30 00:01:57 +000040 return ModuleLoadResult();
Argyrios Kyrtzidis2edbc862012-11-01 17:52:58 +000041 }
NAKAMURA Takumie73d2a92013-01-12 02:16:29 +000042
John Thompson2d94bbb2014-04-23 19:04:32 +000043 void makeModuleVisible(Module *Mod,
44 Module::NameVisibilityKind Visibility,
Richard Smitha7e2cc62015-05-01 01:53:09 +000045 SourceLocation ImportLoc) override { }
John Thompson2255f2c2014-04-23 12:57:01 +000046
John Thompson2d94bbb2014-04-23 19:04:32 +000047 GlobalModuleIndex *loadGlobalModuleIndex(SourceLocation TriggerLoc) override
Craig Topper416fa342014-06-08 08:38:12 +000048 { return nullptr; }
John Thompson2d94bbb2014-04-23 19:04:32 +000049 bool lookupMissingImports(StringRef Name, SourceLocation TriggerLoc) override
50 { return 0; };
Argyrios Kyrtzidis2edbc862012-11-01 17:52:58 +000051};
52
53// Stub to collect data from InclusionDirective callbacks.
54class InclusionDirectiveCallbacks : public PPCallbacks {
55public:
Alexander Kornienko34eb2072015-04-11 02:00:23 +000056 void InclusionDirective(SourceLocation HashLoc, const Token &IncludeTok,
57 StringRef FileName, bool IsAngled,
58 CharSourceRange FilenameRange, const FileEntry *File,
59 StringRef SearchPath, StringRef RelativePath,
60 const Module *Imported) override {
Argyrios Kyrtzidis2edbc862012-11-01 17:52:58 +000061 this->HashLoc = HashLoc;
62 this->IncludeTok = IncludeTok;
63 this->FileName = FileName.str();
64 this->IsAngled = IsAngled;
65 this->FilenameRange = FilenameRange;
66 this->File = File;
67 this->SearchPath = SearchPath.str();
68 this->RelativePath = RelativePath.str();
69 this->Imported = Imported;
70 }
71
72 SourceLocation HashLoc;
73 Token IncludeTok;
74 SmallString<16> FileName;
75 bool IsAngled;
76 CharSourceRange FilenameRange;
77 const FileEntry* File;
78 SmallString<16> SearchPath;
79 SmallString<16> RelativePath;
80 const Module* Imported;
81};
82
Pekka Jaaskelainen1db1da22013-10-12 09:29:48 +000083// Stub to collect data from PragmaOpenCLExtension callbacks.
84class PragmaOpenCLExtensionCallbacks : public PPCallbacks {
85public:
86 typedef struct {
Alexey Samsonov05747f32013-10-14 07:13:59 +000087 SmallString<16> Name;
Pekka Jaaskelainen1db1da22013-10-12 09:29:48 +000088 unsigned State;
89 } CallbackParameters;
90
91 PragmaOpenCLExtensionCallbacks() : Name("Not called."), State(99) {};
92
Alexander Kornienko34eb2072015-04-11 02:00:23 +000093 void PragmaOpenCLExtension(clang::SourceLocation NameLoc,
94 const clang::IdentifierInfo *Name,
95 clang::SourceLocation StateLoc,
96 unsigned State) override {
Pekka Jaaskelainen1db1da22013-10-12 09:29:48 +000097 this->NameLoc = NameLoc;
Alexey Samsonov05747f32013-10-14 07:13:59 +000098 this->Name = Name->getName();
Pekka Jaaskelainen1db1da22013-10-12 09:29:48 +000099 this->StateLoc = StateLoc;
100 this->State = State;
101 };
102
103 SourceLocation NameLoc;
Alexey Samsonov05747f32013-10-14 07:13:59 +0000104 SmallString<16> Name;
Pekka Jaaskelainen1db1da22013-10-12 09:29:48 +0000105 SourceLocation StateLoc;
106 unsigned State;
107};
108
Argyrios Kyrtzidis2edbc862012-11-01 17:52:58 +0000109// PPCallbacks test fixture.
110class PPCallbacksTest : public ::testing::Test {
111protected:
112 PPCallbacksTest()
Alp Toker80758082014-07-06 05:26:44 +0000113 : FileMgr(FileMgrOpts), DiagID(new DiagnosticIDs()),
114 DiagOpts(new DiagnosticOptions()),
115 Diags(DiagID, DiagOpts.get(), new IgnoringDiagConsumer()),
116 SourceMgr(Diags, FileMgr), TargetOpts(new TargetOptions()) {
Argyrios Kyrtzidis2edbc862012-11-01 17:52:58 +0000117 TargetOpts->Triple = "x86_64-apple-darwin11.1.0";
Alp Toker80758082014-07-06 05:26:44 +0000118 Target = TargetInfo::CreateTargetInfo(Diags, TargetOpts);
Argyrios Kyrtzidis2edbc862012-11-01 17:52:58 +0000119 }
120
121 FileSystemOptions FileMgrOpts;
122 FileManager FileMgr;
123 IntrusiveRefCntPtr<DiagnosticIDs> DiagID;
124 IntrusiveRefCntPtr<DiagnosticOptions> DiagOpts;
125 DiagnosticsEngine Diags;
126 SourceManager SourceMgr;
127 LangOptions LangOpts;
Alp Toker80758082014-07-06 05:26:44 +0000128 std::shared_ptr<TargetOptions> TargetOpts;
Argyrios Kyrtzidis2edbc862012-11-01 17:52:58 +0000129 IntrusiveRefCntPtr<TargetInfo> Target;
130
131 // Register a header path as a known file and add its location
132 // to search path.
133 void AddFakeHeader(HeaderSearch& HeaderInfo, const char* HeaderPath,
134 bool IsSystemHeader) {
135 // Tell FileMgr about header.
136 FileMgr.getVirtualFile(HeaderPath, 0, 0);
137
138 // Add header's parent path to search path.
Alexey Samsonovd1127d22014-10-15 22:00:40 +0000139 StringRef SearchPath = llvm::sys::path::parent_path(HeaderPath);
Argyrios Kyrtzidis2edbc862012-11-01 17:52:58 +0000140 const DirectoryEntry *DE = FileMgr.getDirectory(SearchPath);
Daniel Dunbarae4feb62013-01-25 01:50:28 +0000141 DirectoryLookup DL(DE, SrcMgr::C_User, false);
Argyrios Kyrtzidis2edbc862012-11-01 17:52:58 +0000142 HeaderInfo.AddSearchPath(DL, IsSystemHeader);
143 }
144
145 // Get the raw source string of the range.
146 StringRef GetSourceString(CharSourceRange Range) {
147 const char* B = SourceMgr.getCharacterData(Range.getBegin());
148 const char* E = SourceMgr.getCharacterData(Range.getEnd());
149
150 return StringRef(B, E - B);
151 }
152
153 // Run lexer over SourceText and collect FilenameRange from
154 // the InclusionDirective callback.
155 CharSourceRange InclusionDirectiveFilenameRange(const char* SourceText,
156 const char* HeaderPath, bool SystemHeader) {
Alexey Samsonovd1127d22014-10-15 22:00:40 +0000157 std::unique_ptr<llvm::MemoryBuffer> Buf =
158 llvm::MemoryBuffer::getMemBuffer(SourceText);
David Blaikie50a5f972014-08-29 07:59:55 +0000159 SourceMgr.setMainFileID(SourceMgr.createFileID(std::move(Buf)));
Argyrios Kyrtzidis2edbc862012-11-01 17:52:58 +0000160
161 VoidModuleLoader ModLoader;
162
163 IntrusiveRefCntPtr<HeaderSearchOptions> HSOpts = new HeaderSearchOptions();
Manuel Klimek1f76c4e2013-10-24 07:51:24 +0000164 HeaderSearch HeaderInfo(HSOpts, SourceMgr, Diags, LangOpts,
Alp Tokerf994cef2014-07-05 03:08:06 +0000165 Target.get());
Argyrios Kyrtzidis2edbc862012-11-01 17:52:58 +0000166 AddFakeHeader(HeaderInfo, HeaderPath, SystemHeader);
167
168 IntrusiveRefCntPtr<PreprocessorOptions> PPOpts = new PreprocessorOptions();
Alp Toker96637802014-05-02 03:43:38 +0000169 Preprocessor PP(PPOpts, Diags, LangOpts, SourceMgr, HeaderInfo, ModLoader,
Craig Topper416fa342014-06-08 08:38:12 +0000170 /*IILookup =*/nullptr,
Alp Toker96637802014-05-02 03:43:38 +0000171 /*OwnsHeaderSearch =*/false);
Alp Toker1ae02f62014-05-02 03:43:30 +0000172 PP.Initialize(*Target);
Argyrios Kyrtzidis2edbc862012-11-01 17:52:58 +0000173 InclusionDirectiveCallbacks* Callbacks = new InclusionDirectiveCallbacks;
Craig Topperb8a70532014-09-10 04:53:53 +0000174 PP.addPPCallbacks(std::unique_ptr<PPCallbacks>(Callbacks));
Argyrios Kyrtzidis2edbc862012-11-01 17:52:58 +0000175
176 // Lex source text.
177 PP.EnterMainSourceFile();
178
179 while (true) {
180 Token Tok;
181 PP.Lex(Tok);
182 if (Tok.is(tok::eof))
183 break;
184 }
185
186 // Callbacks have been executed at this point -- return filename range.
187 return Callbacks->FilenameRange;
188 }
Pekka Jaaskelainen1db1da22013-10-12 09:29:48 +0000189
190 PragmaOpenCLExtensionCallbacks::CallbackParameters
191 PragmaOpenCLExtensionCall(const char* SourceText) {
192 LangOptions OpenCLLangOpts;
193 OpenCLLangOpts.OpenCL = 1;
194
Alexey Samsonovd1127d22014-10-15 22:00:40 +0000195 std::unique_ptr<llvm::MemoryBuffer> SourceBuf =
196 llvm::MemoryBuffer::getMemBuffer(SourceText, "test.cl");
David Blaikie50a5f972014-08-29 07:59:55 +0000197 SourceMgr.setMainFileID(SourceMgr.createFileID(std::move(SourceBuf)));
Pekka Jaaskelainen1db1da22013-10-12 09:29:48 +0000198
199 VoidModuleLoader ModLoader;
Manuel Klimek1f76c4e2013-10-24 07:51:24 +0000200 HeaderSearch HeaderInfo(new HeaderSearchOptions, SourceMgr, Diags,
Alp Tokerf994cef2014-07-05 03:08:06 +0000201 OpenCLLangOpts, Target.get());
Pekka Jaaskelainen1db1da22013-10-12 09:29:48 +0000202
Alp Toker96637802014-05-02 03:43:38 +0000203 Preprocessor PP(new PreprocessorOptions(), Diags, OpenCLLangOpts, SourceMgr,
Craig Topper416fa342014-06-08 08:38:12 +0000204 HeaderInfo, ModLoader, /*IILookup =*/nullptr,
Alp Toker1ae02f62014-05-02 03:43:30 +0000205 /*OwnsHeaderSearch =*/false);
206 PP.Initialize(*Target);
Pekka Jaaskelainen1db1da22013-10-12 09:29:48 +0000207
208 // parser actually sets correct pragma handlers for preprocessor
209 // according to LangOptions, so we init Parser to register opencl
210 // pragma handlers
Alp Toker08043432014-05-03 03:46:04 +0000211 ASTContext Context(OpenCLLangOpts, SourceMgr,
Pekka Jaaskelainen1db1da22013-10-12 09:29:48 +0000212 PP.getIdentifierTable(), PP.getSelectorTable(),
Alp Toker08043432014-05-03 03:46:04 +0000213 PP.getBuiltinInfo());
214 Context.InitBuiltinTypes(*Target);
215
Pekka Jaaskelainen1db1da22013-10-12 09:29:48 +0000216 ASTConsumer Consumer;
217 Sema S(PP, Context, Consumer);
218 Parser P(PP, S, false);
219 PragmaOpenCLExtensionCallbacks* Callbacks = new PragmaOpenCLExtensionCallbacks;
Craig Topperb8a70532014-09-10 04:53:53 +0000220 PP.addPPCallbacks(std::unique_ptr<PPCallbacks>(Callbacks));
Pekka Jaaskelainen1db1da22013-10-12 09:29:48 +0000221
222 // Lex source text.
223 PP.EnterMainSourceFile();
224 while (true) {
225 Token Tok;
226 PP.Lex(Tok);
227 if (Tok.is(tok::eof))
228 break;
229 }
230
231 PragmaOpenCLExtensionCallbacks::CallbackParameters RetVal = {
Alexey Samsonov05747f32013-10-14 07:13:59 +0000232 Callbacks->Name,
Pekka Jaaskelainen1db1da22013-10-12 09:29:48 +0000233 Callbacks->State
234 };
235 return RetVal;
236 }
Argyrios Kyrtzidis2edbc862012-11-01 17:52:58 +0000237};
238
239TEST_F(PPCallbacksTest, QuotedFilename) {
240 const char* Source =
241 "#include \"quoted.h\"\n";
242
243 CharSourceRange Range =
244 InclusionDirectiveFilenameRange(Source, "/quoted.h", false);
245
246 ASSERT_EQ("\"quoted.h\"", GetSourceString(Range));
247}
248
249TEST_F(PPCallbacksTest, AngledFilename) {
250 const char* Source =
251 "#include <angled.h>\n";
252
253 CharSourceRange Range =
254 InclusionDirectiveFilenameRange(Source, "/angled.h", true);
255
256 ASSERT_EQ("<angled.h>", GetSourceString(Range));
257}
258
259TEST_F(PPCallbacksTest, QuotedInMacro) {
260 const char* Source =
261 "#define MACRO_QUOTED \"quoted.h\"\n"
262 "#include MACRO_QUOTED\n";
263
264 CharSourceRange Range =
265 InclusionDirectiveFilenameRange(Source, "/quoted.h", false);
266
267 ASSERT_EQ("\"quoted.h\"", GetSourceString(Range));
268}
269
270TEST_F(PPCallbacksTest, AngledInMacro) {
271 const char* Source =
272 "#define MACRO_ANGLED <angled.h>\n"
273 "#include MACRO_ANGLED\n";
274
275 CharSourceRange Range =
276 InclusionDirectiveFilenameRange(Source, "/angled.h", true);
277
278 ASSERT_EQ("<angled.h>", GetSourceString(Range));
279}
280
281TEST_F(PPCallbacksTest, StringizedMacroArgument) {
282 const char* Source =
283 "#define MACRO_STRINGIZED(x) #x\n"
284 "#include MACRO_STRINGIZED(quoted.h)\n";
285
286 CharSourceRange Range =
287 InclusionDirectiveFilenameRange(Source, "/quoted.h", false);
288
289 ASSERT_EQ("\"quoted.h\"", GetSourceString(Range));
290}
291
292TEST_F(PPCallbacksTest, ConcatenatedMacroArgument) {
293 const char* Source =
294 "#define MACRO_ANGLED <angled.h>\n"
295 "#define MACRO_CONCAT(x, y) x ## _ ## y\n"
296 "#include MACRO_CONCAT(MACRO, ANGLED)\n";
297
298 CharSourceRange Range =
299 InclusionDirectiveFilenameRange(Source, "/angled.h", false);
300
301 ASSERT_EQ("<angled.h>", GetSourceString(Range));
302}
303
Argyrios Kyrtzidis2edbc862012-11-01 17:52:58 +0000304TEST_F(PPCallbacksTest, TrigraphFilename) {
305 const char* Source =
Benjamin Kramerf9db1302012-11-03 20:58:26 +0000306 "#include \"tri\?\?-graph.h\"\n";
Argyrios Kyrtzidis2edbc862012-11-01 17:52:58 +0000307
308 CharSourceRange Range =
309 InclusionDirectiveFilenameRange(Source, "/tri~graph.h", false);
310
Benjamin Kramerf9db1302012-11-03 20:58:26 +0000311 ASSERT_EQ("\"tri\?\?-graph.h\"", GetSourceString(Range));
Argyrios Kyrtzidis2edbc862012-11-01 17:52:58 +0000312}
313
314TEST_F(PPCallbacksTest, TrigraphInMacro) {
315 const char* Source =
Benjamin Kramerf9db1302012-11-03 20:58:26 +0000316 "#define MACRO_TRIGRAPH \"tri\?\?-graph.h\"\n"
Argyrios Kyrtzidis2edbc862012-11-01 17:52:58 +0000317 "#include MACRO_TRIGRAPH\n";
318
319 CharSourceRange Range =
320 InclusionDirectiveFilenameRange(Source, "/tri~graph.h", false);
321
Benjamin Kramerf9db1302012-11-03 20:58:26 +0000322 ASSERT_EQ("\"tri\?\?-graph.h\"", GetSourceString(Range));
Argyrios Kyrtzidis2edbc862012-11-01 17:52:58 +0000323}
324
Pekka Jaaskelainen1db1da22013-10-12 09:29:48 +0000325TEST_F(PPCallbacksTest, OpenCLExtensionPragmaEnabled) {
326 const char* Source =
327 "#pragma OPENCL EXTENSION cl_khr_fp64 : enable\n";
328
329 PragmaOpenCLExtensionCallbacks::CallbackParameters Parameters =
330 PragmaOpenCLExtensionCall(Source);
331
332 ASSERT_EQ("cl_khr_fp64", Parameters.Name);
333 unsigned ExpectedState = 1;
334 ASSERT_EQ(ExpectedState, Parameters.State);
335}
336
337TEST_F(PPCallbacksTest, OpenCLExtensionPragmaDisabled) {
338 const char* Source =
339 "#pragma OPENCL EXTENSION cl_khr_fp16 : disable\n";
340
341 PragmaOpenCLExtensionCallbacks::CallbackParameters Parameters =
342 PragmaOpenCLExtensionCall(Source);
343
344 ASSERT_EQ("cl_khr_fp16", Parameters.Name);
345 unsigned ExpectedState = 0;
346 ASSERT_EQ(ExpectedState, Parameters.State);
347}
348
Argyrios Kyrtzidis2edbc862012-11-01 17:52:58 +0000349} // anonoymous namespace