src/compiler_llvm/stub_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 "stub_compiler.h"

 #include "compilation_unit.h"
 #include "compiled_method.h"
 #include "compiler.h"
 #include "compiler_llvm.h"
 #include "ir_builder.h"
 #include "logging.h"
 #include "object.h"
 #include "runtime_support_func.h"
 #include "utils_llvm.h"

 #include <llvm/BasicBlock.h>
 #include <llvm/Function.h>
 #include <llvm/GlobalVariable.h>
 #include <llvm/Intrinsics.h>

 #include <string>
 #include <string.h>

 namespace art {
 namespace compiler_llvm {

 using namespace runtime_support;


 StubCompiler::StubCompiler(CompilationUnit* cunit, Compiler& compiler)
 : cunit_(cunit), compiler_(&compiler), module_(cunit_->GetModule()),
   context_(cunit_->GetLLVMContext()), irb_(*cunit_->GetIRBuilder()) {
 }


 CompiledInvokeStub* StubCompiler::CreateInvokeStub(bool is_static,
                                                    const char* shorty) {
   CHECK(shorty != NULL);
   size_t shorty_size = strlen(shorty);

   // Function name
   std::string func_name(ElfFuncName(cunit_->GetIndex()));

   // Get argument types
   llvm::Type* arg_types[] = {
     irb_.getJObjectTy(), // Method object pointer
     irb_.getJObjectTy(), // "this" object pointer (NULL for static)
     irb_.getJObjectTy(), // Thread object pointer
     irb_.getJValueTy()->getPointerTo(),
     irb_.getJValueTy()->getPointerTo(),
   };

   // Function type
   llvm::FunctionType* func_type =
     llvm::FunctionType::get(irb_.getVoidTy(), arg_types, false);

   // Create function
   llvm::Function* func =
     llvm::Function::Create(func_type, llvm::Function::ExternalLinkage,
                            func_name, module_);


   // Create basic block for the body of this function
   llvm::BasicBlock* block_body =
     llvm::BasicBlock::Create(*context_, "upcall", func);

   irb_.SetInsertPoint(block_body);

   // Actual arguments
   llvm::Function::arg_iterator arg_iter = func->arg_begin();

   llvm::Value* method_object_addr = arg_iter++;
   llvm::Value* callee_this_addr = arg_iter++;
   llvm::Value* thread_object_addr = arg_iter++;
   llvm::Value* actual_args_array_addr = arg_iter++;
   llvm::Value* retval_addr = arg_iter++;

   // Setup thread pointer
   llvm::Value* old_thread_register = irb_.Runtime().EmitSetCurrentThread(thread_object_addr);

   // Accurate function type
   llvm::Type* accurate_ret_type = irb_.getJType(shorty[0], kAccurate);

   std::vector<llvm::Type*> accurate_arg_types;

   accurate_arg_types.push_back(irb_.getJObjectTy()); // method object pointer

   if (!is_static) {
     accurate_arg_types.push_back(irb_.getJObjectTy());
   }

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

   llvm::FunctionType* accurate_func_type =
     llvm::FunctionType::get(accurate_ret_type, accurate_arg_types, false);

   // Load actual arguments
   std::vector<llvm::Value*> args;

   args.push_back(method_object_addr);

   if (!is_static) {
     args.push_back(callee_this_addr);
   }

   for (size_t i = 1; i < shorty_size; ++i) {
     char arg_shorty = shorty[i];

     if (arg_shorty == 'Z' || arg_shorty == 'B' || arg_shorty == 'C' ||
         arg_shorty == 'S' || arg_shorty == 'I' || arg_shorty == 'J' ||
         arg_shorty == 'F' || arg_shorty == 'D' || arg_shorty == 'L') {

       llvm::Type* arg_type =
         irb_.getJType(shorty[i], kAccurate)->getPointerTo();

       llvm::Value* arg_jvalue_addr =
         irb_.CreateConstGEP1_32(actual_args_array_addr, i - 1);

       llvm::Value* arg_addr = irb_.CreateBitCast(arg_jvalue_addr, arg_type);

       args.push_back(irb_.CreateLoad(arg_addr, kTBAAStackTemp));

     } else {
       LOG(FATAL) << "Unexpected arg shorty for invoke stub: " << shorty[i];
     }
   }

   // Invoke managed method now!
   llvm::Value* code_field_offset_value =
     irb_.getPtrEquivInt(AbstractMethod::GetCodeOffset().Int32Value());

   llvm::Value* code_field_addr =
     irb_.CreatePtrDisp(method_object_addr, code_field_offset_value,
                        accurate_func_type->getPointerTo()->getPointerTo());

   llvm::Value* code_addr = irb_.CreateLoad(code_field_addr, kTBAAJRuntime);

   llvm::CallInst* retval = irb_.CreateCall(code_addr, args);
 #if defined(ART_USE_PORTABLE_COMPILER)
   for (size_t i = 1; i < shorty_size; ++i) {
     switch(shorty[i]) {
       case 'Z':
       case 'C':
         retval->addAttribute(i + (is_static ? 1 : 2), llvm::Attribute::ZExt);
         break;

       case 'B':
       case 'S':
         retval->addAttribute(i + (is_static ? 1 : 2), llvm::Attribute::SExt);
         break;

       default: break;
     }
   }
 #endif

   // Store the returned value
   if (shorty[0] != 'V') {
     llvm::Value* ret_addr =
       irb_.CreateBitCast(retval_addr, accurate_ret_type->getPointerTo());

     irb_.CreateStore(retval, ret_addr, kTBAAStackTemp);
   }

   // Restore thread register
   irb_.Runtime().EmitSetCurrentThread(old_thread_register);
   irb_.CreateRetVoid();

   // Verify the generated function
   VERIFY_LLVM_FUNCTION(*func);

   cunit_->Materialize();

   return new CompiledInvokeStub(cunit_->GetInstructionSet(),
                                 cunit_->GetCompiledCode());
 }


 CompiledInvokeStub* StubCompiler::CreateProxyStub(const char* shorty) {
   CHECK(shorty != NULL);
   size_t shorty_size = strlen(shorty);

   // Function name
   std::string func_name(ElfFuncName(cunit_->GetIndex()));

   // Accurate function type
   llvm::Type* accurate_ret_type = irb_.getJType(shorty[0], kAccurate);

   std::vector<llvm::Type*> accurate_arg_types;
   accurate_arg_types.push_back(irb_.getJObjectTy()); // method
   accurate_arg_types.push_back(irb_.getJObjectTy()); // this

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

   llvm::FunctionType* accurate_func_type =
     llvm::FunctionType::get(accurate_ret_type, accurate_arg_types, false);

   // Create function
   llvm::Function* func =
     llvm::Function::Create(accurate_func_type, llvm::Function::ExternalLinkage,
                            func_name, module_);
 #if defined(ART_USE_PORTABLE_COMPILER)
   switch(shorty[0]) {
     case 'Z':
     case 'C':
       func->addAttribute(0, llvm::Attribute::ZExt);
       break;

     case 'B':
     case 'S':
       func->addAttribute(0, llvm::Attribute::SExt);
       break;

     default: break;
   }
 #endif

   // Create basic block for the body of this function
   llvm::BasicBlock* block_body =
     llvm::BasicBlock::Create(*context_, "proxy", func);
   irb_.SetInsertPoint(block_body);

   // JValue for proxy return
   llvm::AllocaInst* jvalue_temp = irb_.CreateAlloca(irb_.getJValueTy());

   // Load actual arguments
   llvm::Function::arg_iterator arg_iter = func->arg_begin();

   std::vector<llvm::Value*> args;
   args.push_back(arg_iter++); // method
   args.push_back(arg_iter++); // this
   args.push_back(irb_.Runtime().EmitGetCurrentThread()); // thread

   for (size_t i = 1; i < shorty_size; ++i) {
     args.push_back(arg_iter++);
   }

   if (shorty[0] != 'V') {
     args.push_back(jvalue_temp);
   }

   // Call ProxyInvokeHandler
   // TODO: Partial inline ProxyInvokeHandler, don't use VarArg.
   irb_.CreateCall(irb_.GetRuntime(ProxyInvokeHandler), args);

   if (shorty[0] != 'V') {
     llvm::Value* result_addr =
         irb_.CreateBitCast(jvalue_temp, accurate_ret_type->getPointerTo());
     llvm::Value* retval = irb_.CreateLoad(result_addr, kTBAAStackTemp);
     irb_.CreateRet(retval);
   } else {
     irb_.CreateRetVoid();
   }

   // Verify the generated function
   VERIFY_LLVM_FUNCTION(*func);

   cunit_->Materialize();

   return new CompiledInvokeStub(cunit_->GetInstructionSet(),
                                 cunit_->GetCompiledCode());
 }


 } // 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 "stub_compiler.h"

	#include "compilation_unit.h"
	#include "compiled_method.h"
	#include "compiler.h"
	#include "compiler_llvm.h"
	#include "ir_builder.h"
	#include "logging.h"
	#include "object.h"
	#include "runtime_support_func.h"
	#include "utils_llvm.h"

	#include <llvm/BasicBlock.h>
	#include <llvm/Function.h>
	#include <llvm/GlobalVariable.h>
	#include <llvm/Intrinsics.h>

	#include <string>
	#include <string.h>

	namespace art {
	namespace compiler_llvm {

	using namespace runtime_support;


	StubCompiler::StubCompiler(CompilationUnit* cunit, Compiler& compiler)
	: cunit_(cunit), compiler_(&compiler), module_(cunit_->GetModule()),
	context_(cunit_->GetLLVMContext()), irb_(*cunit_->GetIRBuilder()) {
	}


	CompiledInvokeStub* StubCompiler::CreateInvokeStub(bool is_static,
	const char* shorty) {
	CHECK(shorty != NULL);
	size_t shorty_size = strlen(shorty);

	// Function name
	std::string func_name(ElfFuncName(cunit_->GetIndex()));

	// Get argument types
	llvm::Type* arg_types[] = {
	irb_.getJObjectTy(), // Method object pointer
	irb_.getJObjectTy(), // "this" object pointer (NULL for static)
	irb_.getJObjectTy(), // Thread object pointer
	irb_.getJValueTy()->getPointerTo(),
	irb_.getJValueTy()->getPointerTo(),
	};

	// Function type
	llvm::FunctionType* func_type =
	llvm::FunctionType::get(irb_.getVoidTy(), arg_types, false);

	// Create function
	llvm::Function* func =
	llvm::Function::Create(func_type, llvm::Function::ExternalLinkage,
	func_name, module_);


	// Create basic block for the body of this function
	llvm::BasicBlock* block_body =
	llvm::BasicBlock::Create(*context_, "upcall", func);

	irb_.SetInsertPoint(block_body);

	// Actual arguments
	llvm::Function::arg_iterator arg_iter = func->arg_begin();

	llvm::Value* method_object_addr = arg_iter++;
	llvm::Value* callee_this_addr = arg_iter++;
	llvm::Value* thread_object_addr = arg_iter++;
	llvm::Value* actual_args_array_addr = arg_iter++;
	llvm::Value* retval_addr = arg_iter++;

	// Setup thread pointer
	llvm::Value* old_thread_register = irb_.Runtime().EmitSetCurrentThread(thread_object_addr);

	// Accurate function type
	llvm::Type* accurate_ret_type = irb_.getJType(shorty[0], kAccurate);

	std::vector<llvm::Type*> accurate_arg_types;

	accurate_arg_types.push_back(irb_.getJObjectTy()); // method object pointer

	if (!is_static) {
	accurate_arg_types.push_back(irb_.getJObjectTy());
	}

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

	llvm::FunctionType* accurate_func_type =
	llvm::FunctionType::get(accurate_ret_type, accurate_arg_types, false);

	// Load actual arguments
	std::vector<llvm::Value*> args;

	args.push_back(method_object_addr);

	if (!is_static) {
	args.push_back(callee_this_addr);
	}

	for (size_t i = 1; i < shorty_size; ++i) {
	char arg_shorty = shorty[i];

	if (arg_shorty == 'Z' \|\| arg_shorty == 'B' \|\| arg_shorty == 'C' \|\|
	arg_shorty == 'S' \|\| arg_shorty == 'I' \|\| arg_shorty == 'J' \|\|
	arg_shorty == 'F' \|\| arg_shorty == 'D' \|\| arg_shorty == 'L') {

	llvm::Type* arg_type =
	irb_.getJType(shorty[i], kAccurate)->getPointerTo();

	llvm::Value* arg_jvalue_addr =
	irb_.CreateConstGEP1_32(actual_args_array_addr, i - 1);

	llvm::Value* arg_addr = irb_.CreateBitCast(arg_jvalue_addr, arg_type);

	args.push_back(irb_.CreateLoad(arg_addr, kTBAAStackTemp));

	} else {
	LOG(FATAL) << "Unexpected arg shorty for invoke stub: " << shorty[i];
	}
	}

	// Invoke managed method now!
	llvm::Value* code_field_offset_value =
	irb_.getPtrEquivInt(AbstractMethod::GetCodeOffset().Int32Value());

	llvm::Value* code_field_addr =
	irb_.CreatePtrDisp(method_object_addr, code_field_offset_value,
	accurate_func_type->getPointerTo()->getPointerTo());

	llvm::Value* code_addr = irb_.CreateLoad(code_field_addr, kTBAAJRuntime);

	llvm::CallInst* retval = irb_.CreateCall(code_addr, args);
	#if defined(ART_USE_PORTABLE_COMPILER)
	for (size_t i = 1; i < shorty_size; ++i) {
	switch(shorty[i]) {
	case 'Z':
	case 'C':
	retval->addAttribute(i + (is_static ? 1 : 2), llvm::Attribute::ZExt);
	break;

	case 'B':
	case 'S':
	retval->addAttribute(i + (is_static ? 1 : 2), llvm::Attribute::SExt);
	break;

	default: break;
	}
	}
	#endif

	// Store the returned value
	if (shorty[0] != 'V') {
	llvm::Value* ret_addr =
	irb_.CreateBitCast(retval_addr, accurate_ret_type->getPointerTo());

	irb_.CreateStore(retval, ret_addr, kTBAAStackTemp);
	}

	// Restore thread register
	irb_.Runtime().EmitSetCurrentThread(old_thread_register);
	irb_.CreateRetVoid();

	// Verify the generated function
	VERIFY_LLVM_FUNCTION(*func);

	cunit_->Materialize();

	return new CompiledInvokeStub(cunit_->GetInstructionSet(),
	cunit_->GetCompiledCode());
	}


	CompiledInvokeStub* StubCompiler::CreateProxyStub(const char* shorty) {
	CHECK(shorty != NULL);
	size_t shorty_size = strlen(shorty);

	// Function name
	std::string func_name(ElfFuncName(cunit_->GetIndex()));

	// Accurate function type
	llvm::Type* accurate_ret_type = irb_.getJType(shorty[0], kAccurate);

	std::vector<llvm::Type*> accurate_arg_types;
	accurate_arg_types.push_back(irb_.getJObjectTy()); // method
	accurate_arg_types.push_back(irb_.getJObjectTy()); // this

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

	llvm::FunctionType* accurate_func_type =
	llvm::FunctionType::get(accurate_ret_type, accurate_arg_types, false);

	// Create function
	llvm::Function* func =
	llvm::Function::Create(accurate_func_type, llvm::Function::ExternalLinkage,
	func_name, module_);
	#if defined(ART_USE_PORTABLE_COMPILER)
	switch(shorty[0]) {
	case 'Z':
	case 'C':
	func->addAttribute(0, llvm::Attribute::ZExt);
	break;

	case 'B':
	case 'S':
	func->addAttribute(0, llvm::Attribute::SExt);
	break;

	default: break;
	}
	#endif

	// Create basic block for the body of this function
	llvm::BasicBlock* block_body =
	llvm::BasicBlock::Create(*context_, "proxy", func);
	irb_.SetInsertPoint(block_body);

	// JValue for proxy return
	llvm::AllocaInst* jvalue_temp = irb_.CreateAlloca(irb_.getJValueTy());

	// Load actual arguments
	llvm::Function::arg_iterator arg_iter = func->arg_begin();

	std::vector<llvm::Value*> args;
	args.push_back(arg_iter++); // method
	args.push_back(arg_iter++); // this
	args.push_back(irb_.Runtime().EmitGetCurrentThread()); // thread

	for (size_t i = 1; i < shorty_size; ++i) {
	args.push_back(arg_iter++);
	}

	if (shorty[0] != 'V') {
	args.push_back(jvalue_temp);
	}

	// Call ProxyInvokeHandler
	// TODO: Partial inline ProxyInvokeHandler, don't use VarArg.
	irb_.CreateCall(irb_.GetRuntime(ProxyInvokeHandler), args);

	if (shorty[0] != 'V') {
	llvm::Value* result_addr =
	irb_.CreateBitCast(jvalue_temp, accurate_ret_type->getPointerTo());
	llvm::Value* retval = irb_.CreateLoad(result_addr, kTBAAStackTemp);
	irb_.CreateRet(retval);
	} else {
	irb_.CreateRetVoid();
	}

	// Verify the generated function
	VERIFY_LLVM_FUNCTION(*func);

	cunit_->Materialize();

	return new CompiledInvokeStub(cunit_->GetInstructionSet(),
	cunit_->GetCompiledCode());
	}


	} // namespace compiler_llvm
	} // namespace art