Gitiles
Code Review Sign In
gerrit-public.fairphone.software / platform / frameworks / compile / libbcc / 9ea54b5c030d6d800f480f43fdb9caae5fb7eda3 / . / lib / bcc / Compiler.cpp
blob: 057bb18acf55976aab12825b5d7bb811998b76ae [file] [log] [blame]
/*
* Copyright 2010, 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.
*/
#define LOG_TAG "bcc"
#include <cutils/log.h>
#if defined(__arm__)
# define DEFAULT_ARM_CODEGEN
# define PROVIDE_ARM_CODEGEN
#elif defined(__i386__)
# define DEFAULT_X86_CODEGEN
# define PROVIDE_X86_CODEGEN
#elif defined(__x86_64__)
# define DEFAULT_X64_CODEGEN
# define PROVIDE_X64_CODEGEN
#endif
#if defined(FORCE_ARM_CODEGEN)
# define DEFAULT_ARM_CODEGEN
# undef DEFAULT_X86_CODEGEN
# undef DEFAULT_X64_CODEGEN
# define PROVIDE_ARM_CODEGEN
# undef PROVIDE_X86_CODEGEN
# undef PROVIDE_X64_CODEGEN
#elif defined(FORCE_X86_CODEGEN)
# undef DEFAULT_ARM_CODEGEN
# define DEFAULT_X86_CODEGEN
# undef DEFAULT_X64_CODEGEN
# undef PROVIDE_ARM_CODEGEN
# define PROVIDE_X86_CODEGEN
# undef PROVIDE_X64_CODEGEN
#elif defined(FORCE_X64_CODEGEN)
# undef DEFAULT_ARM_CODEGEN
# undef DEFAULT_X86_CODEGEN
# define DEFAULT_X64_CODEGEN
# undef PROVIDE_ARM_CODEGEN
# undef PROVIDE_X86_CODEGEN
# define PROVIDE_X64_CODEGEN
#endif
#if defined(DEFAULT_ARM_CODEGEN)
# define TARGET_TRIPLE_STRING "armv7-none-linux-gnueabi"
#elif defined(DEFAULT_X86_CODEGEN)
# define TARGET_TRIPLE_STRING "i686-unknown-linux"
#elif defined(DEFAULT_X64_CODEGEN)
# define TARGET_TRIPLE_STRING "x86_64-unknown-linux"
#endif
#if (defined(__VFP_FP__) && !defined(__SOFTFP__))
# define ARM_USE_VFP
#endif
#include "Compiler.h"
#include "llvm/ADT/StringRef.h"
#include "llvm/Analysis/Passes.h"
#include "llvm/Bitcode/ReaderWriter.h"
#include "llvm/CodeGen/Passes.h"
#include "llvm/CodeGen/RegAllocRegistry.h"
#include "llvm/CodeGen/SchedulerRegistry.h"
#include "llvm/Transforms/IPO.h"
#include "llvm/Transforms/Scalar.h"
#include "llvm/Target/SubtargetFeature.h"
#include "llvm/Target/TargetData.h"
#include "llvm/Target/TargetMachine.h"
#include "llvm/Target/TargetOptions.h"
#include "llvm/Target/TargetRegistry.h"
#include "llvm/Target/TargetSelect.h"
#include "llvm/Support/ErrorHandling.h"
#include "llvm/Support/MemoryBuffer.h"
#include "llvm/GlobalValue.h"
#include "llvm/Linker.h"
#include "llvm/LLVMContext.h"
#include "llvm/Metadata.h"
#include "llvm/Module.h"
#include "llvm/PassManager.h"
#include "llvm/Value.h"
#include <errno.h>
#include <sys/file.h>
#include <sys/mman.h>
#include <sys/stat.h>
#include <sys/types.h>
#include <unistd.h>
#include <string>
#include <vector>
namespace {
#define TEMP_FAILURE_RETRY1(exp) ({ \
typeof (exp) _rc; \
do { \
_rc = (exp); \
} while (_rc == -1 && errno == EINTR); \
_rc; })
int sysWriteFully(int fd, const void* buf, size_t count, const char* logMsg) {
while (count != 0) {
ssize_t actual = TEMP_FAILURE_RETRY1(write(fd, buf, count));
if (actual < 0) {
int err = errno;
LOGE("%s: write failed: %s\n", logMsg, strerror(err));
return err;
} else if (actual != (ssize_t) count) {
LOGD("%s: partial write (will retry): (%d of %zd)\n",
logMsg, (int) actual, count);
buf = (const void*) (((const uint8_t*) buf) + actual);
}
count -= actual;
}
return 0;
}
} // namespace anonymous
namespace bcc {
//////////////////////////////////////////////////////////////////////////////
// BCC Compiler Static Variables
//////////////////////////////////////////////////////////////////////////////
bool Compiler::GlobalInitialized = false;
bool Compiler::BccMmapImgAddrTaken[BCC_MMAP_IMG_COUNT];
// Code generation optimization level for the compiler
llvm::CodeGenOpt::Level Compiler::CodeGenOptLevel;
std::string Compiler::Triple;
std::string Compiler::CPU;
std::vector<std::string> Compiler::Features;
// The named of metadata node that pragma resides (should be synced with
// slang.cpp)
const llvm::StringRef Compiler::PragmaMetadataName = "#pragma";
// The named of metadata node that export variable name resides (should be
// synced with slang_rs_metadata.h)
const llvm::StringRef Compiler::ExportVarMetadataName = "#rs_export_var";
// The named of metadata node that export function name resides (should be
// synced with slang_rs_metadata.h)
const llvm::StringRef Compiler::ExportFuncMetadataName = "#rs_export_func";
//////////////////////////////////////////////////////////////////////////////
// Compiler
//////////////////////////////////////////////////////////////////////////////
void Compiler::GlobalInitialization() {
if (GlobalInitialized)
return;
// if (!llvm::llvm_is_multithreaded())
// llvm::llvm_start_multithreaded();
// Set Triple, CPU and Features here
Triple = TARGET_TRIPLE_STRING;
// TODO(sliao): NEON for JIT
// Features.push_back("+neon");
// Features.push_back("+vmlx");
// Features.push_back("+neonfp");
Features.push_back("+vfp3");
Features.push_back("+d16");
#if defined(DEFAULT_ARM_CODEGEN) || defined(PROVIDE_ARM_CODEGEN)
LLVMInitializeARMTargetInfo();
LLVMInitializeARMTarget();
#if defined(USE_DISASSEMBLER)
LLVMInitializeARMDisassembler();
LLVMInitializeARMAsmPrinter();
#endif
#endif
#if defined(DEFAULT_X86_CODEGEN) || defined(PROVIDE_X86_CODEGEN)
LLVMInitializeX86TargetInfo();
LLVMInitializeX86Target();
#if defined(USE_DISASSEMBLER)
LLVMInitializeX86Disassembler();
LLVMInitializeX86AsmPrinter();
#endif
#endif
#if defined(DEFAULT_X64_CODEGEN) || defined(PROVIDE_X64_CODEGEN)
LLVMInitializeX86TargetInfo();
LLVMInitializeX86Target();
#if defined(USE_DISASSEMBLER)
LLVMInitializeX86Disassembler();
LLVMInitializeX86AsmPrinter();
#endif
#endif
// -O0: llvm::CodeGenOpt::None
// -O1: llvm::CodeGenOpt::Less
// -O2: llvm::CodeGenOpt::Default
// -O3: llvm::CodeGenOpt::Aggressive
CodeGenOptLevel = llvm::CodeGenOpt::None;
// Below are the global settings to LLVM
// Disable frame pointer elimination optimization
llvm::NoFramePointerElim = false;
// Use hardfloat ABI
//
// TODO(all): Need to detect the CPU capability and decide whether to use
// softfp. To use softfp, change following 2 lines to
//
// llvm::FloatABIType = llvm::FloatABI::Soft;
// llvm::UseSoftFloat = true;
//
llvm::FloatABIType = llvm::FloatABI::Soft;
llvm::UseSoftFloat = false;
// BCC needs all unknown symbols resolved at JIT/compilation time.
// So we don't need any dynamic relocation model.
llvm::TargetMachine::setRelocationModel(llvm::Reloc::Static);
#if defined(DEFAULT_X64_CODEGEN)
// Data address in X86_64 architecture may reside in a far-away place
llvm::TargetMachine::setCodeModel(llvm::CodeModel::Medium);
#else
// This is set for the linker (specify how large of the virtual addresses
// we can access for all unknown symbols.)
llvm::TargetMachine::setCodeModel(llvm::CodeModel::Small);
#endif
// Register the scheduler
llvm::RegisterScheduler::setDefault(llvm::createDefaultScheduler);
// Register allocation policy:
// createFastRegisterAllocator: fast but bad quality
// createLinearScanRegisterAllocator: not so fast but good quality
llvm::RegisterRegAlloc::setDefault
((CodeGenOptLevel == llvm::CodeGenOpt::None) ?
llvm::createFastRegisterAllocator :
llvm::createLinearScanRegisterAllocator);
GlobalInitialized = true;
}
void Compiler::LLVMErrorHandler(void *UserData, const std::string &Message) {
std::string *Error = static_cast<std::string*>(UserData);
Error->assign(Message);
LOGE("%s", Message.c_str());
exit(1);
}
CodeMemoryManager *Compiler::createCodeMemoryManager() {
mCodeMemMgr.reset(new CodeMemoryManager());
return mCodeMemMgr.get();
}
CodeEmitter *Compiler::createCodeEmitter() {
mCodeEmitter.reset(new CodeEmitter(mCodeMemMgr.take()));
return mCodeEmitter.get();
}
Compiler::Compiler()
: mUseCache(false),
mCacheNew(false),
mCacheFd(-1),
mCacheMapAddr(NULL),
mCacheHdr(NULL),
mCacheSize(0),
mCacheDiff(0),
mCodeDataAddr(NULL),
mpSymbolLookupFn(NULL),
mpSymbolLookupContext(NULL),
mContext(NULL),
mModule(NULL),
mHasLinked(false) /* Turn off linker */ {
llvm::remove_fatal_error_handler();
llvm::install_fatal_error_handler(LLVMErrorHandler, &mError);
mContext = new llvm::LLVMContext();
return;
}
int Compiler::readBC(const char *bitcode,
size_t bitcodeSize,
const BCCchar *resName) {
GlobalInitialization();
if (resName) {
// Turn on mUseCache mode iff
// 1. Has resName
// and, assuming USE_RELOCATE is false:
// 2. Later running code doesn't violate the following condition:
// mCodeDataAddr (set in loadCacheFile()) ==
// mCacheHdr->cachedCodeDataAddr
//
// BTW, this condition is achievable only when in the earlier
// cache-generating run,
// mpCodeMem == BccCodeAddr - MaxCodeSize - MaxGlobalVarSize,
// which means the mmap'ed is in the reserved area,
//
// Note: Upon violation, mUseCache will be set back to false.
mUseCache = true;
mCacheFd = openCacheFile(resName, true /* createIfMissing */);
if (mCacheFd >= 0 && !mCacheNew) { // Just use cache file
return -mCacheFd;
}
}
llvm::OwningPtr<llvm::MemoryBuffer> MEM;
if (bitcode == NULL || bitcodeSize <= 0)
return 0;
// Package input to object MemoryBuffer
MEM.reset(llvm::MemoryBuffer::getMemBuffer(
llvm::StringRef(bitcode, bitcodeSize)));
if (MEM.get() == NULL) {
setError("Error reading input program bitcode into memory");
return hasError();
}
// Read the input Bitcode as a Module
mModule = llvm::ParseBitcodeFile(MEM.get(), *mContext, &mError);
MEM.reset();
return hasError();
}
int Compiler::linkBC(const char *bitcode, size_t bitcodeSize) {
llvm::OwningPtr<llvm::MemoryBuffer> MEM;
if (bitcode == NULL || bitcodeSize <= 0)
return 0;
if (mModule == NULL) {
setError("No module presents for linking");
return hasError();
}
MEM.reset(llvm::MemoryBuffer::getMemBuffer(
llvm::StringRef(bitcode, bitcodeSize)));
if (MEM.get() == NULL) {
setError("Error reading input library bitcode into memory");
return hasError();
}
llvm::OwningPtr<llvm::Module> Lib(llvm::ParseBitcodeFile(MEM.get(),
*mContext,
&mError));
if (Lib.get() == NULL)
return hasError();
if (llvm::Linker::LinkModules(mModule, Lib.take(), &mError))
return hasError();
// Everything for linking should be settled down here with no error occurs
mHasLinked = true;
return hasError();
}
// interface for bccLoadBinary()
int Compiler::loadCacheFile() {
// Check File Descriptor
if (mCacheFd < 0) {
LOGE("loading cache from invalid mCacheFd = %d\n", (int)mCacheFd);
goto giveup;
}
// Check File Size
struct stat statCacheFd;
if (fstat(mCacheFd, &statCacheFd) < 0) {
LOGE("unable to stat mCacheFd = %d\n", (int)mCacheFd);
goto giveup;
}
mCacheSize = statCacheFd.st_size;
if (mCacheSize < sizeof(oBCCHeader) ||
mCacheSize <= MaxCodeSize + MaxGlobalVarSize) {
LOGE("mCacheFd %d is too small to be correct\n", (int)mCacheFd);
goto giveup;
}
if (lseek(mCacheFd, 0, SEEK_SET) != 0) {
LOGE("Unable to seek to 0: %s\n", strerror(errno));
goto giveup;
}
// Part 1. Deal with the non-codedata section first
{
// Read cached file and perform quick integrity check
off_t heuristicCodeOffset = mCacheSize - MaxCodeSize - MaxGlobalVarSize;
LOGW("TODO(sliao)@loadCacheFile: mCacheSize=%x, heuristicCodeOffset=%llx",
(unsigned int)mCacheSize,
(unsigned long long int)heuristicCodeOffset);
mCacheMapAddr = (char *)malloc(heuristicCodeOffset);
if (!mCacheMapAddr) {
flock(mCacheFd, LOCK_UN);
LOGE("allocation failed.\n");
goto bail;
}
size_t nread = TEMP_FAILURE_RETRY1(read(mCacheFd, mCacheMapAddr,
heuristicCodeOffset));
if (nread != (size_t)heuristicCodeOffset) {
LOGE("read(mCacheFd) failed\n");
goto bail;
}
mCacheHdr = reinterpret_cast<oBCCHeader *>(mCacheMapAddr);
// Sanity check
if (mCacheHdr->codeOffset != (uint32_t)heuristicCodeOffset) {
LOGE("assertion failed: heuristic code offset is not correct.\n");
goto bail;
}
LOGW("TODO(sliao): mCacheHdr->cachedCodeDataAddr=%x", mCacheHdr->cachedCodeDataAddr);
LOGW("mCacheHdr->rootAddr=%x", mCacheHdr->rootAddr);
LOGW("mCacheHdr->initAddr=%x", mCacheHdr->initAddr);
LOGW("mCacheHdr->codeOffset=%x", mCacheHdr->codeOffset);
LOGW("mCacheHdr->codeSize=%x", mCacheHdr->codeSize);
// Verify the Cache File
if (memcmp(mCacheHdr->magic, OBCC_MAGIC, 4) != 0) {
LOGE("bad magic word\n");
goto bail;
}
if (memcmp(mCacheHdr->magicVersion, OBCC_MAGIC_VERS, 4) != 0) {
LOGE("bad oBCC version 0x%08x\n",
*reinterpret_cast<uint32_t *>(mCacheHdr->magicVersion));
goto bail;
}
if (mCacheSize < mCacheHdr->relocOffset +
mCacheHdr->relocCount * sizeof(oBCCRelocEntry)) {
LOGE("relocate table overflow\n");
goto bail;
}
if (mCacheSize < mCacheHdr->exportVarsOffset +
mCacheHdr->exportVarsCount * sizeof(uint32_t)) {
LOGE("export variables table overflow\n");
goto bail;
}
if (mCacheSize < mCacheHdr->exportFuncsOffset +
mCacheHdr->exportFuncsCount * sizeof(uint32_t)) {
LOGE("export functions table overflow\n");
goto bail;
}
if (mCacheSize < mCacheHdr->exportPragmasOffset +
mCacheHdr->exportPragmasSize) {
LOGE("export pragmas table overflow\n");
goto bail;
}
if (mCacheSize < mCacheHdr->codeOffset + mCacheHdr->codeSize) {
LOGE("code cache overflow\n");
goto bail;
}
if (mCacheSize < mCacheHdr->dataOffset + mCacheHdr->dataSize) {
LOGE("data (global variable) cache overflow\n");
goto bail;
}
long pagesize = sysconf(_SC_PAGESIZE);
if (mCacheHdr->codeOffset % pagesize != 0) {
LOGE("code offset must aligned to pagesize\n");
goto bail;
}
}
// Part 2. Deal with the codedata section
{
long pagesize = sysconf(_SC_PAGESIZE);
if (mCacheHdr->cachedCodeDataAddr % pagesize == 0) {
void *addr = reinterpret_cast<char *>(mCacheHdr->cachedCodeDataAddr);
// Try to mmap at cached address directly.
mCodeDataAddr = (char *) mmap(addr,
BCC_MMAP_IMG_SIZE,
PROT_READ | PROT_EXEC | PROT_WRITE,
MAP_PRIVATE | MAP_FIXED,
mCacheFd,
mCacheHdr->codeOffset);
if (mCodeDataAddr && mCodeDataAddr != MAP_FAILED) {
// Cheers! Mapped at the cached address successfully.
// Update the BccMmapImgAddrTaken table (if required)
if (mCacheHdr->cachedCodeDataAddr >= BCC_MMAP_IMG_BEGIN) {
size_t offset = mCacheHdr->cachedCodeDataAddr - BCC_MMAP_IMG_BEGIN;
if ((offset % BCC_MMAP_IMG_SIZE) == 0 &&
(offset / BCC_MMAP_IMG_SIZE) < BCC_MMAP_IMG_COUNT) {
Compiler::BccMmapImgAddrTaken[offset / BCC_MMAP_IMG_SIZE] = true;
}
}
#if 1
// Check the checksum of code and data
{
uint32_t sum = mCacheHdr->checksum;
uint32_t *ptr = (uint32_t *)mCodeDataAddr;
for (size_t i = 0; i < BCC_MMAP_IMG_SIZE / sizeof(uint32_t); ++i) {
sum ^= *ptr++;
}
if (sum != 0) {
LOGE("Checksum check failed\n");
goto bail;
}
LOGI("Passed checksum even parity verification.\n");
}
#endif
flock(mCacheFd, LOCK_UN);
return 0; // loadCacheFile succeed!
}
}
}
#if !USE_RELOCATE
// Note: Since this build does not support relocation, we have no
// choose but give up to load the cached file, and recompile the
// code.
flock(mCacheFd, LOCK_UN);
goto bail;
#else
// Note: Currently, relocation code is not working. Give up now.
flock(mCacheFd, LOCK_UN);
goto bail;
// TODO(logan): Following code is not working. Don't use them.
// And rewrite them asap.
#if 0
{
// Try to allocate at arbitary address. And perform relocation.
mCacheMapAddr = (char *) mmap(0,
mCacheSize,
PROT_READ | PROT_EXEC | PROT_WRITE,
MAP_PRIVATE,
mCacheFd,
0);
if (mCacheMapAddr == MAP_FAILED) {
LOGE("unable to mmap .oBBC cache: %s\n", strerror(errno));
flock(mCacheFd, LOCK_UN);
goto giveup;
}
flock(mCacheFd, LOCK_UN);
mCodeDataAddr = mCacheMapAddr + mCacheHdr->codeOffset;
// Relocate
mCacheDiff = mCodeDataAddr -
reinterpret_cast<char *>(mCacheHdr->cachedCodeDataAddr);
if (mCacheDiff) { // To relocate
if (mCacheHdr->rootAddr) {
mCacheHdr->rootAddr += mCacheDiff;
}
if (mCacheHdr->initAddr) {
mCacheHdr->initAddr += mCacheDiff;
}
oBCCRelocEntry *cachedRelocTable =
reinterpret_cast<oBCCRelocEntry *>(mCacheMapAddr +
mCacheHdr->relocOffset);
std::vector<llvm::MachineRelocation> relocations;
// Read in the relocs
for (size_t i = 0; i < mCacheHdr->relocCount; i++) {
oBCCRelocEntry *entry = &cachedRelocTable[i];
llvm::MachineRelocation reloc =
llvm::MachineRelocation::getGV((uintptr_t)entry->relocOffset,
(unsigned)entry->relocType, 0, 0);
reloc.setResultPointer(
reinterpret_cast<char *>(entry->cachedResultAddr) + mCacheDiff);
relocations.push_back(reloc);
}
// Rewrite machine code using llvm::TargetJITInfo relocate
{
llvm::TargetMachine *TM = NULL;
const llvm::Target *Target;
std::string FeaturesStr;
// Create TargetMachine
Target = llvm::TargetRegistry::lookupTarget(Triple, mError);
if (hasError())
goto bail;
if (!CPU.empty() || !Features.empty()) {
llvm::SubtargetFeatures F;
F.setCPU(CPU);
for (std::vector<std::string>::const_iterator I = Features.begin(),
E = Features.end(); I != E; I++)
F.AddFeature(*I);
FeaturesStr = F.getString();
}
TM = Target->createTargetMachine(Triple, FeaturesStr);
if (TM == NULL) {
setError("Failed to create target machine implementation for the"
" specified triple '" + Triple + "'");
goto bail;
}
TM->getJITInfo()->relocate(mCodeDataAddr,
&relocations[0], relocations.size(),
(unsigned char *)mCodeDataAddr+MaxCodeSize);
if (mCodeEmitter.get()) {
mCodeEmitter->Disassemble(llvm::StringRef("cache"),
reinterpret_cast<uint8_t*>(mCodeDataAddr),
2 * 1024 /*MaxCodeSize*/,
false);
}
delete TM;
}
} // End of if (mCacheDiff)
return 0; // Success!
}
#endif
#endif
bail:
if (mCacheMapAddr) {
free(mCacheMapAddr);
}
if (mCodeDataAddr && mCodeDataAddr != MAP_FAILED) {
if (munmap(mCodeDataAddr, BCC_MMAP_IMG_SIZE) != 0) {
LOGE("munmap failed: %s\n", strerror(errno));
}
}
mCacheMapAddr = NULL;
mCacheHdr = NULL;
mCodeDataAddr = NULL;
giveup:
return 1;
}
// interace for bccCompileBC()
int Compiler::compile() {
llvm::TargetData *TD = NULL;
llvm::TargetMachine *TM = NULL;
const llvm::Target *Target;
std::string FeaturesStr;
llvm::FunctionPassManager *CodeGenPasses = NULL;
const llvm::NamedMDNode *PragmaMetadata;
const llvm::NamedMDNode *ExportVarMetadata;
const llvm::NamedMDNode *ExportFuncMetadata;
if (mModule == NULL) // No module was loaded
return 0;
// Create TargetMachine
Target = llvm::TargetRegistry::lookupTarget(Triple, mError);
if (hasError())
goto on_bcc_compile_error;
if (!CPU.empty() || !Features.empty()) {
llvm::SubtargetFeatures F;
F.setCPU(CPU);
for (std::vector<std::string>::const_iterator
I = Features.begin(), E = Features.end(); I != E; I++) {
F.AddFeature(*I);
}
FeaturesStr = F.getString();
}
TM = Target->createTargetMachine(Triple, FeaturesStr);
if (TM == NULL) {
setError("Failed to create target machine implementation for the"
" specified triple '" + Triple + "'");
goto on_bcc_compile_error;
}
// Create memory manager for creation of code emitter later.
if (!mCodeMemMgr.get() && !createCodeMemoryManager()) {
setError("Failed to startup memory management for further compilation");
goto on_bcc_compile_error;
}
mCodeDataAddr = (char *) (mCodeMemMgr.get()->getCodeMemBase());
// Create code emitter
if (!mCodeEmitter.get()) {
if (!createCodeEmitter()) {
setError("Failed to create machine code emitter to complete"
" the compilation");
goto on_bcc_compile_error;
}
} else {
// Reuse the code emitter
mCodeEmitter->reset();
}
mCodeEmitter->setTargetMachine(*TM);
mCodeEmitter->registerSymbolCallback(mpSymbolLookupFn,
mpSymbolLookupContext);
// Get target data from Module
TD = new llvm::TargetData(mModule);
// Load named metadata
ExportVarMetadata = mModule->getNamedMetadata(ExportVarMetadataName);
ExportFuncMetadata = mModule->getNamedMetadata(ExportFuncMetadataName);
PragmaMetadata = mModule->getNamedMetadata(PragmaMetadataName);
// Create LTO passes and run them on the mModule
if (mHasLinked) {
llvm::TimePassesIsEnabled = true; // TODO(all)
llvm::PassManager LTOPasses;
LTOPasses.add(new llvm::TargetData(*TD));
std::vector<const char*> ExportSymbols;
// A workaround for getting export variable and function name. Will refine
// it soon.
if (ExportVarMetadata) {
for (int i = 0, e = ExportVarMetadata->getNumOperands(); i != e; i++) {
llvm::MDNode *ExportVar = ExportVarMetadata->getOperand(i);
if (ExportVar != NULL && ExportVar->getNumOperands() > 1) {
llvm::Value *ExportVarNameMDS = ExportVar->getOperand(0);
if (ExportVarNameMDS->getValueID() == llvm::Value::MDStringVal) {
llvm::StringRef ExportVarName =
static_cast<llvm::MDString*>(ExportVarNameMDS)->getString();
ExportSymbols.push_back(ExportVarName.data());
}
}
}
}
if (ExportFuncMetadata) {
for (int i = 0, e = ExportFuncMetadata->getNumOperands(); i != e; i++) {
llvm::MDNode *ExportFunc = ExportFuncMetadata->getOperand(i);
if (ExportFunc != NULL && ExportFunc->getNumOperands() > 0) {
llvm::Value *ExportFuncNameMDS = ExportFunc->getOperand(0);
if (ExportFuncNameMDS->getValueID() == llvm::Value::MDStringVal) {
llvm::StringRef ExportFuncName =
static_cast<llvm::MDString*>(ExportFuncNameMDS)->getString();
ExportSymbols.push_back(ExportFuncName.data());
}
}
}
}
// root() and init() are born to be exported
ExportSymbols.push_back("root");
ExportSymbols.push_back("init");
// We now create passes list performing LTO. These are copied from
// (including comments) llvm::createStandardLTOPasses().
// Internalize all other symbols not listed in ExportSymbols
LTOPasses.add(llvm::createInternalizePass(ExportSymbols));
// Propagate constants at call sites into the functions they call. This
// opens opportunities for globalopt (and inlining) by substituting
// function pointers passed as arguments to direct uses of functions.
LTOPasses.add(llvm::createIPSCCPPass());
// Now that we internalized some globals, see if we can hack on them!
LTOPasses.add(llvm::createGlobalOptimizerPass());
// Linking modules together can lead to duplicated global constants, only
// keep one copy of each constant...
LTOPasses.add(llvm::createConstantMergePass());
// Remove unused arguments from functions...
LTOPasses.add(llvm::createDeadArgEliminationPass());
// Reduce the code after globalopt and ipsccp. Both can open up
// significant simplification opportunities, and both can propagate
// functions through function pointers. When this happens, we often have
// to resolve varargs calls, etc, so let instcombine do this.
LTOPasses.add(llvm::createInstructionCombiningPass());
// Inline small functions
LTOPasses.add(llvm::createFunctionInliningPass());
// Remove dead EH info.
LTOPasses.add(llvm::createPruneEHPass());
// Internalize the globals again after inlining
LTOPasses.add(llvm::createGlobalOptimizerPass());
// Remove dead functions.
LTOPasses.add(llvm::createGlobalDCEPass());
// If we didn't decide to inline a function, check to see if we can
// transform it to pass arguments by value instead of by reference.
LTOPasses.add(llvm::createArgumentPromotionPass());
// The IPO passes may leave cruft around. Clean up after them.
LTOPasses.add(llvm::createInstructionCombiningPass());
LTOPasses.add(llvm::createJumpThreadingPass());
// Break up allocas
LTOPasses.add(llvm::createScalarReplAggregatesPass());
// Run a few AA driven optimizations here and now, to cleanup the code.
LTOPasses.add(llvm::createFunctionAttrsPass()); // Add nocapture.
LTOPasses.add(llvm::createGlobalsModRefPass()); // IP alias analysis.
// Hoist loop invariants.
LTOPasses.add(llvm::createLICMPass());
// Remove redundancies.
LTOPasses.add(llvm::createGVNPass());
// Remove dead memcpys.
LTOPasses.add(llvm::createMemCpyOptPass());
// Nuke dead stores.
LTOPasses.add(llvm::createDeadStoreEliminationPass());
// Cleanup and simplify the code after the scalar optimizations.
LTOPasses.add(llvm::createInstructionCombiningPass());
LTOPasses.add(llvm::createJumpThreadingPass());
// Delete basic blocks, which optimization passes may have killed.
LTOPasses.add(llvm::createCFGSimplificationPass());
// Now that we have optimized the program, discard unreachable functions.
LTOPasses.add(llvm::createGlobalDCEPass());
LTOPasses.run(*mModule);
}
// Create code-gen pass to run the code emitter
CodeGenPasses = new llvm::FunctionPassManager(mModule);
CodeGenPasses->add(TD); // Will take the ownership of TD
if (TM->addPassesToEmitMachineCode(*CodeGenPasses,
*mCodeEmitter,
CodeGenOptLevel)) {
setError("The machine code emission is not supported by BCC on target '"
+ Triple + "'");
goto on_bcc_compile_error;
}
// Run the pass (the code emitter) on every non-declaration function in the
// module
CodeGenPasses->doInitialization();
for (llvm::Module::iterator I = mModule->begin(), E = mModule->end();
I != E; I++) {
if (!I->isDeclaration()) {
CodeGenPasses->run(*I);
}
}
CodeGenPasses->doFinalization();
// Copy the global address mapping from code emitter and remapping
if (ExportVarMetadata) {
for (int i = 0, e = ExportVarMetadata->getNumOperands(); i != e; i++) {
llvm::MDNode *ExportVar = ExportVarMetadata->getOperand(i);
if (ExportVar != NULL && ExportVar->getNumOperands() > 1) {
llvm::Value *ExportVarNameMDS = ExportVar->getOperand(0);
if (ExportVarNameMDS->getValueID() == llvm::Value::MDStringVal) {
llvm::StringRef ExportVarName =
static_cast<llvm::MDString*>(ExportVarNameMDS)->getString();
CodeEmitter::global_addresses_const_iterator I, E;
for (I = mCodeEmitter->global_address_begin(),
E = mCodeEmitter->global_address_end();
I != E; I++) {
if (I->first->getValueID() != llvm::Value::GlobalVariableVal)
continue;
if (ExportVarName == I->first->getName()) {
mExportVars.push_back(I->second);
break;
}
}
if (I != mCodeEmitter->global_address_end())
continue; // found
}
}
// if reaching here, we know the global variable record in metadata is
// not found. So we make an empty slot
mExportVars.push_back(NULL);
}
assert((mExportVars.size() == ExportVarMetadata->getNumOperands()) &&
"Number of slots doesn't match the number of export variables!");
}
if (ExportFuncMetadata) {
for (int i = 0, e = ExportFuncMetadata->getNumOperands(); i != e; i++) {
llvm::MDNode *ExportFunc = ExportFuncMetadata->getOperand(i);
if (ExportFunc != NULL && ExportFunc->getNumOperands() > 0) {
llvm::Value *ExportFuncNameMDS = ExportFunc->getOperand(0);
if (ExportFuncNameMDS->getValueID() == llvm::Value::MDStringVal) {
llvm::StringRef ExportFuncName =
static_cast<llvm::MDString*>(ExportFuncNameMDS)->getString();
mExportFuncs.push_back(mCodeEmitter->lookup(ExportFuncName));
}
}
}
}
// Tell code emitter now can release the memory using during the JIT since
// we have done the code emission
mCodeEmitter->releaseUnnecessary();
// Finally, read pragma information from the metadata node of the @Module if
// any.
if (PragmaMetadata)
for (int i = 0, e = PragmaMetadata->getNumOperands(); i != e; i++) {
llvm::MDNode *Pragma = PragmaMetadata->getOperand(i);
if (Pragma != NULL &&
Pragma->getNumOperands() == 2 /* should have exactly 2 operands */) {
llvm::Value *PragmaNameMDS = Pragma->getOperand(0);
llvm::Value *PragmaValueMDS = Pragma->getOperand(1);
if ((PragmaNameMDS->getValueID() == llvm::Value::MDStringVal) &&
(PragmaValueMDS->getValueID() == llvm::Value::MDStringVal)) {
llvm::StringRef PragmaName =
static_cast<llvm::MDString*>(PragmaNameMDS)->getString();
llvm::StringRef PragmaValue =
static_cast<llvm::MDString*>(PragmaValueMDS)->getString();
mPragmas.push_back(
std::make_pair(std::string(PragmaName.data(),
PragmaName.size()),
std::string(PragmaValue.data(),
PragmaValue.size())));
}
}
}
on_bcc_compile_error:
// LOGE("on_bcc_compiler_error");
if (CodeGenPasses) {
delete CodeGenPasses;
} else if (TD) {
delete TD;
}
if (TM)
delete TM;
if (mError.empty()) {
if (mUseCache && mCacheFd >= 0 && mCacheNew) {
genCacheFile();
flock(mCacheFd, LOCK_UN);
}
return false;
}
// LOGE(getErrorMessage());
return true;
}
// interface for bccGetScriptLabel()
void *Compiler::lookup(const char *name) {
void *addr = NULL;
if (mUseCache && mCacheFd >= 0 && !mCacheNew) {
if (!strcmp(name, "root")) {
addr = reinterpret_cast<void *>(mCacheHdr->rootAddr);
} else if (!strcmp(name, "init")) {
addr = reinterpret_cast<void *>(mCacheHdr->initAddr);
}
return addr;
}
if (mCodeEmitter.get())
// Find function pointer
addr = mCodeEmitter->lookup(name);
return addr;
}
// Interface for bccGetExportVars()
void Compiler::getExportVars(BCCsizei *actualVarCount,
BCCsizei maxVarCount,
BCCvoid **vars) {
int varCount;
if (mUseCache && mCacheFd >= 0 && !mCacheNew) {
varCount = static_cast<int>(mCacheHdr->exportVarsCount);
if (actualVarCount)
*actualVarCount = varCount;
if (varCount > maxVarCount)
varCount = maxVarCount;
if (vars) {
uint32_t *cachedVars = (uint32_t *)(mCacheMapAddr +
mCacheHdr->exportVarsOffset);
for (int i = 0; i < varCount; i++) {
*vars = (BCCvoid *)((char *)(*cachedVars) + mCacheDiff);
vars++;
cachedVars++;
}
}
return;
}
varCount = mExportVars.size();
if (actualVarCount)
*actualVarCount = varCount;
if (varCount > maxVarCount)
varCount = maxVarCount;
if (vars) {
for (ExportVarList::const_iterator
I = mExportVars.begin(), E = mExportVars.end(); I != E; I++) {
*vars++ = *I;
}
}
}
// Interface for bccGetExportFuncs()
void Compiler::getExportFuncs(BCCsizei *actualFuncCount,
BCCsizei maxFuncCount,
BCCvoid **funcs) {
int funcCount;
if (mUseCache && mCacheFd >= 0 && !mCacheNew) {
funcCount = static_cast<int>(mCacheHdr->exportFuncsCount);
if (actualFuncCount)
*actualFuncCount = funcCount;
if (funcCount > maxFuncCount)
funcCount = maxFuncCount;
if (funcs) {
uint32_t *cachedFuncs = (uint32_t *)(mCacheMapAddr +
mCacheHdr->exportFuncsOffset);
for (int i = 0; i < funcCount; i++) {
*funcs = (BCCvoid *)((char *)(*cachedFuncs) + mCacheDiff);
funcs++;
cachedFuncs++;
}
}
return;
}
funcCount = mExportFuncs.size();
if (actualFuncCount)
*actualFuncCount = funcCount;
if (funcCount > maxFuncCount)
funcCount = maxFuncCount;
if (funcs) {
for (ExportFuncList::const_iterator
I = mExportFuncs.begin(), E = mExportFuncs.end(); I != E; I++) {
*funcs++ = *I;
}
}
}
// Interface for bccGetPragmas()
void Compiler::getPragmas(BCCsizei *actualStringCount,
BCCsizei maxStringCount,
BCCchar **strings) {
int stringCount;
if (mUseCache && mCacheFd >= 0 && !mCacheNew) {
stringCount = static_cast<int>(mCacheHdr->exportPragmasCount) * 2;
if (actualStringCount)
*actualStringCount = stringCount;
if (stringCount > maxStringCount)
stringCount = maxStringCount;
if (strings) {
char *pragmaTab = mCacheMapAddr + mCacheHdr->exportPragmasOffset;
oBCCPragmaEntry *cachedPragmaEntries = (oBCCPragmaEntry *)pragmaTab;
for (int i = 0; stringCount >= 2; stringCount -= 2, i++) {
*strings++ = pragmaTab + cachedPragmaEntries[i].pragmaNameOffset;
*strings++ = pragmaTab + cachedPragmaEntries[i].pragmaValueOffset;
}
}
return;
}
stringCount = mPragmas.size() * 2;
if (actualStringCount)
*actualStringCount = stringCount;
if (stringCount > maxStringCount)
stringCount = maxStringCount;
if (strings) {
size_t i = 0;
for (PragmaList::const_iterator it = mPragmas.begin();
stringCount >= 2; stringCount -= 2, it++, ++i) {
*strings++ = const_cast<BCCchar*>(it->first.c_str());
*strings++ = const_cast<BCCchar*>(it->second.c_str());
}
}
return;
}
// Interface for bccGetFunctions()
void Compiler::getFunctions(BCCsizei *actualFunctionCount,
BCCsizei maxFunctionCount,
BCCchar **functions) {
if (mCodeEmitter.get())
mCodeEmitter->getFunctionNames(actualFunctionCount,
maxFunctionCount,
functions);
else
*actualFunctionCount = 0;
return;
}
// Interface for bccGetFunctionBinary()
void Compiler::getFunctionBinary(BCCchar *function,
BCCvoid **base,
BCCsizei *length) {
if (mCodeEmitter.get()) {
mCodeEmitter->getFunctionBinary(function, base, length);
} else {
*base = NULL;
*length = 0;
}
return;
}
Compiler::~Compiler() {
if (!mCodeMemMgr.get()) {
// mCodeDataAddr and mCacheMapAddr are from loadCacheFile and not
// managed by CodeMemoryManager.
if (mCodeDataAddr != 0 && mCodeDataAddr != MAP_FAILED) {
if (munmap(mCodeDataAddr, BCC_MMAP_IMG_SIZE) < 0) {
LOGE("munmap failed while releasing mCodeDataAddr\n");
}
}
if (mCacheMapAddr) {
free(mCacheMapAddr);
}
mCodeDataAddr = 0;
mCacheMapAddr = 0;
}
delete mModule;
delete mContext;
// llvm::llvm_shutdown();
}
// Design of caching EXE:
// ======================
// 1. Each process will have virtual address available starting at 0x7e00000.
// E.g., Books and Youtube all have its own 0x7e00000. Next, we should
// minimize the chance of needing to do relocation INSIDE an app too.
//
// 2. Each process will have ONE class static variable called BccCodeAddr.
// I.e., even though the Compiler class will have multiple Compiler objects,
// e.g, one object for carousel.rs and the other for pageturn.rs,
// both Compiler objects will share 1 static variable called BccCodeAddr.
//
// Key observation: Every app (process) initiates, say 3, scripts (which
// correspond to 3 Compiler objects) in the same order, usually.
//
// So, we should mmap to, e.g., 0x7e00000, 0x7e40000, 0x7e80000 for the 3
// scripts, respectively. Each time, BccCodeAddr should be updated after
// JITTing a script. BTW, in ~Compiler(), BccCodeAddr should NOT be
// decremented back by CodeDataSize. I.e., for 3 scripts: A, B, C,
// even if it's A -> B -> ~B -> C -> ~C -> B -> C ... no relocation will
// ever be needed.)
//
// If we are lucky, then we don't need relocation ever, since next time the
// application gets run, the 3 scripts are likely created in the SAME order.
//
//
// End-to-end algorithm on when to caching and when to JIT:
// ========================================================
// Prologue:
// ---------
// Assertion: bccReadBC() is always called and is before bccCompileBC(),
// bccLoadBinary(), ...
//
// Key variable definitions: Normally,
// Compiler::BccCodeAddr: non-zero if (USE_CACHE)
// | (Stricter, because currently relocation doesn't work. So mUseCache only
// | when BccCodeAddr is nonzero.)
// V
// mUseCache: In addition to (USE_CACHE), resName is non-zero
// Note: mUseCache will be set to false later on whenever we find that caching
// won't work. E.g., when mCodeDataAddr != mCacheHdr->cachedCodeDataAddr.
// This is because currently relocation doesn't work.
// | (Stricter, initially)
// V
// mCacheFd: In addition, >= 0 if openCacheFile() returns >= 0
// | (Stricter)
// V
// mCacheNew: In addition, mCacheFd's size is 0, so need to call genCacheFile()
// at the end of compile()
//
//
// Main algorithm:
// ---------------
// #if !USE_RELOCATE
// Case 1. ReadBC() doesn't detect a cache file:
// compile(), which calls genCacheFile() at the end.
// Note: mCacheNew will guard the invocation of genCacheFile()
// Case 2. ReadBC() find a cache file
// loadCacheFile(). But if loadCacheFile() failed, should go to Case 1.
// #endif
// Note: loadCacheFile() and genCacheFile() go hand in hand
void Compiler::genCacheFile() {
if (lseek(mCacheFd, 0, SEEK_SET) != 0) {
LOGE("Unable to seek to 0: %s\n", strerror(errno));
return;
}
bool codeOffsetNeedPadding = false;
uint32_t offset = sizeof(oBCCHeader);
// BCC Cache File Header
oBCCHeader *hdr = (oBCCHeader *)malloc(sizeof(oBCCHeader));
if (!hdr) {
LOGE("Unable to allocate oBCCHeader.\n");
return;
}
// Magic Words
memcpy(hdr->magic, OBCC_MAGIC, 4);
memcpy(hdr->magicVersion, OBCC_MAGIC_VERS, 4);
// Timestamp
hdr->sourceWhen = 0; // TODO(all)
hdr->rslibWhen = 0; // TODO(all)
hdr->libRSWhen = 0; // TODO(all)
hdr->libbccWhen = 0; // TODO(all)
// Current Memory Address (Saved for Recalculation)
hdr->cachedCodeDataAddr = reinterpret_cast<uint32_t>(mCodeDataAddr);
hdr->rootAddr = reinterpret_cast<uint32_t>(lookup("root"));
hdr->initAddr = reinterpret_cast<uint32_t>(lookup("init"));
// Relocation Table Offset and Entry Count
hdr->relocOffset = sizeof(oBCCHeader);
hdr->relocCount = mCodeEmitter->getCachingRelocations().size();
offset += hdr->relocCount * sizeof(oBCCRelocEntry);
// Export Variable Table Offset and Entry Count
hdr->exportVarsOffset = offset;
hdr->exportVarsCount = mExportVars.size();
offset += hdr->exportVarsCount * sizeof(uint32_t);
// Export Function Table Offset and Entry Count
hdr->exportFuncsOffset = offset;
hdr->exportFuncsCount = mExportFuncs.size();
offset += hdr->exportFuncsCount * sizeof(uint32_t);
// Export Pragmas Table Offset and Entry Count
hdr->exportPragmasOffset = offset;
hdr->exportPragmasCount = mPragmas.size();
hdr->exportPragmasSize = hdr->exportPragmasCount * sizeof(oBCCPragmaEntry);
offset += hdr->exportPragmasCount * sizeof(oBCCPragmaEntry);
for (PragmaList::const_iterator
I = mPragmas.begin(), E = mPragmas.end(); I != E; ++I) {
offset += I->first.size() + 1;
offset += I->second.size() + 1;
hdr->exportPragmasSize += I->first.size() + I->second.size() + 2;
}
// Code Offset and Size
{ // Always pad to the page boundary for now
long pagesize = sysconf(_SC_PAGESIZE);
if (offset % pagesize > 0) {
codeOffsetNeedPadding = true;
offset += pagesize - (offset % pagesize);
}
}
hdr->codeOffset = offset;
hdr->codeSize = MaxCodeSize;
offset += hdr->codeSize;
// Data (Global Variable) Offset and Size
hdr->dataOffset = offset;
hdr->dataSize = MaxGlobalVarSize;
offset += hdr->dataSize;
// Checksum
#if 1
{
// Note: This is an simple checksum implementation that are using xor
// to calculate even parity (for code and data only).
uint32_t sum = 0;
uint32_t *ptr = (uint32_t *)mCodeDataAddr;
for (size_t i = 0; i < BCC_MMAP_IMG_SIZE / sizeof(uint32_t); ++i) {
sum ^= *ptr++;
}
hdr->checksum = sum;
}
#else
hdr->checksum = 0; // Set Field checksum. TODO(all)
#endif
// Write Header
sysWriteFully(mCacheFd, reinterpret_cast<char const *>(hdr),
sizeof(oBCCHeader), "Write oBCC header");
// Write Relocation Entry Table
{
size_t allocSize = hdr->relocCount * sizeof(oBCCRelocEntry);
oBCCRelocEntry const*records = &mCodeEmitter->getCachingRelocations()[0];
sysWriteFully(mCacheFd, reinterpret_cast<char const *>(records),
allocSize, "Write Relocation Entries");
}
// Write Export Variables Table
{
uint32_t *record, *ptr;
record = (uint32_t *)calloc(hdr->exportVarsCount, sizeof(uint32_t));
ptr = record;
if (!record) {
goto bail;
}
for (ExportVarList::const_iterator I = mExportVars.begin(),
E = mExportVars.end(); I != E; I++) {
*ptr++ = reinterpret_cast<uint32_t>(*I);
}
sysWriteFully(mCacheFd, reinterpret_cast<char const *>(record),
hdr->exportVarsCount * sizeof(uint32_t),
"Write ExportVars");
free(record);
}
// Write Export Functions Table
{
uint32_t *record, *ptr;
record = (uint32_t *)calloc(hdr->exportFuncsCount, sizeof(uint32_t));
ptr = record;
if (!record) {
goto bail;
}
for (ExportFuncList::const_iterator I = mExportFuncs.begin(),
E = mExportFuncs.end(); I != E; I++) {
*ptr++ = reinterpret_cast<uint32_t>(*I);
}
sysWriteFully(mCacheFd, reinterpret_cast<char const *>(record),
hdr->exportFuncsCount * sizeof(uint32_t),
"Write ExportFuncs");
free(record);
}
// Write Export Pragmas Table
{
uint32_t pragmaEntryOffset =
hdr->exportPragmasCount * sizeof(oBCCPragmaEntry);
for (PragmaList::const_iterator
I = mPragmas.begin(), E = mPragmas.end(); I != E; ++I) {
oBCCPragmaEntry entry;
entry.pragmaNameOffset = pragmaEntryOffset;
entry.pragmaNameSize = I->first.size();
pragmaEntryOffset += entry.pragmaNameSize + 1;
entry.pragmaValueOffset = pragmaEntryOffset;
entry.pragmaValueSize = I->second.size();
pragmaEntryOffset += entry.pragmaValueSize + 1;
sysWriteFully(mCacheFd, (char *)&entry, sizeof(oBCCPragmaEntry),
"Write export pragma entry");
}
for (PragmaList::const_iterator
I = mPragmas.begin(), E = mPragmas.end(); I != E; ++I) {
sysWriteFully(mCacheFd, I->first.c_str(), I->first.size() + 1,
"Write export pragma name string");
sysWriteFully(mCacheFd, I->second.c_str(), I->second.size() + 1,
"Write export pragma value string");
}
}
if (codeOffsetNeedPadding) {
// requires additional padding
lseek(mCacheFd, hdr->codeOffset, SEEK_SET);
}
// Write Generated Code and Global Variable
sysWriteFully(mCacheFd, mCodeDataAddr, MaxCodeSize + MaxGlobalVarSize,
"Write code and global variable");
goto close_return;
bail:
if (ftruncate(mCacheFd, 0) != 0) {
LOGW("Warning: unable to truncate cache file: %s\n", strerror(errno));
}
close_return:
free(hdr);
close(mCacheFd);
mCacheFd = -1;
}
// OpenCacheFile() returns fd of the cache file.
// Input:
// BCCchar *resName: Used to genCacheFileName()
// bool createIfMissing: If false, turn off caching
// Output:
// returns fd: If -1: Failed
// mCacheNew: If true, the returned fd is new. Otherwise, the fd is the
// cache file's file descriptor
// Note: openCacheFile() will check the cache file's validity,
// such as Magic number, sourceWhen... dependencies.
int Compiler::openCacheFile(const BCCchar *resName, bool createIfMissing) {
int fd, cc;
struct stat fdStat, fileStat;
bool readOnly = false;
char *cacheFileName = genCacheFileName(resName, ".oBCC");
mCacheNew = false;
retry:
/*
* Try to open the cache file. If we've been asked to,
* create it if it doesn't exist.
*/
fd = createIfMissing ? open(cacheFileName, O_CREAT|O_RDWR, 0644) : -1;
if (fd < 0) {
fd = open(cacheFileName, O_RDONLY, 0);
if (fd < 0) {
if (createIfMissing) {
LOGW("Can't open bcc-cache '%s': %s\n",
cacheFileName, strerror(errno));
mUseCache = false;
}
return fd;
}
readOnly = true;
}
/*
* Grab an exclusive lock on the cache file. If somebody else is
* working on it, we'll block here until they complete.
*/
LOGV("bcc: locking cache file %s (fd=%d, boot=%d)\n",
cacheFileName, fd);
cc = flock(fd, LOCK_EX | LOCK_NB);
if (cc != 0) {
LOGD("bcc: sleeping on flock(%s)\n", cacheFileName);
cc = flock(fd, LOCK_EX);
}
if (cc != 0) {
LOGE("Can't lock bcc cache '%s': %d\n", cacheFileName, cc);
close(fd);
return -1;
}
LOGV("bcc: locked cache file\n");
/*
* Check to see if the fd we opened and locked matches the file in
* the filesystem. If they don't, then somebody else unlinked ours
* and created a new file, and we need to use that one instead. (If
* we caught them between the unlink and the create, we'll get an
* ENOENT from the file stat.)
*/
cc = fstat(fd, &fdStat);
if (cc != 0) {
LOGE("Can't stat open file '%s'\n", cacheFileName);
LOGV("bcc: unlocking cache file %s\n", cacheFileName);
goto close_fail;
}
cc = stat(cacheFileName, &fileStat);
if (cc != 0 ||
fdStat.st_dev != fileStat.st_dev || fdStat.st_ino != fileStat.st_ino) {
LOGD("bcc: our open cache file is stale; sleeping and retrying\n");
LOGV("bcc: unlocking cache file %s\n", cacheFileName);
flock(fd, LOCK_UN);
close(fd);
usleep(250 * 1000); // if something is hosed, don't peg machine
goto retry;
}
/*
* We have the correct file open and locked. If the file size is zero,
* then it was just created by us, and we want to fill in some fields
* in the "bcc" header and set "mCacheNew". Otherwise, we want to
* verify that the fields in the header match our expectations, and
* reset the file if they don't.
*/
if (fdStat.st_size == 0) {
if (readOnly) { // The device is readOnly --> close_fail
LOGW("bcc: file has zero length and isn't writable\n");
goto close_fail;
}
/*cc = createEmptyHeader(fd);
if (cc != 0)
goto close_fail;
*/
mCacheNew = true;
LOGV("bcc: successfully initialized new cache file\n");
} else {
// Calculate sourceWhen
// XXX
uint32_t sourceWhen = 0;
uint32_t rslibWhen = 0;
uint32_t libRSWhen = 0;
uint32_t libbccWhen = 0;
if (!checkHeaderAndDependencies(fd,
sourceWhen,
rslibWhen,
libRSWhen,
libbccWhen)) {
// If checkHeaderAndDependencies returns 0: FAILED
// Will truncate the file and retry to createIfMissing the file
if (readOnly) { // Shouldn't be readonly.
/*
* We could unlink and rewrite the file if we own it or
* the "sticky" bit isn't set on the directory. However,
* we're not able to truncate it, which spoils things. So,
* give up now.
*/
if (createIfMissing) {
LOGW("Cached file %s is stale and not writable\n",
cacheFileName);
}
goto close_fail;
}
/*
* If we truncate the existing file before unlinking it, any
* process that has it mapped will fail when it tries to touch
* the pages? Probably OK because we use MAP_PRIVATE.
*/
LOGD("oBCC file is stale or bad; removing and retrying (%s)\n",
cacheFileName);
if (ftruncate(fd, 0) != 0) {
LOGW("Warning: unable to truncate cache file '%s': %s\n",
cacheFileName, strerror(errno));
/* keep going */
}
if (unlink(cacheFileName) != 0) {
LOGW("Warning: unable to remove cache file '%s': %d %s\n",
cacheFileName, errno, strerror(errno));
/* keep going; permission failure should probably be fatal */
}
LOGV("bcc: unlocking cache file %s\n", cacheFileName);
flock(fd, LOCK_UN);
close(fd);
goto retry;
} else {
// Got cacheFile! Good to go.
LOGV("Good cache file\n");
}
}
assert(fd >= 0);
return fd;
close_fail:
flock(fd, LOCK_UN);
close(fd);
return -1;
} // End of openCacheFile()
char *Compiler::genCacheFileName(const char *fileName,
const char *subFileName) {
char nameBuf[512];
static const char kCachePath[] = "bcc-cache";
char absoluteFile[sizeof(nameBuf)];
const size_t kBufLen = sizeof(nameBuf) - 1;
const char *dataRoot;
char *cp;
// Get the absolute path of the raw/***.bc file.
absoluteFile[0] = '\0';
if (fileName[0] != '/') {
/*
* Generate the absolute path. This doesn't do everything it
* should, e.g. if filename is "./out/whatever" it doesn't crunch
* the leading "./" out, but it'll do.
*/
if (getcwd(absoluteFile, kBufLen) == NULL) {
LOGE("Can't get CWD while opening raw/***.bc file\n");
return NULL;
}
// TODO(srhines): strncat() is a bit dangerous
strncat(absoluteFile, "/", kBufLen);
}
strncat(absoluteFile, fileName, kBufLen);
if (subFileName != NULL) {
strncat(absoluteFile, "/", kBufLen);
strncat(absoluteFile, subFileName, kBufLen);
}
/* Turn the path into a flat filename by replacing
* any slashes after the first one with '@' characters.
*/
cp = absoluteFile + 1;
while (*cp != '\0') {
if (*cp == '/') {
*cp = '@';
}
cp++;
}
/* Build the name of the cache directory.
*/
dataRoot = getenv("ANDROID_DATA");
if (dataRoot == NULL)
dataRoot = "/data";
snprintf(nameBuf, kBufLen, "%s/%s", dataRoot, kCachePath);
/* Tack on the file name for the actual cache file path.
*/
strncat(nameBuf, absoluteFile, kBufLen);
LOGV("Cache file for '%s' '%s' is '%s'\n", fileName, subFileName, nameBuf);
return strdup(nameBuf);
}
/*
* Read the oBCC header, verify it, then read the dependent section
* and verify that data as well.
*
* On successful return, the file will be seeked immediately past the
* oBCC header.
*/
bool Compiler::checkHeaderAndDependencies(int fd,
uint32_t sourceWhen,
uint32_t rslibWhen,
uint32_t libRSWhen,
uint32_t libbccWhen) {
ssize_t actual;
oBCCHeader optHdr;
uint32_t val;
uint8_t const *magic, *magicVer;
/*
* Start at the start. The "bcc" header, when present, will always be
* the first thing in the file.
*/
if (lseek(fd, 0, SEEK_SET) != 0) {
LOGE("bcc: failed to seek to start of file: %s\n", strerror(errno));
goto bail;
}
/*
* Read and do trivial verification on the bcc header. The header is
* always in host byte order.
*/
actual = read(fd, &optHdr, sizeof(optHdr));
if (actual < 0) {
LOGE("bcc: failed reading bcc header: %s\n", strerror(errno));
goto bail;
} else if (actual != sizeof(optHdr)) {
LOGE("bcc: failed reading bcc header (got %d of %zd)\n",
(int) actual, sizeof(optHdr));
goto bail;
}
magic = optHdr.magic;
if (memcmp(magic, OBCC_MAGIC, 4) != 0) {
/* not an oBCC file, or previous attempt was interrupted */
LOGD("bcc: incorrect opt magic number (0x%02x %02x %02x %02x)\n",
magic[0], magic[1], magic[2], magic[3]);
goto bail;
}
magicVer = optHdr.magicVersion;
if (memcmp(magic+4, OBCC_MAGIC_VERS, 4) != 0) {
LOGW("bcc: stale oBCC version (0x%02x %02x %02x %02x)\n",
magicVer[0], magicVer[1], magicVer[2], magicVer[3]);
goto bail;
}
/*
* Do the header flags match up with what we want?
*
* This is useful because it allows us to automatically regenerate
* a file when settings change (e.g. verification is now mandatory),
* but can cause difficulties if the thing we depend upon
* were handled differently than the current options specify.
*
* So, for now, we essentially ignore "expectVerify" and "expectOpt"
* by limiting the match mask.
*
* The only thing we really can't handle is incorrect byte-ordering.
*/
val = optHdr.sourceWhen;
if (val && (val != sourceWhen)) {
LOGI("bcc: source file mod time mismatch (%08x vs %08x)\n",
val, sourceWhen);
goto bail;
}
val = optHdr.rslibWhen;
if (val && (val != rslibWhen)) {
LOGI("bcc: rslib file mod time mismatch (%08x vs %08x)\n",
val, rslibWhen);
goto bail;
}
val = optHdr.libRSWhen;
if (val && (val != libRSWhen)) {
LOGI("bcc: libRS file mod time mismatch (%08x vs %08x)\n",
val, libRSWhen);
goto bail;
}
val = optHdr.libbccWhen;
if (val && (val != libbccWhen)) {
LOGI("bcc: libbcc file mod time mismatch (%08x vs %08x)\n",
val, libbccWhen);
goto bail;
}
return true;
bail:
return false;
}
} // namespace bcc