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