1 /*
2 * Copyright 2010-2012, The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 * http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
17 #include "slang_rs.h"
18
19 #include <cstring>
20 #include <list>
21 #include <sstream>
22 #include <string>
23 #include <utility>
24 #include <vector>
25
26 #include "clang/Basic/SourceLocation.h"
27
28 #include "clang/Frontend/FrontendDiagnostic.h"
29
30 #include "clang/Sema/SemaDiagnostic.h"
31
32 #include "llvm/Support/Path.h"
33
34 #include "os_sep.h"
35 #include "rs_cc_options.h"
36 #include "slang_rs_backend.h"
37 #include "slang_rs_context.h"
38 #include "slang_rs_export_type.h"
39
40 #include "slang_rs_reflection.h"
41 #include "slang_rs_reflection_cpp.h"
42
43 namespace slang {
44
45 #define FS_SUFFIX "fs"
46
47 #define RS_HEADER_SUFFIX "rsh"
48
49 /* RS_HEADER_ENTRY(name) */
50 #define ENUM_RS_HEADER() \
51 RS_HEADER_ENTRY(rs_allocation) \
52 RS_HEADER_ENTRY(rs_atomic) \
53 RS_HEADER_ENTRY(rs_cl) \
54 RS_HEADER_ENTRY(rs_core) \
55 RS_HEADER_ENTRY(rs_core_math) \
56 RS_HEADER_ENTRY(rs_debug) \
57 RS_HEADER_ENTRY(rs_element) \
58 RS_HEADER_ENTRY(rs_graphics) \
59 RS_HEADER_ENTRY(rs_math) \
60 RS_HEADER_ENTRY(rs_mesh) \
61 RS_HEADER_ENTRY(rs_matrix) \
62 RS_HEADER_ENTRY(rs_object) \
63 RS_HEADER_ENTRY(rs_program) \
64 RS_HEADER_ENTRY(rs_quaternion) \
65 RS_HEADER_ENTRY(rs_sampler) \
66 RS_HEADER_ENTRY(rs_time) \
67 RS_HEADER_ENTRY(rs_types) \
68
69 // Returns true if \p Filename ends in ".fs".
isFilterscript(const char * Filename)70 bool SlangRS::isFilterscript(const char *Filename) {
71 const char *c = strrchr(Filename, '.');
72 if (c && !strncmp(FS_SUFFIX, c + 1, strlen(FS_SUFFIX) + 1)) {
73 return true;
74 } else {
75 return false;
76 }
77 }
78
generateJavaBitcodeAccessor(const std::string & OutputPathBase,const std::string & PackageName,const std::string * LicenseNote)79 bool SlangRS::generateJavaBitcodeAccessor(const std::string &OutputPathBase,
80 const std::string &PackageName,
81 const std::string *LicenseNote) {
82 RSSlangReflectUtils::BitCodeAccessorContext BCAccessorContext;
83
84 BCAccessorContext.rsFileName = getInputFileName().c_str();
85 BCAccessorContext.bc32FileName = getOutput32FileName().c_str();
86 BCAccessorContext.bc64FileName = getOutputFileName().c_str();
87 BCAccessorContext.reflectPath = OutputPathBase.c_str();
88 BCAccessorContext.packageName = PackageName.c_str();
89 BCAccessorContext.licenseNote = LicenseNote;
90 BCAccessorContext.bcStorage = BCST_JAVA_CODE; // Must be BCST_JAVA_CODE
91 BCAccessorContext.verbose = false;
92
93 return RSSlangReflectUtils::GenerateJavaBitCodeAccessor(BCAccessorContext);
94 }
95
checkODR(const char * CurInputFile)96 bool SlangRS::checkODR(const char *CurInputFile) {
97 for (RSContext::ExportableList::iterator I = mRSContext->exportable_begin(),
98 E = mRSContext->exportable_end();
99 I != E;
100 I++) {
101 RSExportable *RSE = *I;
102 if (RSE->getKind() != RSExportable::EX_TYPE)
103 continue;
104
105 RSExportType *ET = static_cast<RSExportType *>(RSE);
106 if (ET->getClass() != RSExportType::ExportClassRecord)
107 continue;
108
109 RSExportRecordType *ERT = static_cast<RSExportRecordType *>(ET);
110
111 // Artificial record types (create by us not by user in the source) always
112 // conforms the ODR.
113 if (ERT->isArtificial())
114 continue;
115
116 // Key to lookup ERT in ReflectedDefinitions
117 llvm::StringRef RDKey(ERT->getName());
118 ReflectedDefinitionListTy::const_iterator RD =
119 ReflectedDefinitions.find(RDKey);
120
121 if (RD != ReflectedDefinitions.end()) {
122 const RSExportRecordType *Reflected = RD->getValue().first;
123 // There's a record (struct) with the same name reflected before. Enforce
124 // ODR checking - the Reflected must hold *exactly* the same "definition"
125 // as the one defined previously. We say two record types A and B have the
126 // same definition iff:
127 //
128 // struct A { struct B {
129 // Type(a1) a1, Type(b1) b1,
130 // Type(a2) a2, Type(b1) b2,
131 // ... ...
132 // Type(aN) aN Type(b3) b3,
133 // }; }
134 // Cond. #1. They have same number of fields, i.e., N = M;
135 // Cond. #2. for (i := 1 to N)
136 // Type(ai) = Type(bi) must hold;
137 // Cond. #3. for (i := 1 to N)
138 // Name(ai) = Name(bi) must hold;
139 //
140 // where,
141 // Type(F) = the type of field F and
142 // Name(F) = the field name.
143
144 bool PassODR = false;
145 // Cond. #1 and Cond. #2
146 if (Reflected->equals(ERT)) {
147 // Cond #3.
148 RSExportRecordType::const_field_iterator AI = Reflected->fields_begin(),
149 BI = ERT->fields_begin();
150
151 for (unsigned i = 0, e = Reflected->getFields().size(); i != e; i++) {
152 if ((*AI)->getName() != (*BI)->getName())
153 break;
154 AI++;
155 BI++;
156 }
157 PassODR = (AI == (Reflected->fields_end()));
158 }
159
160 if (!PassODR) {
161 getDiagnostics().Report(mDiagErrorODR) << Reflected->getName()
162 << getInputFileName()
163 << RD->getValue().second;
164 return false;
165 }
166 } else {
167 llvm::StringMapEntry<ReflectedDefinitionTy> *ME =
168 llvm::StringMapEntry<ReflectedDefinitionTy>::Create(RDKey);
169 ME->setValue(std::make_pair(ERT, CurInputFile));
170
171 if (!ReflectedDefinitions.insert(ME))
172 delete ME;
173
174 // Take the ownership of ERT such that it won't be freed in ~RSContext().
175 ERT->keep();
176 }
177 }
178 return true;
179 }
180
initDiagnostic()181 void SlangRS::initDiagnostic() {
182 clang::DiagnosticsEngine &DiagEngine = getDiagnostics();
183
184 if (DiagEngine.setSeverityForGroup("implicit-function-declaration",
185 clang::diag::Severity::Error))
186 DiagEngine.Report(clang::diag::warn_unknown_warning_option)
187 << "implicit-function-declaration";
188
189 DiagEngine.setSeverity(
190 clang::diag::ext_typecheck_convert_discards_qualifiers,
191 clang::diag::Severity::Error,
192 clang::SourceLocation());
193
194 mDiagErrorInvalidOutputDepParameter =
195 DiagEngine.getCustomDiagID(
196 clang::DiagnosticsEngine::Error,
197 "invalid parameter for output dependencies files.");
198
199 mDiagErrorODR =
200 DiagEngine.getCustomDiagID(
201 clang::DiagnosticsEngine::Error,
202 "type '%0' in different translation unit (%1 v.s. %2) "
203 "has incompatible type definition");
204
205 mDiagErrorTargetAPIRange =
206 DiagEngine.getCustomDiagID(
207 clang::DiagnosticsEngine::Error,
208 "target API level '%0' is out of range ('%1' - '%2')");
209 }
210
initPreprocessor()211 void SlangRS::initPreprocessor() {
212 clang::Preprocessor &PP = getPreprocessor();
213
214 std::stringstream RSH;
215 RSH << PP.getPredefines();
216 RSH << "#define RS_VERSION " << mTargetAPI << "\n";
217 RSH << "#include \"rs_core." RS_HEADER_SUFFIX "\"\n";
218 PP.setPredefines(RSH.str());
219 }
220
initASTContext()221 void SlangRS::initASTContext() {
222 mRSContext = new RSContext(getPreprocessor(),
223 getASTContext(),
224 getTargetInfo(),
225 &mPragmas,
226 mTargetAPI,
227 mVerbose);
228 }
229
230 clang::ASTConsumer
createBackend(const clang::CodeGenOptions & CodeGenOpts,llvm::raw_ostream * OS,Slang::OutputType OT)231 *SlangRS::createBackend(const clang::CodeGenOptions& CodeGenOpts,
232 llvm::raw_ostream *OS,
233 Slang::OutputType OT) {
234 return new RSBackend(mRSContext,
235 &getDiagnostics(),
236 CodeGenOpts,
237 getTargetOptions(),
238 &mPragmas,
239 OS,
240 OT,
241 getSourceManager(),
242 mAllowRSPrefix,
243 mIsFilterscript);
244 }
245
IsRSHeaderFile(const char * File)246 bool SlangRS::IsRSHeaderFile(const char *File) {
247 #define RS_HEADER_ENTRY(name) \
248 if (::strcmp(File, #name "." RS_HEADER_SUFFIX) == 0) \
249 return true;
250 ENUM_RS_HEADER()
251 #undef RS_HEADER_ENTRY
252 return false;
253 }
254
IsLocInRSHeaderFile(const clang::SourceLocation & Loc,const clang::SourceManager & SourceMgr)255 bool SlangRS::IsLocInRSHeaderFile(const clang::SourceLocation &Loc,
256 const clang::SourceManager &SourceMgr) {
257 clang::FullSourceLoc FSL(Loc, SourceMgr);
258 clang::PresumedLoc PLoc = SourceMgr.getPresumedLoc(FSL);
259
260 const char *Filename = PLoc.getFilename();
261 if (!Filename) {
262 return false;
263 } else {
264 return IsRSHeaderFile(llvm::sys::path::filename(Filename).data());
265 }
266 }
267
SlangRS()268 SlangRS::SlangRS()
269 : Slang(), mRSContext(NULL), mAllowRSPrefix(false), mTargetAPI(0),
270 mVerbose(false), mIsFilterscript(false) {
271 }
272
compile(const std::list<std::pair<const char *,const char * >> & IOFiles64,const std::list<std::pair<const char *,const char * >> & IOFiles32,const std::list<std::pair<const char *,const char * >> & DepFiles,const RSCCOptions & Opts)273 bool SlangRS::compile(
274 const std::list<std::pair<const char*, const char*> > &IOFiles64,
275 const std::list<std::pair<const char*, const char*> > &IOFiles32,
276 const std::list<std::pair<const char*, const char*> > &DepFiles,
277 const RSCCOptions &Opts) {
278 if (IOFiles32.empty())
279 return true;
280
281 if (Opts.mEmitDependency && (DepFiles.size() != IOFiles32.size())) {
282 getDiagnostics().Report(mDiagErrorInvalidOutputDepParameter);
283 return false;
284 }
285
286 if (Opts.mEmit3264 && (IOFiles64.size() != IOFiles32.size())) {
287 slangAssert(false && "Should have equal number of 32/64-bit files");
288 return false;
289 }
290
291 std::string RealPackageName;
292
293 const char *InputFile, *Output64File, *Output32File, *BCOutputFile,
294 *DepOutputFile;
295 std::list<std::pair<const char*, const char*> >::const_iterator
296 IOFile64Iter = IOFiles64.begin(),
297 IOFile32Iter = IOFiles32.begin(),
298 DepFileIter = DepFiles.begin();
299
300 setIncludePaths(Opts.mIncludePaths);
301 setOutputType(Opts.mOutputType);
302 if (Opts.mEmitDependency) {
303 setAdditionalDepTargets(Opts.mAdditionalDepTargets);
304 }
305
306 setDebugMetadataEmission(Opts.mDebugEmission);
307
308 setOptimizationLevel(Opts.mOptimizationLevel);
309
310 mAllowRSPrefix = Opts.mAllowRSPrefix;
311
312 mTargetAPI = Opts.mTargetAPI;
313 if (mTargetAPI != SLANG_DEVELOPMENT_TARGET_API &&
314 (mTargetAPI < SLANG_MINIMUM_TARGET_API ||
315 mTargetAPI > SLANG_MAXIMUM_TARGET_API)) {
316 getDiagnostics().Report(mDiagErrorTargetAPIRange) << mTargetAPI
317 << SLANG_MINIMUM_TARGET_API << SLANG_MAXIMUM_TARGET_API;
318 return false;
319 }
320
321 mVerbose = Opts.mVerbose;
322
323 // Skip generation of warnings a second time if we are doing more than just
324 // a single pass over the input file.
325 bool SuppressAllWarnings = (Opts.mOutputType != Slang::OT_Dependency);
326
327 bool CompileSecondTimeFor64Bit = Opts.mEmit3264 && Opts.mBitWidth == 64;
328
329 for (unsigned i = 0, e = IOFiles32.size(); i != e; i++) {
330 InputFile = IOFile64Iter->first;
331 Output64File = IOFile64Iter->second;
332 Output32File = IOFile32Iter->second;
333
334 // We suppress warnings (via reset) if we are doing a second compilation.
335 reset(CompileSecondTimeFor64Bit);
336
337 if (!setInputSource(InputFile))
338 return false;
339
340 if (!setOutput(Output64File))
341 return false;
342
343 setOutput32(Output32File);
344
345 mIsFilterscript = isFilterscript(InputFile);
346
347 if (Slang::compile() > 0)
348 return false;
349
350 if (!Opts.mJavaReflectionPackageName.empty()) {
351 mRSContext->setReflectJavaPackageName(Opts.mJavaReflectionPackageName);
352 }
353 const std::string &RealPackageName =
354 mRSContext->getReflectJavaPackageName();
355
356 bool doReflection = true;
357 if (Opts.mEmit3264 && (Opts.mBitWidth == 32)) {
358 // Skip reflection on the 32-bit path if we are going to emit it on the
359 // 64-bit path.
360 doReflection = false;
361 }
362 if (Opts.mOutputType != Slang::OT_Dependency && doReflection) {
363
364 if (Opts.mBitcodeStorage == BCST_CPP_CODE) {
365 const std::string &outputFileName = (Opts.mBitWidth == 64) ?
366 getOutputFileName() : getOutput32FileName();
367 RSReflectionCpp R(mRSContext, Opts.mJavaReflectionPathBase,
368 getInputFileName(), outputFileName);
369 if (!R.reflect()) {
370 return false;
371 }
372 } else {
373 if (!Opts.mRSPackageName.empty()) {
374 mRSContext->setRSPackageName(Opts.mRSPackageName);
375 }
376
377 RSReflectionJava R(mRSContext, &mGeneratedFileNames,
378 Opts.mJavaReflectionPathBase, getInputFileName(),
379 getOutputFileName(),
380 Opts.mBitcodeStorage == BCST_JAVA_CODE);
381 if (!R.reflect()) {
382 // TODO Is this needed or will the error message have been printed
383 // already? and why not for the C++ case?
384 fprintf(stderr, "RSContext::reflectToJava : failed to do reflection "
385 "(%s)\n",
386 R.getLastError());
387 return false;
388 }
389
390 for (std::vector<std::string>::const_iterator
391 I = mGeneratedFileNames.begin(), E = mGeneratedFileNames.end();
392 I != E;
393 I++) {
394 std::string ReflectedName = RSSlangReflectUtils::ComputePackagedPath(
395 Opts.mJavaReflectionPathBase.c_str(),
396 (RealPackageName + OS_PATH_SEPARATOR_STR + *I).c_str());
397 appendGeneratedFileName(ReflectedName + ".java");
398 }
399
400 if ((Opts.mOutputType == Slang::OT_Bitcode) &&
401 (Opts.mBitcodeStorage == BCST_JAVA_CODE) &&
402 !generateJavaBitcodeAccessor(Opts.mJavaReflectionPathBase,
403 RealPackageName.c_str(),
404 mRSContext->getLicenseNote())) {
405 return false;
406 }
407 }
408 }
409
410 if (Opts.mEmitDependency) {
411 BCOutputFile = DepFileIter->first;
412 DepOutputFile = DepFileIter->second;
413
414 setDepTargetBC(BCOutputFile);
415
416 if (!setDepOutput(DepOutputFile))
417 return false;
418
419 if (SuppressAllWarnings) {
420 getDiagnostics().setSuppressAllDiagnostics(true);
421 }
422 if (generateDepFile() > 0)
423 return false;
424 if (SuppressAllWarnings) {
425 getDiagnostics().setSuppressAllDiagnostics(false);
426 }
427
428 DepFileIter++;
429 }
430
431 if (!checkODR(InputFile))
432 return false;
433
434 IOFile64Iter++;
435 IOFile32Iter++;
436 }
437
438 return true;
439 }
440
reset(bool SuppressWarnings)441 void SlangRS::reset(bool SuppressWarnings) {
442 delete mRSContext;
443 mRSContext = NULL;
444 mGeneratedFileNames.clear();
445 Slang::reset(SuppressWarnings);
446 }
447
~SlangRS()448 SlangRS::~SlangRS() {
449 delete mRSContext;
450 for (ReflectedDefinitionListTy::iterator I = ReflectedDefinitions.begin(),
451 E = ReflectedDefinitions.end();
452 I != E;
453 I++) {
454 delete I->getValue().first;
455 }
456 }
457
458 } // namespace slang
459