| #include "slang.h" |
| |
| #include <stdlib.h> |
| |
| #include "llvm/Target/TargetSelect.h" |
| |
| #include "llvm/Support/MemoryBuffer.h" |
| #include "llvm/Support/ErrorHandling.h" |
| #include "llvm/Support/ManagedStatic.h" |
| |
| #include "clang/Basic/TargetInfo.h" |
| #include "clang/Basic/LangOptions.h" |
| #include "clang/Basic/TargetOptions.h" |
| |
| #include "clang/Frontend/FrontendDiagnostic.h" |
| |
| #include "clang/Parse/ParseAST.h" |
| |
| #include "libslang.h" |
| #include "slang_rs_export_func.h" |
| |
| using namespace slang; |
| |
| #if defined(__arm__) |
| # define DEFAULT_TARGET_TRIPLE_STRING "armv7-none-linux-gnueabi" |
| #elif defined(__x86_64__) |
| # define DEFAULT_TARGET_TRIPLE_STRING "x86_64-unknown-linux" |
| #else |
| // let's use x86 as default target |
| # define DEFAULT_TARGET_TRIPLE_STRING "i686-unknown-linux" |
| #endif |
| |
| bool Slang::GlobalInitialized = false; |
| |
| // Language option (define the language feature for compiler such as C99) |
| clang::LangOptions Slang::LangOpts; |
| |
| // Code generation option for the compiler |
| clang::CodeGenOptions Slang::CodeGenOpts; |
| |
| const std::string Slang::TargetDescription = |
| "e-" // little-endian |
| "p:32:32:32-" // 32-bit pointer |
| "i1:8:8-" |
| "i8:8:8-" |
| "i16:16:16-" |
| "i32:32:32-" |
| "i64:64:64-" |
| "f32:32:32-" |
| "f64:64:64-" |
| "v64:64:64-" // 64-bit vector (e.g. float2, int2, short4) |
| "v128:128:128-" |
| "a0:0:64-" |
| "n32"; // native CPU only support 32-bit integer width. |
| |
| // The named of metadata node that pragma resides (should be synced with |
| // bcc.cpp) |
| const llvm::StringRef Slang::PragmaMetadataName = "#pragma"; |
| |
| void Slang::GlobalInitialization() { |
| if (!GlobalInitialized) { |
| // We only support x86, x64 and ARM target |
| |
| // For ARM |
| LLVMInitializeARMTargetInfo(); |
| LLVMInitializeARMTarget(); |
| LLVMInitializeARMAsmPrinter(); |
| |
| // For x86 and x64 |
| LLVMInitializeX86TargetInfo(); |
| LLVMInitializeX86Target(); |
| LLVMInitializeX86AsmPrinter(); |
| |
| // Please refer to clang/include/clang/Basic/LangOptions.h to set up |
| // the options. |
| LangOpts.RTTI = 0; // Turn off the RTTI information support |
| LangOpts.NeXTRuntime = 0; // Turn off the NeXT runtime uses |
| LangOpts.Bool = 1; // Turn on 'bool', 'true', 'false' keywords |
| |
| CodeGenOpts.OptimizationLevel = 3; /* -O3 */ |
| |
| GlobalInitialized = true; |
| } |
| |
| return; |
| } |
| |
| void Slang::LLVMErrorHandler(void *UserData, const std::string &Message) { |
| clang::Diagnostic* Diags = static_cast<clang::Diagnostic*>(UserData); |
| Diags->Report(clang::diag::err_fe_error_backend) << Message; |
| exit(1); |
| } |
| |
| void Slang::createTarget(const char* Triple, const char* CPU, |
| const char** Features) { |
| if (Triple != NULL) |
| mTargetOpts.Triple = Triple; |
| else |
| mTargetOpts.Triple = DEFAULT_TARGET_TRIPLE_STRING; |
| |
| if (CPU != NULL) |
| mTargetOpts.CPU = CPU; |
| |
| mTarget.reset(clang::TargetInfo::CreateTargetInfo(*mDiagnostics, |
| mTargetOpts)); |
| |
| if (Features != NULL) |
| for (int i = 0; Features[i] != NULL; i++) |
| mTargetOpts.Features.push_back(Features[i]); |
| |
| return; |
| } |
| |
| void Slang::createPreprocessor() { |
| // Default only search header file in current dir |
| clang::HeaderSearch *HS = new clang::HeaderSearch(*mFileMgr); |
| |
| mPP.reset(new clang::Preprocessor(*mDiagnostics, |
| LangOpts, |
| *mTarget, |
| *mSourceMgr, |
| *HS, |
| NULL, |
| /* OwnsHeaderSearch */true)); |
| // Initialize the prepocessor |
| mPragmas.clear(); |
| mPP->AddPragmaHandler(new PragmaRecorder(mPragmas)); |
| |
| std::string inclFiles("#include \"rs_types.rsh\""); |
| mPP->setPredefines(inclFiles + "\n" + "#include \"rs_math.rsh\"" + "\n"); |
| |
| std::vector<clang::DirectoryLookup> SearchList; |
| for (unsigned i = 0; i < mIncludePaths.size(); ++i) { |
| if (const clang::DirectoryEntry *DE = |
| mFileMgr->getDirectory(mIncludePaths[i])) { |
| SearchList.push_back(clang::DirectoryLookup(DE, |
| clang::SrcMgr::C_System, |
| false, |
| false)); |
| } |
| } |
| |
| HS->SetSearchPaths(SearchList, 1, false); |
| |
| return; |
| } |
| |
| Slang::Slang(const char *Triple, const char *CPU, const char **Features) |
| : mOutputType(SlangCompilerOutput_Default), |
| mAllowRSPrefix(false) { |
| GlobalInitialization(); |
| |
| createDiagnostic(); |
| llvm::install_fatal_error_handler(LLVMErrorHandler, mDiagnostics.get()); |
| |
| createTarget(Triple, CPU, Features); |
| createFileManager(); |
| createSourceManager(); |
| |
| return; |
| } |
| |
| bool Slang::setInputSource(llvm::StringRef inputFile, |
| const char *text, |
| size_t textLength) { |
| mInputFileName = inputFile.str(); |
| |
| // Reset the ID tables if we are reusing the SourceManager |
| mSourceMgr->clearIDTables(); |
| |
| // Load the source |
| llvm::MemoryBuffer *SB = |
| llvm::MemoryBuffer::getMemBuffer(text, text + textLength); |
| mSourceMgr->createMainFileIDForMemBuffer(SB); |
| |
| if (mSourceMgr->getMainFileID().isInvalid()) { |
| mDiagnostics->Report(clang::diag::err_fe_error_reading) << inputFile; |
| return false; |
| } |
| return true; |
| } |
| |
| bool Slang::setInputSource(llvm::StringRef inputFile) { |
| mInputFileName = inputFile.str(); |
| |
| mSourceMgr->clearIDTables(); |
| |
| const clang::FileEntry *File = mFileMgr->getFile(inputFile); |
| if (File) |
| mSourceMgr->createMainFileID(File); |
| |
| if (mSourceMgr->getMainFileID().isInvalid()) { |
| mDiagnostics->Report(clang::diag::err_fe_error_reading) << inputFile; |
| return false; |
| } |
| |
| return true; |
| } |
| |
| void Slang::addIncludePath(const char *path) { |
| mIncludePaths.push_back(path); |
| } |
| |
| void Slang::setOutputType(SlangCompilerOutputTy outputType) { |
| mOutputType = outputType; |
| if ( mOutputType != SlangCompilerOutput_Assembly && |
| mOutputType != SlangCompilerOutput_LL && |
| mOutputType != SlangCompilerOutput_Bitcode && |
| mOutputType != SlangCompilerOutput_Nothing && |
| mOutputType != SlangCompilerOutput_Obj) |
| mOutputType = SlangCompilerOutput_Default; |
| return; |
| } |
| |
| static void _mkdir_given_a_file(const char *file) { |
| char buf[256]; |
| char *tmp, *p = NULL; |
| size_t len = strlen(file); |
| |
| if (len + 1 <= sizeof(buf)) |
| tmp = buf; |
| else |
| tmp = new char[len + 1]; |
| |
| strcpy(tmp, file); |
| |
| if (tmp[len - 1] == '/') |
| tmp[len - 1] = 0; |
| |
| for (p = tmp + 1; *p; p++) { |
| if (*p == '/') { |
| *p = 0; |
| mkdir(tmp, S_IRWXU); |
| *p = '/'; |
| } |
| } |
| |
| if (tmp != buf) |
| delete[] tmp; |
| } |
| |
| bool Slang::setOutput(const char *outputFile) { |
| std::string Error; |
| |
| _mkdir_given_a_file(outputFile); |
| |
| switch (mOutputType) { |
| case SlangCompilerOutput_Assembly: |
| case SlangCompilerOutput_LL: { |
| mOS.reset(new llvm::raw_fd_ostream(outputFile, Error, 0)); |
| break; |
| } |
| case SlangCompilerOutput_Nothing: { |
| mOS.reset(); |
| break; |
| } |
| case SlangCompilerOutput_Obj: |
| case SlangCompilerOutput_Bitcode: |
| default: { |
| mOS.reset(new llvm::raw_fd_ostream(outputFile, |
| Error, |
| llvm::raw_fd_ostream::F_Binary)); |
| break; |
| } |
| } |
| |
| if (!Error.empty()) { |
| mOS.reset(); |
| mDiagnostics->Report(clang::diag::err_fe_error_opening) << outputFile |
| << Error; |
| return false; |
| } |
| |
| mOutputFileName = outputFile; |
| |
| return true; |
| } |
| |
| int Slang::compile() { |
| if ((mDiagnostics->getNumErrors() > 0) || (mOS.get() == NULL)) |
| return mDiagnostics->getNumErrors(); |
| |
| // Here is per-compilation needed initialization |
| createPreprocessor(); |
| createASTContext(); |
| createRSContext(); |
| //createBackend(); |
| createRSBackend(); |
| |
| // Inform the diagnostic client we are processing a source file |
| mDiagClient->BeginSourceFile(LangOpts, mPP.get()); |
| |
| // The core of the slang compiler |
| ParseAST(*mPP, mBackend.get(), *mASTContext); |
| |
| // The compilation ended, clear up |
| mBackend.reset(); |
| // Can't reset yet because the reflection later on still needs mRSContext |
| //mRSContext.reset(); |
| mASTContext.reset(); |
| mPP.reset(); |
| |
| // Inform the diagnostic client we are done with previous source file |
| mDiagClient->EndSourceFile(); |
| |
| return mDiagnostics->getNumErrors(); |
| } |
| |
| bool Slang::reflectToJava(const char *outputPackageName, |
| char *realPackageName, |
| int bSize) { |
| if (mRSContext.get()) |
| return mRSContext->reflectToJava(outputPackageName, |
| mInputFileName, |
| mOutputFileName, |
| realPackageName, |
| bSize); |
| else |
| return false; |
| } |
| |
| bool Slang::reflectToJavaPath(const char *outputPathName) { |
| if (mRSContext.get()) |
| return mRSContext->reflectToJavaPath(outputPathName); |
| else |
| return false; |
| } |
| |
| void Slang::getPragmas(size_t *actualStringCount, |
| size_t maxStringCount, |
| char **strings) { |
| unsigned stringCount = mPragmas.size() * 2; |
| |
| if (actualStringCount) |
| *actualStringCount = stringCount; |
| if (stringCount > maxStringCount) |
| stringCount = maxStringCount; |
| if (strings) |
| for (PragmaList::const_iterator it = mPragmas.begin(); |
| stringCount > 0; |
| stringCount -= 2, it++) { |
| *strings++ = const_cast<char*>(it->first.c_str()); |
| *strings++ = const_cast<char*>(it->second.c_str()); |
| } |
| |
| return; |
| } |
| |
| typedef std::list<RSExportFunc*> ExportFuncList; |
| |
| const char* Slang::exportFuncs() { |
| std::string fNames; |
| for (RSContext::const_export_func_iterator |
| I = mRSContext->export_funcs_begin(), |
| E = mRSContext->export_funcs_end(); |
| I != E; |
| I++) { |
| RSExportFunc* func = *I; |
| fNames.push_back(','); |
| fNames.append(func->getName()); |
| } |
| return fNames.c_str(); |
| } |
| |
| Slang::~Slang() { |
| llvm::llvm_shutdown(); |
| return; |
| } |