1 /*
2  * Copyright 2010, 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.h"
18 
19 #include <stdlib.h>
20 
21 #include <cstring>
22 #include <list>
23 #include <sstream>
24 #include <string>
25 #include <utility>
26 #include <vector>
27 
28 #include "clang/AST/ASTConsumer.h"
29 #include "clang/AST/ASTContext.h"
30 
31 #include "clang/Basic/DiagnosticIDs.h"
32 #include "clang/Basic/DiagnosticOptions.h"
33 #include "clang/Basic/FileManager.h"
34 #include "clang/Basic/FileSystemOptions.h"
35 #include "clang/Basic/SourceLocation.h"
36 #include "clang/Basic/SourceManager.h"
37 #include "clang/Basic/TargetInfo.h"
38 #include "clang/Basic/TargetOptions.h"
39 
40 #include "clang/Frontend/DependencyOutputOptions.h"
41 #include "clang/Frontend/FrontendDiagnostic.h"
42 #include "clang/Frontend/FrontendOptions.h"
43 #include "clang/Frontend/PCHContainerOperations.h"
44 #include "clang/Frontend/TextDiagnosticPrinter.h"
45 #include "clang/Frontend/Utils.h"
46 
47 #include "clang/Lex/HeaderSearch.h"
48 #include "clang/Lex/HeaderSearchOptions.h"
49 #include "clang/Lex/Preprocessor.h"
50 #include "clang/Lex/PreprocessorOptions.h"
51 
52 #include "clang/Parse/ParseAST.h"
53 
54 #include "clang/Sema/SemaDiagnostic.h"
55 
56 #include "llvm/ADT/IntrusiveRefCntPtr.h"
57 
58 #include "llvm/Bitcode/ReaderWriter.h"
59 
60 // More force linking
61 #include "llvm/Linker/Linker.h"
62 
63 // Force linking all passes/vmcore stuffs to libslang.so
64 #include "llvm/LinkAllIR.h"
65 #include "llvm/LinkAllPasses.h"
66 
67 #include "llvm/Support/raw_ostream.h"
68 #include "llvm/Support/MemoryBuffer.h"
69 #include "llvm/Support/ErrorHandling.h"
70 #include "llvm/Support/ManagedStatic.h"
71 #include "llvm/Support/Path.h"
72 #include "llvm/Support/TargetSelect.h"
73 #include "llvm/Support/ToolOutputFile.h"
74 
75 #include "os_sep.h"
76 #include "rs_cc_options.h"
77 #include "slang_assert.h"
78 #include "slang_backend.h"
79 
80 #include "slang_rs_context.h"
81 #include "slang_rs_export_type.h"
82 
83 #include "slang_rs_reflection.h"
84 #include "slang_rs_reflection_cpp.h"
85 
86 
87 namespace {
88 
89 static const char *kRSTriple32 = "renderscript32-none-linux-gnueabi";
90 static const char *kRSTriple64 = "renderscript64-none-linux-gnueabi";
91 
92 }  // namespace
93 
94 namespace slang {
95 
96 
97 #define FS_SUFFIX  "fs"
98 
99 #define RS_HEADER_SUFFIX  "rsh"
100 
101 /* RS_HEADER_ENTRY(name) */
102 #define ENUM_RS_HEADER()  \
103   RS_HEADER_ENTRY(rs_allocation_create) \
104   RS_HEADER_ENTRY(rs_allocation_data) \
105   RS_HEADER_ENTRY(rs_atomic) \
106   RS_HEADER_ENTRY(rs_convert) \
107   RS_HEADER_ENTRY(rs_core) \
108   RS_HEADER_ENTRY(rs_debug) \
109   RS_HEADER_ENTRY(rs_for_each) \
110   RS_HEADER_ENTRY(rs_graphics) \
111   RS_HEADER_ENTRY(rs_graphics_types) \
112   RS_HEADER_ENTRY(rs_io) \
113   RS_HEADER_ENTRY(rs_math) \
114   RS_HEADER_ENTRY(rs_matrix) \
115   RS_HEADER_ENTRY(rs_object_info) \
116   RS_HEADER_ENTRY(rs_object_types) \
117   RS_HEADER_ENTRY(rs_quaternion) \
118   RS_HEADER_ENTRY(rs_time) \
119   RS_HEADER_ENTRY(rs_value_types) \
120   RS_HEADER_ENTRY(rs_vector_math) \
121 
122 
123 // The named of metadata node that pragma resides (should be synced with
124 // bcc.cpp)
125 const llvm::StringRef Slang::PragmaMetadataName = "#pragma";
126 
127 static llvm::LLVMContext globalContext;
128 
getGlobalLLVMContext()129 llvm::LLVMContext &getGlobalLLVMContext() { return globalContext; }
130 
131 static inline llvm::tool_output_file *
OpenOutputFile(const char * OutputFile,llvm::sys::fs::OpenFlags Flags,std::error_code & EC,clang::DiagnosticsEngine * DiagEngine)132 OpenOutputFile(const char *OutputFile,
133                llvm::sys::fs::OpenFlags Flags,
134                std::error_code &EC,
135                clang::DiagnosticsEngine *DiagEngine) {
136   slangAssert((OutputFile != nullptr) &&
137               (DiagEngine != nullptr) && "Invalid parameter!");
138 
139   EC = llvm::sys::fs::create_directories(
140       llvm::sys::path::parent_path(OutputFile));
141   if (!EC) {
142     llvm::tool_output_file *F =
143           new llvm::tool_output_file(OutputFile, EC, Flags);
144     if (F != nullptr)
145       return F;
146   }
147 
148   // Report error here.
149   DiagEngine->Report(clang::diag::err_fe_error_opening)
150     << OutputFile << EC.message();
151 
152   return nullptr;
153 }
154 
createTarget(uint32_t BitWidth)155 void Slang::createTarget(uint32_t BitWidth) {
156   if (BitWidth == 64) {
157     mTargetOpts->Triple = kRSTriple64;
158   } else {
159     mTargetOpts->Triple = kRSTriple32;
160   }
161 
162   mTarget.reset(clang::TargetInfo::CreateTargetInfo(*mDiagEngine,
163                                                     mTargetOpts));
164 }
165 
createFileManager()166 void Slang::createFileManager() {
167   mFileSysOpt.reset(new clang::FileSystemOptions());
168   mFileMgr.reset(new clang::FileManager(*mFileSysOpt));
169 }
170 
createSourceManager()171 void Slang::createSourceManager() {
172   mSourceMgr.reset(new clang::SourceManager(*mDiagEngine, *mFileMgr));
173 }
174 
createPreprocessor()175 void Slang::createPreprocessor() {
176   // Default only search header file in current dir
177   clang::HeaderSearch *HeaderInfo = new clang::HeaderSearch(&getHeaderSearchOpts(),
178                                                             *mSourceMgr,
179                                                             *mDiagEngine,
180                                                             LangOpts,
181                                                             mTarget.get());
182 
183   mPP.reset(new clang::Preprocessor(&getPreprocessorOpts(),
184                                     *mDiagEngine,
185                                     LangOpts,
186                                     *mSourceMgr,
187                                     *HeaderInfo,
188                                     *this,
189                                     nullptr,
190                                     /* OwnsHeaderSearch = */true));
191   // Initialize the preprocessor
192   mPP->Initialize(getTargetInfo());
193   clang::FrontendOptions FEOpts;
194 
195   auto *Reader = mPCHContainerOperations->getReaderOrNull(
196       getHeaderSearchOpts().ModuleFormat);
197   clang::InitializePreprocessor(*mPP, getPreprocessorOpts(), *Reader, FEOpts);
198 
199   clang::ApplyHeaderSearchOptions(*HeaderInfo, getHeaderSearchOpts(), LangOpts,
200       mPP->getTargetInfo().getTriple());
201 
202   mPragmas.clear();
203 
204   std::vector<clang::DirectoryLookup> SearchList;
205   for (unsigned i = 0, e = mIncludePaths.size(); i != e; i++) {
206     if (const clang::DirectoryEntry *DE =
207             mFileMgr->getDirectory(mIncludePaths[i])) {
208       SearchList.push_back(clang::DirectoryLookup(DE,
209                                                   clang::SrcMgr::C_System,
210                                                   false));
211     }
212   }
213 
214   HeaderInfo->SetSearchPaths(SearchList,
215                              /* angledDirIdx = */1,
216                              /* systemDixIdx = */1,
217                              /* noCurDirSearch = */false);
218 
219   initPreprocessor();
220 }
221 
createASTContext()222 void Slang::createASTContext() {
223   mASTContext.reset(
224       new clang::ASTContext(LangOpts, *mSourceMgr, mPP->getIdentifierTable(),
225                             mPP->getSelectorTable(), mPP->getBuiltinInfo()));
226   mASTContext->InitBuiltinTypes(getTargetInfo());
227   initASTContext();
228 }
229 
230 clang::ASTConsumer *
createBackend(const RSCCOptions & Opts,const clang::CodeGenOptions & CodeGenOpts,llvm::raw_ostream * OS,OutputType OT)231 Slang::createBackend(const RSCCOptions &Opts, const clang::CodeGenOptions &CodeGenOpts,
232                      llvm::raw_ostream *OS, OutputType OT) {
233   auto *B = new Backend(mRSContext, &getDiagnostics(), Opts,
234                         getHeaderSearchOpts(), getPreprocessorOpts(),
235                         CodeGenOpts, getTargetOptions(), &mPragmas, OS, OT,
236                         getSourceManager(), mAllowRSPrefix, mIsFilterscript);
237   B->Initialize(getASTContext());
238   return B;
239 }
240 
Slang(uint32_t BitWidth,clang::DiagnosticsEngine * DiagEngine,DiagnosticBuffer * DiagClient)241 Slang::Slang(uint32_t BitWidth, clang::DiagnosticsEngine *DiagEngine,
242              DiagnosticBuffer *DiagClient)
243     : mDiagEngine(DiagEngine), mDiagClient(DiagClient),
244       mTargetOpts(new clang::TargetOptions()),
245       mHSOpts(new clang::HeaderSearchOptions()),
246       mPPOpts(new clang::PreprocessorOptions()),
247       mPCHContainerOperations(std::make_shared<clang::PCHContainerOperations>()),
248       mOT(OT_Default), mRSContext(nullptr), mAllowRSPrefix(false), mTargetAPI(0),
249       mVerbose(false), mIsFilterscript(false) {
250   // Please refer to include/clang/Basic/LangOptions.h to setup
251   // the options.
252   LangOpts.RTTI = 0;  // Turn off the RTTI information support
253   LangOpts.LineComment = 1;
254   LangOpts.C99 = 1;
255   LangOpts.RenderScript = 1;
256   LangOpts.LaxVectorConversions = 0;  // Do not bitcast vectors!
257   LangOpts.CharIsSigned = 1;  // Signed char is our default.
258 
259   CodeGenOpts.OptimizationLevel = 3;
260 
261   // We must set StackRealignment, because the default is for the actual
262   // Clang driver to pass this option (-mstackrealign) directly to cc1.
263   // Since we don't use Clang's driver, we need to similarly supply it.
264   // If StackRealignment is zero (i.e. the option wasn't set), then the
265   // backend assumes that it can't adjust the stack in any way, which breaks
266   // alignment for vector loads/stores.
267   CodeGenOpts.StackRealignment = 1;
268 
269   createTarget(BitWidth);
270   createFileManager();
271   createSourceManager();
272 }
273 
~Slang()274 Slang::~Slang() {
275   delete mRSContext;
276   for (ReflectedDefinitionListTy::iterator I = ReflectedDefinitions.begin(),
277                                            E = ReflectedDefinitions.end();
278        I != E; I++) {
279     delete I->getValue().first;
280   }
281 }
282 
loadModule(clang::SourceLocation ImportLoc,clang::ModuleIdPath Path,clang::Module::NameVisibilityKind Visibility,bool IsInclusionDirective)283 clang::ModuleLoadResult Slang::loadModule(
284     clang::SourceLocation ImportLoc,
285     clang::ModuleIdPath Path,
286     clang::Module::NameVisibilityKind Visibility,
287     bool IsInclusionDirective) {
288   slangAssert(0 && "Not implemented");
289   return clang::ModuleLoadResult();
290 }
291 
setInputSource(llvm::StringRef InputFile)292 bool Slang::setInputSource(llvm::StringRef InputFile) {
293   mInputFileName = InputFile.str();
294 
295   mSourceMgr->clearIDTables();
296 
297   const clang::FileEntry *File = mFileMgr->getFile(InputFile);
298   if (File) {
299     mSourceMgr->setMainFileID(mSourceMgr->createFileID(File,
300         clang::SourceLocation(), clang::SrcMgr::C_User));
301   }
302 
303   if (mSourceMgr->getMainFileID().isInvalid()) {
304     mDiagEngine->Report(clang::diag::err_fe_error_reading) << InputFile;
305     return false;
306   }
307 
308   return true;
309 }
310 
setOutput(const char * OutputFile)311 bool Slang::setOutput(const char *OutputFile) {
312   std::error_code EC;
313   llvm::tool_output_file *OS = nullptr;
314 
315   switch (mOT) {
316     case OT_Dependency:
317     case OT_Assembly:
318     case OT_LLVMAssembly: {
319       OS = OpenOutputFile(OutputFile, llvm::sys::fs::F_Text, EC, mDiagEngine);
320       break;
321     }
322     case OT_Nothing: {
323       break;
324     }
325     case OT_Object:
326     case OT_Bitcode: {
327       OS = OpenOutputFile(OutputFile, llvm::sys::fs::F_None, EC, mDiagEngine);
328       break;
329     }
330     default: {
331       llvm_unreachable("Unknown compiler output type");
332     }
333   }
334 
335   if (EC)
336     return false;
337 
338   mOS.reset(OS);
339 
340   mOutputFileName = OutputFile;
341 
342   return true;
343 }
344 
setDepOutput(const char * OutputFile)345 bool Slang::setDepOutput(const char *OutputFile) {
346   std::error_code EC;
347 
348   mDOS.reset(
349       OpenOutputFile(OutputFile, llvm::sys::fs::F_Text, EC, mDiagEngine));
350   if (EC || (mDOS.get() == nullptr))
351     return false;
352 
353   mDepOutputFileName = OutputFile;
354 
355   return true;
356 }
357 
generateDepFile(bool PhonyTarget)358 int Slang::generateDepFile(bool PhonyTarget) {
359   if (mDiagEngine->hasErrorOccurred())
360     return 1;
361   if (mDOS.get() == nullptr)
362     return 1;
363 
364   // Initialize options for generating dependency file
365   clang::DependencyOutputOptions DepOpts;
366   DepOpts.IncludeSystemHeaders = 1;
367   if (PhonyTarget)
368     DepOpts.UsePhonyTargets = 1;
369   DepOpts.OutputFile = mDepOutputFileName;
370   DepOpts.Targets = mAdditionalDepTargets;
371   DepOpts.Targets.push_back(mDepTargetBCFileName);
372   for (std::vector<std::string>::const_iterator
373            I = mGeneratedFileNames.begin(), E = mGeneratedFileNames.end();
374        I != E;
375        I++) {
376     DepOpts.Targets.push_back(*I);
377   }
378   mGeneratedFileNames.clear();
379 
380   // Per-compilation needed initialization
381   createPreprocessor();
382   clang::DependencyFileGenerator::CreateAndAttachToPreprocessor(*mPP.get(), DepOpts);
383 
384   // Inform the diagnostic client we are processing a source file
385   mDiagClient->BeginSourceFile(LangOpts, mPP.get());
386 
387   // Go through the source file (no operations necessary)
388   clang::Token Tok;
389   mPP->EnterMainSourceFile();
390   do {
391     mPP->Lex(Tok);
392   } while (Tok.isNot(clang::tok::eof));
393 
394   mPP->EndSourceFile();
395 
396   // Declare success if no error
397   if (!mDiagEngine->hasErrorOccurred())
398     mDOS->keep();
399 
400   // Clean up after compilation
401   mPP.reset();
402   mDOS.reset();
403 
404   return mDiagEngine->hasErrorOccurred() ? 1 : 0;
405 }
406 
compile(const RSCCOptions & Opts)407 int Slang::compile(const RSCCOptions &Opts) {
408   if (mDiagEngine->hasErrorOccurred())
409     return 1;
410   if (mOS.get() == nullptr)
411     return 1;
412 
413   // Here is per-compilation needed initialization
414   createPreprocessor();
415   createASTContext();
416 
417   mBackend.reset(createBackend(Opts, CodeGenOpts, &mOS->os(), mOT));
418 
419   // Inform the diagnostic client we are processing a source file
420   mDiagClient->BeginSourceFile(LangOpts, mPP.get());
421 
422   // The core of the slang compiler
423   ParseAST(*mPP, mBackend.get(), *mASTContext);
424 
425   // Inform the diagnostic client we are done with previous source file
426   mDiagClient->EndSourceFile();
427 
428   // Declare success if no error
429   if (!mDiagEngine->hasErrorOccurred())
430     mOS->keep();
431 
432   // The compilation ended, clear
433   mBackend.reset();
434   mOS.reset();
435 
436   return mDiagEngine->hasErrorOccurred() ? 1 : 0;
437 }
438 
setDebugMetadataEmission(bool EmitDebug)439 void Slang::setDebugMetadataEmission(bool EmitDebug) {
440   if (EmitDebug)
441     CodeGenOpts.setDebugInfo(clang::codegenoptions::FullDebugInfo);
442   else
443     CodeGenOpts.setDebugInfo(clang::codegenoptions::NoDebugInfo);
444 }
445 
setOptimizationLevel(llvm::CodeGenOpt::Level OptimizationLevel)446 void Slang::setOptimizationLevel(llvm::CodeGenOpt::Level OptimizationLevel) {
447   CodeGenOpts.OptimizationLevel = OptimizationLevel;
448 }
449 
isFilterscript(const char * Filename)450 bool Slang::isFilterscript(const char *Filename) {
451   const char *c = strrchr(Filename, '.');
452   if (c && !strncmp(FS_SUFFIX, c + 1, strlen(FS_SUFFIX) + 1)) {
453     return true;
454   } else {
455     return false;
456   }
457 }
458 
generateJavaBitcodeAccessor(const std::string & OutputPathBase,const std::string & PackageName,const std::string * LicenseNote)459 bool Slang::generateJavaBitcodeAccessor(const std::string &OutputPathBase,
460                                           const std::string &PackageName,
461                                           const std::string *LicenseNote) {
462   RSSlangReflectUtils::BitCodeAccessorContext BCAccessorContext;
463 
464   BCAccessorContext.rsFileName = getInputFileName().c_str();
465   BCAccessorContext.bc32FileName = mOutput32FileName.c_str();
466   BCAccessorContext.bc64FileName = mOutputFileName.c_str();
467   BCAccessorContext.reflectPath = OutputPathBase.c_str();
468   BCAccessorContext.packageName = PackageName.c_str();
469   BCAccessorContext.licenseNote = LicenseNote;
470   BCAccessorContext.bcStorage = BCST_JAVA_CODE;   // Must be BCST_JAVA_CODE
471   BCAccessorContext.verbose = false;
472 
473   return RSSlangReflectUtils::GenerateJavaBitCodeAccessor(BCAccessorContext);
474 }
475 
checkODR(const char * CurInputFile)476 bool Slang::checkODR(const char *CurInputFile) {
477   for (RSContext::ExportableList::iterator I = mRSContext->exportable_begin(),
478           E = mRSContext->exportable_end();
479        I != E;
480        I++) {
481     RSExportable *RSE = *I;
482     if (RSE->getKind() != RSExportable::EX_TYPE)
483       continue;
484 
485     RSExportType *ET = static_cast<RSExportType *>(RSE);
486     if (ET->getClass() != RSExportType::ExportClassRecord)
487       continue;
488 
489     RSExportRecordType *ERT = static_cast<RSExportRecordType *>(ET);
490 
491     // Artificial record types (create by us not by user in the source) always
492     // conforms the ODR.
493     if (ERT->isArtificial())
494       continue;
495 
496     // Key to lookup ERT in ReflectedDefinitions
497     llvm::StringRef RDKey(ERT->getName());
498     ReflectedDefinitionListTy::const_iterator RD =
499         ReflectedDefinitions.find(RDKey);
500 
501     if (RD != ReflectedDefinitions.end()) {
502       const RSExportRecordType *Reflected = RD->getValue().first;
503 
504       // See RSExportRecordType::matchODR for the logic
505       if (!Reflected->matchODR(ERT, true)) {
506         unsigned DiagID = mDiagEngine->getCustomDiagID(
507             clang::DiagnosticsEngine::Error,
508             "type '%0' in different translation unit (%1 v.s. %2) "
509             "has incompatible type definition");
510         getDiagnostics().Report(DiagID) << Reflected->getName()
511                                         << getInputFileName()
512                                         << RD->getValue().second;
513         return false;
514       }
515     } else {
516       llvm::StringMapEntry<ReflectedDefinitionTy> *ME =
517           llvm::StringMapEntry<ReflectedDefinitionTy>::Create(RDKey);
518       ME->setValue(std::make_pair(ERT, CurInputFile));
519 
520       if (!ReflectedDefinitions.insert(ME)) {
521         slangAssert(false && "Type shouldn't be in map yet!");
522       }
523 
524       // Take the ownership of ERT such that it won't be freed in ~RSContext().
525       ERT->keep();
526     }
527   }
528   return true;
529 }
530 
initPreprocessor()531 void Slang::initPreprocessor() {
532   clang::Preprocessor &PP = getPreprocessor();
533 
534   std::stringstream RSH;
535   RSH << PP.getPredefines();
536   RSH << "#define RS_VERSION " << mTargetAPI << "\n";
537   RSH << "#include \"rs_core." RS_HEADER_SUFFIX "\"\n";
538   PP.setPredefines(RSH.str());
539 }
540 
initASTContext()541 void Slang::initASTContext() {
542   mRSContext = new RSContext(getPreprocessor(),
543                              getASTContext(),
544                              getTargetInfo(),
545                              &mPragmas,
546                              mTargetAPI,
547                              mVerbose);
548 }
549 
IsRSHeaderFile(const char * File)550 bool Slang::IsRSHeaderFile(const char *File) {
551 #define RS_HEADER_ENTRY(name)  \
552   if (::strcmp(File, #name "." RS_HEADER_SUFFIX) == 0)  \
553     return true;
554 ENUM_RS_HEADER()
555 #undef RS_HEADER_ENTRY
556   return false;
557 }
558 
IsLocInRSHeaderFile(const clang::SourceLocation & Loc,const clang::SourceManager & SourceMgr)559 bool Slang::IsLocInRSHeaderFile(const clang::SourceLocation &Loc,
560                                   const clang::SourceManager &SourceMgr) {
561   clang::FullSourceLoc FSL(Loc, SourceMgr);
562   clang::PresumedLoc PLoc = SourceMgr.getPresumedLoc(FSL);
563 
564   const char *Filename = PLoc.getFilename();
565   if (!Filename) {
566     return false;
567   } else {
568     return IsRSHeaderFile(llvm::sys::path::filename(Filename).data());
569   }
570 }
571 
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,clang::DiagnosticOptions & DiagOpts)572 bool Slang::compile(
573     const std::list<std::pair<const char*, const char*> > &IOFiles64,
574     const std::list<std::pair<const char*, const char*> > &IOFiles32,
575     const std::list<std::pair<const char*, const char*> > &DepFiles,
576     const RSCCOptions &Opts,
577     clang::DiagnosticOptions &DiagOpts) {
578   if (IOFiles32.empty())
579     return true;
580 
581   if (Opts.mEmitDependency && (DepFiles.size() != IOFiles32.size())) {
582     unsigned DiagID = mDiagEngine->getCustomDiagID(
583         clang::DiagnosticsEngine::Error,
584         "invalid parameter for output dependencies files.");
585     getDiagnostics().Report(DiagID);
586     return false;
587   }
588 
589   if (Opts.mEmit3264 && (IOFiles64.size() != IOFiles32.size())) {
590     slangAssert(false && "Should have equal number of 32/64-bit files");
591     return false;
592   }
593 
594   std::string RealPackageName;
595 
596   const char *InputFile, *Output64File, *Output32File, *BCOutputFile,
597              *DepOutputFile;
598 
599   setIncludePaths(Opts.mIncludePaths);
600   setOutputType(Opts.mOutputType);
601   if (Opts.mEmitDependency) {
602     setAdditionalDepTargets(Opts.mAdditionalDepTargets);
603   }
604 
605   setDebugMetadataEmission(Opts.mDebugEmission);
606 
607   setOptimizationLevel(Opts.mOptimizationLevel);
608 
609   mAllowRSPrefix = Opts.mAllowRSPrefix;
610 
611   mTargetAPI = Opts.mTargetAPI;
612   if (mTargetAPI != SLANG_DEVELOPMENT_TARGET_API &&
613       (mTargetAPI < SLANG_MINIMUM_TARGET_API ||
614        mTargetAPI > SLANG_MAXIMUM_TARGET_API)) {
615     unsigned DiagID = mDiagEngine->getCustomDiagID(
616         clang::DiagnosticsEngine::Error,
617         "target API level '%0' is out of range ('%1' - '%2')");
618     getDiagnostics().Report(DiagID) << mTargetAPI << SLANG_MINIMUM_TARGET_API
619                                     << SLANG_MAXIMUM_TARGET_API;
620     return false;
621   }
622 
623   if (mTargetAPI >= SLANG_M_TARGET_API) {
624     LangOpts.NativeHalfArgsAndReturns = 1;
625     LangOpts.NativeHalfType = 1;
626     LangOpts.HalfArgsAndReturns = 1;
627   }
628 
629   mVerbose = Opts.mVerbose;
630 
631   // Skip generation of warnings a second time if we are doing more than just
632   // a single pass over the input file.
633   bool SuppressAllWarnings = (Opts.mOutputType != Slang::OT_Dependency);
634 
635   std::list<std::pair<const char*, const char*> >::const_iterator
636       IOFile64Iter = IOFiles64.begin(),
637       IOFile32Iter = IOFiles32.begin(),
638       DepFileIter = DepFiles.begin();
639 
640   for (unsigned i = 0, e = IOFiles32.size(); i != e; i++) {
641     InputFile = IOFile64Iter->first;
642     Output64File = IOFile64Iter->second;
643     Output32File = IOFile32Iter->second;
644 
645     if (!setInputSource(InputFile))
646       return false;
647 
648     if (!setOutput(Output64File))
649       return false;
650 
651     // For use with 64-bit compilation/reflection. This only sets the filename of
652     // the 32-bit bitcode file, and doesn't actually verify it already exists.
653     mOutput32FileName = Output32File;
654 
655     mIsFilterscript = isFilterscript(InputFile);
656 
657     CodeGenOpts.MainFileName = mInputFileName;
658 
659     if (Slang::compile(Opts) > 0)
660       return false;
661 
662     if (!Opts.mJavaReflectionPackageName.empty()) {
663       mRSContext->setReflectJavaPackageName(Opts.mJavaReflectionPackageName);
664     }
665     const std::string &RealPackageName =
666         mRSContext->getReflectJavaPackageName();
667 
668     bool doReflection = true;
669     if (Opts.mEmit3264 && (Opts.mBitWidth == 32)) {
670       // Skip reflection on the 32-bit path if we are going to emit it on the
671       // 64-bit path.
672       doReflection = false;
673     }
674     if (Opts.mOutputType != Slang::OT_Dependency && doReflection) {
675 
676       if (Opts.mBitcodeStorage == BCST_CPP_CODE) {
677         const std::string &outputFileName = (Opts.mBitWidth == 64) ?
678                                             mOutputFileName : mOutput32FileName;
679         RSReflectionCpp R(mRSContext, Opts.mJavaReflectionPathBase,
680                           getInputFileName(), outputFileName);
681         if (!R.reflect()) {
682             return false;
683         }
684       } else {
685         if (!Opts.mRSPackageName.empty()) {
686           mRSContext->setRSPackageName(Opts.mRSPackageName);
687         }
688 
689         std::vector<std::string> generatedFileNames;
690         RSReflectionJava R(mRSContext, &generatedFileNames,
691                            Opts.mJavaReflectionPathBase, getInputFileName(),
692                            mOutputFileName,
693                            Opts.mBitcodeStorage == BCST_JAVA_CODE);
694         if (!R.reflect()) {
695           // TODO Is this needed or will the error message have been printed
696           // already? and why not for the C++ case?
697           fprintf(stderr, "RSContext::reflectToJava : failed to do reflection "
698                           "(%s)\n",
699                   R.getLastError());
700           return false;
701         }
702 
703         for (std::vector<std::string>::const_iterator
704                  I = generatedFileNames.begin(), E = generatedFileNames.end();
705              I != E;
706              I++) {
707           std::string ReflectedName = RSSlangReflectUtils::ComputePackagedPath(
708               Opts.mJavaReflectionPathBase.c_str(),
709               (RealPackageName + OS_PATH_SEPARATOR_STR + *I).c_str());
710           appendGeneratedFileName(ReflectedName + ".java");
711         }
712 
713         if ((Opts.mOutputType == Slang::OT_Bitcode) &&
714             (Opts.mBitcodeStorage == BCST_JAVA_CODE) &&
715             !generateJavaBitcodeAccessor(Opts.mJavaReflectionPathBase,
716                                          RealPackageName.c_str(),
717                                          mRSContext->getLicenseNote())) {
718           return false;
719         }
720       }
721     }
722 
723     if (Opts.mEmitDependency) {
724       BCOutputFile = DepFileIter->first;
725       DepOutputFile = DepFileIter->second;
726 
727       setDepTargetBC(BCOutputFile);
728 
729       if (!setDepOutput(DepOutputFile))
730         return false;
731 
732       if (SuppressAllWarnings) {
733         getDiagnostics().setSuppressAllDiagnostics(true);
734       }
735       if (generateDepFile(Opts.mEmitPhonyDependency) > 0)
736         return false;
737       if (SuppressAllWarnings) {
738         getDiagnostics().setSuppressAllDiagnostics(false);
739       }
740 
741       DepFileIter++;
742     }
743 
744     if (!checkODR(InputFile))
745       return false;
746 
747     IOFile64Iter++;
748     IOFile32Iter++;
749   }
750   return true;
751 }
752 
753 }  // namespace slang
754