src/compiler_llvm/jni_compiler.cc - platform/art - Git at Google

 /*
  * 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 "class_linker.h"
 #include "compilation_unit.h"
 #include "compiled_method.h"
 #include "compiler.h"
 #include "compiler_llvm.h"
 #include "ir_builder.h"
 #include "logging.h"
 #include "oat_compilation_unit.h"
 #include "object.h"
 #include "runtime.h"
 #include "runtime_support_func.h"
 #include "shadow_frame.h"
 #include "utils_llvm.h"

 #include <llvm/Analysis/Verifier.h>
 #include <llvm/BasicBlock.h>
 #include <llvm/DerivedTypes.h>
 #include <llvm/Function.h>
 #include <llvm/Type.h>

 namespace art {
 namespace compiler_llvm {


 JniCompiler::JniCompiler(CompilationUnit* cunit,
                          Compiler const& compiler,
                          OatCompilationUnit* oat_compilation_unit)
 : cunit_(cunit), compiler_(&compiler), module_(cunit_->GetModule()),
   context_(cunit_->GetLLVMContext()), irb_(*cunit_->GetIRBuilder()),
   oat_compilation_unit_(oat_compilation_unit),
   access_flags_(oat_compilation_unit->access_flags_),
   method_idx_(oat_compilation_unit->method_idx_),
   class_linker_(oat_compilation_unit->class_linker_),
   class_loader_(oat_compilation_unit->class_loader_),
   dex_cache_(oat_compilation_unit->dex_cache_),
   dex_file_(oat_compilation_unit->dex_file_),
   method_(dex_cache_->GetResolvedMethod(method_idx_)) {

   // Check: Ensure that the method is resolved
   CHECK_NE(method_, static_cast<art::Method*>(NULL));

   // Check: Ensure that JNI compiler will only get "native" method
   CHECK((access_flags_ & kAccNative) != 0);
 }


 CompiledMethod* JniCompiler::Compile() {
   const bool is_static = (access_flags_ & kAccStatic) != 0;
   const bool is_synchronized = (access_flags_ & kAccSynchronized) != 0;
   DexFile::MethodId const& method_id = dex_file_->GetMethodId(method_idx_);
   char const return_shorty = dex_file_->GetMethodShorty(method_id)[0];
   llvm::Value* this_object_or_class_object;

   CreateFunction();

   // 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 =
         LoadFromObjectOffset(method_object_addr,
                              Method::DeclaringClassOffset().Int32Value(),
                              irb_.getJObjectTy());
   }
   // Actual argument (ignore method and this object)
   arg_begin = arg_iter;

   // Count the number of Object* arguments
   uint32_t sirt_size = 1;
   // "this" object pointer for non-static
   // "class" object pointer for static
   for (unsigned i = 0; arg_iter != arg_end; ++i, ++arg_iter) {
     arg_iter->setName(StringPrintf("a%u", i));
     if (arg_iter->getType() == irb_.getJObjectTy()) {
       ++sirt_size;
     }
   }

   // Get thread object
   llvm::Value* thread_object_addr =
     irb_.CreateCall(irb_.GetRuntime(runtime_support::GetCurrentThread));

   // Shadow stack
   llvm::StructType* shadow_frame_type = irb_.getShadowFrameTy(sirt_size);
   llvm::AllocaInst* shadow_frame_ = irb_.CreateAlloca(shadow_frame_type);

   // Zero-initialization of the shadow frame
   llvm::ConstantAggregateZero* zero_initializer =
     llvm::ConstantAggregateZero::get(shadow_frame_type);
   irb_.CreateStore(zero_initializer, shadow_frame_);

   // Store the method pointer
   llvm::Value* method_field_addr =
     irb_.CreatePtrDisp(shadow_frame_,
                        irb_.getPtrEquivInt(ShadowFrame::MethodOffset()),
                        irb_.getJObjectTy()->getPointerTo());
   irb_.CreateStore(method_object_addr, method_field_addr);

   // Store the number of the pointer slots
   StoreToObjectOffset(shadow_frame_,
                       ShadowFrame::NumberOfReferencesOffset(),
                       irb_.getInt32(sirt_size));

   // Push the shadow frame
   llvm::Value* shadow_frame_upcast = irb_.CreateConstGEP2_32(shadow_frame_, 0, 0);
   irb_.CreateCall(irb_.GetRuntime(runtime_support::PushShadowFrame), shadow_frame_upcast);

   // Set top of managed stack to the method field in the SIRT
   StoreToObjectOffset(thread_object_addr,
                       Thread::TopOfManagedStackOffset().Int32Value(),
                       method_field_addr);

   // Get JNIEnv
   llvm::Value* jni_env_object_addr = LoadFromObjectOffset(thread_object_addr,
                                                           Thread::JniEnvOffset().Int32Value(),
                                                           irb_.getJObjectTy());

   // Set thread state to kNative
   StoreToObjectOffset(thread_object_addr,
                       Thread::StateOffset().Int32Value(),
                       irb_.getInt32(Thread::kNative));

   // Get callee code_addr
   llvm::Value* code_addr =
       LoadFromObjectOffset(method_object_addr,
                            Method::NativeMethodOffset().Int32Value(),
                            GetFunctionType(method_idx_, is_static, true)->getPointerTo());


   // 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), // SIRT
     NULL,
   };

   size_t sirt_member_index = 0;

   // Store the "this object or class object" to SIRT
   gep_index[2] = irb_.getInt32(sirt_member_index++);
   llvm::Value* sirt_field_addr = irb_.CreateGEP(shadow_frame_, gep_index);
   irb_.CreateStore(this_object_or_class_object, sirt_field_addr);
   // Push the "this object or class object" to out args
   args.push_back(irb_.CreateBitCast(sirt_field_addr, irb_.getJObjectTy()));
   // Store arguments to SIRT, 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 SIRT
       gep_index[2] = irb_.getInt32(sirt_member_index++);
       llvm::Value* sirt_field_addr = irb_.CreateGEP(shadow_frame_, gep_index);
       irb_.CreateStore(arg_iter, sirt_field_addr);
       // Note null is placed in the SIRT but the jobject passed to the native code must be null
       // (not a pointer into the SIRT 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(sirt_field_addr, irb_.getJObjectTy()));
       args.push_back(arg);
     } else {
       args.push_back(arg_iter);
     }
   }

   // Acquire lock for synchronized methods.
   if (is_synchronized) {
     // Acquire lock
     irb_.CreateCall(irb_.GetRuntime(runtime_support::LockObject), this_object_or_class_object);

     // Check exception pending
     llvm::Value* exception_pending =
         irb_.CreateCall(irb_.GetRuntime(runtime_support::IsExceptionPending));

     // Create two basic block for branch
     llvm::BasicBlock* block_cont = llvm::BasicBlock::Create(*context_, "B.cont", func_);
     llvm::BasicBlock* block_exception_ = llvm::BasicBlock::Create(*context_, "B.exception", func_);

     // Branch by exception_pending
     irb_.CreateCondBr(exception_pending, block_exception_, block_cont);


     // If exception pending
     irb_.SetInsertPoint(block_exception_);
     // TODO: Set thread state?
     // Pop the shadow frame
     irb_.CreateCall(irb_.GetRuntime(runtime_support::PopShadowFrame));
     // Unwind
     if (return_shorty != 'V') {
       irb_.CreateRet(irb_.getJZero(return_shorty));
     } else {
       irb_.CreateRetVoid();
     }

     // If no exception pending
     irb_.SetInsertPoint(block_cont);
   }

   // saved_local_ref_cookie = env->local_ref_cookie
   llvm::Value* saved_local_ref_cookie =
       LoadFromObjectOffset(jni_env_object_addr,
                            JNIEnvExt::LocalRefCookieOffset().Int32Value(),
                            irb_.getInt32Ty());

   // env->local_ref_cookie = env->locals.segment_state
   llvm::Value* segment_state =
       LoadFromObjectOffset(jni_env_object_addr,
                            JNIEnvExt::SegmentStateOffset().Int32Value(),
                            irb_.getInt32Ty());
   StoreToObjectOffset(jni_env_object_addr,
                       JNIEnvExt::LocalRefCookieOffset().Int32Value(),
                       segment_state);


   // Call!!!
   llvm::Value* retval = irb_.CreateCall(code_addr, args);


   // Release lock for synchronized methods.
   if (is_synchronized) {
     irb_.CreateCall(irb_.GetRuntime(runtime_support::UnlockObject), this_object_or_class_object);
   }

   // Set thread state to kRunnable
   StoreToObjectOffset(thread_object_addr,
                       Thread::StateOffset().Int32Value(),
                       irb_.getInt32(Thread::kRunnable));

   if (return_shorty == 'L') {
     // If the return value is reference, it may point to SIRT, we should decode it.
     retval = irb_.CreateCall2(irb_.GetRuntime(runtime_support::DecodeJObjectInThread),
                               thread_object_addr,
                               retval);
   }

   // env->locals.segment_state = env->local_ref_cookie
   llvm::Value* local_ref_cookie =
       LoadFromObjectOffset(jni_env_object_addr,
                            JNIEnvExt::LocalRefCookieOffset().Int32Value(),
                            irb_.getInt32Ty());
   StoreToObjectOffset(jni_env_object_addr,
                       JNIEnvExt::SegmentStateOffset().Int32Value(),
                       local_ref_cookie);

   // env->local_ref_cookie = saved_local_ref_cookie
   StoreToObjectOffset(jni_env_object_addr,
                       JNIEnvExt::LocalRefCookieOffset().Int32Value(),
                       saved_local_ref_cookie);

   // Pop the shadow frame
   irb_.CreateCall(irb_.GetRuntime(runtime_support::PopShadowFrame));

   // Return!
   if (return_shorty != 'V') {
     irb_.CreateRet(retval);
   } else {
     irb_.CreateRetVoid();
   }

   // Verify the generated bitcode
   llvm::verifyFunction(*func_, llvm::PrintMessageAction);

   return new CompiledMethod(cunit_->GetInstructionSet(),
                             cunit_->GetElfIndex());
 }


 void JniCompiler::CreateFunction() {
   // LLVM function name
   std::string func_name(LLVMLongName(method_));

   // Get function type
   llvm::FunctionType* func_type =
     GetFunctionType(method_idx_, method_->IsStatic(), false);

   // Create function
   func_ = llvm::Function::Create(func_type, llvm::Function::ExternalLinkage,
                                  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
   DexFile::MethodId const& method_id = dex_file_->GetMethodId(method_idx);

   uint32_t shorty_size;
   char const* shorty = dex_file_->GetMethodShorty(method_id, &shorty_size);
   CHECK_GE(shorty_size, 1u);

   // Get return type
   llvm::Type* ret_type = irb_.getJType(shorty[0], kAccurate);

   // 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', kAccurate));
   }

   for (uint32_t i = 1; i < shorty_size; ++i) {
     args_type.push_back(irb_.getJType(shorty[i], kAccurate));
   }

   return llvm::FunctionType::get(ret_type, args_type, false);
 }

 llvm::Value* JniCompiler::LoadFromObjectOffset(llvm::Value* object_addr,
                                                int32_t offset,
                                                llvm::Type* type) {
   // Convert offset to llvm::value
   llvm::Value* llvm_offset = irb_.getPtrEquivInt(offset);
   // Calculate the value's address
   llvm::Value* value_addr = irb_.CreatePtrDisp(object_addr, llvm_offset, type->getPointerTo());
   // Load
   return irb_.CreateLoad(value_addr);
 }

 void JniCompiler::StoreToObjectOffset(llvm::Value* object_addr,
                                       int32_t offset,
                                       llvm::Value* new_value) {
   // Convert offset to llvm::value
   llvm::Value* llvm_offset = irb_.getPtrEquivInt(offset);
   // Calculate the value's address
   llvm::Value* value_addr = irb_.CreatePtrDisp(object_addr,
                                                llvm_offset,
                                                new_value->getType()->getPointerTo());
   // Store
   irb_.CreateStore(new_value, value_addr);
 }

 } // namespace compiler_llvm
 } // namespace art
	/*
	* 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 "class_linker.h"
	#include "compilation_unit.h"
	#include "compiled_method.h"
	#include "compiler.h"
	#include "compiler_llvm.h"
	#include "ir_builder.h"
	#include "logging.h"
	#include "oat_compilation_unit.h"
	#include "object.h"
	#include "runtime.h"
	#include "runtime_support_func.h"
	#include "shadow_frame.h"
	#include "utils_llvm.h"

	#include <llvm/Analysis/Verifier.h>
	#include <llvm/BasicBlock.h>
	#include <llvm/DerivedTypes.h>
	#include <llvm/Function.h>
	#include <llvm/Type.h>

	namespace art {
	namespace compiler_llvm {


	JniCompiler::JniCompiler(CompilationUnit* cunit,
	Compiler const& compiler,
	OatCompilationUnit* oat_compilation_unit)
	: cunit_(cunit), compiler_(&compiler), module_(cunit_->GetModule()),
	context_(cunit_->GetLLVMContext()), irb_(*cunit_->GetIRBuilder()),
	oat_compilation_unit_(oat_compilation_unit),
	access_flags_(oat_compilation_unit->access_flags_),
	method_idx_(oat_compilation_unit->method_idx_),
	class_linker_(oat_compilation_unit->class_linker_),
	class_loader_(oat_compilation_unit->class_loader_),
	dex_cache_(oat_compilation_unit->dex_cache_),
	dex_file_(oat_compilation_unit->dex_file_),
	method_(dex_cache_->GetResolvedMethod(method_idx_)) {

	// Check: Ensure that the method is resolved
	CHECK_NE(method_, static_cast<art::Method*>(NULL));

	// Check: Ensure that JNI compiler will only get "native" method
	CHECK((access_flags_ & kAccNative) != 0);
	}


	CompiledMethod* JniCompiler::Compile() {
	const bool is_static = (access_flags_ & kAccStatic) != 0;
	const bool is_synchronized = (access_flags_ & kAccSynchronized) != 0;
	DexFile::MethodId const& method_id = dex_file_->GetMethodId(method_idx_);
	char const return_shorty = dex_file_->GetMethodShorty(method_id)[0];
	llvm::Value* this_object_or_class_object;

	CreateFunction();

	// 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 =
	LoadFromObjectOffset(method_object_addr,
	Method::DeclaringClassOffset().Int32Value(),
	irb_.getJObjectTy());
	}
	// Actual argument (ignore method and this object)
	arg_begin = arg_iter;

	// Count the number of Object* arguments
	uint32_t sirt_size = 1;
	// "this" object pointer for non-static
	// "class" object pointer for static
	for (unsigned i = 0; arg_iter != arg_end; ++i, ++arg_iter) {
	arg_iter->setName(StringPrintf("a%u", i));
	if (arg_iter->getType() == irb_.getJObjectTy()) {
	++sirt_size;
	}
	}

	// Get thread object
	llvm::Value* thread_object_addr =
	irb_.CreateCall(irb_.GetRuntime(runtime_support::GetCurrentThread));

	// Shadow stack
	llvm::StructType* shadow_frame_type = irb_.getShadowFrameTy(sirt_size);
	llvm::AllocaInst* shadow_frame_ = irb_.CreateAlloca(shadow_frame_type);

	// Zero-initialization of the shadow frame
	llvm::ConstantAggregateZero* zero_initializer =
	llvm::ConstantAggregateZero::get(shadow_frame_type);
	irb_.CreateStore(zero_initializer, shadow_frame_);

	// Store the method pointer
	llvm::Value* method_field_addr =
	irb_.CreatePtrDisp(shadow_frame_,
	irb_.getPtrEquivInt(ShadowFrame::MethodOffset()),
	irb_.getJObjectTy()->getPointerTo());
	irb_.CreateStore(method_object_addr, method_field_addr);

	// Store the number of the pointer slots
	StoreToObjectOffset(shadow_frame_,
	ShadowFrame::NumberOfReferencesOffset(),
	irb_.getInt32(sirt_size));

	// Push the shadow frame
	llvm::Value* shadow_frame_upcast = irb_.CreateConstGEP2_32(shadow_frame_, 0, 0);
	irb_.CreateCall(irb_.GetRuntime(runtime_support::PushShadowFrame), shadow_frame_upcast);

	// Set top of managed stack to the method field in the SIRT
	StoreToObjectOffset(thread_object_addr,
	Thread::TopOfManagedStackOffset().Int32Value(),
	method_field_addr);

	// Get JNIEnv
	llvm::Value* jni_env_object_addr = LoadFromObjectOffset(thread_object_addr,
	Thread::JniEnvOffset().Int32Value(),
	irb_.getJObjectTy());

	// Set thread state to kNative
	StoreToObjectOffset(thread_object_addr,
	Thread::StateOffset().Int32Value(),
	irb_.getInt32(Thread::kNative));

	// Get callee code_addr
	llvm::Value* code_addr =
	LoadFromObjectOffset(method_object_addr,
	Method::NativeMethodOffset().Int32Value(),
	GetFunctionType(method_idx_, is_static, true)->getPointerTo());


	// 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), // SIRT
	NULL,
	};

	size_t sirt_member_index = 0;

	// Store the "this object or class object" to SIRT
	gep_index[2] = irb_.getInt32(sirt_member_index++);
	llvm::Value* sirt_field_addr = irb_.CreateGEP(shadow_frame_, gep_index);
	irb_.CreateStore(this_object_or_class_object, sirt_field_addr);
	// Push the "this object or class object" to out args
	args.push_back(irb_.CreateBitCast(sirt_field_addr, irb_.getJObjectTy()));
	// Store arguments to SIRT, 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 SIRT
	gep_index[2] = irb_.getInt32(sirt_member_index++);
	llvm::Value* sirt_field_addr = irb_.CreateGEP(shadow_frame_, gep_index);
	irb_.CreateStore(arg_iter, sirt_field_addr);
	// Note null is placed in the SIRT but the jobject passed to the native code must be null
	// (not a pointer into the SIRT 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(sirt_field_addr, irb_.getJObjectTy()));
	args.push_back(arg);
	} else {
	args.push_back(arg_iter);
	}
	}

	// Acquire lock for synchronized methods.
	if (is_synchronized) {
	// Acquire lock
	irb_.CreateCall(irb_.GetRuntime(runtime_support::LockObject), this_object_or_class_object);

	// Check exception pending
	llvm::Value* exception_pending =
	irb_.CreateCall(irb_.GetRuntime(runtime_support::IsExceptionPending));

	// Create two basic block for branch
	llvm::BasicBlock* block_cont = llvm::BasicBlock::Create(*context_, "B.cont", func_);
	llvm::BasicBlock* block_exception_ = llvm::BasicBlock::Create(*context_, "B.exception", func_);

	// Branch by exception_pending
	irb_.CreateCondBr(exception_pending, block_exception_, block_cont);


	// If exception pending
	irb_.SetInsertPoint(block_exception_);
	// TODO: Set thread state?
	// Pop the shadow frame
	irb_.CreateCall(irb_.GetRuntime(runtime_support::PopShadowFrame));
	// Unwind
	if (return_shorty != 'V') {
	irb_.CreateRet(irb_.getJZero(return_shorty));
	} else {
	irb_.CreateRetVoid();
	}

	// If no exception pending
	irb_.SetInsertPoint(block_cont);
	}

	// saved_local_ref_cookie = env->local_ref_cookie
	llvm::Value* saved_local_ref_cookie =
	LoadFromObjectOffset(jni_env_object_addr,
	JNIEnvExt::LocalRefCookieOffset().Int32Value(),
	irb_.getInt32Ty());

	// env->local_ref_cookie = env->locals.segment_state
	llvm::Value* segment_state =
	LoadFromObjectOffset(jni_env_object_addr,
	JNIEnvExt::SegmentStateOffset().Int32Value(),
	irb_.getInt32Ty());
	StoreToObjectOffset(jni_env_object_addr,
	JNIEnvExt::LocalRefCookieOffset().Int32Value(),
	segment_state);


	// Call!!!
	llvm::Value* retval = irb_.CreateCall(code_addr, args);


	// Release lock for synchronized methods.
	if (is_synchronized) {
	irb_.CreateCall(irb_.GetRuntime(runtime_support::UnlockObject), this_object_or_class_object);
	}

	// Set thread state to kRunnable
	StoreToObjectOffset(thread_object_addr,
	Thread::StateOffset().Int32Value(),
	irb_.getInt32(Thread::kRunnable));

	if (return_shorty == 'L') {
	// If the return value is reference, it may point to SIRT, we should decode it.
	retval = irb_.CreateCall2(irb_.GetRuntime(runtime_support::DecodeJObjectInThread),
	thread_object_addr,
	retval);
	}

	// env->locals.segment_state = env->local_ref_cookie
	llvm::Value* local_ref_cookie =
	LoadFromObjectOffset(jni_env_object_addr,
	JNIEnvExt::LocalRefCookieOffset().Int32Value(),
	irb_.getInt32Ty());
	StoreToObjectOffset(jni_env_object_addr,
	JNIEnvExt::SegmentStateOffset().Int32Value(),
	local_ref_cookie);

	// env->local_ref_cookie = saved_local_ref_cookie
	StoreToObjectOffset(jni_env_object_addr,
	JNIEnvExt::LocalRefCookieOffset().Int32Value(),
	saved_local_ref_cookie);

	// Pop the shadow frame
	irb_.CreateCall(irb_.GetRuntime(runtime_support::PopShadowFrame));

	// Return!
	if (return_shorty != 'V') {
	irb_.CreateRet(retval);
	} else {
	irb_.CreateRetVoid();
	}

	// Verify the generated bitcode
	llvm::verifyFunction(*func_, llvm::PrintMessageAction);

	return new CompiledMethod(cunit_->GetInstructionSet(),
	cunit_->GetElfIndex());
	}


	void JniCompiler::CreateFunction() {
	// LLVM function name
	std::string func_name(LLVMLongName(method_));

	// Get function type
	llvm::FunctionType* func_type =
	GetFunctionType(method_idx_, method_->IsStatic(), false);

	// Create function
	func_ = llvm::Function::Create(func_type, llvm::Function::ExternalLinkage,
	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
	DexFile::MethodId const& method_id = dex_file_->GetMethodId(method_idx);

	uint32_t shorty_size;
	char const* shorty = dex_file_->GetMethodShorty(method_id, &shorty_size);
	CHECK_GE(shorty_size, 1u);

	// Get return type
	llvm::Type* ret_type = irb_.getJType(shorty[0], kAccurate);

	// 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', kAccurate));
	}

	for (uint32_t i = 1; i < shorty_size; ++i) {
	args_type.push_back(irb_.getJType(shorty[i], kAccurate));
	}

	return llvm::FunctionType::get(ret_type, args_type, false);
	}

	llvm::Value* JniCompiler::LoadFromObjectOffset(llvm::Value* object_addr,
	int32_t offset,
	llvm::Type* type) {
	// Convert offset to llvm::value
	llvm::Value* llvm_offset = irb_.getPtrEquivInt(offset);
	// Calculate the value's address
	llvm::Value* value_addr = irb_.CreatePtrDisp(object_addr, llvm_offset, type->getPointerTo());
	// Load
	return irb_.CreateLoad(value_addr);
	}

	void JniCompiler::StoreToObjectOffset(llvm::Value* object_addr,
	int32_t offset,
	llvm::Value* new_value) {
	// Convert offset to llvm::value
	llvm::Value* llvm_offset = irb_.getPtrEquivInt(offset);
	// Calculate the value's address
	llvm::Value* value_addr = irb_.CreatePtrDisp(object_addr,
	llvm_offset,
	new_value->getType()->getPointerTo());
	// Store
	irb_.CreateStore(new_value, value_addr);
	}

	} // namespace compiler_llvm
	} // namespace art