1 //===- 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 
10 #include "clang/Lex/Preprocessor.h"
11 #include "clang/AST/ASTConsumer.h"
12 #include "clang/AST/ASTContext.h"
13 #include "clang/Basic/Diagnostic.h"
14 #include "clang/Basic/DiagnosticOptions.h"
15 #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"
23 #include "clang/Lex/PreprocessorOptions.h"
24 #include "clang/Parse/Parser.h"
25 #include "clang/Sema/Sema.h"
26 #include "llvm/ADT/SmallString.h"
27 #include "llvm/Support/Path.h"
28 #include "gtest/gtest.h"
29 
30 using namespace clang;
31 
32 namespace {
33 
34 // Stub out module loading.
35 class VoidModuleLoader : public ModuleLoader {
36   ModuleLoadResult loadModule(SourceLocation ImportLoc,
37                               ModuleIdPath Path,
38                               Module::NameVisibilityKind Visibility,
39                               bool IsInclusionDirective) override {
40     return ModuleLoadResult();
41   }
42 
43   void makeModuleVisible(Module *Mod,
44                          Module::NameVisibilityKind Visibility,
45                          SourceLocation ImportLoc) override { }
46 
47   GlobalModuleIndex *loadGlobalModuleIndex(SourceLocation TriggerLoc) override
48     { return nullptr; }
49   bool lookupMissingImports(StringRef Name, SourceLocation TriggerLoc) override
50     { return 0; };
51 };
52 
53 // Stub to collect data from InclusionDirective callbacks.
54 class InclusionDirectiveCallbacks : public PPCallbacks {
55 public:
56   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 {
61       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 
83 // Stub to collect data from PragmaOpenCLExtension callbacks.
84 class PragmaOpenCLExtensionCallbacks : public PPCallbacks {
85 public:
86   typedef struct {
87     SmallString<16> Name;
88     unsigned State;
89   } CallbackParameters;
90 
91   PragmaOpenCLExtensionCallbacks() : Name("Not called."), State(99) {};
92 
93   void PragmaOpenCLExtension(clang::SourceLocation NameLoc,
94                              const clang::IdentifierInfo *Name,
95                              clang::SourceLocation StateLoc,
96                              unsigned State) override {
97       this->NameLoc = NameLoc;
98       this->Name = Name->getName();
99       this->StateLoc = StateLoc;
100       this->State = State;
101   };
102 
103   SourceLocation NameLoc;
104   SmallString<16> Name;
105   SourceLocation StateLoc;
106   unsigned State;
107 };
108 
109 // PPCallbacks test fixture.
110 class PPCallbacksTest : public ::testing::Test {
111 protected:
112   PPCallbacksTest()
113       : FileMgr(FileMgrOpts), DiagID(new DiagnosticIDs()),
114         DiagOpts(new DiagnosticOptions()),
115         Diags(DiagID, DiagOpts.get(), new IgnoringDiagConsumer()),
116         SourceMgr(Diags, FileMgr), TargetOpts(new TargetOptions()) {
117     TargetOpts->Triple = "x86_64-apple-darwin11.1.0";
118     Target = TargetInfo::CreateTargetInfo(Diags, TargetOpts);
119   }
120 
121   FileSystemOptions FileMgrOpts;
122   FileManager FileMgr;
123   IntrusiveRefCntPtr<DiagnosticIDs> DiagID;
124   IntrusiveRefCntPtr<DiagnosticOptions> DiagOpts;
125   DiagnosticsEngine Diags;
126   SourceManager SourceMgr;
127   LangOptions LangOpts;
128   std::shared_ptr<TargetOptions> TargetOpts;
129   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.
139       StringRef SearchPath = llvm::sys::path::parent_path(HeaderPath);
140       const DirectoryEntry *DE = FileMgr.getDirectory(SearchPath);
141       DirectoryLookup DL(DE, SrcMgr::C_User, false);
142       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) {
157     std::unique_ptr<llvm::MemoryBuffer> Buf =
158         llvm::MemoryBuffer::getMemBuffer(SourceText);
159     SourceMgr.setMainFileID(SourceMgr.createFileID(std::move(Buf)));
160 
161     VoidModuleLoader ModLoader;
162 
163     IntrusiveRefCntPtr<HeaderSearchOptions> HSOpts = new HeaderSearchOptions();
164     HeaderSearch HeaderInfo(HSOpts, SourceMgr, Diags, LangOpts,
165                             Target.get());
166     AddFakeHeader(HeaderInfo, HeaderPath, SystemHeader);
167 
168     IntrusiveRefCntPtr<PreprocessorOptions> PPOpts = new PreprocessorOptions();
169     Preprocessor PP(PPOpts, Diags, LangOpts, SourceMgr, HeaderInfo, ModLoader,
170                     /*IILookup =*/nullptr,
171                     /*OwnsHeaderSearch =*/false);
172     PP.Initialize(*Target);
173     InclusionDirectiveCallbacks* Callbacks = new InclusionDirectiveCallbacks;
174     PP.addPPCallbacks(std::unique_ptr<PPCallbacks>(Callbacks));
175 
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   }
189 
190   PragmaOpenCLExtensionCallbacks::CallbackParameters
191   PragmaOpenCLExtensionCall(const char* SourceText) {
192     LangOptions OpenCLLangOpts;
193     OpenCLLangOpts.OpenCL = 1;
194 
195     std::unique_ptr<llvm::MemoryBuffer> SourceBuf =
196         llvm::MemoryBuffer::getMemBuffer(SourceText, "test.cl");
197     SourceMgr.setMainFileID(SourceMgr.createFileID(std::move(SourceBuf)));
198 
199     VoidModuleLoader ModLoader;
200     HeaderSearch HeaderInfo(new HeaderSearchOptions, SourceMgr, Diags,
201                             OpenCLLangOpts, Target.get());
202 
203     Preprocessor PP(new PreprocessorOptions(), Diags, OpenCLLangOpts, SourceMgr,
204                     HeaderInfo, ModLoader, /*IILookup =*/nullptr,
205                     /*OwnsHeaderSearch =*/false);
206     PP.Initialize(*Target);
207 
208     // parser actually sets correct pragma handlers for preprocessor
209     // according to LangOptions, so we init Parser to register opencl
210     // pragma handlers
211     ASTContext Context(OpenCLLangOpts, SourceMgr,
212                        PP.getIdentifierTable(), PP.getSelectorTable(),
213                        PP.getBuiltinInfo());
214     Context.InitBuiltinTypes(*Target);
215 
216     ASTConsumer Consumer;
217     Sema S(PP, Context, Consumer);
218     Parser P(PP, S, false);
219     PragmaOpenCLExtensionCallbacks* Callbacks = new PragmaOpenCLExtensionCallbacks;
220     PP.addPPCallbacks(std::unique_ptr<PPCallbacks>(Callbacks));
221 
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 = {
232       Callbacks->Name,
233       Callbacks->State
234     };
235     return RetVal;
236   }
237 };
238 
239 TEST_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 
249 TEST_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 
259 TEST_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 
270 TEST_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 
281 TEST_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 
292 TEST_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 
304 TEST_F(PPCallbacksTest, TrigraphFilename) {
305   const char* Source =
306     "#include \"tri\?\?-graph.h\"\n";
307 
308   CharSourceRange Range =
309     InclusionDirectiveFilenameRange(Source, "/tri~graph.h", false);
310 
311   ASSERT_EQ("\"tri\?\?-graph.h\"", GetSourceString(Range));
312 }
313 
314 TEST_F(PPCallbacksTest, TrigraphInMacro) {
315   const char* Source =
316     "#define MACRO_TRIGRAPH \"tri\?\?-graph.h\"\n"
317     "#include MACRO_TRIGRAPH\n";
318 
319   CharSourceRange Range =
320     InclusionDirectiveFilenameRange(Source, "/tri~graph.h", false);
321 
322   ASSERT_EQ("\"tri\?\?-graph.h\"", GetSourceString(Range));
323 }
324 
325 TEST_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 
337 TEST_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 
349 } // anonoymous namespace
350