lib/Renderscript/RSCompilerDriver.cpp

/*
 * Copyright 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 <string>

#include "bcc/Renderscript/RSCompilerDriver.h"

#include <llvm/IR/Module.h>
#include <llvm/Support/CommandLine.h>
#include <llvm/Support/Path.h>
#include <llvm/Support/raw_ostream.h>

#include "bcinfo/BitcodeWrapper.h"

#include "bcc/Compiler.h"
#include "bcc/Config/Config.h"
#include "bcc/Renderscript/RSExecutable.h"
#include "bcc/Renderscript/RSInfo.h"
#include "bcc/Renderscript/RSScript.h"
#include "bcc/Support/CompilerConfig.h"
#include "bcc/Source.h"
#include "bcc/Support/FileMutex.h"
#include "bcc/Support/Log.h"
#include "bcc/Support/InputFile.h"
#include "bcc/Support/Initialization.h"
#include "bcc/Support/Sha1Util.h"
#include "bcc/Support/OutputFile.h"

#ifdef HAVE_ANDROID_OS
#include <cutils/properties.h>
#endif
#include <utils/StopWatch.h>

using namespace bcc;

// Get the build fingerprint of the Android device we are running on.
static std::string getBuildFingerPrint() {
#ifdef HAVE_ANDROID_OS
    char fingerprint[PROPERTY_VALUE_MAX];
    property_get("ro.build.fingerprint", fingerprint, "");
    return fingerprint;
#else
    return "HostBuild";
#endif
}

RSCompilerDriver::RSCompilerDriver(bool pUseCompilerRT) :
    mConfig(nullptr), mCompiler(), mDebugContext(false),
    mLinkRuntimeCallback(nullptr), mEnableGlobalMerge(true) {
  init::Initialize();
}

RSCompilerDriver::~RSCompilerDriver() {
  delete mConfig;
}

RSExecutable* RSCompilerDriver::loadScript(const char* pCacheDir, const char* pResName,
                                           const char* pBitcode, size_t pBitcodeSize,
                                           const char* expectedCompileCommandLine,
                                           SymbolResolverProxy& pResolver) {
  // android::StopWatch load_time("bcc: RSCompilerDriver::loadScript time");
  if ((pCacheDir == nullptr) || (pResName == nullptr)) {
    ALOGE("Missing pCacheDir and/or pResName");
    return nullptr;
  }

  if ((pBitcode == nullptr) || (pBitcodeSize <= 0)) {
    ALOGE("No bitcode supplied! (bitcode: %p, size of bitcode: %zu)",
          pBitcode, pBitcodeSize);
    return nullptr;
  }

  // {pCacheDir}/{pResName}.o
  llvm::SmallString<80> output_path(pCacheDir);
  llvm::sys::path::append(output_path, pResName);
  llvm::sys::path::replace_extension(output_path, ".o");

  //===--------------------------------------------------------------------===//
  // Acquire the read lock for reading the Script object file.
  //===--------------------------------------------------------------------===//
  FileMutex<FileBase::kReadLock> read_output_mutex(output_path.c_str());

  if (read_output_mutex.hasError() || !read_output_mutex.lock()) {
    ALOGE("Unable to acquire the read lock for %s! (%s)", output_path.c_str(),
          read_output_mutex.getErrorMessage().c_str());
    return nullptr;
  }

  //===--------------------------------------------------------------------===//
  // Read the output object file.
  //===--------------------------------------------------------------------===//
  InputFile *object_file = new (std::nothrow) InputFile(output_path.c_str());

  if ((object_file == nullptr) || object_file->hasError()) {
      //      ALOGE("Unable to open the %s for read! (%s)", output_path.c_str(),
      //            object_file->getErrorMessage().c_str());
    delete object_file;
    return nullptr;
  }

  //===--------------------------------------------------------------------===//
  // Acquire the read lock on object_file for reading its RS info file.
  //===--------------------------------------------------------------------===//
  std::string info_path = RSInfo::GetPath(output_path.c_str());

  if (!object_file->lock()) {
    ALOGE("Unable to acquire the read lock on %s for reading %s! (%s)",
          output_path.c_str(), info_path.c_str(),
          object_file->getErrorMessage().c_str());
    delete object_file;
    return nullptr;
  }

  //===---------------------------------------------------------------------===//
  // Open and load the RS info file.
  //===--------------------------------------------------------------------===//
  InputFile info_file(info_path.c_str());
  RSInfo *info = RSInfo::ReadFromFile(info_file);

  // Release the lock on object_file.
  object_file->unlock();

  if (info == nullptr) {
    delete object_file;
    return nullptr;
  }

  //===---------------------------------------------------------------------===//
  // Check that the info in the RS info file is consistent we what we want.
  //===--------------------------------------------------------------------===//

  uint8_t expectedSourceHash[SHA1_DIGEST_LENGTH];
  Sha1Util::GetSHA1DigestFromBuffer(expectedSourceHash, pBitcode, pBitcodeSize);

  std::string expectedBuildFingerprint = getBuildFingerPrint();

  // If the info file contains different hash for the source than what we are
  // looking for, bail.  Do the same if the command line used when compiling or the
  // build fingerprint of Android has changed.  The compiled code found on disk is
  // out of date and needs to be recompiled first.
  if (!info->IsConsistent(output_path.c_str(), expectedSourceHash, expectedCompileCommandLine,
                          expectedBuildFingerprint.c_str())) {
      delete object_file;
      delete info;
      return nullptr;
  }

  //===--------------------------------------------------------------------===//
  // Create the RSExecutable.
  //===--------------------------------------------------------------------===//
  RSExecutable *executable = RSExecutable::Create(*info, *object_file, pResolver);
  if (executable == nullptr) {
    delete object_file;
    delete info;
    return nullptr;
  }

  return executable;
}

#if defined(PROVIDE_ARM_CODEGEN)
extern llvm::cl::opt<bool> EnableGlobalMerge;
#endif

bool RSCompilerDriver::setupConfig(const RSScript &pScript) {
  bool changed = false;

  const llvm::CodeGenOpt::Level script_opt_level =
      static_cast<llvm::CodeGenOpt::Level>(pScript.getOptimizationLevel());

#if defined(PROVIDE_ARM_CODEGEN)
  EnableGlobalMerge = mEnableGlobalMerge;
#endif

  if (mConfig != nullptr) {
    // Renderscript bitcode may have their optimization flag configuration
    // different than the previous run of RS compilation.
    if (mConfig->getOptimizationLevel() != script_opt_level) {
      mConfig->setOptimizationLevel(script_opt_level);
      changed = true;
    }
  } else {
    // Haven't run the compiler ever.
    mConfig = new (std::nothrow) CompilerConfig(DEFAULT_TARGET_TRIPLE_STRING);
    if (mConfig == nullptr) {
      // Return false since mConfig remains NULL and out-of-memory.
      return false;
    }
    mConfig->setOptimizationLevel(script_opt_level);
    changed = true;
  }

#if defined(PROVIDE_ARM_CODEGEN)
  assert((pScript.getInfo() != nullptr) && "NULL RS info!");
  bool script_full_prec = (pScript.getInfo()->getFloatPrecisionRequirement() ==
                           RSInfo::FP_Full);
  if (mConfig->getFullPrecision() != script_full_prec) {
    mConfig->setFullPrecision(script_full_prec);
    changed = true;
  }
#endif

  return changed;
}

Compiler::ErrorCode RSCompilerDriver::compileScript(RSScript& pScript, const char* pScriptName,
                                                    const char* pOutputPath,
                                                    const char* pRuntimePath,
                                                    const RSInfo::DependencyHashTy& pSourceHash,
                                                    const char* compileCommandLineToEmbed,
                                                    bool saveInfoFile, bool pDumpIR) {
  // android::StopWatch compile_time("bcc: RSCompilerDriver::compileScript time");
  RSInfo *info = nullptr;

  //===--------------------------------------------------------------------===//
  // Extract RS-specific information from source bitcode.
  //===--------------------------------------------------------------------===//
  // RS info may contains configuration (such as #optimization_level) to the
  // compiler therefore it should be extracted before compilation.
  info = RSInfo::ExtractFromSource(pScript.getSource(), pSourceHash, compileCommandLineToEmbed,
                                   getBuildFingerPrint().c_str());
  if (info == nullptr) {
    return Compiler::kErrInvalidSource;
  }

  //===--------------------------------------------------------------------===//
  // Associate script with its info
  //===--------------------------------------------------------------------===//
  // This is required since RS compiler may need information in the info file
  // to do some transformation (e.g., expand foreach-able function.)
  pScript.setInfo(info);

  //===--------------------------------------------------------------------===//
  // Link RS script with Renderscript runtime.
  //===--------------------------------------------------------------------===//
  if (!RSScript::LinkRuntime(pScript, pRuntimePath)) {
    ALOGE("Failed to link script '%s' with Renderscript runtime!", pScriptName);
    return Compiler::kErrInvalidSource;
  }

  {
    // FIXME(srhines): Windows compilation can't use locking like this, but
    // we also don't need to worry about concurrent writers of the same file.
#ifndef USE_MINGW
    //===------------------------------------------------------------------===//
    // Acquire the write lock for writing output object file.
    //===------------------------------------------------------------------===//
    FileMutex<FileBase::kWriteLock> write_output_mutex(pOutputPath);

    if (write_output_mutex.hasError() || !write_output_mutex.lock()) {
      ALOGE("Unable to acquire the lock for writing %s! (%s)",
            pOutputPath, write_output_mutex.getErrorMessage().c_str());
      return Compiler::kErrInvalidSource;
    }
#endif

    // Open the output file for write.
    OutputFile output_file(pOutputPath,
                           FileBase::kTruncate | FileBase::kBinary);

    if (output_file.hasError()) {
        ALOGE("Unable to open %s for write! (%s)", pOutputPath,
              output_file.getErrorMessage().c_str());
      return Compiler::kErrInvalidSource;
    }

    // Setup the config to the compiler.
    bool compiler_need_reconfigure = setupConfig(pScript);

    if (mConfig == nullptr) {
      ALOGE("Failed to setup config for RS compiler to compile %s!",
            pOutputPath);
      return Compiler::kErrInvalidSource;
    }

    if (compiler_need_reconfigure) {
      Compiler::ErrorCode err = mCompiler.config(*mConfig);
      if (err != Compiler::kSuccess) {
        ALOGE("Failed to config the RS compiler for %s! (%s)",pOutputPath,
              Compiler::GetErrorString(err));
        return Compiler::kErrInvalidSource;
      }
    }

    OutputFile *ir_file = nullptr;
    llvm::raw_fd_ostream *IRStream = nullptr;
    if (pDumpIR) {
      std::string path(pOutputPath);
      path.append(".ll");
      ir_file = new OutputFile(path.c_str(), FileBase::kTruncate);
      IRStream = ir_file->dup();
    }

    // Run the compiler.
    Compiler::ErrorCode compile_result =
        mCompiler.compile(pScript, output_file, IRStream);

    if (ir_file) {
      ir_file->close();
      delete ir_file;
    }

    if (compile_result != Compiler::kSuccess) {
      ALOGE("Unable to compile the source to file %s! (%s)", pOutputPath,
            Compiler::GetErrorString(compile_result));
      return Compiler::kErrInvalidSource;
    }
  }

  if (saveInfoFile) {
    std::string info_path = RSInfo::GetPath(pOutputPath);
    OutputFile info_file(info_path.c_str(), FileBase::kTruncate);

    if (info_file.hasError()) {
      ALOGE("Failed to open the info file %s for write! (%s)",
            info_path.c_str(), info_file.getErrorMessage().c_str());
      return Compiler::kErrInvalidSource;
    }

    FileMutex<FileBase::kWriteLock> write_info_mutex(info_path.c_str());
    if (write_info_mutex.hasError() || !write_info_mutex.lock()) {
      ALOGE("Unable to acquire the lock for writing %s! (%s)",
            info_path.c_str(), write_info_mutex.getErrorMessage().c_str());
      return Compiler::kErrInvalidSource;
    }

    // Perform the write.
    if (!info->write(info_file)) {
      ALOGE("Failed to sync the RS info file %s!", info_path.c_str());
      return Compiler::kErrInvalidSource;
    }
  }

  return Compiler::kSuccess;
}

bool RSCompilerDriver::build(BCCContext &pContext,
                             const char *pCacheDir,
                             const char *pResName,
                             const char *pBitcode,
                             size_t pBitcodeSize,
                             const char *commandLine,
                             const char *pRuntimePath,
                             RSLinkRuntimeCallback pLinkRuntimeCallback,
                             bool pDumpIR) {
    //  android::StopWatch build_time("bcc: RSCompilerDriver::build time");
  //===--------------------------------------------------------------------===//
  // Check parameters.
  //===--------------------------------------------------------------------===//
  if ((pCacheDir == nullptr) || (pResName == nullptr)) {
    ALOGE("Invalid parameter passed to RSCompilerDriver::build()! (cache dir: "
          "%s, resource name: %s)", ((pCacheDir) ? pCacheDir : "(null)"),
                                    ((pResName) ? pResName : "(null)"));
    return false;
  }

  if ((pBitcode == nullptr) || (pBitcodeSize <= 0)) {
    ALOGE("No bitcode supplied! (bitcode: %p, size of bitcode: %u)",
          pBitcode, static_cast<unsigned>(pBitcodeSize));
    return false;
  }

  //===--------------------------------------------------------------------===//
  // Prepare dependency information.
  //===--------------------------------------------------------------------===//
  uint8_t bitcode_sha1[SHA1_DIGEST_LENGTH];
  Sha1Util::GetSHA1DigestFromBuffer(bitcode_sha1, pBitcode, pBitcodeSize);

  //===--------------------------------------------------------------------===//
  // Construct output path.
  // {pCacheDir}/{pResName}.o
  //===--------------------------------------------------------------------===//
  llvm::SmallString<80> output_path(pCacheDir);
  llvm::sys::path::append(output_path, pResName);
  llvm::sys::path::replace_extension(output_path, ".o");

  //===--------------------------------------------------------------------===//
  // Load the bitcode and create script.
  //===--------------------------------------------------------------------===//
  Source *source = Source::CreateFromBuffer(pContext, pResName,
                                            pBitcode, pBitcodeSize);
  if (source == nullptr) {
    return false;
  }

  RSScript script(*source);
  if (pLinkRuntimeCallback) {
    setLinkRuntimeCallback(pLinkRuntimeCallback);
  }

  script.setLinkRuntimeCallback(getLinkRuntimeCallback());

  // Read information from bitcode wrapper.
  bcinfo::BitcodeWrapper wrapper(pBitcode, pBitcodeSize);
  script.setCompilerVersion(wrapper.getCompilerVersion());
  script.setOptimizationLevel(static_cast<RSScript::OptimizationLevel>(
                              wrapper.getOptimizationLevel()));

  //===--------------------------------------------------------------------===//
  // Compile the script
  //===--------------------------------------------------------------------===//
  Compiler::ErrorCode status = compileScript(script, pResName,
                                             output_path.c_str(),
                                             pRuntimePath, bitcode_sha1, commandLine,
                                             true, pDumpIR);

  return status == Compiler::kSuccess;
}


bool RSCompilerDriver::buildForCompatLib(RSScript &pScript, const char *pOut,
                                         const char *pRuntimePath) {
  // For compat lib, we don't check the RS info file so we don't need the source hash,
  // compile command, and build fingerprint.
  // TODO We may want to make them optional or embed real values.
  uint8_t bitcode_sha1[SHA1_DIGEST_LENGTH] = {0};
  const char* compileCommandLineToEmbed = "";
  const char* buildFingerprintToEmbed = "";

  RSInfo* info = RSInfo::ExtractFromSource(pScript.getSource(), bitcode_sha1,
                                           compileCommandLineToEmbed, buildFingerprintToEmbed);
  if (info == nullptr) {
    return false;
  }
  pScript.setInfo(info);

  // Embed the info string directly in the ELF, since this path is for an
  // offline (host) compilation.
  pScript.setEmbedInfo(true);

  Compiler::ErrorCode status = compileScript(pScript, pOut, pOut, pRuntimePath, bitcode_sha1,
                                             compileCommandLineToEmbed, false, false);
  if (status != Compiler::kSuccess) {
    return false;
  }

  return true;
}