libbcc/lib/Renderscript/RSX86CallConvPass.cpp

/*
 * Copyright 2015, 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 "bcc/Assert.h"
#include "bcc/Renderscript/RSUtils.h"
#include "bcc/Support/Log.h"

#include <algorithm>
#include <vector>

#include <llvm/IR/CallSite.h>
#include <llvm/IR/Type.h>
#include <llvm/IR/Instructions.h>
#include <llvm/IR/Module.h>
#include <llvm/IR/Function.h>
#include <llvm/Pass.h>

namespace { // anonymous namespace

static const bool kDebug = false;

/* RSX86_64CallConvPass: This pass scans for calls to Renderscript functions in
 * the CPU reference driver.  For such calls, it  identifies the
 * pass-by-reference large-object pointer arguments introduced by the frontend
 * to conform to the AArch64 calling convention (AAPCS).  These pointer
 * arguments are converted to pass-by-value to match the calling convention of
 * the CPU reference driver.
 */
class RSX86_64CallConvPass: public llvm::ModulePass {
private:
  bool IsRSFunctionOfInterest(llvm::Function &F) {
  // Only Renderscript functions that are not defined locally be considered
    if (!F.empty()) // defined locally
      return false;

    // llvm intrinsic or internal function
    llvm::StringRef FName = F.getName();
    if (FName.startswith("llvm."))
      return false;

    // All other functions need to be checked for large-object parameters.
    // Disallowed (non-Renderscript) functions are detected by a different pass.
    return true;
  }

  // Test if this argument needs to be converted to pass-by-value.
  bool IsDerefNeeded(llvm::Function *F, llvm::Argument &Arg) {
    unsigned ArgNo = Arg.getArgNo();
    llvm::Type *ArgTy = Arg.getType();

    // Do not consider arguments with 'sret' attribute.  Parameters with this
    // attribute are actually pointers to structure return values.
    if (Arg.hasStructRetAttr())
      return false;

    // Dereference needed only if type is a pointer to a struct
    if (!ArgTy->isPointerTy() || !ArgTy->getPointerElementType()->isStructTy())
      return false;

    // Dereference needed only for certain RS struct objects.
    llvm::Type *StructTy = ArgTy->getPointerElementType();
    if (!isRsObjectType(StructTy))
      return false;

    // TODO Find a better way to encode exceptions
    llvm::StringRef FName = F->getName();
    // rsSetObject's first parameter is a pointer
    if (FName.find("rsSetObject") != std::string::npos && ArgNo == 0)
      return false;
    // rsClearObject's first parameter is a pointer
    if (FName.find("rsClearObject") != std::string::npos && ArgNo == 0)
      return false;
    // rsForEachInternal's fifth parameter is a pointer
    if (FName.find("rsForEachInternal") != std::string::npos && ArgNo == 4)
      return false;

    return true;
  }

  // Compute which arguments to this function need be converted to pass-by-value
  bool FillArgsToDeref(llvm::Function *F, std::vector<unsigned> &ArgNums) {
    bccAssert(ArgNums.size() == 0);

    for (auto &Arg: F->getArgumentList()) {
      if (IsDerefNeeded(F, Arg)) {
        ArgNums.push_back(Arg.getArgNo());

        if (kDebug) {
          ALOGV("Lowering argument %u for function %s\n", Arg.getArgNo(),
                F->getName().str().c_str());
        }
      }
    }
    return ArgNums.size() > 0;
  }

  llvm::Function *RedefineFn(llvm::Function *OrigFn,
                             std::vector<unsigned> &ArgsToDeref) {

    llvm::FunctionType *FTy = OrigFn->getFunctionType();
    std::vector<llvm::Type *> Params(FTy->param_begin(), FTy->param_end());

    llvm::FunctionType *NewTy = llvm::FunctionType::get(FTy->getReturnType(),
                                                        Params,
                                                        FTy->isVarArg());
    llvm::Function *NewFn = llvm::Function::Create(NewTy,
                                                   OrigFn->getLinkage(),
                                                   OrigFn->getName(),
                                                   OrigFn->getParent());

    // Add the ByVal attribute to the attribute list corresponding to this
    // argument.  The list at index (i+1) corresponds to the i-th argument.  The
    // list at index 0 corresponds to the return value's attribute.
    for (auto i: ArgsToDeref) {
      NewFn->addAttribute(i+1, llvm::Attribute::ByVal);
    }

    NewFn->copyAttributesFrom(OrigFn);
    NewFn->takeName(OrigFn);

    for (auto AI=OrigFn->arg_begin(), AE=OrigFn->arg_end(),
              NAI=NewFn->arg_begin();
         AI != AE; ++ AI, ++NAI) {
      NAI->takeName(&*AI);
    }

    return NewFn;
  }

  void ReplaceCallInsn(llvm::CallSite &CS,
                       llvm::Function *NewFn,
                       std::vector<unsigned> &ArgsToDeref) {

    llvm::CallInst *CI = llvm::cast<llvm::CallInst>(CS.getInstruction());
    std::vector<llvm::Value *> Args(CS.arg_begin(), CS.arg_end());
    auto NewCI = llvm::CallInst::Create(NewFn, Args, "", CI);

    // Add the ByVal attribute to the attribute list corresponding to this
    // argument.  The list at index (i+1) corresponds to the i-th argument.  The
    // list at index 0 corresponds to the return value's attribute.
    for (auto i: ArgsToDeref) {
      NewCI->addAttribute(i+1, llvm::Attribute::ByVal);
    }
    if (CI->isTailCall())
      NewCI->setTailCall();

    if (!CI->getType()->isVoidTy())
      CI->replaceAllUsesWith(NewCI);

    CI->eraseFromParent();
  }

public:
  static char ID;

  RSX86_64CallConvPass()
    : ModulePass (ID) {
  }

  virtual void getAnalysisUsage(llvm::AnalysisUsage &AU) const override {
    // This pass does not use any other analysis passes, but it does
    // modify the existing functions in the module (thus altering the CFG).
  }

  bool runOnModule(llvm::Module &M) override {
    // Avoid adding Functions and altering FunctionList while iterating over it
    // by collecting functions and processing them later.
    std::vector<llvm::Function *> FunctionsToHandle;

    auto &FunctionList = M.getFunctionList();
    for (auto &OrigFn: FunctionList) {
      if (!IsRSFunctionOfInterest(OrigFn))
        continue;
      FunctionsToHandle.push_back(&OrigFn);
    }

    for (auto OrigFn: FunctionsToHandle) {
      std::vector<unsigned> ArgsToDeref;
      if (!FillArgsToDeref(OrigFn, ArgsToDeref))
        continue;

      // Replace all calls to OrigFn and erase it from parent.
      llvm::Function *NewFn = RedefineFn(OrigFn, ArgsToDeref);
      while (!OrigFn->use_empty()) {
        llvm::CallSite CS(OrigFn->user_back());
        ReplaceCallInsn(CS, NewFn, ArgsToDeref);
      }
      OrigFn->eraseFromParent();
    }

    return FunctionsToHandle.size() > 0;
  }

};

}

char RSX86_64CallConvPass::ID = 0;

static llvm::RegisterPass<RSX86_64CallConvPass> X("X86-64-calling-conv",
  "remove AArch64 assumptions from calls in X86-64");

namespace bcc {

llvm::ModulePass *
createRSX86_64CallConvPass() {
  return new RSX86_64CallConvPass();
}

}