slang.cpp revision 21c94c9b4cc3c139c0d2c08f81e773aa3e269cff
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 86namespace { 87 88static const char *kRSTriple32 = "armv7-none-linux-gnueabi"; 89static const char *kRSTriple64 = "aarch64-none-linux-gnueabi"; 90 91} // namespace 92 93namespace 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) 123const llvm::StringRef Slang::PragmaMetadataName = "#pragma"; 124 125static inline llvm::tool_output_file * 126OpenOutputFile(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 149void 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 165void Slang::createFileManager() { 166 mFileSysOpt.reset(new clang::FileSystemOptions()); 167 mFileMgr.reset(new clang::FileManager(*mFileSysOpt)); 168} 169 170void Slang::createSourceManager() { 171 mSourceMgr.reset(new clang::SourceManager(*mDiagEngine, *mFileMgr)); 172} 173 174void 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 220void 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 228clang::ASTConsumer * 229Slang::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 236Slang::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 258Slang::~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 267clang::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 276bool 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 295bool 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 329bool 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 342int Slang::generateDepFile(bool PhonyTarget) { 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 if (PhonyTarget) 352 DepOpts.UsePhonyTargets = 1; 353 DepOpts.OutputFile = mDepOutputFileName; 354 DepOpts.Targets = mAdditionalDepTargets; 355 DepOpts.Targets.push_back(mDepTargetBCFileName); 356 for (std::vector<std::string>::const_iterator 357 I = mGeneratedFileNames.begin(), E = mGeneratedFileNames.end(); 358 I != E; 359 I++) { 360 DepOpts.Targets.push_back(*I); 361 } 362 mGeneratedFileNames.clear(); 363 364 // Per-compilation needed initialization 365 createPreprocessor(); 366 clang::DependencyFileGenerator::CreateAndAttachToPreprocessor(*mPP.get(), DepOpts); 367 368 // Inform the diagnostic client we are processing a source file 369 mDiagClient->BeginSourceFile(LangOpts, mPP.get()); 370 371 // Go through the source file (no operations necessary) 372 clang::Token Tok; 373 mPP->EnterMainSourceFile(); 374 do { 375 mPP->Lex(Tok); 376 } while (Tok.isNot(clang::tok::eof)); 377 378 mPP->EndSourceFile(); 379 380 // Declare success if no error 381 if (!mDiagEngine->hasErrorOccurred()) 382 mDOS->keep(); 383 384 // Clean up after compilation 385 mPP.reset(); 386 mDOS.reset(); 387 388 return mDiagEngine->hasErrorOccurred() ? 1 : 0; 389} 390 391int Slang::compile() { 392 if (mDiagEngine->hasErrorOccurred()) 393 return 1; 394 if (mOS.get() == nullptr) 395 return 1; 396 397 // Here is per-compilation needed initialization 398 createPreprocessor(); 399 createASTContext(); 400 401 mBackend.reset(createBackend(CodeGenOpts, &mOS->os(), mOT)); 402 403 // Inform the diagnostic client we are processing a source file 404 mDiagClient->BeginSourceFile(LangOpts, mPP.get()); 405 406 // The core of the slang compiler 407 ParseAST(*mPP, mBackend.get(), *mASTContext); 408 409 // Inform the diagnostic client we are done with previous source file 410 mDiagClient->EndSourceFile(); 411 412 // Declare success if no error 413 if (!mDiagEngine->hasErrorOccurred()) 414 mOS->keep(); 415 416 // The compilation ended, clear 417 mBackend.reset(); 418 mOS.reset(); 419 420 return mDiagEngine->hasErrorOccurred() ? 1 : 0; 421} 422 423void Slang::setDebugMetadataEmission(bool EmitDebug) { 424 if (EmitDebug) 425 CodeGenOpts.setDebugInfo(clang::CodeGenOptions::FullDebugInfo); 426 else 427 CodeGenOpts.setDebugInfo(clang::CodeGenOptions::NoDebugInfo); 428} 429 430void Slang::setOptimizationLevel(llvm::CodeGenOpt::Level OptimizationLevel) { 431 CodeGenOpts.OptimizationLevel = OptimizationLevel; 432} 433 434bool Slang::isFilterscript(const char *Filename) { 435 const char *c = strrchr(Filename, '.'); 436 if (c && !strncmp(FS_SUFFIX, c + 1, strlen(FS_SUFFIX) + 1)) { 437 return true; 438 } else { 439 return false; 440 } 441} 442 443bool Slang::generateJavaBitcodeAccessor(const std::string &OutputPathBase, 444 const std::string &PackageName, 445 const std::string *LicenseNote) { 446 RSSlangReflectUtils::BitCodeAccessorContext BCAccessorContext; 447 448 BCAccessorContext.rsFileName = getInputFileName().c_str(); 449 BCAccessorContext.bc32FileName = mOutput32FileName.c_str(); 450 BCAccessorContext.bc64FileName = mOutputFileName.c_str(); 451 BCAccessorContext.reflectPath = OutputPathBase.c_str(); 452 BCAccessorContext.packageName = PackageName.c_str(); 453 BCAccessorContext.licenseNote = LicenseNote; 454 BCAccessorContext.bcStorage = BCST_JAVA_CODE; // Must be BCST_JAVA_CODE 455 BCAccessorContext.verbose = false; 456 457 return RSSlangReflectUtils::GenerateJavaBitCodeAccessor(BCAccessorContext); 458} 459 460bool Slang::checkODR(const char *CurInputFile) { 461 for (RSContext::ExportableList::iterator I = mRSContext->exportable_begin(), 462 E = mRSContext->exportable_end(); 463 I != E; 464 I++) { 465 RSExportable *RSE = *I; 466 if (RSE->getKind() != RSExportable::EX_TYPE) 467 continue; 468 469 RSExportType *ET = static_cast<RSExportType *>(RSE); 470 if (ET->getClass() != RSExportType::ExportClassRecord) 471 continue; 472 473 RSExportRecordType *ERT = static_cast<RSExportRecordType *>(ET); 474 475 // Artificial record types (create by us not by user in the source) always 476 // conforms the ODR. 477 if (ERT->isArtificial()) 478 continue; 479 480 // Key to lookup ERT in ReflectedDefinitions 481 llvm::StringRef RDKey(ERT->getName()); 482 ReflectedDefinitionListTy::const_iterator RD = 483 ReflectedDefinitions.find(RDKey); 484 485 if (RD != ReflectedDefinitions.end()) { 486 const RSExportRecordType *Reflected = RD->getValue().first; 487 // There's a record (struct) with the same name reflected before. Enforce 488 // ODR checking - the Reflected must hold *exactly* the same "definition" 489 // as the one defined previously. We say two record types A and B have the 490 // same definition iff: 491 // 492 // struct A { struct B { 493 // Type(a1) a1, Type(b1) b1, 494 // Type(a2) a2, Type(b1) b2, 495 // ... ... 496 // Type(aN) aN Type(b3) b3, 497 // }; } 498 // Cond. #1. They have same number of fields, i.e., N = M; 499 // Cond. #2. for (i := 1 to N) 500 // Type(ai) = Type(bi) must hold; 501 // Cond. #3. for (i := 1 to N) 502 // Name(ai) = Name(bi) must hold; 503 // 504 // where, 505 // Type(F) = the type of field F and 506 // Name(F) = the field name. 507 508 bool PassODR = false; 509 // Cond. #1 and Cond. #2 510 if (Reflected->equals(ERT)) { 511 // Cond #3. 512 RSExportRecordType::const_field_iterator AI = Reflected->fields_begin(), 513 BI = ERT->fields_begin(); 514 515 for (unsigned i = 0, e = Reflected->getFields().size(); i != e; i++) { 516 if ((*AI)->getName() != (*BI)->getName()) 517 break; 518 AI++; 519 BI++; 520 } 521 PassODR = (AI == (Reflected->fields_end())); 522 } 523 524 if (!PassODR) { 525 unsigned DiagID = mDiagEngine->getCustomDiagID( 526 clang::DiagnosticsEngine::Error, 527 "type '%0' in different translation unit (%1 v.s. %2) " 528 "has incompatible type definition"); 529 getDiagnostics().Report(DiagID) << Reflected->getName() 530 << getInputFileName() 531 << RD->getValue().second; 532 return false; 533 } 534 } else { 535 llvm::StringMapEntry<ReflectedDefinitionTy> *ME = 536 llvm::StringMapEntry<ReflectedDefinitionTy>::Create(RDKey); 537 ME->setValue(std::make_pair(ERT, CurInputFile)); 538 539 if (!ReflectedDefinitions.insert(ME)) { 540 slangAssert(false && "Type shouldn't be in map yet!"); 541 } 542 543 // Take the ownership of ERT such that it won't be freed in ~RSContext(). 544 ERT->keep(); 545 } 546 } 547 return true; 548} 549 550void Slang::initPreprocessor() { 551 clang::Preprocessor &PP = getPreprocessor(); 552 553 std::stringstream RSH; 554 RSH << PP.getPredefines(); 555 RSH << "#define RS_VERSION " << mTargetAPI << "\n"; 556 RSH << "#include \"rs_core." RS_HEADER_SUFFIX "\"\n"; 557 PP.setPredefines(RSH.str()); 558} 559 560void Slang::initASTContext() { 561 mRSContext = new RSContext(getPreprocessor(), 562 getASTContext(), 563 getTargetInfo(), 564 &mPragmas, 565 mTargetAPI, 566 mVerbose); 567} 568 569bool Slang::IsRSHeaderFile(const char *File) { 570#define RS_HEADER_ENTRY(name) \ 571 if (::strcmp(File, #name "." RS_HEADER_SUFFIX) == 0) \ 572 return true; 573ENUM_RS_HEADER() 574#undef RS_HEADER_ENTRY 575 return false; 576} 577 578bool Slang::IsLocInRSHeaderFile(const clang::SourceLocation &Loc, 579 const clang::SourceManager &SourceMgr) { 580 clang::FullSourceLoc FSL(Loc, SourceMgr); 581 clang::PresumedLoc PLoc = SourceMgr.getPresumedLoc(FSL); 582 583 const char *Filename = PLoc.getFilename(); 584 if (!Filename) { 585 return false; 586 } else { 587 return IsRSHeaderFile(llvm::sys::path::filename(Filename).data()); 588 } 589} 590 591bool Slang::compile( 592 const std::list<std::pair<const char*, const char*> > &IOFiles64, 593 const std::list<std::pair<const char*, const char*> > &IOFiles32, 594 const std::list<std::pair<const char*, const char*> > &DepFiles, 595 const RSCCOptions &Opts, 596 clang::DiagnosticOptions &DiagOpts) { 597 if (IOFiles32.empty()) 598 return true; 599 600 if (Opts.mEmitDependency && (DepFiles.size() != IOFiles32.size())) { 601 unsigned DiagID = mDiagEngine->getCustomDiagID( 602 clang::DiagnosticsEngine::Error, 603 "invalid parameter for output dependencies files."); 604 getDiagnostics().Report(DiagID); 605 return false; 606 } 607 608 if (Opts.mEmit3264 && (IOFiles64.size() != IOFiles32.size())) { 609 slangAssert(false && "Should have equal number of 32/64-bit files"); 610 return false; 611 } 612 613 std::string RealPackageName; 614 615 const char *InputFile, *Output64File, *Output32File, *BCOutputFile, 616 *DepOutputFile; 617 618 setIncludePaths(Opts.mIncludePaths); 619 setOutputType(Opts.mOutputType); 620 if (Opts.mEmitDependency) { 621 setAdditionalDepTargets(Opts.mAdditionalDepTargets); 622 } 623 624 setDebugMetadataEmission(Opts.mDebugEmission); 625 626 setOptimizationLevel(Opts.mOptimizationLevel); 627 628 mAllowRSPrefix = Opts.mAllowRSPrefix; 629 630 mTargetAPI = Opts.mTargetAPI; 631 if (mTargetAPI != SLANG_DEVELOPMENT_TARGET_API && 632 (mTargetAPI < SLANG_MINIMUM_TARGET_API || 633 mTargetAPI > SLANG_MAXIMUM_TARGET_API)) { 634 unsigned DiagID = mDiagEngine->getCustomDiagID( 635 clang::DiagnosticsEngine::Error, 636 "target API level '%0' is out of range ('%1' - '%2')"); 637 getDiagnostics().Report(DiagID) << mTargetAPI << SLANG_MINIMUM_TARGET_API 638 << SLANG_MAXIMUM_TARGET_API; 639 return false; 640 } 641 642 if (mTargetAPI >= SLANG_M_TARGET_API) { 643 LangOpts.NativeHalfType = 1; 644 LangOpts.HalfArgsAndReturns = 1; 645 } 646 647 mVerbose = Opts.mVerbose; 648 649 // Skip generation of warnings a second time if we are doing more than just 650 // a single pass over the input file. 651 bool SuppressAllWarnings = (Opts.mOutputType != Slang::OT_Dependency); 652 653 std::list<std::pair<const char*, const char*> >::const_iterator 654 IOFile64Iter = IOFiles64.begin(), 655 IOFile32Iter = IOFiles32.begin(), 656 DepFileIter = DepFiles.begin(); 657 658 for (unsigned i = 0, e = IOFiles32.size(); i != e; i++) { 659 InputFile = IOFile64Iter->first; 660 Output64File = IOFile64Iter->second; 661 Output32File = IOFile32Iter->second; 662 663 if (!setInputSource(InputFile)) 664 return false; 665 666 if (!setOutput(Output64File)) 667 return false; 668 669 // For use with 64-bit compilation/reflection. This only sets the filename of 670 // the 32-bit bitcode file, and doesn't actually verify it already exists. 671 mOutput32FileName = Output32File; 672 673 mIsFilterscript = isFilterscript(InputFile); 674 675 CodeGenOpts.MainFileName = mInputFileName; 676 677 if (Slang::compile() > 0) 678 return false; 679 680 if (!Opts.mJavaReflectionPackageName.empty()) { 681 mRSContext->setReflectJavaPackageName(Opts.mJavaReflectionPackageName); 682 } 683 const std::string &RealPackageName = 684 mRSContext->getReflectJavaPackageName(); 685 686 bool doReflection = true; 687 if (Opts.mEmit3264 && (Opts.mBitWidth == 32)) { 688 // Skip reflection on the 32-bit path if we are going to emit it on the 689 // 64-bit path. 690 doReflection = false; 691 } 692 if (Opts.mOutputType != Slang::OT_Dependency && doReflection) { 693 694 if (Opts.mBitcodeStorage == BCST_CPP_CODE) { 695 const std::string &outputFileName = (Opts.mBitWidth == 64) ? 696 mOutputFileName : mOutput32FileName; 697 RSReflectionCpp R(mRSContext, Opts.mJavaReflectionPathBase, 698 getInputFileName(), outputFileName); 699 if (!R.reflect()) { 700 return false; 701 } 702 } else { 703 if (!Opts.mRSPackageName.empty()) { 704 mRSContext->setRSPackageName(Opts.mRSPackageName); 705 } 706 707 std::vector<std::string> generatedFileNames; 708 RSReflectionJava R(mRSContext, &generatedFileNames, 709 Opts.mJavaReflectionPathBase, getInputFileName(), 710 mOutputFileName, 711 Opts.mBitcodeStorage == BCST_JAVA_CODE); 712 if (!R.reflect()) { 713 // TODO Is this needed or will the error message have been printed 714 // already? and why not for the C++ case? 715 fprintf(stderr, "RSContext::reflectToJava : failed to do reflection " 716 "(%s)\n", 717 R.getLastError()); 718 return false; 719 } 720 721 for (std::vector<std::string>::const_iterator 722 I = generatedFileNames.begin(), E = generatedFileNames.end(); 723 I != E; 724 I++) { 725 std::string ReflectedName = RSSlangReflectUtils::ComputePackagedPath( 726 Opts.mJavaReflectionPathBase.c_str(), 727 (RealPackageName + OS_PATH_SEPARATOR_STR + *I).c_str()); 728 appendGeneratedFileName(ReflectedName + ".java"); 729 } 730 731 if ((Opts.mOutputType == Slang::OT_Bitcode) && 732 (Opts.mBitcodeStorage == BCST_JAVA_CODE) && 733 !generateJavaBitcodeAccessor(Opts.mJavaReflectionPathBase, 734 RealPackageName.c_str(), 735 mRSContext->getLicenseNote())) { 736 return false; 737 } 738 } 739 } 740 741 if (Opts.mEmitDependency) { 742 BCOutputFile = DepFileIter->first; 743 DepOutputFile = DepFileIter->second; 744 745 setDepTargetBC(BCOutputFile); 746 747 if (!setDepOutput(DepOutputFile)) 748 return false; 749 750 if (SuppressAllWarnings) { 751 getDiagnostics().setSuppressAllDiagnostics(true); 752 } 753 if (generateDepFile(Opts.mEmitPhonyDependency) > 0) 754 return false; 755 if (SuppressAllWarnings) { 756 getDiagnostics().setSuppressAllDiagnostics(false); 757 } 758 759 DepFileIter++; 760 } 761 762 if (!checkODR(InputFile)) 763 return false; 764 765 IOFile64Iter++; 766 IOFile32Iter++; 767 } 768 return true; 769} 770 771} // namespace slang 772