/* * Copyright 2011-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. */ #include "bcinfo/BitcodeTranslator.h" #include "bcinfo/BitcodeWrapper.h" #include "BitReader_2_7/BitReader_2_7.h" #include "BitReader_3_0/BitReader_3_0.h" #define LOG_TAG "bcinfo" #include <cutils/log.h> #include "llvm/ADT/OwningPtr.h" #include "llvm/Bitcode/BitstreamWriter.h" #include "llvm/Bitcode/ReaderWriter.h" #include "llvm/LLVMContext.h" #include "llvm/Module.h" #include "llvm/Support/MemoryBuffer.h" #include "llvm/Support/raw_ostream.h" #include <cstdlib> namespace bcinfo { /** * Define minimum and maximum target API versions. These correspond to the * same API levels used by the standard Android SDK. * * LLVM 2.7 * 11 - Honeycomb * 12 - Honeycomb MR1 * 13 - Honeycomb MR2 * * LLVM 3.0 * 14 - Ice Cream Sandwich * 15 - Ice Cream Sandwich MR1 * * LLVM 3.1 * 16 - Ice Cream Sandwich MR2 */ static const unsigned int kMinimumAPIVersion = 11; static const unsigned int kMaximumAPIVersion = BCINFO_API_VERSION; static const unsigned int kCurrentAPIVersion = 10000; /** * The minimum version which does not require translation (i.e. is already * compatible with LLVM's default bitcode reader). */ static const unsigned int kMinimumUntranslatedVersion = 16; static const unsigned int kMinimumCompatibleVersion_LLVM_3_0 = 14; static const unsigned int kMinimumCompatibleVersion_LLVM_2_7 = 11; BitcodeTranslator::BitcodeTranslator(const char *bitcode, size_t bitcodeSize, unsigned int version) : mBitcode(bitcode), mBitcodeSize(bitcodeSize), mTranslatedBitcode(NULL), mTranslatedBitcodeSize(0), mVersion(version) { return; } BitcodeTranslator::~BitcodeTranslator() { if (mVersion < kMinimumUntranslatedVersion) { // We didn't actually do a translation in the alternate case, so deleting // the bitcode would be improper. delete [] mTranslatedBitcode; } mTranslatedBitcode = NULL; return; } bool BitcodeTranslator::translate() { if (!mBitcode || !mBitcodeSize) { ALOGE("Invalid/empty bitcode"); return false; } BitcodeWrapper BCWrapper(mBitcode, mBitcodeSize); if (BCWrapper.getTargetAPI() != mVersion) { ALOGE("Bitcode wrapper (%u) and translator (%u) disagree about target API", BCWrapper.getTargetAPI(), mVersion); } if ((mVersion != kCurrentAPIVersion) && ((mVersion < kMinimumAPIVersion) || (mVersion > kMaximumAPIVersion))) { ALOGE("Invalid API version: %u is out of range ('%u' - '%u')", mVersion, kMinimumAPIVersion, kMaximumAPIVersion); return false; } // We currently don't need to transcode any API version higher than 14 or // the current API version (i.e. 10000) if (mVersion >= kMinimumUntranslatedVersion) { mTranslatedBitcode = mBitcode; mTranslatedBitcodeSize = mBitcodeSize; return true; } // Do the actual transcoding by invoking a 2.7-era bitcode reader that can // then write the bitcode back out in a more modern (acceptable) version. llvm::OwningPtr<llvm::LLVMContext> mContext(new llvm::LLVMContext()); llvm::OwningPtr<llvm::MemoryBuffer> MEM( llvm::MemoryBuffer::getMemBuffer( llvm::StringRef(mBitcode, mBitcodeSize), "", false)); std::string error; // Module ownership is handled by the context, so we don't need to free it. llvm::Module *module = NULL; if (mVersion >= kMinimumCompatibleVersion_LLVM_3_0) { module = llvm_3_0::ParseBitcodeFile(MEM.get(), *mContext, &error); } else if (mVersion >= kMinimumCompatibleVersion_LLVM_2_7) { module = llvm_2_7::ParseBitcodeFile(MEM.get(), *mContext, &error); } else { ALOGE("No compatible bitcode reader for API version %d", mVersion); return false; } if (!module) { ALOGE("Could not parse bitcode file"); ALOGE("%s", error.c_str()); return false; } std::string Buffer; llvm::raw_string_ostream OS(Buffer); llvm::WriteBitcodeToFile(module, OS); OS.flush(); AndroidBitcodeWrapper wrapper; size_t actualWrapperLen = writeAndroidBitcodeWrapper( &wrapper, Buffer.size(), BCWrapper.getTargetAPI(), BCWrapper.getCompilerVersion(), BCWrapper.getOptimizationLevel()); if (!actualWrapperLen) { ALOGE("Couldn't produce bitcode wrapper!"); return false; } mTranslatedBitcodeSize = actualWrapperLen + Buffer.size(); char *c = new char[mTranslatedBitcodeSize]; memcpy(c, &wrapper, actualWrapperLen); memcpy(c + actualWrapperLen, Buffer.c_str(), Buffer.size()); mTranslatedBitcode = c; return true; } } // namespace bcinfo