4 files changed, 47 insertions, 23 deletions

diff --git a/src/compiler_llvm/compiler_llvm.cc b/src/compiler_llvm/compiler_llvm.cc
index 95e9803f68..6c8188ef6f 100644
--- a/src/compiler_llvm/compiler_llvm.cc
+++ b/src/compiler_llvm/compiler_llvm.cc
@@ -225,8 +225,8 @@ const void* CompilerLLVM::GetMethodCodeAddr(const CompiledMethod* cm) const {
 
 const Method::InvokeStub* CompilerLLVM::
 GetMethodInvokeStubAddr(const CompiledInvokeStub* cm) const {
-  return elf_loader_->GetMethodInvokeStubAddr(cm->GetStubElfIndex(),
-                                              cm->GetInvokeStubElfFuncIndex());
+  return elf_loader_->GetMethodInvokeStubAddr(cm->GetElfIndex(),
+                                              cm->GetElfFuncIndex());
 }
 
 
@@ -282,12 +282,21 @@ CompiledInvokeStub* CompilerLLVM::CreateInvokeStub(bool is_static,
   UniquePtr<StubCompiler> stub_compiler(
     new StubCompiler(curr_cunit_, *compiler_));
 
-  CompiledInvokeStub* compiled_stub = new CompiledInvokeStub(curr_cunit_->GetElfIndex());
+  return stub_compiler->CreateInvokeStub(is_static, shorty);
+}
+
+
+CompiledInvokeStub* CompilerLLVM::CreateProxyStub(char const *shorty) {
+  MutexLock GUARD(compiler_lock_);
 
-  compiled_stub->SetInvokeStub(stub_compiler->CreateInvokeStub(is_static, shorty));
-  compiled_stub->SetProxyStub(stub_compiler->CreateProxyStub(is_static, shorty));
+  EnsureCompilationUnit();
+
+  MutexLock GUARD_CUNIT(curr_cunit_->cunit_lock_);
 
-  return compiled_stub;
+  UniquePtr<StubCompiler> stub_compiler(
+    new StubCompiler(curr_cunit_, *compiler_));
+
+  return stub_compiler->CreateProxyStub(shorty);
 }
 
 } // namespace compiler_llvm
@@ -349,14 +358,25 @@ extern "C" art::CompiledMethod* ArtJniCompileMethod(art::Compiler& compiler,
   return result;
 }
 
-extern "C" art::CompiledInvokeStub* ArtCreateInvokeStub(art::Compiler& compiler, bool is_static,
-                                                        const char* shorty, uint32_t shorty_len) {
+extern "C" art::CompiledInvokeStub* ArtCreateInvokeStub(art::Compiler& compiler,
+                                                        bool is_static,
+                                                        const char* shorty,
+                                                        uint32_t shorty_len) {
   art::compiler_llvm::CompilerLLVM* compiler_llvm = ContextOf(compiler);
   art::CompiledInvokeStub* result = compiler_llvm->CreateInvokeStub(is_static, shorty);
   compiler_llvm->MaterializeIfThresholdReached();
   return result;
 }
 
+extern "C" art::CompiledInvokeStub* ArtCreateProxyStub(art::Compiler& compiler,
+                                                       const char* shorty,
+                                                       uint32_t shorty_len) {
+  art::compiler_llvm::CompilerLLVM* compiler_llvm = ContextOf(compiler);
+  art::CompiledInvokeStub* result = compiler_llvm->CreateProxyStub(shorty);
+  compiler_llvm->MaterializeIfThresholdReached();
+  return result;
+}
+
 extern "C" void compilerLLVMSetBitcodeFileName(art::Compiler& compiler,
                                                std::string const& filename) {
   ContextOf(compiler)->SetBitcodeFileName(filename);
diff --git a/src/compiler_llvm/compiler_llvm.h b/src/compiler_llvm/compiler_llvm.h
index a6cf966416..7cc4a0e42d 100644
--- a/src/compiler_llvm/compiler_llvm.h
+++ b/src/compiler_llvm/compiler_llvm.h
@@ -104,7 +104,9 @@ class CompilerLLVM {
 
   CompiledMethod* CompileNativeMethod(OatCompilationUnit* oat_compilation_unit);
 
-  CompiledInvokeStub* CreateInvokeStub(bool is_static, char const *shorty);
+  CompiledInvokeStub* CreateInvokeStub(bool is_static, const char *shorty);
+
+  CompiledInvokeStub* CreateProxyStub(const char *shorty);
 
  private:
   void EnsureCompilationUnit();
diff --git a/src/compiler_llvm/stub_compiler.cc b/src/compiler_llvm/stub_compiler.cc
index a94a5ad333..84447b2cc8 100644
--- a/src/compiler_llvm/stub_compiler.cc
+++ b/src/compiler_llvm/stub_compiler.cc
@@ -46,11 +46,11 @@ StubCompiler::StubCompiler(CompilationUnit* cunit, Compiler& compiler)
 }
 
 
-uint16_t StubCompiler::CreateInvokeStub(bool is_static,
-                                        char const* shorty) {
+CompiledInvokeStub* StubCompiler::CreateInvokeStub(bool is_static,
+                                                   char const* shorty) {
   uint16_t elf_func_idx = cunit_->AcquireUniqueElfFuncIndex();
 
-  CHECK_NE(shorty, static_cast<char const*>(NULL));
+  CHECK(shorty != NULL);
   size_t shorty_size = strlen(shorty);
 
   // Function name
@@ -189,17 +189,12 @@ uint16_t StubCompiler::CreateInvokeStub(bool is_static,
   // store ret_addr, and ret_void.  Beside, we guess that we have to use
   // 50 bytes to represent one LLVM instruction.
 
-  return elf_func_idx;
+  return new CompiledInvokeStub(cunit_->GetElfIndex(), elf_func_idx);
 }
 
-uint16_t StubCompiler::CreateProxyStub(bool is_static,
-                                       char const* shorty) {
-  // Static method dosen't need proxy stub.
-  if (is_static) {
-    return 0;
-  }
 
-  CHECK_NE(shorty, static_cast<char const*>(NULL));
+CompiledInvokeStub* StubCompiler::CreateProxyStub(char const* shorty) {
+  CHECK(shorty != NULL);
   size_t shorty_size = strlen(shorty);
 
   uint16_t elf_func_idx = cunit_->AcquireUniqueElfFuncIndex();
@@ -209,12 +204,15 @@ uint16_t StubCompiler::CreateProxyStub(bool is_static,
 
   // 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);
 
@@ -233,13 +231,16 @@ uint16_t StubCompiler::CreateProxyStub(bool is_static,
 
   // 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);
   }
@@ -247,6 +248,7 @@ uint16_t StubCompiler::CreateProxyStub(bool is_static,
   // 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());
@@ -262,7 +264,7 @@ uint16_t StubCompiler::CreateProxyStub(bool is_static,
   // Add the memory usage approximation of the compilation unit
   cunit_->AddMemUsageApproximation((shorty_size + 2) * 50);
 
-  return elf_func_idx;
+  return new CompiledInvokeStub(cunit_->GetElfIndex(), elf_func_idx);
 }
 
 
diff --git a/src/compiler_llvm/stub_compiler.h b/src/compiler_llvm/stub_compiler.h
index 4b49ec49a9..0ed626169b 100644
--- a/src/compiler_llvm/stub_compiler.h
+++ b/src/compiler_llvm/stub_compiler.h
@@ -41,8 +41,8 @@ class StubCompiler {
  public:
   StubCompiler(CompilationUnit* cunit, Compiler& compiler);
 
-  uint16_t CreateInvokeStub(bool is_static, char const* shorty);
-  uint16_t CreateProxyStub(bool is_static, char const* shorty);
+  CompiledInvokeStub* CreateInvokeStub(bool is_static, char const* shorty);
+  CompiledInvokeStub* CreateProxyStub(char const* shorty);
 
  private:
   CompilationUnit* cunit_;