| /* |
| * Copyright 2010-2012, The Android Open Source Project |
| * |
| * Licensed under the Apache License, Version 2.0 (the "License"); |
| * you may not use this file except in compliance with the License. |
| * You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License. |
| */ |
| |
| // Bitcode compiler (bcc) for Android: |
| // This is an eager-compilation JIT running on Android. |
| |
| #include <bcc/bcc.h> |
| |
| #include <llvm/Support/CodeGen.h> |
| |
| #include <utils/StopWatch.h> |
| |
| #include "DebugHelper.h" |
| #include "Initialization.h" |
| #include "RSExecutable.h" |
| #include "RSScript.h" |
| #include "Sha1Helper.h" |
| #include "Source.h" |
| |
| #include "bcc_internal.h" |
| #include <bcinfo/BitcodeWrapper.h> |
| |
| using namespace bcc; |
| |
| namespace llvm { |
| class Module; |
| } |
| |
| static bool bccBuildStampPrinted = false; |
| |
| static void bccPrintBuildStamp() { |
| if (!bccBuildStampPrinted) { |
| ALOGI("LIBBCC build time: %s", bccGetBuildTime()); |
| ALOGI("LIBBCC build revision: %s", bccGetBuildRev()); |
| bccBuildStampPrinted = true; |
| } |
| } |
| |
| extern "C" BCCScriptRef bccCreateScript() { |
| BCC_FUNC_LOGGER(); |
| bccPrintBuildStamp(); |
| init::Initialize(); |
| RSScriptContext *rsctx = new (std::nothrow) RSScriptContext(); |
| if (rsctx != NULL) { |
| rsctx->script = NULL; |
| rsctx->result = NULL; |
| } |
| return wrap(rsctx); |
| } |
| |
| |
| extern "C" void bccDisposeScript(BCCScriptRef script) { |
| BCC_FUNC_LOGGER(); |
| RSScriptContext *rsctx = unwrap(script); |
| if (rsctx != NULL) { |
| delete rsctx->script; |
| delete rsctx->result; |
| } |
| delete rsctx; |
| } |
| |
| |
| extern "C" int bccRegisterSymbolCallback(BCCScriptRef script, |
| BCCSymbolLookupFn pFn, |
| void *pContext) { |
| BCC_FUNC_LOGGER(); |
| unwrap(script)->driver.setRSRuntimeLookupFunction(pFn); |
| unwrap(script)->driver.setRSRuntimeLookupContext(pContext); |
| return BCC_NO_ERROR; |
| } |
| |
| |
| extern "C" int bccGetError(BCCScriptRef script) { |
| BCC_FUNC_LOGGER(); |
| return BCC_DEPRECATED_API; |
| } |
| |
| static bool helper_add_source(RSScriptContext *pCtx, |
| char const *pName, |
| char const *pBitcode, |
| size_t pBitcodeSize, |
| unsigned long pFlags, |
| bool pIsLink) { |
| bool need_dependency_check = !(pFlags & BCC_SKIP_DEP_SHA1); |
| if (!pName && need_dependency_check) { |
| pFlags |= BCC_SKIP_DEP_SHA1; |
| |
| ALOGW("It is required to give resName for sha1 dependency check.\n"); |
| ALOGW("Sha1sum dependency check will be skipped.\n"); |
| ALOGW("Set BCC_SKIP_DEP_SHA1 for flags to surpress this warning.\n"); |
| } |
| |
| Source *source = Source::CreateFromBuffer(pCtx->context, pName, |
| pBitcode, pBitcodeSize); |
| if (source == NULL) { |
| return false; |
| } |
| |
| if (pCtx->script == NULL) { |
| pCtx->script = new (std::nothrow) RSScript(*source); |
| if (pCtx->script == NULL) { |
| ALOGE("Out of memory during script creation."); |
| return false; |
| } |
| } else { |
| bool result; |
| if (pIsLink) { |
| result = pCtx->script->mergeSource(*source); |
| } else { |
| result = pCtx->script->reset(*source); |
| } |
| if (!result) { |
| return false; |
| } else { |
| bcinfo::BitcodeWrapper wrapper(pBitcode, pBitcodeSize); |
| pCtx->script->setCompilerVersion(wrapper.getCompilerVersion()); |
| pCtx->script->setOptimizationLevel( |
| static_cast<RSScript::OptimizationLevel>( |
| wrapper.getOptimizationLevel())); |
| } |
| } |
| |
| if (need_dependency_check) { |
| uint8_t sha1[20]; |
| calcSHA1(sha1, pBitcode, pBitcodeSize); |
| if (!pCtx->script->addSourceDependency(pName, sha1)) { |
| return false; |
| } |
| } |
| |
| return true; |
| } |
| |
| static bool helper_add_source(RSScriptContext *pCtx, |
| llvm::Module *pModule, |
| bool pIsLink) { |
| if (pModule == NULL) { |
| ALOGE("Cannot add null module to script!"); |
| return false; |
| } |
| |
| Source *source = Source::CreateFromModule(pCtx->context, *pModule, true); |
| if (source == NULL) { |
| return false; |
| } |
| |
| if (pCtx->script == NULL) { |
| pCtx->script = new (std::nothrow) RSScript(*source); |
| if (pCtx->script == NULL) { |
| ALOGE("Out of memory during script creation."); |
| return false; |
| } |
| } else { |
| bool result; |
| if (pIsLink) { |
| result = pCtx->script->mergeSource(*source); |
| } else { |
| result = pCtx->script->reset(*source); |
| } |
| if (!result) { |
| return false; |
| } |
| } |
| |
| return true; |
| } |
| |
| static bool helper_add_source(RSScriptContext *pCtx, |
| char const *pPath, |
| unsigned long pFlags, |
| bool pIsLink) { |
| bool need_dependency_check = !(pFlags & BCC_SKIP_DEP_SHA1); |
| |
| Source *source = Source::CreateFromFile(pCtx->context, pPath); |
| if (source == NULL) { |
| return false; |
| } |
| |
| if (pCtx->script == NULL) { |
| pCtx->script = new (std::nothrow) RSScript(*source); |
| if (pCtx->script == NULL) { |
| ALOGE("Out of memory during script creation."); |
| return false; |
| } |
| } else { |
| bool result; |
| if (pIsLink) { |
| result = pCtx->script->mergeSource(*source); |
| } else { |
| result = pCtx->script->reset(*source); |
| } |
| if (!result) { |
| return false; |
| } |
| } |
| |
| if (need_dependency_check) { |
| uint8_t sha1[20]; |
| calcFileSHA1(sha1, pPath); |
| if (!pCtx->script->addSourceDependency(pPath, sha1)) { |
| return false; |
| } |
| } |
| |
| return true; |
| } |
| |
| extern "C" int bccReadBC(BCCScriptRef script, |
| char const *resName, |
| char const *bitcode, |
| size_t bitcodeSize, |
| unsigned long flags) { |
| BCC_FUNC_LOGGER(); |
| return (helper_add_source(unwrap(script), resName, |
| bitcode, bitcodeSize, |
| flags, /* pIsLink */false) == false); |
| } |
| |
| |
| extern "C" int bccReadModule(BCCScriptRef script, |
| char const *resName /* deprecated */, |
| LLVMModuleRef module, |
| unsigned long flags) { |
| BCC_FUNC_LOGGER(); |
| return (helper_add_source(unwrap(script), unwrap(module), |
| /* pIsLink */false) == false); |
| } |
| |
| |
| extern "C" int bccReadFile(BCCScriptRef script, |
| char const *path, |
| unsigned long flags) { |
| BCC_FUNC_LOGGER(); |
| return (helper_add_source(unwrap(script), path, |
| flags, /* pIsLink */false) == false); |
| } |
| |
| |
| extern "C" int bccLinkBC(BCCScriptRef script, |
| char const *resName, |
| char const *bitcode, |
| size_t bitcodeSize, |
| unsigned long flags) { |
| BCC_FUNC_LOGGER(); |
| return (helper_add_source(unwrap(script), resName, |
| bitcode, bitcodeSize, |
| flags, /* pIsLink */true) == false); |
| } |
| |
| |
| extern "C" int bccLinkFile(BCCScriptRef script, |
| char const *path, |
| unsigned long flags) { |
| BCC_FUNC_LOGGER(); |
| return (helper_add_source(unwrap(script), path, |
| flags, /* pIsLink */true) == false); |
| } |
| |
| |
| extern "C" void bccMarkExternalSymbol(BCCScriptRef script, char const *name) { |
| BCC_FUNC_LOGGER(); |
| return /* BCC_DEPRECATED_API */; |
| } |
| |
| |
| extern "C" int bccPrepareRelocatable(BCCScriptRef script, |
| char const *objPath, |
| bccRelocModelEnum RelocModel, |
| unsigned long flags) { |
| BCC_FUNC_LOGGER(); |
| return BCC_DEPRECATED_API; |
| } |
| |
| |
| extern "C" int bccPrepareSharedObject(BCCScriptRef script, |
| char const *objPath, |
| char const *dsoPath, |
| unsigned long flags) { |
| BCC_FUNC_LOGGER(); |
| return BCC_DEPRECATED_API; |
| } |
| |
| |
| extern "C" int bccPrepareExecutable(BCCScriptRef script, |
| char const *cacheDir, |
| char const *cacheName, |
| unsigned long flags) { |
| BCC_FUNC_LOGGER(); |
| |
| android::StopWatch compileTimer("bcc: PrepareExecutable time"); |
| |
| RSScriptContext *rsctx = unwrap(script); |
| |
| if (rsctx->script == NULL) { |
| return 1; |
| } |
| |
| // Construct the output path. |
| std::string output_path(cacheDir); |
| if (!output_path.empty() && (*output_path.rbegin() != '/')) { |
| output_path.append(1, '/'); |
| } |
| output_path.append(cacheName); |
| output_path.append(".o"); |
| |
| // Make sure the result container is clean. |
| if (rsctx->result != NULL) { |
| delete rsctx->result; |
| rsctx->result = NULL; |
| } |
| |
| rsctx->result = rsctx->driver.build(*rsctx->script, output_path); |
| |
| return (rsctx->result == NULL); |
| } |
| |
| |
| extern "C" void *bccGetFuncAddr(BCCScriptRef script, char const *funcname) { |
| BCC_FUNC_LOGGER(); |
| |
| RSScriptContext *rsctx = unwrap(script); |
| |
| void *addr = NULL; |
| if (rsctx->result != NULL) { |
| addr = rsctx->result->getSymbolAddress(funcname); |
| } |
| |
| #if DEBUG_BCC_REFLECT |
| ALOGD("Function Address: %s --> %p\n", funcname, addr); |
| #endif |
| |
| return addr; |
| } |
| |
| |
| extern "C" void bccGetExportVarList(BCCScriptRef script, |
| size_t varListSize, |
| void **varList) { |
| BCC_FUNC_LOGGER(); |
| |
| const RSScriptContext *rsctx = unwrap(script); |
| if (varList && rsctx->result) { |
| const android::Vector<void *> &export_var_addrs = |
| rsctx->result->getExportVarAddrs(); |
| size_t count = export_var_addrs.size(); |
| |
| if (count > varListSize) { |
| count = varListSize; |
| } |
| |
| for (size_t i = 0; i < count; ++i) { |
| varList[i] = export_var_addrs[i]; |
| } |
| |
| #if DEBUG_BCC_REFLECT |
| ALOGD("ExportVarCount = %lu\n", |
| static_cast<unsigned long>(export_var_addrs.size())); |
| |
| for (size_t i = 0; i < count; ++i) { |
| ALOGD("ExportVarList[%lu] = %p\n", static_cast<unsigned long>(i), |
| varList[i]); |
| } |
| #endif |
| } |
| } |
| |
| |
| extern "C" void bccGetExportFuncList(BCCScriptRef script, |
| size_t funcListSize, |
| void **funcList) { |
| BCC_FUNC_LOGGER(); |
| |
| const RSScriptContext *rsctx = unwrap(script); |
| if (funcList && rsctx->result) { |
| const android::Vector<void *> &export_func_addrs = |
| rsctx->result->getExportFuncAddrs(); |
| size_t count = export_func_addrs.size(); |
| |
| if (count > funcListSize) { |
| count = funcListSize; |
| } |
| |
| for (size_t i = 0; i < count; ++i) { |
| funcList[i] = export_func_addrs[i]; |
| } |
| |
| #if DEBUG_BCC_REFLECT |
| ALOGD("ExportFuncCount = %lu\n", |
| static_cast<unsigned long>(export_var_addrs.size())); |
| |
| for (size_t i = 0; i < count; ++i) { |
| ALOGD("ExportFuncList[%lu] = %p\n", static_cast<unsigned long>(i), |
| varList[i]); |
| } |
| #endif |
| } |
| } |
| |
| |
| extern "C" void bccGetExportForEachList(BCCScriptRef script, |
| size_t forEachListSize, |
| void **forEachList) { |
| BCC_FUNC_LOGGER(); |
| |
| const RSScriptContext *rsctx = unwrap(script); |
| if (forEachList && rsctx->result) { |
| const android::Vector<void *> &export_foreach_func_addrs = |
| rsctx->result->getExportForeachFuncAddrs(); |
| size_t count = export_foreach_func_addrs.size(); |
| |
| if (count > forEachListSize) { |
| count = forEachListSize; |
| } |
| |
| for (size_t i = 0; i < count; ++i) { |
| forEachList[i] = export_foreach_func_addrs[i]; |
| } |
| |
| #if DEBUG_BCC_REFLECT |
| ALOGD("ExportForEachCount = %lu\n", |
| static_cast<unsigned long>(export_foreach_func_addrs.size())); |
| |
| for (size_t i = 0; i < count; ++i) { |
| ALOGD("ExportForEachList[%lu] = %p\n", static_cast<unsigned long>(i), |
| forEachList[i]); |
| } |
| #endif |
| } |
| } |