blob: ff37d858ad7d38fbe98fc0b16734d6c1835d26f4 [file] [log] [blame]
/*
* Copyright (C) 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 "jni_compiler.h"
#include "base/logging.h"
#include "class_linker.h"
#include "compiled_method.h"
#include "dex_file-inl.h"
#include "driver/compiler_driver.h"
#include "driver/dex_compilation_unit.h"
#include "llvm/compiler_llvm.h"
#include "llvm/ir_builder.h"
#include "llvm/llvm_compilation_unit.h"
#include "llvm/runtime_support_llvm_func.h"
#include "llvm/utils_llvm.h"
#include "mirror/art_method.h"
#include "runtime.h"
#include "stack.h"
#include "thread.h"
#include <llvm/ADT/SmallVector.h>
#include <llvm/IR/BasicBlock.h>
#include <llvm/IR/DerivedTypes.h>
#include <llvm/IR/Function.h>
#include <llvm/IR/Type.h>
namespace art {
namespace llvm {
using ::art::llvm::runtime_support::JniMethodEnd;
using ::art::llvm::runtime_support::JniMethodEndSynchronized;
using ::art::llvm::runtime_support::JniMethodEndWithReference;
using ::art::llvm::runtime_support::JniMethodEndWithReferenceSynchronized;
using ::art::llvm::runtime_support::JniMethodStart;
using ::art::llvm::runtime_support::JniMethodStartSynchronized;
using ::art::llvm::runtime_support::RuntimeId;
JniCompiler::JniCompiler(LlvmCompilationUnit* cunit,
CompilerDriver* driver,
const DexCompilationUnit* dex_compilation_unit)
: cunit_(cunit), driver_(driver), module_(cunit_->GetModule()),
context_(cunit_->GetLLVMContext()), irb_(*cunit_->GetIRBuilder()),
dex_compilation_unit_(dex_compilation_unit),
func_(NULL), elf_func_idx_(0) {
// Check: Ensure that JNI compiler will only get "native" method
CHECK(dex_compilation_unit->IsNative());
}
CompiledMethod* JniCompiler::Compile() {
const bool is_static = dex_compilation_unit_->IsStatic();
const bool is_synchronized = dex_compilation_unit_->IsSynchronized();
const DexFile* dex_file = dex_compilation_unit_->GetDexFile();
DexFile::MethodId const& method_id =
dex_file->GetMethodId(dex_compilation_unit_->GetDexMethodIndex());
char const return_shorty = dex_file->GetMethodShorty(method_id)[0];
::llvm::Value* this_object_or_class_object;
uint32_t method_idx = dex_compilation_unit_->GetDexMethodIndex();
std::string func_name(StringPrintf("jni_%s",
MangleForJni(PrettyMethod(method_idx, *dex_file)).c_str()));
CreateFunction(func_name);
// Set argument name
::llvm::Function::arg_iterator arg_begin(func_->arg_begin());
::llvm::Function::arg_iterator arg_end(func_->arg_end());
::llvm::Function::arg_iterator arg_iter(arg_begin);
DCHECK_NE(arg_iter, arg_end);
arg_iter->setName("method");
::llvm::Value* method_object_addr = arg_iter++;
if (!is_static) {
// Non-static, the second argument is "this object"
this_object_or_class_object = arg_iter++;
} else {
// Load class object
this_object_or_class_object =
irb_.LoadFromObjectOffset(method_object_addr,
mirror::ArtMethod::DeclaringClassOffset().Int32Value(),
irb_.getJObjectTy(),
kTBAAConstJObject);
}
// Actual argument (ignore method and this object)
arg_begin = arg_iter;
// Count the number of Object* arguments
uint32_t handle_scope_size = 1;
// "this" object pointer for non-static
// "class" object pointer for static
for (unsigned i = 0; arg_iter != arg_end; ++i, ++arg_iter) {
#if !defined(NDEBUG)
arg_iter->setName(StringPrintf("a%u", i));
#endif
if (arg_iter->getType() == irb_.getJObjectTy()) {
++handle_scope_size;
}
}
// Shadow stack
::llvm::StructType* shadow_frame_type = irb_.getShadowFrameTy(handle_scope_size);
::llvm::AllocaInst* shadow_frame_ = irb_.CreateAlloca(shadow_frame_type);
// Store the dex pc
irb_.StoreToObjectOffset(shadow_frame_,
ShadowFrame::DexPCOffset(),
irb_.getInt32(DexFile::kDexNoIndex),
kTBAAShadowFrame);
// Push the shadow frame
::llvm::Value* shadow_frame_upcast = irb_.CreateConstGEP2_32(shadow_frame_, 0, 0);
::llvm::Value* old_shadow_frame =
irb_.Runtime().EmitPushShadowFrame(shadow_frame_upcast, method_object_addr, handle_scope_size);
// Get JNIEnv
::llvm::Value* jni_env_object_addr =
irb_.Runtime().EmitLoadFromThreadOffset(Thread::JniEnvOffset().Int32Value(),
irb_.getJObjectTy(),
kTBAARuntimeInfo);
// Get callee code_addr
::llvm::Value* code_addr =
irb_.LoadFromObjectOffset(method_object_addr,
mirror::ArtMethod::NativeMethodOffset().Int32Value(),
GetFunctionType(dex_compilation_unit_->GetDexMethodIndex(),
is_static, true)->getPointerTo(),
kTBAARuntimeInfo);
// Load actual parameters
std::vector< ::llvm::Value*> args;
// The 1st parameter: JNIEnv*
args.push_back(jni_env_object_addr);
// Variables for GetElementPtr
::llvm::Value* gep_index[] = {
irb_.getInt32(0), // No displacement for shadow frame pointer
irb_.getInt32(1), // handle scope
NULL,
};
size_t handle_scope_member_index = 0;
// Store the "this object or class object" to handle scope
gep_index[2] = irb_.getInt32(handle_scope_member_index++);
::llvm::Value* handle_scope_field_addr = irb_.CreateBitCast(irb_.CreateGEP(shadow_frame_, gep_index),
irb_.getJObjectTy()->getPointerTo());
irb_.CreateStore(this_object_or_class_object, handle_scope_field_addr, kTBAAShadowFrame);
// Push the "this object or class object" to out args
this_object_or_class_object = irb_.CreateBitCast(handle_scope_field_addr, irb_.getJObjectTy());
args.push_back(this_object_or_class_object);
// Store arguments to handle scope, and push back to args
for (arg_iter = arg_begin; arg_iter != arg_end; ++arg_iter) {
if (arg_iter->getType() == irb_.getJObjectTy()) {
// Store the reference type arguments to handle scope
gep_index[2] = irb_.getInt32(handle_scope_member_index++);
::llvm::Value* handle_scope_field_addr = irb_.CreateBitCast(irb_.CreateGEP(shadow_frame_, gep_index),
irb_.getJObjectTy()->getPointerTo());
irb_.CreateStore(arg_iter, handle_scope_field_addr, kTBAAShadowFrame);
// Note null is placed in the handle scope but the jobject passed to the native code must be null
// (not a pointer into the handle scope as with regular references).
::llvm::Value* equal_null = irb_.CreateICmpEQ(arg_iter, irb_.getJNull());
::llvm::Value* arg =
irb_.CreateSelect(equal_null,
irb_.getJNull(),
irb_.CreateBitCast(handle_scope_field_addr, irb_.getJObjectTy()));
args.push_back(arg);
} else {
args.push_back(arg_iter);
}
}
::llvm::Value* saved_local_ref_cookie;
{ // JniMethodStart
RuntimeId func_id = is_synchronized ? JniMethodStartSynchronized
: JniMethodStart;
::llvm::SmallVector< ::llvm::Value*, 2> args;
if (is_synchronized) {
args.push_back(this_object_or_class_object);
}
args.push_back(irb_.Runtime().EmitGetCurrentThread());
saved_local_ref_cookie =
irb_.CreateCall(irb_.GetRuntime(func_id), args);
}
// Call!!!
::llvm::Value* retval = irb_.CreateCall(code_addr, args);
{ // JniMethodEnd
bool is_return_ref = return_shorty == 'L';
RuntimeId func_id =
is_return_ref ? (is_synchronized ? JniMethodEndWithReferenceSynchronized
: JniMethodEndWithReference)
: (is_synchronized ? JniMethodEndSynchronized
: JniMethodEnd);
::llvm::SmallVector< ::llvm::Value*, 4> args;
if (is_return_ref) {
args.push_back(retval);
}
args.push_back(saved_local_ref_cookie);
if (is_synchronized) {
args.push_back(this_object_or_class_object);
}
args.push_back(irb_.Runtime().EmitGetCurrentThread());
::llvm::Value* decoded_jobject =
irb_.CreateCall(irb_.GetRuntime(func_id), args);
// Return decoded jobject if return reference.
if (is_return_ref) {
retval = decoded_jobject;
}
}
// Pop the shadow frame
irb_.Runtime().EmitPopShadowFrame(old_shadow_frame);
// Return!
switch (return_shorty) {
case 'V':
irb_.CreateRetVoid();
break;
case 'Z':
case 'C':
irb_.CreateRet(irb_.CreateZExt(retval, irb_.getInt32Ty()));
break;
case 'B':
case 'S':
irb_.CreateRet(irb_.CreateSExt(retval, irb_.getInt32Ty()));
break;
default:
irb_.CreateRet(retval);
break;
}
// Verify the generated bitcode
VERIFY_LLVM_FUNCTION(*func_);
cunit_->Materialize();
return new CompiledMethod(*driver_, cunit_->GetInstructionSet(), cunit_->GetElfObject(),
func_name);
}
void JniCompiler::CreateFunction(const std::string& func_name) {
CHECK_NE(0U, func_name.size());
const bool is_static = dex_compilation_unit_->IsStatic();
// Get function type
::llvm::FunctionType* func_type =
GetFunctionType(dex_compilation_unit_->GetDexMethodIndex(), is_static, false);
// Create function
func_ = ::llvm::Function::Create(func_type, ::llvm::Function::InternalLinkage,
func_name, module_);
// Create basic block
::llvm::BasicBlock* basic_block = ::llvm::BasicBlock::Create(*context_, "B0", func_);
// Set insert point
irb_.SetInsertPoint(basic_block);
}
::llvm::FunctionType* JniCompiler::GetFunctionType(uint32_t method_idx,
bool is_static, bool is_native_function) {
// Get method signature
uint32_t shorty_size;
const char* shorty = dex_compilation_unit_->GetShorty(&shorty_size);
CHECK_GE(shorty_size, 1u);
// Get return type
::llvm::Type* ret_type = NULL;
switch (shorty[0]) {
case 'V': ret_type = irb_.getJVoidTy(); break;
case 'Z':
case 'B':
case 'C':
case 'S':
case 'I': ret_type = irb_.getJIntTy(); break;
case 'F': ret_type = irb_.getJFloatTy(); break;
case 'J': ret_type = irb_.getJLongTy(); break;
case 'D': ret_type = irb_.getJDoubleTy(); break;
case 'L': ret_type = irb_.getJObjectTy(); break;
default: LOG(FATAL) << "Unreachable: unexpected return type in shorty " << shorty;
UNREACHABLE();
}
// Get argument type
std::vector< ::llvm::Type*> args_type;
args_type.push_back(irb_.getJObjectTy()); // method object pointer
if (!is_static || is_native_function) {
// "this" object pointer for non-static
// "class" object pointer for static naitve
args_type.push_back(irb_.getJType('L'));
}
for (uint32_t i = 1; i < shorty_size; ++i) {
args_type.push_back(irb_.getJType(shorty[i]));
}
return ::llvm::FunctionType::get(ret_type, args_type, false);
}
} // namespace llvm
} // namespace art