compiler/jni/portable/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 "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;
   }
   // 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
	/*
	* 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;
	}
	// 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