diff --git a/src/compiler_llvm/art_module.ll b/src/compiler_llvm/art_module.ll
index 434aa7b..74616d1 100644
--- a/src/compiler_llvm/art_module.ll
+++ b/src/compiler_llvm/art_module.ll
@@ -142,12 +142,9 @@
 declare void @art_check_cast_from_code(%JavaObject*, %JavaObject*)
 declare void @art_check_put_array_element_from_code(%JavaObject*, %JavaObject*)
 
-declare void @art_ensure_link_from_code(%JavaObject*)
-
 declare %JavaObject* @art_ensure_resolved_from_code(%JavaObject*,
                                                     %JavaObject*,
                                                     i32,
-                                                    i32)
+                                                    i1)
 
-declare %JavaObject* @art_ensure_initialized_from_code(%JavaObject*,
-                                                       %JavaObject*)
+declare %JavaObject* @art_fix_stub_from_code(%JavaObject*)
diff --git a/src/compiler_llvm/generated/art_module.cc b/src/compiler_llvm/generated/art_module.cc
index 52048eb..6676e02 100644
--- a/src/compiler_llvm/generated/art_module.cc
+++ b/src/compiler_llvm/generated/art_module.cc
@@ -268,12 +268,19 @@
 FuncTy_28_args.push_back(PointerTy_1);
 FuncTy_28_args.push_back(PointerTy_1);
 FuncTy_28_args.push_back(IntegerType::get(mod->getContext(), 32));
-FuncTy_28_args.push_back(IntegerType::get(mod->getContext(), 32));
+FuncTy_28_args.push_back(IntegerType::get(mod->getContext(), 1));
 FunctionType* FuncTy_28 = FunctionType::get(
  /*Result=*/PointerTy_1,
  /*Params=*/FuncTy_28_args,
  /*isVarArg=*/false);
 
+std::vector<Type*>FuncTy_29_args;
+FuncTy_29_args.push_back(PointerTy_1);
+FunctionType* FuncTy_29 = FunctionType::get(
+ /*Result=*/PointerTy_1,
+ /*Params=*/FuncTy_29_args,
+ /*isVarArg=*/false);
+
 
 // Function Declarations
 
@@ -794,17 +801,6 @@
 AttrListPtr func_art_check_put_array_element_from_code_PAL;
 func_art_check_put_array_element_from_code->setAttributes(func_art_check_put_array_element_from_code_PAL);
 
-Function* func_art_ensure_link_from_code = mod->getFunction("art_ensure_link_from_code");
-if (!func_art_ensure_link_from_code) {
-func_art_ensure_link_from_code = Function::Create(
- /*Type=*/FuncTy_4,
- /*Linkage=*/GlobalValue::ExternalLinkage,
- /*Name=*/"art_ensure_link_from_code", mod); // (external, no body)
-func_art_ensure_link_from_code->setCallingConv(CallingConv::C);
-}
-AttrListPtr func_art_ensure_link_from_code_PAL;
-func_art_ensure_link_from_code->setAttributes(func_art_ensure_link_from_code_PAL);
-
 Function* func_art_ensure_resolved_from_code = mod->getFunction("art_ensure_resolved_from_code");
 if (!func_art_ensure_resolved_from_code) {
 func_art_ensure_resolved_from_code = Function::Create(
@@ -816,16 +812,16 @@
 AttrListPtr func_art_ensure_resolved_from_code_PAL;
 func_art_ensure_resolved_from_code->setAttributes(func_art_ensure_resolved_from_code_PAL);
 
-Function* func_art_ensure_initialized_from_code = mod->getFunction("art_ensure_initialized_from_code");
-if (!func_art_ensure_initialized_from_code) {
-func_art_ensure_initialized_from_code = Function::Create(
- /*Type=*/FuncTy_25,
+Function* func_art_fix_stub_from_code = mod->getFunction("art_fix_stub_from_code");
+if (!func_art_fix_stub_from_code) {
+func_art_fix_stub_from_code = Function::Create(
+ /*Type=*/FuncTy_29,
  /*Linkage=*/GlobalValue::ExternalLinkage,
- /*Name=*/"art_ensure_initialized_from_code", mod); // (external, no body)
-func_art_ensure_initialized_from_code->setCallingConv(CallingConv::C);
+ /*Name=*/"art_fix_stub_from_code", mod); // (external, no body)
+func_art_fix_stub_from_code->setCallingConv(CallingConv::C);
 }
-AttrListPtr func_art_ensure_initialized_from_code_PAL;
-func_art_ensure_initialized_from_code->setAttributes(func_art_ensure_initialized_from_code_PAL);
+AttrListPtr func_art_fix_stub_from_code_PAL;
+func_art_fix_stub_from_code->setAttributes(func_art_fix_stub_from_code_PAL);
 
 // Global Variable Declarations
 
diff --git a/src/compiler_llvm/jni_compiler.cc b/src/compiler_llvm/jni_compiler.cc
index e0a5704..492ad25 100644
--- a/src/compiler_llvm/jni_compiler.cc
+++ b/src/compiler_llvm/jni_compiler.cc
@@ -39,6 +39,7 @@
 namespace art {
 namespace compiler_llvm {
 
+using namespace runtime_support;
 
 JniCompiler::JniCompiler(CompilationUnit* cunit,
                          Compiler const& compiler,
@@ -106,8 +107,7 @@
   }
 
   // Get thread object
-  llvm::Value* thread_object_addr =
-    irb_.CreateCall(irb_.GetRuntime(runtime_support::GetCurrentThread));
+  llvm::Value* thread_object_addr = irb_.CreateCall(irb_.GetRuntime(GetCurrentThread));
 
   // Shadow stack
   llvm::StructType* shadow_frame_type = irb_.getShadowFrameTy(sirt_size);
@@ -132,7 +132,7 @@
 
   // 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);
+  irb_.CreateCall(irb_.GetRuntime(PushShadowFrame), shadow_frame_upcast);
 
   // Get JNIEnv
   llvm::Value* jni_env_object_addr = LoadFromObjectOffset(thread_object_addr,
@@ -145,20 +145,10 @@
                       irb_.getInt32(kNative));
 
   // Get callee code_addr
-  llvm::Value* code_addr_ =
+  llvm::Value* code_addr =
       LoadFromObjectOffset(method_object_addr,
                            Method::NativeMethodOffset().Int32Value(),
                            GetFunctionType(method_idx_, is_static, true)->getPointerTo());
-  llvm::Value* code_addr;
-  llvm::FunctionType* method_type = GetFunctionType(method_idx_, is_static, true);
-
-  // TODO: Inline check
-  llvm::Value* runtime_func = irb_.GetRuntime(runtime_support::EnsureInitialized);
-  llvm::Value* result = irb_.CreateCall2(runtime_func,
-                                         method_object_addr,
-                                         irb_.CreatePointerCast(code_addr_,
-                                                                irb_.getJObjectTy()));
-  code_addr = irb_.CreatePointerCast(result, method_type->getPointerTo());
 
   // Load actual parameters
   std::vector<llvm::Value*> args;
@@ -204,11 +194,10 @@
   // Acquire lock for synchronized methods.
   if (is_synchronized) {
     // Acquire lock
-    irb_.CreateCall(irb_.GetRuntime(runtime_support::LockObject), this_object_or_class_object);
+    irb_.CreateCall(irb_.GetRuntime(LockObject), this_object_or_class_object);
 
     // Check exception pending
-    llvm::Value* exception_pending =
-        irb_.CreateCall(irb_.GetRuntime(runtime_support::IsExceptionPending));
+    llvm::Value* exception_pending = irb_.CreateCall(irb_.GetRuntime(IsExceptionPending));
 
     // Create two basic block for branch
     llvm::BasicBlock* block_cont = llvm::BasicBlock::Create(*context_, "B.cont", func_);
@@ -222,7 +211,7 @@
     irb_.SetInsertPoint(block_exception_);
     // TODO: Set thread state?
     // Pop the shadow frame
-    irb_.CreateCall(irb_.GetRuntime(runtime_support::PopShadowFrame));
+    irb_.CreateCall(irb_.GetRuntime(PopShadowFrame));
     // Unwind
     if (return_shorty != 'V') {
       irb_.CreateRet(irb_.getJZero(return_shorty));
@@ -256,7 +245,7 @@
 
   // Release lock for synchronized methods.
   if (is_synchronized) {
-    irb_.CreateCall(irb_.GetRuntime(runtime_support::UnlockObject), this_object_or_class_object);
+    irb_.CreateCall(irb_.GetRuntime(UnlockObject), this_object_or_class_object);
   }
 
   // Set thread state to kRunnable
@@ -266,7 +255,7 @@
 
   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),
+    retval = irb_.CreateCall2(irb_.GetRuntime(DecodeJObjectInThread),
                               thread_object_addr,
                               retval);
   }
@@ -286,7 +275,7 @@
                       saved_local_ref_cookie);
 
   // Pop the shadow frame
-  irb_.CreateCall(irb_.GetRuntime(runtime_support::PopShadowFrame));
+  irb_.CreateCall(irb_.GetRuntime(PopShadowFrame));
 
   // Return!
   if (return_shorty != 'V') {
diff --git a/src/compiler_llvm/method_compiler.cc b/src/compiler_llvm/method_compiler.cc
index 615e600..5485ba6 100644
--- a/src/compiler_llvm/method_compiler.cc
+++ b/src/compiler_llvm/method_compiler.cc
@@ -2782,38 +2782,27 @@
     << PrettyMethod(callee_method_idx, *dex_file_);
 }
 
-llvm::Value* MethodCompiler::EmitEnsureInitialized(llvm::Value* callee_method_object_addr,
-                                                   uint32_t method_idx,
-                                                   bool is_static,
-                                                   llvm::Value* code_addr) {
-  llvm::FunctionType* method_type = GetFunctionType(method_idx, is_static);
-
-  // TODO: Inline check
-  llvm::Value* runtime_func = irb_.GetRuntime(EnsureInitialized);
-  llvm::Value* result = irb_.CreateCall2(runtime_func,
-                                         callee_method_object_addr,
-                                         irb_.CreatePointerCast(code_addr,
-                                                                irb_.getJObjectTy()));
-  return irb_.CreatePointerCast(result, method_type->getPointerTo());
-}
-
 llvm::Value* MethodCompiler::EmitEnsureResolved(llvm::Value* callee,
                                                 llvm::Value* caller,
                                                 uint32_t dex_method_idx,
-                                                Instruction::Code instr_code) {
-  // TODO: Inline check
-  llvm::Value* runtime_func = irb_.GetRuntime(EnsureResolved);
-  return irb_.CreateCall4(runtime_func,
-                          callee,
-                          caller,
-                          irb_.getInt32(dex_method_idx),
-                          irb_.getInt32(instr_code));
+                                                bool is_virtual) {
+  // TODO: Remove this after we solve the trampoline related problems.
+  return  irb_.CreateCall4(irb_.GetRuntime(EnsureResolved),
+                           callee,
+                           caller,
+                           irb_.getInt32(dex_method_idx),
+                           irb_.getInt1(is_virtual));
 }
 
-void MethodCompiler::EmitEnsureLink(llvm::Value* method_object_addr) {
-  // TODO: Inline check
-  llvm::Value* runtime_func = irb_.GetRuntime(EnsureLink);
-  irb_.CreateCall(runtime_func, method_object_addr);
+llvm::Value* MethodCompiler::EmitFixStub(llvm::Value* callee_method_object_addr,
+                                         uint32_t method_idx,
+                                         bool is_static) {
+  // TODO: Remove this after we solve the link and trampoline related problems.
+  llvm::Value* code_addr =  irb_.CreateCall(irb_.GetRuntime(FixStub), callee_method_object_addr);
+
+  llvm::FunctionType* method_type = GetFunctionType(method_idx, is_static);
+
+  return irb_.CreatePointerCast(code_addr, method_type->getPointerTo());
 }
 
 void MethodCompiler::EmitInsn_InvokeVirtualSuperSlow(uint32_t dex_pc,
@@ -2842,28 +2831,23 @@
 
   EmitUpdateLineNumFromDexPC(dex_pc);
 
-  llvm::Value* callee_method_object_addr_ =
+  llvm::Value* callee_method_object_addr =
       irb_.CreateCall3(runtime_func,
                        callee_method_idx_value, this_addr, method_object_addr);
 
   EmitGuard_ExceptionLandingPad(dex_pc);
 
-  llvm::Value* callee_method_object_addr = EmitEnsureResolved(callee_method_object_addr_,
-                                                              method_object_addr,
-                                                              callee_method_idx,
-                                                              (is_virtual ?
-                                                               Instruction::INVOKE_VIRTUAL :
-                                                               Instruction::INVOKE_SUPER));
-
-  EmitEnsureLink(callee_method_object_addr);
-
-  llvm::Value* code_addr_ =
+#if 0
+  llvm::Value* code_addr =
       EmitLoadCodeAddr(callee_method_object_addr, callee_method_idx, false);
+#else
+  // TODO: Remove this after we solve the link and trampoline related problems.
+  llvm::Value* code_addr = EmitFixStub(callee_method_object_addr,
+                                       callee_method_idx,
+                                       false);
+  EmitGuard_ExceptionLandingPad(dex_pc);
+#endif
 
-  llvm::Value* code_addr = EmitEnsureInitialized(callee_method_object_addr,
-                                                 callee_method_idx,
-                                                 false,
-                                                 code_addr_);
   // Load the actual parameter
   std::vector<llvm::Value*> args;
   args.push_back(callee_method_object_addr);
@@ -2908,25 +2892,26 @@
     // Load callee method code address (branch destination)
     llvm::Value* vtable_addr = EmitLoadVTableAddr(class_object_addr);
 
-    llvm::Value* method_object_addr_ =
+    llvm::Value* method_object_addr =
       EmitLoadMethodObjectAddrFromVTable(vtable_addr,
                                          callee_method->GetMethodIndex());
 
-    llvm::Value* method_object_addr = EmitEnsureResolved(method_object_addr_,
-                                                         EmitLoadMethodObjectAddr(),
-                                                         callee_method_idx,
-                                                         Instruction::INVOKE_VIRTUAL);
+#if 0
+    llvm::Value* code_addr =
+        EmitLoadCodeAddr(method_object_addr, callee_method_idx, false);
+#else
+    // TODO: Remove this after we solve the link and trampoline related problems.
+    method_object_addr = EmitEnsureResolved(method_object_addr,
+                                            EmitLoadMethodObjectAddr(),
+                                            callee_method_idx,
+                                            true);
+    EmitGuard_ExceptionLandingPad(dex_pc);
 
-    EmitEnsureLink(method_object_addr);
-
-    llvm::Value* code_addr_ =
-      EmitLoadCodeAddr(method_object_addr, callee_method_idx, false);
-
-    llvm::Value* code_addr = EmitEnsureInitialized(method_object_addr,
-                                                   callee_method_idx,
-                                                   false,
-                                                   code_addr_);
-
+    llvm::Value* code_addr = EmitFixStub(method_object_addr,
+                                         callee_method_idx,
+                                         false);
+    EmitGuard_ExceptionLandingPad(dex_pc);
+#endif
     // Load actual parameters
     std::vector<llvm::Value*> args;
     args.push_back(method_object_addr);
@@ -3009,25 +2994,26 @@
     // Load method object from virtual table
     llvm::Value* vtable_addr = EmitLoadVTableAddr(super_class_addr);
 
-    llvm::Value* callee_method_object_addr_ =
+    llvm::Value* callee_method_object_addr =
       EmitLoadMethodObjectAddrFromVTable(vtable_addr,
                                          callee_method->GetMethodIndex());
 
-    llvm::Value* callee_method_object_addr = EmitEnsureResolved(callee_method_object_addr_,
-                                                                method_object_addr,
-                                                                callee_method_idx,
-                                                                Instruction::INVOKE_SUPER);
-
-    EmitEnsureLink(callee_method_object_addr);
-
-    llvm::Value* code_addr_ =
-      EmitLoadCodeAddr(callee_method_object_addr,
-                       callee_method_idx, false);
-
-    llvm::Value* code_addr = EmitEnsureInitialized(callee_method_object_addr,
+#if 0
+    llvm::Value* code_addr =
+        EmitLoadCodeAddr(callee_method_object_addr, callee_method_idx, false);
+#else
+    // TODO: Remove this after we solve the link and trampoline related problems.
+    callee_method_object_addr = EmitEnsureResolved(callee_method_object_addr,
+                                                   method_object_addr,
                                                    callee_method_idx,
-                                                   false,
-                                                   code_addr_);
+                                                   true);
+    EmitGuard_ExceptionLandingPad(dex_pc);
+
+    llvm::Value* code_addr = EmitFixStub(callee_method_object_addr,
+                                         callee_method_idx,
+                                         false);
+    EmitGuard_ExceptionLandingPad(dex_pc);
+#endif
 
     // Load actual parameters
     std::vector<llvm::Value*> args;
@@ -3087,24 +3073,26 @@
   llvm::Value* callee_method_object_field_addr =
     EmitLoadDexCacheResolvedMethodFieldAddr(callee_method_idx);
 
-  llvm::Value* callee_method_object_addr_ =
+  llvm::Value* callee_method_object_addr =
     irb_.CreateLoad(callee_method_object_field_addr);
 
-  llvm::Value* callee_method_object_addr = EmitEnsureResolved(callee_method_object_addr_,
-                                                              EmitLoadMethodObjectAddr(),
-                                                              callee_method_idx,
-                                                              Instruction::INVOKE_DIRECT);
+#if 0
+    llvm::Value* code_addr =
+        EmitLoadCodeAddr(callee_method_object_addr, callee_method_idx, is_static);
+#else
+    // TODO: Remove this after we solve the link and trampoline related problems.
+    callee_method_object_addr = EmitEnsureResolved(callee_method_object_addr,
+                                                   EmitLoadMethodObjectAddr(),
+                                                   callee_method_idx,
+                                                   false);
+    EmitGuard_ExceptionLandingPad(dex_pc);
 
-  EmitEnsureLink(callee_method_object_addr);
-
-  llvm::Value* code_addr_ =
-    EmitLoadCodeAddr(callee_method_object_addr, callee_method_idx, is_static);
-
-  llvm::Value* code_addr = EmitEnsureInitialized(callee_method_object_addr,
-                                                 callee_method_idx,
-                                                 is_static,
-                                                 code_addr_);
-  EmitGuard_ExceptionLandingPad(dex_pc);
+    llvm::Value* code_addr = EmitFixStub(callee_method_object_addr,
+                                         callee_method_idx,
+                                         is_static);
+    EmitGuard_ExceptionLandingPad(dex_pc);
+    // FixStub may resolve method, so we need to reload method.
+#endif
 
   // Load the actual parameter
   std::vector<llvm::Value*> args;
@@ -3156,26 +3144,22 @@
 
   EmitUpdateLineNumFromDexPC(dex_pc);
 
-  llvm::Value* callee_method_object_addr_ =
+  llvm::Value* callee_method_object_addr =
     irb_.CreateCall3(runtime_func,
                      callee_method_idx_value, this_addr, method_object_addr);
 
   EmitGuard_ExceptionLandingPad(dex_pc);
 
-  llvm::Value* callee_method_object_addr = EmitEnsureResolved(callee_method_object_addr_,
-                                                              method_object_addr,
-                                                              callee_method_idx,
-                                                              Instruction::INVOKE_INTERFACE);
-
-  EmitEnsureLink(callee_method_object_addr);
-
-  llvm::Value* code_addr_ =
+#if 0
+  llvm::Value* code_addr =
     EmitLoadCodeAddr(callee_method_object_addr, callee_method_idx, false);
-
-  llvm::Value* code_addr = EmitEnsureInitialized(callee_method_object_addr,
-                                                 callee_method_idx,
-                                                 false,
-                                                 code_addr_);
+#else
+  // TODO: Remove this after we solve the link and trampoline related problems.
+  llvm::Value* code_addr = EmitFixStub(callee_method_object_addr,
+                                       callee_method_idx,
+                                       false);
+  EmitGuard_ExceptionLandingPad(dex_pc);
+#endif
 
   // Load the actual parameter
   std::vector<llvm::Value*> args;
diff --git a/src/compiler_llvm/method_compiler.h b/src/compiler_llvm/method_compiler.h
index e5be3ba..48d4467 100644
--- a/src/compiler_llvm/method_compiler.h
+++ b/src/compiler_llvm/method_compiler.h
@@ -194,15 +194,13 @@
   void EmitInsn_SPut(GEN_INSN_ARGS, JType field_jty);
 
   // INVOKE instructions
-  llvm::Value* EmitEnsureInitialized(llvm::Value* callee_method_object_addr,
-                                     uint32_t method_idx,
-                                     bool is_static,
-                                     llvm::Value* code_addr);
+  llvm::Value* EmitFixStub(llvm::Value* callee_method_object_addr,
+                           uint32_t method_idx,
+                           bool is_static);
   llvm::Value* EmitEnsureResolved(llvm::Value* callee,
                                   llvm::Value* caller,
                                   uint32_t dex_method_idx,
-                                  Instruction::Code instr_code);
-  void EmitEnsureLink(llvm::Value*);
+                                  bool is_virtual);
 
   void EmitInsn_InvokeVirtual(GEN_INSN_ARGS, bool is_range);
   void EmitInsn_InvokeSuper(GEN_INSN_ARGS, bool is_range);
diff --git a/src/compiler_llvm/runtime_support_func_list.h b/src/compiler_llvm/runtime_support_func_list.h
index 2f1fb13..56755fa 100644
--- a/src/compiler_llvm/runtime_support_func_list.h
+++ b/src/compiler_llvm/runtime_support_func_list.h
@@ -57,7 +57,6 @@
   V(InitializeStaticStorage, art_initialize_static_storage_from_code) \
   V(IsExceptionPending, art_is_exception_pending_from_code) \
   V(FindCatchBlock, art_find_catch_block_from_code) \
-  V(EnsureInitialized, art_ensure_initialized_from_code) \
-  V(EnsureLink, art_ensure_link_from_code) \
   V(EnsureResolved, art_ensure_resolved_from_code) \
+  V(FixStub, art_fix_stub_from_code) \
   V(DecodeJObjectInThread, art_decode_jobject_in_thread)
diff --git a/src/compiler_llvm/runtime_support_llvm.cc b/src/compiler_llvm/runtime_support_llvm.cc
index e7e2d86..79d06df 100644
--- a/src/compiler_llvm/runtime_support_llvm.cc
+++ b/src/compiler_llvm/runtime_support_llvm.cc
@@ -521,92 +521,87 @@
   }
 }
 
-const void* art_ensure_initialized_from_code(Method* called,
-                                             void* code) {
-  if (LIKELY(code != Runtime::Current()->GetResolutionStubArray(Runtime::kStaticMethod)->GetData())) {
-    return code;
-  }
-  ClassLinker* linker = Runtime::Current()->GetClassLinker();
-  Class* called_class = called->GetDeclaringClass();
-  linker->EnsureInitialized(called_class, true, true);
-  if (LIKELY(called_class->IsInitialized())) {
-    return called->GetCode();
-  } else if (called_class->IsInitializing()) {
-    return linker->GetOatCodeFor(called);
-  } else {
-    DCHECK(called_class->IsErroneous());
-    return code;
-  }
-}
-
+// TODO: This runtime support function is the temporary solution for the stubs. Because now the
+// stubs and runtime support functions in the LLVM part and the non-LLVM part is different.
+// After deal these problems, we should remove this function, and will save a function call before
+// every method invocation.
 Method* art_ensure_resolved_from_code(Method* called,
                                       Method* caller,
                                       uint32_t dex_method_idx,
-                                      Instruction::Code instr_code) {
+                                      bool is_virtual) {
   if (LIKELY(!called->IsResolutionMethod())) {
     return called;
   }
-  // Compute details about the called method (avoid GCs)
+
+  // If the called method is ResolutionMethod.  -> ResolutionTrampoline(kUnknownMethod)
+  //                                               Resolve method.
   ClassLinker* linker = Runtime::Current()->GetClassLinker();
-  bool is_static = (instr_code == Instruction::INVOKE_STATIC) ||
-                   (instr_code == Instruction::INVOKE_STATIC_RANGE);
-
-  bool is_virtual = (instr_code == Instruction::INVOKE_VIRTUAL) ||
-                    (instr_code == Instruction::INVOKE_VIRTUAL_RANGE) ||
-                    (instr_code == Instruction::INVOKE_SUPER) ||
-                    (instr_code == Instruction::INVOKE_SUPER_RANGE);
-
-  DCHECK(is_static || is_virtual ||
-         (instr_code == Instruction::INVOKE_DIRECT) ||
-         (instr_code == Instruction::INVOKE_DIRECT_RANGE));
-
   called = linker->ResolveMethod(dex_method_idx, caller, !is_virtual);
+  if (UNLIKELY(Thread::Current()->IsExceptionPending())) {
+    return NULL;
+  }
+  if (LIKELY(called->IsDirect() == !is_virtual)) {
+    // Ensure that the called method's class is initialized.
+    Class* called_class = called->GetDeclaringClass();
+    linker->EnsureInitialized(called_class, true, true);
+    return called;
+  } else {
+    // Direct method has been made virtual
+    Thread::Current()->ThrowNewExceptionF("Ljava/lang/IncompatibleClassChangeError;",
+                                          "Expected direct method but found virtual: %s",
+                                          PrettyMethod(called, true).c_str());
+    return NULL;
+  }
+}
 
-  const void* code = NULL;
-  Thread* thread = art_get_current_thread_from_code();
-  if (LIKELY(!thread->IsExceptionPending())) {
-    if (LIKELY(called->IsDirect() == !is_virtual)) {
-      // Ensure that the called method's class is initialized.
-      Class* called_class = called->GetDeclaringClass();
-      linker->EnsureInitialized(called_class, true, true);
-      if (LIKELY(called_class->IsInitialized())) {
-        code = called->GetCode();
-      } else if (called_class->IsInitializing()) {
-        if (is_static) {
-          // Class is still initializing, go to oat and grab code (trampoline must be left in place
-          // until class is initialized to stop races between threads).
-          code = linker->GetOatCodeFor(called);
-          LOG(FATAL) << "Is static";
-        } else {
-          // No trampoline for non-static methods.
-          code = called->GetCode();
-        }
-      } else {
-        DCHECK(called_class->IsErroneous());
-        LOG(FATAL) << "Is erroneous";
-      }
+
+// TODO: This runtime support function is the temporary solution for the stubs. Because now the
+// stubs and runtime support functions in the LLVM part and the non-LLVM part is different.
+// After deal these problems, we should remove this function, and will save a function call before
+// every method invocation.
+// It calls to this function before invoking any function, and this function will check:
+// 1. The code address is ResolutionStub.          -> ResolutionTrampoline(kStaticMethod)
+//                                                    Initialize class.
+// 2. The code address is AbstractMethodErrorStub. -> AbstractMethodErrorStub
+// 3. The code address is 0.                       -> Link the code by ELFLoader
+// The item 3 will solved by in-place linking at image loading.
+const void* art_fix_stub_from_code(Method* called) {
+  if (UNLIKELY(called->IsResolutionMethod())) {
+    LOG(FATAL) << "is ResolutionMethod!!";
+  }
+  Runtime* runtime = Runtime::Current();
+  const void* code = called->GetCode();
+
+  // 1. The code address is ResolutionStub.          -> ResolutionTrampoline(kStaticMethod)
+  if (UNLIKELY(code == runtime->GetResolutionStubArray(Runtime::kStaticMethod)->GetData())) {
+    ClassLinker* linker = runtime->GetClassLinker();
+    Class* called_class = called->GetDeclaringClass();
+    linker->EnsureInitialized(called_class, true, true);
+    if (LIKELY(called_class->IsInitialized())) {
+      return called->GetCode();
+    } else if (called_class->IsInitializing()) {
+      return linker->GetOatCodeFor(called);
     } else {
-      // Direct method has been made virtual
-      thread->ThrowNewExceptionF("Ljava/lang/IncompatibleClassChangeError;",
-                                 "Expected direct method but found virtual: %s",
-                                 PrettyMethod(called, true).c_str());
+      DCHECK(Thread::Current()->IsExceptionPending());
+      DCHECK(called_class->IsErroneous());
+      return NULL;
     }
   }
 
-  if (code != NULL) {
-    // Expect class to at least be initializing.
-    DCHECK(called->GetDeclaringClass()->IsInitializing());
-    // Don't want infinite recursion.
-    DCHECK(code != Runtime::Current()->GetResolutionStubArray(Runtime::kUnknownMethod)->GetData());
+  // 2. The code address is AbstractMethodErrorStub. -> AbstractMethodErrorStub
+  if (UNLIKELY(code == runtime->GetAbstractMethodErrorStubArray()->GetData())) {
+    Thread::Current()->ThrowNewExceptionF("Ljava/lang/AbstractMethodError;",
+                                          "abstract method \"%s\"", PrettyMethod(called).c_str());
+    return NULL;
   }
 
-  return called;
-}
-
-void art_ensure_link_from_code(Method* method) {
-  if (method->GetInvokeStub() == NULL || method->GetCode() == NULL) {
-    Runtime::Current()->GetClassLinker()->LinkOatCodeFor(method);
+  // 3. The code address is 0.                       -> Link the code by ELFLoader
+  if (UNLIKELY(called->GetInvokeStub() == NULL || code == NULL)) {
+    runtime->GetClassLinker()->LinkOatCodeFor(called);
+    return called->GetCode();
   }
+
+  return code;
 }
 
 void* art_find_runtime_support_func(void* context, char const* name) {
diff --git a/src/compiler_llvm/runtime_support_llvm.h b/src/compiler_llvm/runtime_support_llvm.h
index 1dbd71d..ab5c804 100644
--- a/src/compiler_llvm/runtime_support_llvm.h
+++ b/src/compiler_llvm/runtime_support_llvm.h
@@ -62,7 +62,7 @@
 
 void* art_find_runtime_support_func(void* context, char const* name);
 
-void art_ensure_link_from_code(Method* method);
+const void* art_fix_stub_from_code(Method* called);
 
 }  // namespace art
 
diff --git a/src/compiler_llvm/upcall_compiler.cc b/src/compiler_llvm/upcall_compiler.cc
index 6d14a19..691d7e5 100644
--- a/src/compiler_llvm/upcall_compiler.cc
+++ b/src/compiler_llvm/upcall_compiler.cc
@@ -144,6 +144,8 @@
   }
 
   // Invoke managed method now!
+  // TODO: If we solve the trampoline related problems, we can just get the code address and call.
+#if 0
   llvm::Value* code_field_offset_value =
     irb_.getPtrEquivInt(Method::GetCodeOffset().Int32Value());
 
@@ -151,15 +153,20 @@
     irb_.CreatePtrDisp(method_object_addr, code_field_offset_value,
                        accurate_func_type->getPointerTo()->getPointerTo());
 
-  llvm::Value* code_addr_ = irb_.CreateLoad(code_field_addr);
-  llvm::Value* code_addr;
-  // TODO: Inline check
-  llvm::Value* runtime_func = irb_.GetRuntime(runtime_support::EnsureInitialized);
-  llvm::Value* result = irb_.CreateCall2(runtime_func,
-                                         method_object_addr,
-                                         irb_.CreatePointerCast(code_addr_,
-                                                                irb_.getJObjectTy()));
-  code_addr = irb_.CreatePointerCast(result, accurate_func_type->getPointerTo());
+  llvm::Value* code_addr = irb_.CreateLoad(code_field_addr);
+#else
+  llvm::Value* result = irb_.CreateCall(irb_.GetRuntime(FixStub), method_object_addr);
+  llvm::Value* code_addr = irb_.CreatePointerCast(result, accurate_func_type->getPointerTo());
+
+  // Exception unwind.
+  llvm::Value* exception_pending = irb_.CreateCall(irb_.GetRuntime(IsExceptionPending));
+  llvm::BasicBlock* block_unwind = llvm::BasicBlock::Create(*context_, "exception_unwind", func);
+  llvm::BasicBlock* block_cont = llvm::BasicBlock::Create(*context_, "cont", func);
+  irb_.CreateCondBr(exception_pending, block_unwind, block_cont);
+  irb_.SetInsertPoint(block_unwind);
+  irb_.CreateRetVoid();
+  irb_.SetInsertPoint(block_cont);
+#endif
 
   llvm::Value* retval = irb_.CreateCall(code_addr, args);
 
diff --git a/src/object.cc b/src/object.cc
index 7fdff31..0bcf5c7 100644
--- a/src/object.cc
+++ b/src/object.cc
@@ -566,20 +566,16 @@
   self->PushNativeToManagedRecord(&record);
 #endif
 
+#if defined(ART_USE_LLVM_COMPILER)
+  art_fix_stub_from_code(const_cast<Method*>(this));
+#endif
+
   // Call the invoke stub associated with the method.
   // Pass everything as arguments.
   const Method::InvokeStub* stub = GetInvokeStub();
 
   bool have_executable_code = (GetCode() != NULL);
 
-#if defined(ART_USE_LLVM_COMPILER)
-  if (stub == NULL || !have_executable_code) {
-    art_ensure_link_from_code(const_cast<Method*>(this));
-    stub = GetInvokeStub();
-    have_executable_code = (GetCode() != NULL);
-  }
-#endif
-
   if (Runtime::Current()->IsStarted() && have_executable_code && stub != NULL) {
     bool log = false;
     if (log) {