diff --git a/src/class_linker.cc b/src/class_linker.cc
index 9aa4dda..ad51b5e 100644
--- a/src/class_linker.cc
+++ b/src/class_linker.cc
@@ -2570,7 +2570,7 @@
   method->SetFpSpillMask(refs_and_args->GetFpSpillMask());
   method->SetFrameSizeInBytes(refs_and_args->GetFrameSizeInBytes());
 #if !defined(ART_USE_LLVM_COMPILER)
-  method->SetCode(reinterpret_cast<void*>(art_proxy_invoke_handler));
+  method->SetCode(reinterpret_cast<void*>(art_quick_proxy_invoke_handler));
 #else
   OatFile::OatMethod oat_method = GetOatMethodFor(prototype.get());
   method->SetCode(oat_method.GetProxyStub());
diff --git a/src/compiler/codegen/gen_invoke.cc b/src/compiler/codegen/gen_invoke.cc
index 816927f..712e44b 100644
--- a/src/compiler/codegen/gen_invoke.cc
+++ b/src/compiler/codegen/gen_invoke.cc
@@ -456,7 +456,7 @@
 }
 
 /*
- * All invoke-interface calls bounce off of art_invoke_interface_trampoline,
+ * All invoke-interface calls bounce off of art_quick_invoke_interface_trampoline,
  * which will locate the target and continue on via a tail call.
  */
 static int NextInterfaceCallInsn(CompilationUnit* cu, CallInfo* info, int state,
diff --git a/src/compiler_llvm/art_module.ll b/src/compiler_llvm/art_module.ll
index 32f9b51..233692c 100644
--- a/src/compiler_llvm/art_module.ll
+++ b/src/compiler_llvm/art_module.ll
@@ -35,17 +35,16 @@
 ; Thread
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
-declare %JavaObject* @art_get_current_thread_from_code()
-declare %JavaObject* @art_set_current_thread_from_code(%JavaObject*)
+declare %JavaObject* @art_portable_get_current_thread_from_code()
+declare %JavaObject* @art_portable_set_current_thread_from_code(%JavaObject*)
 
-declare void @art_lock_object_from_code(%JavaObject*, %JavaObject*)
-declare void @art_unlock_object_from_code(%JavaObject*, %JavaObject*)
+declare void @art_portable_lock_object_from_code(%JavaObject*, %JavaObject*)
+declare void @art_portable_unlock_object_from_code(%JavaObject*, %JavaObject*)
 
-declare void @art_test_suspend_from_code(%JavaObject*)
+declare void @art_portable_test_suspend_from_code(%JavaObject*)
 
-declare %ShadowFrame* @art_push_shadow_frame_from_code(%JavaObject*, %ShadowFrame*,
-                                                       %JavaObject*, i32)
-declare void @art_pop_shadow_frame_from_code(%ShadowFrame*)
+declare %ShadowFrame* @art_portable_push_shadow_frame_from_code(%JavaObject*, %ShadowFrame*, %JavaObject*, i32)
+declare void @art_portable_pop_shadow_frame_from_code(%ShadowFrame*)
 
 
 
@@ -53,15 +52,15 @@
 ; Exception
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
-declare %JavaObject* @art_get_and_clear_exception(%JavaObject*)
-declare void @art_throw_div_zero_from_code()
-declare void @art_throw_array_bounds_from_code(i32, i32)
-declare void @art_throw_no_such_method_from_code(i32)
-declare void @art_throw_null_pointer_exception_from_code(i32)
-declare void @art_throw_stack_overflow_from_code()
-declare void @art_throw_exception_from_code(%JavaObject*)
+declare %JavaObject* @art_portable_get_and_clear_exception(%JavaObject*)
+declare void @art_portable_throw_div_zero_from_code()
+declare void @art_portable_throw_array_bounds_from_code(i32, i32)
+declare void @art_portable_throw_no_such_method_from_code(i32)
+declare void @art_portable_throw_null_pointer_exception_from_code(i32)
+declare void @art_portable_throw_stack_overflow_from_code()
+declare void @art_portable_throw_exception_from_code(%JavaObject*)
 
-declare i32 @art_find_catch_block_from_code(%JavaObject*, i32)
+declare i32 @art_portable_find_catch_block_from_code(%JavaObject*, i32)
 
 
 
@@ -69,91 +68,58 @@
 ; Object Space
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
-declare %JavaObject* @art_alloc_object_from_code(i32, %JavaObject*, %JavaObject*)
-declare %JavaObject* @art_alloc_object_from_code_with_access_check(
-  i32, %JavaObject*, %JavaObject*)
+declare %JavaObject* @art_portable_alloc_object_from_code(i32, %JavaObject*, %JavaObject*)
+declare %JavaObject* @art_portable_alloc_object_from_code_with_access_check(i32, %JavaObject*, %JavaObject*)
 
-declare %JavaObject* @art_alloc_array_from_code(i32, %JavaObject*, i32, %JavaObject*)
-declare %JavaObject* @art_alloc_array_from_code_with_access_check(
-  i32, %JavaObject*, i32, %JavaObject*)
-declare %JavaObject* @art_check_and_alloc_array_from_code(
-  i32, %JavaObject*, i32, %JavaObject*)
-declare %JavaObject* @art_check_and_alloc_array_from_code_with_access_check(
-  i32, %JavaObject*, i32, %JavaObject*)
+declare %JavaObject* @art_portable_alloc_array_from_code(i32, %JavaObject*, i32, %JavaObject*)
+declare %JavaObject* @art_portable_alloc_array_from_code_with_access_check(i32, %JavaObject*, i32, %JavaObject*)
+declare %JavaObject* @art_portable_check_and_alloc_array_from_code(i32, %JavaObject*, i32, %JavaObject*)
+declare %JavaObject* @art_portable_check_and_alloc_array_from_code_with_access_check(i32, %JavaObject*, i32, %JavaObject*)
 
-declare void @art_find_instance_field_from_code(i32, %JavaObject*)
-declare void @art_find_static_field_from_code(i32, %JavaObject*)
+declare void @art_portable_find_instance_field_from_code(i32, %JavaObject*)
+declare void @art_portable_find_static_field_from_code(i32, %JavaObject*)
 
-declare %JavaObject* @art_find_static_method_from_code_with_access_check(
-  i32, %JavaObject*, %JavaObject*, %JavaObject*)
-declare %JavaObject* @art_find_direct_method_from_code_with_access_check(
-  i32, %JavaObject*, %JavaObject*, %JavaObject*)
-declare %JavaObject* @art_find_virtual_method_from_code_with_access_check(
-  i32, %JavaObject*, %JavaObject*, %JavaObject*)
-declare %JavaObject* @art_find_super_method_from_code_with_access_check(
-  i32, %JavaObject*, %JavaObject*, %JavaObject*)
-declare %JavaObject* @art_find_interface_method_from_code_with_access_check(
-  i32, %JavaObject*, %JavaObject*, %JavaObject*)
-declare %JavaObject* @art_find_interface_method_from_code(
-  i32, %JavaObject*, %JavaObject*, %JavaObject*)
+declare %JavaObject* @art_portable_find_static_method_from_code_with_access_check(i32, %JavaObject*, %JavaObject*, %JavaObject*)
+declare %JavaObject* @art_portable_find_direct_method_from_code_with_access_check(i32, %JavaObject*, %JavaObject*, %JavaObject*)
+declare %JavaObject* @art_portable_find_virtual_method_from_code_with_access_check(i32, %JavaObject*, %JavaObject*, %JavaObject*)
+declare %JavaObject* @art_portable_find_super_method_from_code_with_access_check(i32, %JavaObject*, %JavaObject*, %JavaObject*)
+declare %JavaObject* @art_portable_find_interface_method_from_code_with_access_check(i32, %JavaObject*, %JavaObject*, %JavaObject*)
+declare %JavaObject* @art_portable_find_interface_method_from_code(i32, %JavaObject*, %JavaObject*, %JavaObject*)
 
-declare %JavaObject* @art_initialize_static_storage_from_code(i32, %JavaObject*, %JavaObject*)
-declare %JavaObject* @art_initialize_type_from_code(i32, %JavaObject*, %JavaObject*)
-declare %JavaObject* @art_initialize_type_and_verify_access_from_code(
-  i32, %JavaObject*, %JavaObject*)
+declare %JavaObject* @art_portable_initialize_static_storage_from_code(i32, %JavaObject*, %JavaObject*)
+declare %JavaObject* @art_portable_initialize_type_from_code(i32, %JavaObject*, %JavaObject*)
+declare %JavaObject* @art_portable_initialize_type_and_verify_access_from_code(i32, %JavaObject*, %JavaObject*)
 
-declare %JavaObject* @art_resolve_string_from_code(%JavaObject*, i32)
+declare %JavaObject* @art_portable_resolve_string_from_code(%JavaObject*, i32)
 
-declare i32 @art_set32_static_from_code(i32, %JavaObject*, i32)
-declare i32 @art_set64_static_from_code(i32, %JavaObject*, i64)
-declare i32 @art_set_obj_static_from_code(i32, %JavaObject*, %JavaObject*)
+declare i32 @art_portable_set32_static_from_code(i32, %JavaObject*, i32)
+declare i32 @art_portable_set64_static_from_code(i32, %JavaObject*, i64)
+declare i32 @art_portable_set_obj_static_from_code(i32, %JavaObject*, %JavaObject*)
 
-declare i32 @art_get32_static_from_code(i32, %JavaObject*)
-declare i64 @art_get64_static_from_code(i32, %JavaObject*)
-declare %JavaObject* @art_get_obj_static_from_code(i32, %JavaObject*)
+declare i32 @art_portable_get32_static_from_code(i32, %JavaObject*)
+declare i64 @art_portable_get64_static_from_code(i32, %JavaObject*)
+declare %JavaObject* @art_portable_get_obj_static_from_code(i32, %JavaObject*)
 
-declare i32 @art_set32_instance_from_code(i32,
-                                          %JavaObject*,
-                                          %JavaObject*,
-                                          i32)
+declare i32 @art_portable_set32_instance_from_code(i32, %JavaObject*, %JavaObject*, i32)
+declare i32 @art_portable_set64_instance_from_code(i32, %JavaObject*, %JavaObject*, i64)
+declare i32 @art_portable_set_obj_instance_from_code(i32, %JavaObject*, %JavaObject*, %JavaObject*)
 
-declare i32 @art_set64_instance_from_code(i32,
-                                          %JavaObject*,
-                                          %JavaObject*,
-                                          i64)
+declare i32 @art_portable_get32_instance_from_code(i32, %JavaObject*, %JavaObject*)
+declare i64 @art_portable_get64_instance_from_code(i32, %JavaObject*, %JavaObject*)
+declare %JavaObject* @art_portable_get_obj_instance_from_code(i32, %JavaObject*, %JavaObject*)
 
-declare i32 @art_set_obj_instance_from_code(i32,
-                                            %JavaObject*,
-                                            %JavaObject*,
-                                            %JavaObject*)
+declare %JavaObject* @art_portable_decode_jobject_in_thread(%JavaObject*, %JavaObject*)
 
-declare i32 @art_get32_instance_from_code(i32,
-                                          %JavaObject*,
-                                          %JavaObject*)
-
-declare i64 @art_get64_instance_from_code(i32,
-                                          %JavaObject*,
-                                          %JavaObject*)
-
-declare %JavaObject* @art_get_obj_instance_from_code(i32,
-                                                     %JavaObject*,
-                                                     %JavaObject*)
-
-declare %JavaObject* @art_decode_jobject_in_thread(%JavaObject*,
-                                                   %JavaObject*)
-
-
-declare void @art_fill_array_data_from_code(%JavaObject*, i32,
-                                            %JavaObject*, i32)
+declare void @art_portable_fill_array_data_from_code(%JavaObject*, i32, %JavaObject*, i32)
 
 
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 ; Type Checking, in the nature of casting
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
-declare i32 @art_is_assignable_from_code(%JavaObject*, %JavaObject*)
-declare void @art_check_cast_from_code(%JavaObject*, %JavaObject*)
-declare void @art_check_put_array_element_from_code(%JavaObject*, %JavaObject*)
+declare i32 @art_portable_is_assignable_from_code(%JavaObject*, %JavaObject*)
+declare void @art_portable_check_cast_from_code(%JavaObject*, %JavaObject*)
+declare void @art_portable_check_put_array_element_from_code(%JavaObject*, %JavaObject*)
 
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 ; Math
@@ -168,34 +134,20 @@
 ; JNI
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
-declare i32 @art_jni_method_start(%JavaObject*)
+declare i32 @art_portable_jni_method_start(%JavaObject*)
+declare i32 @art_portable_jni_method_start_synchronized(%JavaObject*, %JavaObject*)
 
-declare i32 @art_jni_method_start_synchronized(%JavaObject*,
-                                               %JavaObject*)
-
-declare void @art_jni_method_end(i32,
-                                 %JavaObject*)
-
-
-declare void @art_jni_method_end_synchronized(i32,
-                                              %JavaObject*,
-                                              %JavaObject*)
-
-declare %JavaObject* @art_jni_method_end_with_reference(%JavaObject*,
-                                                        i32,
-                                                        %JavaObject*)
-
-declare %JavaObject* @art_jni_method_end_with_reference_synchronized(%JavaObject*,
-                                                                     i32,
-                                                                     %JavaObject*,
-                                                                     %JavaObject*)
+declare void @art_portable_jni_method_end(i32, %JavaObject*)
+declare void @art_portable_jni_method_end_synchronized(i32, %JavaObject*, %JavaObject*)
+declare %JavaObject* @art_portable_jni_method_end_with_reference(%JavaObject*, i32, %JavaObject*)
+declare %JavaObject* @art_portable_jni_method_end_with_reference_synchronized(%JavaObject*, i32, %JavaObject*, %JavaObject*)
 
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 ; Temporary runtime support, will be removed in the future
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
-declare i1 @art_is_exception_pending_from_code()
+declare i1 @art_portable_is_exception_pending_from_code()
 
-declare void @art_mark_gc_card_from_code(%JavaObject*, %JavaObject*)
+declare void @art_portable_mark_gc_card_from_code(%JavaObject*, %JavaObject*)
 
-declare void @art_proxy_invoke_handler_from_code(%JavaObject*, ...)
+declare void @art_portable_proxy_invoke_handler_from_code(%JavaObject*, ...)
diff --git a/src/compiler_llvm/generated/art_module.cc b/src/compiler_llvm/generated/art_module.cc
index ef8d6da..f794be1 100644
--- a/src/compiler_llvm/generated/art_module.cc
+++ b/src/compiler_llvm/generated/art_module.cc
@@ -1,4 +1,4 @@
-// Generated with tools/gen_art_module_cc.sh
+// Generated with ../tools/gen_art_module_cc.sh
 
 
 #pragma GCC diagnostic ignored "-Wframe-larger-than="
@@ -386,555 +386,555 @@
 AttrListPtr func___art_type_list_PAL;
 func___art_type_list->setAttributes(func___art_type_list_PAL);
 
-Function* func_art_get_current_thread_from_code = mod->getFunction("art_get_current_thread_from_code");
-if (!func_art_get_current_thread_from_code) {
-func_art_get_current_thread_from_code = Function::Create(
+Function* func_art_portable_get_current_thread_from_code = mod->getFunction("art_portable_get_current_thread_from_code");
+if (!func_art_portable_get_current_thread_from_code) {
+func_art_portable_get_current_thread_from_code = Function::Create(
  /*Type=*/FuncTy_3,
  /*Linkage=*/GlobalValue::ExternalLinkage,
- /*Name=*/"art_get_current_thread_from_code", mod); // (external, no body)
-func_art_get_current_thread_from_code->setCallingConv(CallingConv::C);
+ /*Name=*/"art_portable_get_current_thread_from_code", mod); // (external, no body)
+func_art_portable_get_current_thread_from_code->setCallingConv(CallingConv::C);
 }
-AttrListPtr func_art_get_current_thread_from_code_PAL;
-func_art_get_current_thread_from_code->setAttributes(func_art_get_current_thread_from_code_PAL);
+AttrListPtr func_art_portable_get_current_thread_from_code_PAL;
+func_art_portable_get_current_thread_from_code->setAttributes(func_art_portable_get_current_thread_from_code_PAL);
 
-Function* func_art_set_current_thread_from_code = mod->getFunction("art_set_current_thread_from_code");
-if (!func_art_set_current_thread_from_code) {
-func_art_set_current_thread_from_code = Function::Create(
+Function* func_art_portable_set_current_thread_from_code = mod->getFunction("art_portable_set_current_thread_from_code");
+if (!func_art_portable_set_current_thread_from_code) {
+func_art_portable_set_current_thread_from_code = Function::Create(
  /*Type=*/FuncTy_4,
  /*Linkage=*/GlobalValue::ExternalLinkage,
- /*Name=*/"art_set_current_thread_from_code", mod); // (external, no body)
-func_art_set_current_thread_from_code->setCallingConv(CallingConv::C);
+ /*Name=*/"art_portable_set_current_thread_from_code", mod); // (external, no body)
+func_art_portable_set_current_thread_from_code->setCallingConv(CallingConv::C);
 }
-AttrListPtr func_art_set_current_thread_from_code_PAL;
-func_art_set_current_thread_from_code->setAttributes(func_art_set_current_thread_from_code_PAL);
+AttrListPtr func_art_portable_set_current_thread_from_code_PAL;
+func_art_portable_set_current_thread_from_code->setAttributes(func_art_portable_set_current_thread_from_code_PAL);
 
-Function* func_art_lock_object_from_code = mod->getFunction("art_lock_object_from_code");
-if (!func_art_lock_object_from_code) {
-func_art_lock_object_from_code = Function::Create(
+Function* func_art_portable_lock_object_from_code = mod->getFunction("art_portable_lock_object_from_code");
+if (!func_art_portable_lock_object_from_code) {
+func_art_portable_lock_object_from_code = Function::Create(
  /*Type=*/FuncTy_5,
  /*Linkage=*/GlobalValue::ExternalLinkage,
- /*Name=*/"art_lock_object_from_code", mod); // (external, no body)
-func_art_lock_object_from_code->setCallingConv(CallingConv::C);
+ /*Name=*/"art_portable_lock_object_from_code", mod); // (external, no body)
+func_art_portable_lock_object_from_code->setCallingConv(CallingConv::C);
 }
-AttrListPtr func_art_lock_object_from_code_PAL;
-func_art_lock_object_from_code->setAttributes(func_art_lock_object_from_code_PAL);
+AttrListPtr func_art_portable_lock_object_from_code_PAL;
+func_art_portable_lock_object_from_code->setAttributes(func_art_portable_lock_object_from_code_PAL);
 
-Function* func_art_unlock_object_from_code = mod->getFunction("art_unlock_object_from_code");
-if (!func_art_unlock_object_from_code) {
-func_art_unlock_object_from_code = Function::Create(
+Function* func_art_portable_unlock_object_from_code = mod->getFunction("art_portable_unlock_object_from_code");
+if (!func_art_portable_unlock_object_from_code) {
+func_art_portable_unlock_object_from_code = Function::Create(
  /*Type=*/FuncTy_5,
  /*Linkage=*/GlobalValue::ExternalLinkage,
- /*Name=*/"art_unlock_object_from_code", mod); // (external, no body)
-func_art_unlock_object_from_code->setCallingConv(CallingConv::C);
+ /*Name=*/"art_portable_unlock_object_from_code", mod); // (external, no body)
+func_art_portable_unlock_object_from_code->setCallingConv(CallingConv::C);
 }
-AttrListPtr func_art_unlock_object_from_code_PAL;
-func_art_unlock_object_from_code->setAttributes(func_art_unlock_object_from_code_PAL);
+AttrListPtr func_art_portable_unlock_object_from_code_PAL;
+func_art_portable_unlock_object_from_code->setAttributes(func_art_portable_unlock_object_from_code_PAL);
 
-Function* func_art_test_suspend_from_code = mod->getFunction("art_test_suspend_from_code");
-if (!func_art_test_suspend_from_code) {
-func_art_test_suspend_from_code = Function::Create(
+Function* func_art_portable_test_suspend_from_code = mod->getFunction("art_portable_test_suspend_from_code");
+if (!func_art_portable_test_suspend_from_code) {
+func_art_portable_test_suspend_from_code = Function::Create(
  /*Type=*/FuncTy_6,
  /*Linkage=*/GlobalValue::ExternalLinkage,
- /*Name=*/"art_test_suspend_from_code", mod); // (external, no body)
-func_art_test_suspend_from_code->setCallingConv(CallingConv::C);
+ /*Name=*/"art_portable_test_suspend_from_code", mod); // (external, no body)
+func_art_portable_test_suspend_from_code->setCallingConv(CallingConv::C);
 }
-AttrListPtr func_art_test_suspend_from_code_PAL;
-func_art_test_suspend_from_code->setAttributes(func_art_test_suspend_from_code_PAL);
+AttrListPtr func_art_portable_test_suspend_from_code_PAL;
+func_art_portable_test_suspend_from_code->setAttributes(func_art_portable_test_suspend_from_code_PAL);
 
-Function* func_art_push_shadow_frame_from_code = mod->getFunction("art_push_shadow_frame_from_code");
-if (!func_art_push_shadow_frame_from_code) {
-func_art_push_shadow_frame_from_code = Function::Create(
+Function* func_art_portable_push_shadow_frame_from_code = mod->getFunction("art_portable_push_shadow_frame_from_code");
+if (!func_art_portable_push_shadow_frame_from_code) {
+func_art_portable_push_shadow_frame_from_code = Function::Create(
  /*Type=*/FuncTy_7,
  /*Linkage=*/GlobalValue::ExternalLinkage,
- /*Name=*/"art_push_shadow_frame_from_code", mod); // (external, no body)
-func_art_push_shadow_frame_from_code->setCallingConv(CallingConv::C);
+ /*Name=*/"art_portable_push_shadow_frame_from_code", mod); // (external, no body)
+func_art_portable_push_shadow_frame_from_code->setCallingConv(CallingConv::C);
 }
-AttrListPtr func_art_push_shadow_frame_from_code_PAL;
-func_art_push_shadow_frame_from_code->setAttributes(func_art_push_shadow_frame_from_code_PAL);
+AttrListPtr func_art_portable_push_shadow_frame_from_code_PAL;
+func_art_portable_push_shadow_frame_from_code->setAttributes(func_art_portable_push_shadow_frame_from_code_PAL);
 
-Function* func_art_pop_shadow_frame_from_code = mod->getFunction("art_pop_shadow_frame_from_code");
-if (!func_art_pop_shadow_frame_from_code) {
-func_art_pop_shadow_frame_from_code = Function::Create(
+Function* func_art_portable_pop_shadow_frame_from_code = mod->getFunction("art_portable_pop_shadow_frame_from_code");
+if (!func_art_portable_pop_shadow_frame_from_code) {
+func_art_portable_pop_shadow_frame_from_code = Function::Create(
  /*Type=*/FuncTy_8,
  /*Linkage=*/GlobalValue::ExternalLinkage,
- /*Name=*/"art_pop_shadow_frame_from_code", mod); // (external, no body)
-func_art_pop_shadow_frame_from_code->setCallingConv(CallingConv::C);
+ /*Name=*/"art_portable_pop_shadow_frame_from_code", mod); // (external, no body)
+func_art_portable_pop_shadow_frame_from_code->setCallingConv(CallingConv::C);
 }
-AttrListPtr func_art_pop_shadow_frame_from_code_PAL;
-func_art_pop_shadow_frame_from_code->setAttributes(func_art_pop_shadow_frame_from_code_PAL);
+AttrListPtr func_art_portable_pop_shadow_frame_from_code_PAL;
+func_art_portable_pop_shadow_frame_from_code->setAttributes(func_art_portable_pop_shadow_frame_from_code_PAL);
 
-Function* func_art_get_and_clear_exception = mod->getFunction("art_get_and_clear_exception");
-if (!func_art_get_and_clear_exception) {
-func_art_get_and_clear_exception = Function::Create(
+Function* func_art_portable_get_and_clear_exception = mod->getFunction("art_portable_get_and_clear_exception");
+if (!func_art_portable_get_and_clear_exception) {
+func_art_portable_get_and_clear_exception = Function::Create(
  /*Type=*/FuncTy_4,
  /*Linkage=*/GlobalValue::ExternalLinkage,
- /*Name=*/"art_get_and_clear_exception", mod); // (external, no body)
-func_art_get_and_clear_exception->setCallingConv(CallingConv::C);
+ /*Name=*/"art_portable_get_and_clear_exception", mod); // (external, no body)
+func_art_portable_get_and_clear_exception->setCallingConv(CallingConv::C);
 }
-AttrListPtr func_art_get_and_clear_exception_PAL;
-func_art_get_and_clear_exception->setAttributes(func_art_get_and_clear_exception_PAL);
+AttrListPtr func_art_portable_get_and_clear_exception_PAL;
+func_art_portable_get_and_clear_exception->setAttributes(func_art_portable_get_and_clear_exception_PAL);
 
-Function* func_art_throw_div_zero_from_code = mod->getFunction("art_throw_div_zero_from_code");
-if (!func_art_throw_div_zero_from_code) {
-func_art_throw_div_zero_from_code = Function::Create(
+Function* func_art_portable_throw_div_zero_from_code = mod->getFunction("art_portable_throw_div_zero_from_code");
+if (!func_art_portable_throw_div_zero_from_code) {
+func_art_portable_throw_div_zero_from_code = Function::Create(
  /*Type=*/FuncTy_9,
  /*Linkage=*/GlobalValue::ExternalLinkage,
- /*Name=*/"art_throw_div_zero_from_code", mod); // (external, no body)
-func_art_throw_div_zero_from_code->setCallingConv(CallingConv::C);
+ /*Name=*/"art_portable_throw_div_zero_from_code", mod); // (external, no body)
+func_art_portable_throw_div_zero_from_code->setCallingConv(CallingConv::C);
 }
-AttrListPtr func_art_throw_div_zero_from_code_PAL;
-func_art_throw_div_zero_from_code->setAttributes(func_art_throw_div_zero_from_code_PAL);
+AttrListPtr func_art_portable_throw_div_zero_from_code_PAL;
+func_art_portable_throw_div_zero_from_code->setAttributes(func_art_portable_throw_div_zero_from_code_PAL);
 
-Function* func_art_throw_array_bounds_from_code = mod->getFunction("art_throw_array_bounds_from_code");
-if (!func_art_throw_array_bounds_from_code) {
-func_art_throw_array_bounds_from_code = Function::Create(
+Function* func_art_portable_throw_array_bounds_from_code = mod->getFunction("art_portable_throw_array_bounds_from_code");
+if (!func_art_portable_throw_array_bounds_from_code) {
+func_art_portable_throw_array_bounds_from_code = Function::Create(
  /*Type=*/FuncTy_10,
  /*Linkage=*/GlobalValue::ExternalLinkage,
- /*Name=*/"art_throw_array_bounds_from_code", mod); // (external, no body)
-func_art_throw_array_bounds_from_code->setCallingConv(CallingConv::C);
+ /*Name=*/"art_portable_throw_array_bounds_from_code", mod); // (external, no body)
+func_art_portable_throw_array_bounds_from_code->setCallingConv(CallingConv::C);
 }
-AttrListPtr func_art_throw_array_bounds_from_code_PAL;
-func_art_throw_array_bounds_from_code->setAttributes(func_art_throw_array_bounds_from_code_PAL);
+AttrListPtr func_art_portable_throw_array_bounds_from_code_PAL;
+func_art_portable_throw_array_bounds_from_code->setAttributes(func_art_portable_throw_array_bounds_from_code_PAL);
 
-Function* func_art_throw_no_such_method_from_code = mod->getFunction("art_throw_no_such_method_from_code");
-if (!func_art_throw_no_such_method_from_code) {
-func_art_throw_no_such_method_from_code = Function::Create(
+Function* func_art_portable_throw_no_such_method_from_code = mod->getFunction("art_portable_throw_no_such_method_from_code");
+if (!func_art_portable_throw_no_such_method_from_code) {
+func_art_portable_throw_no_such_method_from_code = Function::Create(
  /*Type=*/FuncTy_11,
  /*Linkage=*/GlobalValue::ExternalLinkage,
- /*Name=*/"art_throw_no_such_method_from_code", mod); // (external, no body)
-func_art_throw_no_such_method_from_code->setCallingConv(CallingConv::C);
+ /*Name=*/"art_portable_throw_no_such_method_from_code", mod); // (external, no body)
+func_art_portable_throw_no_such_method_from_code->setCallingConv(CallingConv::C);
 }
-AttrListPtr func_art_throw_no_such_method_from_code_PAL;
-func_art_throw_no_such_method_from_code->setAttributes(func_art_throw_no_such_method_from_code_PAL);
+AttrListPtr func_art_portable_throw_no_such_method_from_code_PAL;
+func_art_portable_throw_no_such_method_from_code->setAttributes(func_art_portable_throw_no_such_method_from_code_PAL);
 
-Function* func_art_throw_null_pointer_exception_from_code = mod->getFunction("art_throw_null_pointer_exception_from_code");
-if (!func_art_throw_null_pointer_exception_from_code) {
-func_art_throw_null_pointer_exception_from_code = Function::Create(
+Function* func_art_portable_throw_null_pointer_exception_from_code = mod->getFunction("art_portable_throw_null_pointer_exception_from_code");
+if (!func_art_portable_throw_null_pointer_exception_from_code) {
+func_art_portable_throw_null_pointer_exception_from_code = Function::Create(
  /*Type=*/FuncTy_11,
  /*Linkage=*/GlobalValue::ExternalLinkage,
- /*Name=*/"art_throw_null_pointer_exception_from_code", mod); // (external, no body)
-func_art_throw_null_pointer_exception_from_code->setCallingConv(CallingConv::C);
+ /*Name=*/"art_portable_throw_null_pointer_exception_from_code", mod); // (external, no body)
+func_art_portable_throw_null_pointer_exception_from_code->setCallingConv(CallingConv::C);
 }
-AttrListPtr func_art_throw_null_pointer_exception_from_code_PAL;
-func_art_throw_null_pointer_exception_from_code->setAttributes(func_art_throw_null_pointer_exception_from_code_PAL);
+AttrListPtr func_art_portable_throw_null_pointer_exception_from_code_PAL;
+func_art_portable_throw_null_pointer_exception_from_code->setAttributes(func_art_portable_throw_null_pointer_exception_from_code_PAL);
 
-Function* func_art_throw_stack_overflow_from_code = mod->getFunction("art_throw_stack_overflow_from_code");
-if (!func_art_throw_stack_overflow_from_code) {
-func_art_throw_stack_overflow_from_code = Function::Create(
+Function* func_art_portable_throw_stack_overflow_from_code = mod->getFunction("art_portable_throw_stack_overflow_from_code");
+if (!func_art_portable_throw_stack_overflow_from_code) {
+func_art_portable_throw_stack_overflow_from_code = Function::Create(
  /*Type=*/FuncTy_9,
  /*Linkage=*/GlobalValue::ExternalLinkage,
- /*Name=*/"art_throw_stack_overflow_from_code", mod); // (external, no body)
-func_art_throw_stack_overflow_from_code->setCallingConv(CallingConv::C);
+ /*Name=*/"art_portable_throw_stack_overflow_from_code", mod); // (external, no body)
+func_art_portable_throw_stack_overflow_from_code->setCallingConv(CallingConv::C);
 }
-AttrListPtr func_art_throw_stack_overflow_from_code_PAL;
-func_art_throw_stack_overflow_from_code->setAttributes(func_art_throw_stack_overflow_from_code_PAL);
+AttrListPtr func_art_portable_throw_stack_overflow_from_code_PAL;
+func_art_portable_throw_stack_overflow_from_code->setAttributes(func_art_portable_throw_stack_overflow_from_code_PAL);
 
-Function* func_art_throw_exception_from_code = mod->getFunction("art_throw_exception_from_code");
-if (!func_art_throw_exception_from_code) {
-func_art_throw_exception_from_code = Function::Create(
+Function* func_art_portable_throw_exception_from_code = mod->getFunction("art_portable_throw_exception_from_code");
+if (!func_art_portable_throw_exception_from_code) {
+func_art_portable_throw_exception_from_code = Function::Create(
  /*Type=*/FuncTy_6,
  /*Linkage=*/GlobalValue::ExternalLinkage,
- /*Name=*/"art_throw_exception_from_code", mod); // (external, no body)
-func_art_throw_exception_from_code->setCallingConv(CallingConv::C);
+ /*Name=*/"art_portable_throw_exception_from_code", mod); // (external, no body)
+func_art_portable_throw_exception_from_code->setCallingConv(CallingConv::C);
 }
-AttrListPtr func_art_throw_exception_from_code_PAL;
-func_art_throw_exception_from_code->setAttributes(func_art_throw_exception_from_code_PAL);
+AttrListPtr func_art_portable_throw_exception_from_code_PAL;
+func_art_portable_throw_exception_from_code->setAttributes(func_art_portable_throw_exception_from_code_PAL);
 
-Function* func_art_find_catch_block_from_code = mod->getFunction("art_find_catch_block_from_code");
-if (!func_art_find_catch_block_from_code) {
-func_art_find_catch_block_from_code = Function::Create(
+Function* func_art_portable_find_catch_block_from_code = mod->getFunction("art_portable_find_catch_block_from_code");
+if (!func_art_portable_find_catch_block_from_code) {
+func_art_portable_find_catch_block_from_code = Function::Create(
  /*Type=*/FuncTy_12,
  /*Linkage=*/GlobalValue::ExternalLinkage,
- /*Name=*/"art_find_catch_block_from_code", mod); // (external, no body)
-func_art_find_catch_block_from_code->setCallingConv(CallingConv::C);
+ /*Name=*/"art_portable_find_catch_block_from_code", mod); // (external, no body)
+func_art_portable_find_catch_block_from_code->setCallingConv(CallingConv::C);
 }
-AttrListPtr func_art_find_catch_block_from_code_PAL;
-func_art_find_catch_block_from_code->setAttributes(func_art_find_catch_block_from_code_PAL);
+AttrListPtr func_art_portable_find_catch_block_from_code_PAL;
+func_art_portable_find_catch_block_from_code->setAttributes(func_art_portable_find_catch_block_from_code_PAL);
 
-Function* func_art_alloc_object_from_code = mod->getFunction("art_alloc_object_from_code");
-if (!func_art_alloc_object_from_code) {
-func_art_alloc_object_from_code = Function::Create(
+Function* func_art_portable_alloc_object_from_code = mod->getFunction("art_portable_alloc_object_from_code");
+if (!func_art_portable_alloc_object_from_code) {
+func_art_portable_alloc_object_from_code = Function::Create(
  /*Type=*/FuncTy_13,
  /*Linkage=*/GlobalValue::ExternalLinkage,
- /*Name=*/"art_alloc_object_from_code", mod); // (external, no body)
-func_art_alloc_object_from_code->setCallingConv(CallingConv::C);
+ /*Name=*/"art_portable_alloc_object_from_code", mod); // (external, no body)
+func_art_portable_alloc_object_from_code->setCallingConv(CallingConv::C);
 }
-AttrListPtr func_art_alloc_object_from_code_PAL;
-func_art_alloc_object_from_code->setAttributes(func_art_alloc_object_from_code_PAL);
+AttrListPtr func_art_portable_alloc_object_from_code_PAL;
+func_art_portable_alloc_object_from_code->setAttributes(func_art_portable_alloc_object_from_code_PAL);
 
-Function* func_art_alloc_object_from_code_with_access_check = mod->getFunction("art_alloc_object_from_code_with_access_check");
-if (!func_art_alloc_object_from_code_with_access_check) {
-func_art_alloc_object_from_code_with_access_check = Function::Create(
+Function* func_art_portable_alloc_object_from_code_with_access_check = mod->getFunction("art_portable_alloc_object_from_code_with_access_check");
+if (!func_art_portable_alloc_object_from_code_with_access_check) {
+func_art_portable_alloc_object_from_code_with_access_check = Function::Create(
  /*Type=*/FuncTy_13,
  /*Linkage=*/GlobalValue::ExternalLinkage,
- /*Name=*/"art_alloc_object_from_code_with_access_check", mod); // (external, no body)
-func_art_alloc_object_from_code_with_access_check->setCallingConv(CallingConv::C);
+ /*Name=*/"art_portable_alloc_object_from_code_with_access_check", mod); // (external, no body)
+func_art_portable_alloc_object_from_code_with_access_check->setCallingConv(CallingConv::C);
 }
-AttrListPtr func_art_alloc_object_from_code_with_access_check_PAL;
-func_art_alloc_object_from_code_with_access_check->setAttributes(func_art_alloc_object_from_code_with_access_check_PAL);
+AttrListPtr func_art_portable_alloc_object_from_code_with_access_check_PAL;
+func_art_portable_alloc_object_from_code_with_access_check->setAttributes(func_art_portable_alloc_object_from_code_with_access_check_PAL);
 
-Function* func_art_alloc_array_from_code = mod->getFunction("art_alloc_array_from_code");
-if (!func_art_alloc_array_from_code) {
-func_art_alloc_array_from_code = Function::Create(
+Function* func_art_portable_alloc_array_from_code = mod->getFunction("art_portable_alloc_array_from_code");
+if (!func_art_portable_alloc_array_from_code) {
+func_art_portable_alloc_array_from_code = Function::Create(
  /*Type=*/FuncTy_14,
  /*Linkage=*/GlobalValue::ExternalLinkage,
- /*Name=*/"art_alloc_array_from_code", mod); // (external, no body)
-func_art_alloc_array_from_code->setCallingConv(CallingConv::C);
+ /*Name=*/"art_portable_alloc_array_from_code", mod); // (external, no body)
+func_art_portable_alloc_array_from_code->setCallingConv(CallingConv::C);
 }
-AttrListPtr func_art_alloc_array_from_code_PAL;
-func_art_alloc_array_from_code->setAttributes(func_art_alloc_array_from_code_PAL);
+AttrListPtr func_art_portable_alloc_array_from_code_PAL;
+func_art_portable_alloc_array_from_code->setAttributes(func_art_portable_alloc_array_from_code_PAL);
 
-Function* func_art_alloc_array_from_code_with_access_check = mod->getFunction("art_alloc_array_from_code_with_access_check");
-if (!func_art_alloc_array_from_code_with_access_check) {
-func_art_alloc_array_from_code_with_access_check = Function::Create(
+Function* func_art_portable_alloc_array_from_code_with_access_check = mod->getFunction("art_portable_alloc_array_from_code_with_access_check");
+if (!func_art_portable_alloc_array_from_code_with_access_check) {
+func_art_portable_alloc_array_from_code_with_access_check = Function::Create(
  /*Type=*/FuncTy_14,
  /*Linkage=*/GlobalValue::ExternalLinkage,
- /*Name=*/"art_alloc_array_from_code_with_access_check", mod); // (external, no body)
-func_art_alloc_array_from_code_with_access_check->setCallingConv(CallingConv::C);
+ /*Name=*/"art_portable_alloc_array_from_code_with_access_check", mod); // (external, no body)
+func_art_portable_alloc_array_from_code_with_access_check->setCallingConv(CallingConv::C);
 }
-AttrListPtr func_art_alloc_array_from_code_with_access_check_PAL;
-func_art_alloc_array_from_code_with_access_check->setAttributes(func_art_alloc_array_from_code_with_access_check_PAL);
+AttrListPtr func_art_portable_alloc_array_from_code_with_access_check_PAL;
+func_art_portable_alloc_array_from_code_with_access_check->setAttributes(func_art_portable_alloc_array_from_code_with_access_check_PAL);
 
-Function* func_art_check_and_alloc_array_from_code = mod->getFunction("art_check_and_alloc_array_from_code");
-if (!func_art_check_and_alloc_array_from_code) {
-func_art_check_and_alloc_array_from_code = Function::Create(
+Function* func_art_portable_check_and_alloc_array_from_code = mod->getFunction("art_portable_check_and_alloc_array_from_code");
+if (!func_art_portable_check_and_alloc_array_from_code) {
+func_art_portable_check_and_alloc_array_from_code = Function::Create(
  /*Type=*/FuncTy_14,
  /*Linkage=*/GlobalValue::ExternalLinkage,
- /*Name=*/"art_check_and_alloc_array_from_code", mod); // (external, no body)
-func_art_check_and_alloc_array_from_code->setCallingConv(CallingConv::C);
+ /*Name=*/"art_portable_check_and_alloc_array_from_code", mod); // (external, no body)
+func_art_portable_check_and_alloc_array_from_code->setCallingConv(CallingConv::C);
 }
-AttrListPtr func_art_check_and_alloc_array_from_code_PAL;
-func_art_check_and_alloc_array_from_code->setAttributes(func_art_check_and_alloc_array_from_code_PAL);
+AttrListPtr func_art_portable_check_and_alloc_array_from_code_PAL;
+func_art_portable_check_and_alloc_array_from_code->setAttributes(func_art_portable_check_and_alloc_array_from_code_PAL);
 
-Function* func_art_check_and_alloc_array_from_code_with_access_check = mod->getFunction("art_check_and_alloc_array_from_code_with_access_check");
-if (!func_art_check_and_alloc_array_from_code_with_access_check) {
-func_art_check_and_alloc_array_from_code_with_access_check = Function::Create(
+Function* func_art_portable_check_and_alloc_array_from_code_with_access_check = mod->getFunction("art_portable_check_and_alloc_array_from_code_with_access_check");
+if (!func_art_portable_check_and_alloc_array_from_code_with_access_check) {
+func_art_portable_check_and_alloc_array_from_code_with_access_check = Function::Create(
  /*Type=*/FuncTy_14,
  /*Linkage=*/GlobalValue::ExternalLinkage,
- /*Name=*/"art_check_and_alloc_array_from_code_with_access_check", mod); // (external, no body)
-func_art_check_and_alloc_array_from_code_with_access_check->setCallingConv(CallingConv::C);
+ /*Name=*/"art_portable_check_and_alloc_array_from_code_with_access_check", mod); // (external, no body)
+func_art_portable_check_and_alloc_array_from_code_with_access_check->setCallingConv(CallingConv::C);
 }
-AttrListPtr func_art_check_and_alloc_array_from_code_with_access_check_PAL;
-func_art_check_and_alloc_array_from_code_with_access_check->setAttributes(func_art_check_and_alloc_array_from_code_with_access_check_PAL);
+AttrListPtr func_art_portable_check_and_alloc_array_from_code_with_access_check_PAL;
+func_art_portable_check_and_alloc_array_from_code_with_access_check->setAttributes(func_art_portable_check_and_alloc_array_from_code_with_access_check_PAL);
 
-Function* func_art_find_instance_field_from_code = mod->getFunction("art_find_instance_field_from_code");
-if (!func_art_find_instance_field_from_code) {
-func_art_find_instance_field_from_code = Function::Create(
+Function* func_art_portable_find_instance_field_from_code = mod->getFunction("art_portable_find_instance_field_from_code");
+if (!func_art_portable_find_instance_field_from_code) {
+func_art_portable_find_instance_field_from_code = Function::Create(
  /*Type=*/FuncTy_15,
  /*Linkage=*/GlobalValue::ExternalLinkage,
- /*Name=*/"art_find_instance_field_from_code", mod); // (external, no body)
-func_art_find_instance_field_from_code->setCallingConv(CallingConv::C);
+ /*Name=*/"art_portable_find_instance_field_from_code", mod); // (external, no body)
+func_art_portable_find_instance_field_from_code->setCallingConv(CallingConv::C);
 }
-AttrListPtr func_art_find_instance_field_from_code_PAL;
-func_art_find_instance_field_from_code->setAttributes(func_art_find_instance_field_from_code_PAL);
+AttrListPtr func_art_portable_find_instance_field_from_code_PAL;
+func_art_portable_find_instance_field_from_code->setAttributes(func_art_portable_find_instance_field_from_code_PAL);
 
-Function* func_art_find_static_field_from_code = mod->getFunction("art_find_static_field_from_code");
-if (!func_art_find_static_field_from_code) {
-func_art_find_static_field_from_code = Function::Create(
+Function* func_art_portable_find_static_field_from_code = mod->getFunction("art_portable_find_static_field_from_code");
+if (!func_art_portable_find_static_field_from_code) {
+func_art_portable_find_static_field_from_code = Function::Create(
  /*Type=*/FuncTy_15,
  /*Linkage=*/GlobalValue::ExternalLinkage,
- /*Name=*/"art_find_static_field_from_code", mod); // (external, no body)
-func_art_find_static_field_from_code->setCallingConv(CallingConv::C);
+ /*Name=*/"art_portable_find_static_field_from_code", mod); // (external, no body)
+func_art_portable_find_static_field_from_code->setCallingConv(CallingConv::C);
 }
-AttrListPtr func_art_find_static_field_from_code_PAL;
-func_art_find_static_field_from_code->setAttributes(func_art_find_static_field_from_code_PAL);
+AttrListPtr func_art_portable_find_static_field_from_code_PAL;
+func_art_portable_find_static_field_from_code->setAttributes(func_art_portable_find_static_field_from_code_PAL);
 
-Function* func_art_find_static_method_from_code_with_access_check = mod->getFunction("art_find_static_method_from_code_with_access_check");
-if (!func_art_find_static_method_from_code_with_access_check) {
-func_art_find_static_method_from_code_with_access_check = Function::Create(
+Function* func_art_portable_find_static_method_from_code_with_access_check = mod->getFunction("art_portable_find_static_method_from_code_with_access_check");
+if (!func_art_portable_find_static_method_from_code_with_access_check) {
+func_art_portable_find_static_method_from_code_with_access_check = Function::Create(
  /*Type=*/FuncTy_16,
  /*Linkage=*/GlobalValue::ExternalLinkage,
- /*Name=*/"art_find_static_method_from_code_with_access_check", mod); // (external, no body)
-func_art_find_static_method_from_code_with_access_check->setCallingConv(CallingConv::C);
+ /*Name=*/"art_portable_find_static_method_from_code_with_access_check", mod); // (external, no body)
+func_art_portable_find_static_method_from_code_with_access_check->setCallingConv(CallingConv::C);
 }
-AttrListPtr func_art_find_static_method_from_code_with_access_check_PAL;
-func_art_find_static_method_from_code_with_access_check->setAttributes(func_art_find_static_method_from_code_with_access_check_PAL);
+AttrListPtr func_art_portable_find_static_method_from_code_with_access_check_PAL;
+func_art_portable_find_static_method_from_code_with_access_check->setAttributes(func_art_portable_find_static_method_from_code_with_access_check_PAL);
 
-Function* func_art_find_direct_method_from_code_with_access_check = mod->getFunction("art_find_direct_method_from_code_with_access_check");
-if (!func_art_find_direct_method_from_code_with_access_check) {
-func_art_find_direct_method_from_code_with_access_check = Function::Create(
+Function* func_art_portable_find_direct_method_from_code_with_access_check = mod->getFunction("art_portable_find_direct_method_from_code_with_access_check");
+if (!func_art_portable_find_direct_method_from_code_with_access_check) {
+func_art_portable_find_direct_method_from_code_with_access_check = Function::Create(
  /*Type=*/FuncTy_16,
  /*Linkage=*/GlobalValue::ExternalLinkage,
- /*Name=*/"art_find_direct_method_from_code_with_access_check", mod); // (external, no body)
-func_art_find_direct_method_from_code_with_access_check->setCallingConv(CallingConv::C);
+ /*Name=*/"art_portable_find_direct_method_from_code_with_access_check", mod); // (external, no body)
+func_art_portable_find_direct_method_from_code_with_access_check->setCallingConv(CallingConv::C);
 }
-AttrListPtr func_art_find_direct_method_from_code_with_access_check_PAL;
-func_art_find_direct_method_from_code_with_access_check->setAttributes(func_art_find_direct_method_from_code_with_access_check_PAL);
+AttrListPtr func_art_portable_find_direct_method_from_code_with_access_check_PAL;
+func_art_portable_find_direct_method_from_code_with_access_check->setAttributes(func_art_portable_find_direct_method_from_code_with_access_check_PAL);
 
-Function* func_art_find_virtual_method_from_code_with_access_check = mod->getFunction("art_find_virtual_method_from_code_with_access_check");
-if (!func_art_find_virtual_method_from_code_with_access_check) {
-func_art_find_virtual_method_from_code_with_access_check = Function::Create(
+Function* func_art_portable_find_virtual_method_from_code_with_access_check = mod->getFunction("art_portable_find_virtual_method_from_code_with_access_check");
+if (!func_art_portable_find_virtual_method_from_code_with_access_check) {
+func_art_portable_find_virtual_method_from_code_with_access_check = Function::Create(
  /*Type=*/FuncTy_16,
  /*Linkage=*/GlobalValue::ExternalLinkage,
- /*Name=*/"art_find_virtual_method_from_code_with_access_check", mod); // (external, no body)
-func_art_find_virtual_method_from_code_with_access_check->setCallingConv(CallingConv::C);
+ /*Name=*/"art_portable_find_virtual_method_from_code_with_access_check", mod); // (external, no body)
+func_art_portable_find_virtual_method_from_code_with_access_check->setCallingConv(CallingConv::C);
 }
-AttrListPtr func_art_find_virtual_method_from_code_with_access_check_PAL;
-func_art_find_virtual_method_from_code_with_access_check->setAttributes(func_art_find_virtual_method_from_code_with_access_check_PAL);
+AttrListPtr func_art_portable_find_virtual_method_from_code_with_access_check_PAL;
+func_art_portable_find_virtual_method_from_code_with_access_check->setAttributes(func_art_portable_find_virtual_method_from_code_with_access_check_PAL);
 
-Function* func_art_find_super_method_from_code_with_access_check = mod->getFunction("art_find_super_method_from_code_with_access_check");
-if (!func_art_find_super_method_from_code_with_access_check) {
-func_art_find_super_method_from_code_with_access_check = Function::Create(
+Function* func_art_portable_find_super_method_from_code_with_access_check = mod->getFunction("art_portable_find_super_method_from_code_with_access_check");
+if (!func_art_portable_find_super_method_from_code_with_access_check) {
+func_art_portable_find_super_method_from_code_with_access_check = Function::Create(
  /*Type=*/FuncTy_16,
  /*Linkage=*/GlobalValue::ExternalLinkage,
- /*Name=*/"art_find_super_method_from_code_with_access_check", mod); // (external, no body)
-func_art_find_super_method_from_code_with_access_check->setCallingConv(CallingConv::C);
+ /*Name=*/"art_portable_find_super_method_from_code_with_access_check", mod); // (external, no body)
+func_art_portable_find_super_method_from_code_with_access_check->setCallingConv(CallingConv::C);
 }
-AttrListPtr func_art_find_super_method_from_code_with_access_check_PAL;
-func_art_find_super_method_from_code_with_access_check->setAttributes(func_art_find_super_method_from_code_with_access_check_PAL);
+AttrListPtr func_art_portable_find_super_method_from_code_with_access_check_PAL;
+func_art_portable_find_super_method_from_code_with_access_check->setAttributes(func_art_portable_find_super_method_from_code_with_access_check_PAL);
 
-Function* func_art_find_interface_method_from_code_with_access_check = mod->getFunction("art_find_interface_method_from_code_with_access_check");
-if (!func_art_find_interface_method_from_code_with_access_check) {
-func_art_find_interface_method_from_code_with_access_check = Function::Create(
+Function* func_art_portable_find_interface_method_from_code_with_access_check = mod->getFunction("art_portable_find_interface_method_from_code_with_access_check");
+if (!func_art_portable_find_interface_method_from_code_with_access_check) {
+func_art_portable_find_interface_method_from_code_with_access_check = Function::Create(
  /*Type=*/FuncTy_16,
  /*Linkage=*/GlobalValue::ExternalLinkage,
- /*Name=*/"art_find_interface_method_from_code_with_access_check", mod); // (external, no body)
-func_art_find_interface_method_from_code_with_access_check->setCallingConv(CallingConv::C);
+ /*Name=*/"art_portable_find_interface_method_from_code_with_access_check", mod); // (external, no body)
+func_art_portable_find_interface_method_from_code_with_access_check->setCallingConv(CallingConv::C);
 }
-AttrListPtr func_art_find_interface_method_from_code_with_access_check_PAL;
-func_art_find_interface_method_from_code_with_access_check->setAttributes(func_art_find_interface_method_from_code_with_access_check_PAL);
+AttrListPtr func_art_portable_find_interface_method_from_code_with_access_check_PAL;
+func_art_portable_find_interface_method_from_code_with_access_check->setAttributes(func_art_portable_find_interface_method_from_code_with_access_check_PAL);
 
-Function* func_art_find_interface_method_from_code = mod->getFunction("art_find_interface_method_from_code");
-if (!func_art_find_interface_method_from_code) {
-func_art_find_interface_method_from_code = Function::Create(
+Function* func_art_portable_find_interface_method_from_code = mod->getFunction("art_portable_find_interface_method_from_code");
+if (!func_art_portable_find_interface_method_from_code) {
+func_art_portable_find_interface_method_from_code = Function::Create(
  /*Type=*/FuncTy_16,
  /*Linkage=*/GlobalValue::ExternalLinkage,
- /*Name=*/"art_find_interface_method_from_code", mod); // (external, no body)
-func_art_find_interface_method_from_code->setCallingConv(CallingConv::C);
+ /*Name=*/"art_portable_find_interface_method_from_code", mod); // (external, no body)
+func_art_portable_find_interface_method_from_code->setCallingConv(CallingConv::C);
 }
-AttrListPtr func_art_find_interface_method_from_code_PAL;
-func_art_find_interface_method_from_code->setAttributes(func_art_find_interface_method_from_code_PAL);
+AttrListPtr func_art_portable_find_interface_method_from_code_PAL;
+func_art_portable_find_interface_method_from_code->setAttributes(func_art_portable_find_interface_method_from_code_PAL);
 
-Function* func_art_initialize_static_storage_from_code = mod->getFunction("art_initialize_static_storage_from_code");
-if (!func_art_initialize_static_storage_from_code) {
-func_art_initialize_static_storage_from_code = Function::Create(
+Function* func_art_portable_initialize_static_storage_from_code = mod->getFunction("art_portable_initialize_static_storage_from_code");
+if (!func_art_portable_initialize_static_storage_from_code) {
+func_art_portable_initialize_static_storage_from_code = Function::Create(
  /*Type=*/FuncTy_13,
  /*Linkage=*/GlobalValue::ExternalLinkage,
- /*Name=*/"art_initialize_static_storage_from_code", mod); // (external, no body)
-func_art_initialize_static_storage_from_code->setCallingConv(CallingConv::C);
+ /*Name=*/"art_portable_initialize_static_storage_from_code", mod); // (external, no body)
+func_art_portable_initialize_static_storage_from_code->setCallingConv(CallingConv::C);
 }
-AttrListPtr func_art_initialize_static_storage_from_code_PAL;
-func_art_initialize_static_storage_from_code->setAttributes(func_art_initialize_static_storage_from_code_PAL);
+AttrListPtr func_art_portable_initialize_static_storage_from_code_PAL;
+func_art_portable_initialize_static_storage_from_code->setAttributes(func_art_portable_initialize_static_storage_from_code_PAL);
 
-Function* func_art_initialize_type_from_code = mod->getFunction("art_initialize_type_from_code");
-if (!func_art_initialize_type_from_code) {
-func_art_initialize_type_from_code = Function::Create(
+Function* func_art_portable_initialize_type_from_code = mod->getFunction("art_portable_initialize_type_from_code");
+if (!func_art_portable_initialize_type_from_code) {
+func_art_portable_initialize_type_from_code = Function::Create(
  /*Type=*/FuncTy_13,
  /*Linkage=*/GlobalValue::ExternalLinkage,
- /*Name=*/"art_initialize_type_from_code", mod); // (external, no body)
-func_art_initialize_type_from_code->setCallingConv(CallingConv::C);
+ /*Name=*/"art_portable_initialize_type_from_code", mod); // (external, no body)
+func_art_portable_initialize_type_from_code->setCallingConv(CallingConv::C);
 }
-AttrListPtr func_art_initialize_type_from_code_PAL;
-func_art_initialize_type_from_code->setAttributes(func_art_initialize_type_from_code_PAL);
+AttrListPtr func_art_portable_initialize_type_from_code_PAL;
+func_art_portable_initialize_type_from_code->setAttributes(func_art_portable_initialize_type_from_code_PAL);
 
-Function* func_art_initialize_type_and_verify_access_from_code = mod->getFunction("art_initialize_type_and_verify_access_from_code");
-if (!func_art_initialize_type_and_verify_access_from_code) {
-func_art_initialize_type_and_verify_access_from_code = Function::Create(
+Function* func_art_portable_initialize_type_and_verify_access_from_code = mod->getFunction("art_portable_initialize_type_and_verify_access_from_code");
+if (!func_art_portable_initialize_type_and_verify_access_from_code) {
+func_art_portable_initialize_type_and_verify_access_from_code = Function::Create(
  /*Type=*/FuncTy_13,
  /*Linkage=*/GlobalValue::ExternalLinkage,
- /*Name=*/"art_initialize_type_and_verify_access_from_code", mod); // (external, no body)
-func_art_initialize_type_and_verify_access_from_code->setCallingConv(CallingConv::C);
+ /*Name=*/"art_portable_initialize_type_and_verify_access_from_code", mod); // (external, no body)
+func_art_portable_initialize_type_and_verify_access_from_code->setCallingConv(CallingConv::C);
 }
-AttrListPtr func_art_initialize_type_and_verify_access_from_code_PAL;
-func_art_initialize_type_and_verify_access_from_code->setAttributes(func_art_initialize_type_and_verify_access_from_code_PAL);
+AttrListPtr func_art_portable_initialize_type_and_verify_access_from_code_PAL;
+func_art_portable_initialize_type_and_verify_access_from_code->setAttributes(func_art_portable_initialize_type_and_verify_access_from_code_PAL);
 
-Function* func_art_resolve_string_from_code = mod->getFunction("art_resolve_string_from_code");
-if (!func_art_resolve_string_from_code) {
-func_art_resolve_string_from_code = Function::Create(
+Function* func_art_portable_resolve_string_from_code = mod->getFunction("art_portable_resolve_string_from_code");
+if (!func_art_portable_resolve_string_from_code) {
+func_art_portable_resolve_string_from_code = Function::Create(
  /*Type=*/FuncTy_17,
  /*Linkage=*/GlobalValue::ExternalLinkage,
- /*Name=*/"art_resolve_string_from_code", mod); // (external, no body)
-func_art_resolve_string_from_code->setCallingConv(CallingConv::C);
+ /*Name=*/"art_portable_resolve_string_from_code", mod); // (external, no body)
+func_art_portable_resolve_string_from_code->setCallingConv(CallingConv::C);
 }
-AttrListPtr func_art_resolve_string_from_code_PAL;
-func_art_resolve_string_from_code->setAttributes(func_art_resolve_string_from_code_PAL);
+AttrListPtr func_art_portable_resolve_string_from_code_PAL;
+func_art_portable_resolve_string_from_code->setAttributes(func_art_portable_resolve_string_from_code_PAL);
 
-Function* func_art_set32_static_from_code = mod->getFunction("art_set32_static_from_code");
-if (!func_art_set32_static_from_code) {
-func_art_set32_static_from_code = Function::Create(
+Function* func_art_portable_set32_static_from_code = mod->getFunction("art_portable_set32_static_from_code");
+if (!func_art_portable_set32_static_from_code) {
+func_art_portable_set32_static_from_code = Function::Create(
  /*Type=*/FuncTy_18,
  /*Linkage=*/GlobalValue::ExternalLinkage,
- /*Name=*/"art_set32_static_from_code", mod); // (external, no body)
-func_art_set32_static_from_code->setCallingConv(CallingConv::C);
+ /*Name=*/"art_portable_set32_static_from_code", mod); // (external, no body)
+func_art_portable_set32_static_from_code->setCallingConv(CallingConv::C);
 }
-AttrListPtr func_art_set32_static_from_code_PAL;
-func_art_set32_static_from_code->setAttributes(func_art_set32_static_from_code_PAL);
+AttrListPtr func_art_portable_set32_static_from_code_PAL;
+func_art_portable_set32_static_from_code->setAttributes(func_art_portable_set32_static_from_code_PAL);
 
-Function* func_art_set64_static_from_code = mod->getFunction("art_set64_static_from_code");
-if (!func_art_set64_static_from_code) {
-func_art_set64_static_from_code = Function::Create(
+Function* func_art_portable_set64_static_from_code = mod->getFunction("art_portable_set64_static_from_code");
+if (!func_art_portable_set64_static_from_code) {
+func_art_portable_set64_static_from_code = Function::Create(
  /*Type=*/FuncTy_19,
  /*Linkage=*/GlobalValue::ExternalLinkage,
- /*Name=*/"art_set64_static_from_code", mod); // (external, no body)
-func_art_set64_static_from_code->setCallingConv(CallingConv::C);
+ /*Name=*/"art_portable_set64_static_from_code", mod); // (external, no body)
+func_art_portable_set64_static_from_code->setCallingConv(CallingConv::C);
 }
-AttrListPtr func_art_set64_static_from_code_PAL;
-func_art_set64_static_from_code->setAttributes(func_art_set64_static_from_code_PAL);
+AttrListPtr func_art_portable_set64_static_from_code_PAL;
+func_art_portable_set64_static_from_code->setAttributes(func_art_portable_set64_static_from_code_PAL);
 
-Function* func_art_set_obj_static_from_code = mod->getFunction("art_set_obj_static_from_code");
-if (!func_art_set_obj_static_from_code) {
-func_art_set_obj_static_from_code = Function::Create(
+Function* func_art_portable_set_obj_static_from_code = mod->getFunction("art_portable_set_obj_static_from_code");
+if (!func_art_portable_set_obj_static_from_code) {
+func_art_portable_set_obj_static_from_code = Function::Create(
  /*Type=*/FuncTy_20,
  /*Linkage=*/GlobalValue::ExternalLinkage,
- /*Name=*/"art_set_obj_static_from_code", mod); // (external, no body)
-func_art_set_obj_static_from_code->setCallingConv(CallingConv::C);
+ /*Name=*/"art_portable_set_obj_static_from_code", mod); // (external, no body)
+func_art_portable_set_obj_static_from_code->setCallingConv(CallingConv::C);
 }
-AttrListPtr func_art_set_obj_static_from_code_PAL;
-func_art_set_obj_static_from_code->setAttributes(func_art_set_obj_static_from_code_PAL);
+AttrListPtr func_art_portable_set_obj_static_from_code_PAL;
+func_art_portable_set_obj_static_from_code->setAttributes(func_art_portable_set_obj_static_from_code_PAL);
 
-Function* func_art_get32_static_from_code = mod->getFunction("art_get32_static_from_code");
-if (!func_art_get32_static_from_code) {
-func_art_get32_static_from_code = Function::Create(
+Function* func_art_portable_get32_static_from_code = mod->getFunction("art_portable_get32_static_from_code");
+if (!func_art_portable_get32_static_from_code) {
+func_art_portable_get32_static_from_code = Function::Create(
  /*Type=*/FuncTy_21,
  /*Linkage=*/GlobalValue::ExternalLinkage,
- /*Name=*/"art_get32_static_from_code", mod); // (external, no body)
-func_art_get32_static_from_code->setCallingConv(CallingConv::C);
+ /*Name=*/"art_portable_get32_static_from_code", mod); // (external, no body)
+func_art_portable_get32_static_from_code->setCallingConv(CallingConv::C);
 }
-AttrListPtr func_art_get32_static_from_code_PAL;
-func_art_get32_static_from_code->setAttributes(func_art_get32_static_from_code_PAL);
+AttrListPtr func_art_portable_get32_static_from_code_PAL;
+func_art_portable_get32_static_from_code->setAttributes(func_art_portable_get32_static_from_code_PAL);
 
-Function* func_art_get64_static_from_code = mod->getFunction("art_get64_static_from_code");
-if (!func_art_get64_static_from_code) {
-func_art_get64_static_from_code = Function::Create(
+Function* func_art_portable_get64_static_from_code = mod->getFunction("art_portable_get64_static_from_code");
+if (!func_art_portable_get64_static_from_code) {
+func_art_portable_get64_static_from_code = Function::Create(
  /*Type=*/FuncTy_22,
  /*Linkage=*/GlobalValue::ExternalLinkage,
- /*Name=*/"art_get64_static_from_code", mod); // (external, no body)
-func_art_get64_static_from_code->setCallingConv(CallingConv::C);
+ /*Name=*/"art_portable_get64_static_from_code", mod); // (external, no body)
+func_art_portable_get64_static_from_code->setCallingConv(CallingConv::C);
 }
-AttrListPtr func_art_get64_static_from_code_PAL;
-func_art_get64_static_from_code->setAttributes(func_art_get64_static_from_code_PAL);
+AttrListPtr func_art_portable_get64_static_from_code_PAL;
+func_art_portable_get64_static_from_code->setAttributes(func_art_portable_get64_static_from_code_PAL);
 
-Function* func_art_get_obj_static_from_code = mod->getFunction("art_get_obj_static_from_code");
-if (!func_art_get_obj_static_from_code) {
-func_art_get_obj_static_from_code = Function::Create(
+Function* func_art_portable_get_obj_static_from_code = mod->getFunction("art_portable_get_obj_static_from_code");
+if (!func_art_portable_get_obj_static_from_code) {
+func_art_portable_get_obj_static_from_code = Function::Create(
  /*Type=*/FuncTy_23,
  /*Linkage=*/GlobalValue::ExternalLinkage,
- /*Name=*/"art_get_obj_static_from_code", mod); // (external, no body)
-func_art_get_obj_static_from_code->setCallingConv(CallingConv::C);
+ /*Name=*/"art_portable_get_obj_static_from_code", mod); // (external, no body)
+func_art_portable_get_obj_static_from_code->setCallingConv(CallingConv::C);
 }
-AttrListPtr func_art_get_obj_static_from_code_PAL;
-func_art_get_obj_static_from_code->setAttributes(func_art_get_obj_static_from_code_PAL);
+AttrListPtr func_art_portable_get_obj_static_from_code_PAL;
+func_art_portable_get_obj_static_from_code->setAttributes(func_art_portable_get_obj_static_from_code_PAL);
 
-Function* func_art_set32_instance_from_code = mod->getFunction("art_set32_instance_from_code");
-if (!func_art_set32_instance_from_code) {
-func_art_set32_instance_from_code = Function::Create(
+Function* func_art_portable_set32_instance_from_code = mod->getFunction("art_portable_set32_instance_from_code");
+if (!func_art_portable_set32_instance_from_code) {
+func_art_portable_set32_instance_from_code = Function::Create(
  /*Type=*/FuncTy_24,
  /*Linkage=*/GlobalValue::ExternalLinkage,
- /*Name=*/"art_set32_instance_from_code", mod); // (external, no body)
-func_art_set32_instance_from_code->setCallingConv(CallingConv::C);
+ /*Name=*/"art_portable_set32_instance_from_code", mod); // (external, no body)
+func_art_portable_set32_instance_from_code->setCallingConv(CallingConv::C);
 }
-AttrListPtr func_art_set32_instance_from_code_PAL;
-func_art_set32_instance_from_code->setAttributes(func_art_set32_instance_from_code_PAL);
+AttrListPtr func_art_portable_set32_instance_from_code_PAL;
+func_art_portable_set32_instance_from_code->setAttributes(func_art_portable_set32_instance_from_code_PAL);
 
-Function* func_art_set64_instance_from_code = mod->getFunction("art_set64_instance_from_code");
-if (!func_art_set64_instance_from_code) {
-func_art_set64_instance_from_code = Function::Create(
+Function* func_art_portable_set64_instance_from_code = mod->getFunction("art_portable_set64_instance_from_code");
+if (!func_art_portable_set64_instance_from_code) {
+func_art_portable_set64_instance_from_code = Function::Create(
  /*Type=*/FuncTy_25,
  /*Linkage=*/GlobalValue::ExternalLinkage,
- /*Name=*/"art_set64_instance_from_code", mod); // (external, no body)
-func_art_set64_instance_from_code->setCallingConv(CallingConv::C);
+ /*Name=*/"art_portable_set64_instance_from_code", mod); // (external, no body)
+func_art_portable_set64_instance_from_code->setCallingConv(CallingConv::C);
 }
-AttrListPtr func_art_set64_instance_from_code_PAL;
-func_art_set64_instance_from_code->setAttributes(func_art_set64_instance_from_code_PAL);
+AttrListPtr func_art_portable_set64_instance_from_code_PAL;
+func_art_portable_set64_instance_from_code->setAttributes(func_art_portable_set64_instance_from_code_PAL);
 
-Function* func_art_set_obj_instance_from_code = mod->getFunction("art_set_obj_instance_from_code");
-if (!func_art_set_obj_instance_from_code) {
-func_art_set_obj_instance_from_code = Function::Create(
+Function* func_art_portable_set_obj_instance_from_code = mod->getFunction("art_portable_set_obj_instance_from_code");
+if (!func_art_portable_set_obj_instance_from_code) {
+func_art_portable_set_obj_instance_from_code = Function::Create(
  /*Type=*/FuncTy_26,
  /*Linkage=*/GlobalValue::ExternalLinkage,
- /*Name=*/"art_set_obj_instance_from_code", mod); // (external, no body)
-func_art_set_obj_instance_from_code->setCallingConv(CallingConv::C);
+ /*Name=*/"art_portable_set_obj_instance_from_code", mod); // (external, no body)
+func_art_portable_set_obj_instance_from_code->setCallingConv(CallingConv::C);
 }
-AttrListPtr func_art_set_obj_instance_from_code_PAL;
-func_art_set_obj_instance_from_code->setAttributes(func_art_set_obj_instance_from_code_PAL);
+AttrListPtr func_art_portable_set_obj_instance_from_code_PAL;
+func_art_portable_set_obj_instance_from_code->setAttributes(func_art_portable_set_obj_instance_from_code_PAL);
 
-Function* func_art_get32_instance_from_code = mod->getFunction("art_get32_instance_from_code");
-if (!func_art_get32_instance_from_code) {
-func_art_get32_instance_from_code = Function::Create(
+Function* func_art_portable_get32_instance_from_code = mod->getFunction("art_portable_get32_instance_from_code");
+if (!func_art_portable_get32_instance_from_code) {
+func_art_portable_get32_instance_from_code = Function::Create(
  /*Type=*/FuncTy_20,
  /*Linkage=*/GlobalValue::ExternalLinkage,
- /*Name=*/"art_get32_instance_from_code", mod); // (external, no body)
-func_art_get32_instance_from_code->setCallingConv(CallingConv::C);
+ /*Name=*/"art_portable_get32_instance_from_code", mod); // (external, no body)
+func_art_portable_get32_instance_from_code->setCallingConv(CallingConv::C);
 }
-AttrListPtr func_art_get32_instance_from_code_PAL;
-func_art_get32_instance_from_code->setAttributes(func_art_get32_instance_from_code_PAL);
+AttrListPtr func_art_portable_get32_instance_from_code_PAL;
+func_art_portable_get32_instance_from_code->setAttributes(func_art_portable_get32_instance_from_code_PAL);
 
-Function* func_art_get64_instance_from_code = mod->getFunction("art_get64_instance_from_code");
-if (!func_art_get64_instance_from_code) {
-func_art_get64_instance_from_code = Function::Create(
+Function* func_art_portable_get64_instance_from_code = mod->getFunction("art_portable_get64_instance_from_code");
+if (!func_art_portable_get64_instance_from_code) {
+func_art_portable_get64_instance_from_code = Function::Create(
  /*Type=*/FuncTy_27,
  /*Linkage=*/GlobalValue::ExternalLinkage,
- /*Name=*/"art_get64_instance_from_code", mod); // (external, no body)
-func_art_get64_instance_from_code->setCallingConv(CallingConv::C);
+ /*Name=*/"art_portable_get64_instance_from_code", mod); // (external, no body)
+func_art_portable_get64_instance_from_code->setCallingConv(CallingConv::C);
 }
-AttrListPtr func_art_get64_instance_from_code_PAL;
-func_art_get64_instance_from_code->setAttributes(func_art_get64_instance_from_code_PAL);
+AttrListPtr func_art_portable_get64_instance_from_code_PAL;
+func_art_portable_get64_instance_from_code->setAttributes(func_art_portable_get64_instance_from_code_PAL);
 
-Function* func_art_get_obj_instance_from_code = mod->getFunction("art_get_obj_instance_from_code");
-if (!func_art_get_obj_instance_from_code) {
-func_art_get_obj_instance_from_code = Function::Create(
+Function* func_art_portable_get_obj_instance_from_code = mod->getFunction("art_portable_get_obj_instance_from_code");
+if (!func_art_portable_get_obj_instance_from_code) {
+func_art_portable_get_obj_instance_from_code = Function::Create(
  /*Type=*/FuncTy_13,
  /*Linkage=*/GlobalValue::ExternalLinkage,
- /*Name=*/"art_get_obj_instance_from_code", mod); // (external, no body)
-func_art_get_obj_instance_from_code->setCallingConv(CallingConv::C);
+ /*Name=*/"art_portable_get_obj_instance_from_code", mod); // (external, no body)
+func_art_portable_get_obj_instance_from_code->setCallingConv(CallingConv::C);
 }
-AttrListPtr func_art_get_obj_instance_from_code_PAL;
-func_art_get_obj_instance_from_code->setAttributes(func_art_get_obj_instance_from_code_PAL);
+AttrListPtr func_art_portable_get_obj_instance_from_code_PAL;
+func_art_portable_get_obj_instance_from_code->setAttributes(func_art_portable_get_obj_instance_from_code_PAL);
 
-Function* func_art_decode_jobject_in_thread = mod->getFunction("art_decode_jobject_in_thread");
-if (!func_art_decode_jobject_in_thread) {
-func_art_decode_jobject_in_thread = Function::Create(
+Function* func_art_portable_decode_jobject_in_thread = mod->getFunction("art_portable_decode_jobject_in_thread");
+if (!func_art_portable_decode_jobject_in_thread) {
+func_art_portable_decode_jobject_in_thread = Function::Create(
  /*Type=*/FuncTy_28,
  /*Linkage=*/GlobalValue::ExternalLinkage,
- /*Name=*/"art_decode_jobject_in_thread", mod); // (external, no body)
-func_art_decode_jobject_in_thread->setCallingConv(CallingConv::C);
+ /*Name=*/"art_portable_decode_jobject_in_thread", mod); // (external, no body)
+func_art_portable_decode_jobject_in_thread->setCallingConv(CallingConv::C);
 }
-AttrListPtr func_art_decode_jobject_in_thread_PAL;
-func_art_decode_jobject_in_thread->setAttributes(func_art_decode_jobject_in_thread_PAL);
+AttrListPtr func_art_portable_decode_jobject_in_thread_PAL;
+func_art_portable_decode_jobject_in_thread->setAttributes(func_art_portable_decode_jobject_in_thread_PAL);
 
-Function* func_art_fill_array_data_from_code = mod->getFunction("art_fill_array_data_from_code");
-if (!func_art_fill_array_data_from_code) {
-func_art_fill_array_data_from_code = Function::Create(
+Function* func_art_portable_fill_array_data_from_code = mod->getFunction("art_portable_fill_array_data_from_code");
+if (!func_art_portable_fill_array_data_from_code) {
+func_art_portable_fill_array_data_from_code = Function::Create(
  /*Type=*/FuncTy_29,
  /*Linkage=*/GlobalValue::ExternalLinkage,
- /*Name=*/"art_fill_array_data_from_code", mod); // (external, no body)
-func_art_fill_array_data_from_code->setCallingConv(CallingConv::C);
+ /*Name=*/"art_portable_fill_array_data_from_code", mod); // (external, no body)
+func_art_portable_fill_array_data_from_code->setCallingConv(CallingConv::C);
 }
-AttrListPtr func_art_fill_array_data_from_code_PAL;
-func_art_fill_array_data_from_code->setAttributes(func_art_fill_array_data_from_code_PAL);
+AttrListPtr func_art_portable_fill_array_data_from_code_PAL;
+func_art_portable_fill_array_data_from_code->setAttributes(func_art_portable_fill_array_data_from_code_PAL);
 
-Function* func_art_is_assignable_from_code = mod->getFunction("art_is_assignable_from_code");
-if (!func_art_is_assignable_from_code) {
-func_art_is_assignable_from_code = Function::Create(
+Function* func_art_portable_is_assignable_from_code = mod->getFunction("art_portable_is_assignable_from_code");
+if (!func_art_portable_is_assignable_from_code) {
+func_art_portable_is_assignable_from_code = Function::Create(
  /*Type=*/FuncTy_30,
  /*Linkage=*/GlobalValue::ExternalLinkage,
- /*Name=*/"art_is_assignable_from_code", mod); // (external, no body)
-func_art_is_assignable_from_code->setCallingConv(CallingConv::C);
+ /*Name=*/"art_portable_is_assignable_from_code", mod); // (external, no body)
+func_art_portable_is_assignable_from_code->setCallingConv(CallingConv::C);
 }
-AttrListPtr func_art_is_assignable_from_code_PAL;
-func_art_is_assignable_from_code->setAttributes(func_art_is_assignable_from_code_PAL);
+AttrListPtr func_art_portable_is_assignable_from_code_PAL;
+func_art_portable_is_assignable_from_code->setAttributes(func_art_portable_is_assignable_from_code_PAL);
 
-Function* func_art_check_cast_from_code = mod->getFunction("art_check_cast_from_code");
-if (!func_art_check_cast_from_code) {
-func_art_check_cast_from_code = Function::Create(
+Function* func_art_portable_check_cast_from_code = mod->getFunction("art_portable_check_cast_from_code");
+if (!func_art_portable_check_cast_from_code) {
+func_art_portable_check_cast_from_code = Function::Create(
  /*Type=*/FuncTy_5,
  /*Linkage=*/GlobalValue::ExternalLinkage,
- /*Name=*/"art_check_cast_from_code", mod); // (external, no body)
-func_art_check_cast_from_code->setCallingConv(CallingConv::C);
+ /*Name=*/"art_portable_check_cast_from_code", mod); // (external, no body)
+func_art_portable_check_cast_from_code->setCallingConv(CallingConv::C);
 }
-AttrListPtr func_art_check_cast_from_code_PAL;
-func_art_check_cast_from_code->setAttributes(func_art_check_cast_from_code_PAL);
+AttrListPtr func_art_portable_check_cast_from_code_PAL;
+func_art_portable_check_cast_from_code->setAttributes(func_art_portable_check_cast_from_code_PAL);
 
-Function* func_art_check_put_array_element_from_code = mod->getFunction("art_check_put_array_element_from_code");
-if (!func_art_check_put_array_element_from_code) {
-func_art_check_put_array_element_from_code = Function::Create(
+Function* func_art_portable_check_put_array_element_from_code = mod->getFunction("art_portable_check_put_array_element_from_code");
+if (!func_art_portable_check_put_array_element_from_code) {
+func_art_portable_check_put_array_element_from_code = Function::Create(
  /*Type=*/FuncTy_5,
  /*Linkage=*/GlobalValue::ExternalLinkage,
- /*Name=*/"art_check_put_array_element_from_code", mod); // (external, no body)
-func_art_check_put_array_element_from_code->setCallingConv(CallingConv::C);
+ /*Name=*/"art_portable_check_put_array_element_from_code", mod); // (external, no body)
+func_art_portable_check_put_array_element_from_code->setCallingConv(CallingConv::C);
 }
-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);
+AttrListPtr func_art_portable_check_put_array_element_from_code_PAL;
+func_art_portable_check_put_array_element_from_code->setAttributes(func_art_portable_check_put_array_element_from_code_PAL);
 
 Function* func_art_d2l = mod->getFunction("art_d2l");
 if (!func_art_d2l) {
@@ -980,104 +980,104 @@
 AttrListPtr func_art_f2i_PAL;
 func_art_f2i->setAttributes(func_art_f2i_PAL);
 
-Function* func_art_jni_method_start = mod->getFunction("art_jni_method_start");
-if (!func_art_jni_method_start) {
-func_art_jni_method_start = Function::Create(
+Function* func_art_portable_jni_method_start = mod->getFunction("art_portable_jni_method_start");
+if (!func_art_portable_jni_method_start) {
+func_art_portable_jni_method_start = Function::Create(
  /*Type=*/FuncTy_35,
  /*Linkage=*/GlobalValue::ExternalLinkage,
- /*Name=*/"art_jni_method_start", mod); // (external, no body)
-func_art_jni_method_start->setCallingConv(CallingConv::C);
+ /*Name=*/"art_portable_jni_method_start", mod); // (external, no body)
+func_art_portable_jni_method_start->setCallingConv(CallingConv::C);
 }
-AttrListPtr func_art_jni_method_start_PAL;
-func_art_jni_method_start->setAttributes(func_art_jni_method_start_PAL);
+AttrListPtr func_art_portable_jni_method_start_PAL;
+func_art_portable_jni_method_start->setAttributes(func_art_portable_jni_method_start_PAL);
 
-Function* func_art_jni_method_start_synchronized = mod->getFunction("art_jni_method_start_synchronized");
-if (!func_art_jni_method_start_synchronized) {
-func_art_jni_method_start_synchronized = Function::Create(
+Function* func_art_portable_jni_method_start_synchronized = mod->getFunction("art_portable_jni_method_start_synchronized");
+if (!func_art_portable_jni_method_start_synchronized) {
+func_art_portable_jni_method_start_synchronized = Function::Create(
  /*Type=*/FuncTy_30,
  /*Linkage=*/GlobalValue::ExternalLinkage,
- /*Name=*/"art_jni_method_start_synchronized", mod); // (external, no body)
-func_art_jni_method_start_synchronized->setCallingConv(CallingConv::C);
+ /*Name=*/"art_portable_jni_method_start_synchronized", mod); // (external, no body)
+func_art_portable_jni_method_start_synchronized->setCallingConv(CallingConv::C);
 }
-AttrListPtr func_art_jni_method_start_synchronized_PAL;
-func_art_jni_method_start_synchronized->setAttributes(func_art_jni_method_start_synchronized_PAL);
+AttrListPtr func_art_portable_jni_method_start_synchronized_PAL;
+func_art_portable_jni_method_start_synchronized->setAttributes(func_art_portable_jni_method_start_synchronized_PAL);
 
-Function* func_art_jni_method_end = mod->getFunction("art_jni_method_end");
-if (!func_art_jni_method_end) {
-func_art_jni_method_end = Function::Create(
+Function* func_art_portable_jni_method_end = mod->getFunction("art_portable_jni_method_end");
+if (!func_art_portable_jni_method_end) {
+func_art_portable_jni_method_end = Function::Create(
  /*Type=*/FuncTy_15,
  /*Linkage=*/GlobalValue::ExternalLinkage,
- /*Name=*/"art_jni_method_end", mod); // (external, no body)
-func_art_jni_method_end->setCallingConv(CallingConv::C);
+ /*Name=*/"art_portable_jni_method_end", mod); // (external, no body)
+func_art_portable_jni_method_end->setCallingConv(CallingConv::C);
 }
-AttrListPtr func_art_jni_method_end_PAL;
-func_art_jni_method_end->setAttributes(func_art_jni_method_end_PAL);
+AttrListPtr func_art_portable_jni_method_end_PAL;
+func_art_portable_jni_method_end->setAttributes(func_art_portable_jni_method_end_PAL);
 
-Function* func_art_jni_method_end_synchronized = mod->getFunction("art_jni_method_end_synchronized");
-if (!func_art_jni_method_end_synchronized) {
-func_art_jni_method_end_synchronized = Function::Create(
+Function* func_art_portable_jni_method_end_synchronized = mod->getFunction("art_portable_jni_method_end_synchronized");
+if (!func_art_portable_jni_method_end_synchronized) {
+func_art_portable_jni_method_end_synchronized = Function::Create(
  /*Type=*/FuncTy_36,
  /*Linkage=*/GlobalValue::ExternalLinkage,
- /*Name=*/"art_jni_method_end_synchronized", mod); // (external, no body)
-func_art_jni_method_end_synchronized->setCallingConv(CallingConv::C);
+ /*Name=*/"art_portable_jni_method_end_synchronized", mod); // (external, no body)
+func_art_portable_jni_method_end_synchronized->setCallingConv(CallingConv::C);
 }
-AttrListPtr func_art_jni_method_end_synchronized_PAL;
-func_art_jni_method_end_synchronized->setAttributes(func_art_jni_method_end_synchronized_PAL);
+AttrListPtr func_art_portable_jni_method_end_synchronized_PAL;
+func_art_portable_jni_method_end_synchronized->setAttributes(func_art_portable_jni_method_end_synchronized_PAL);
 
-Function* func_art_jni_method_end_with_reference = mod->getFunction("art_jni_method_end_with_reference");
-if (!func_art_jni_method_end_with_reference) {
-func_art_jni_method_end_with_reference = Function::Create(
+Function* func_art_portable_jni_method_end_with_reference = mod->getFunction("art_portable_jni_method_end_with_reference");
+if (!func_art_portable_jni_method_end_with_reference) {
+func_art_portable_jni_method_end_with_reference = Function::Create(
  /*Type=*/FuncTy_37,
  /*Linkage=*/GlobalValue::ExternalLinkage,
- /*Name=*/"art_jni_method_end_with_reference", mod); // (external, no body)
-func_art_jni_method_end_with_reference->setCallingConv(CallingConv::C);
+ /*Name=*/"art_portable_jni_method_end_with_reference", mod); // (external, no body)
+func_art_portable_jni_method_end_with_reference->setCallingConv(CallingConv::C);
 }
-AttrListPtr func_art_jni_method_end_with_reference_PAL;
-func_art_jni_method_end_with_reference->setAttributes(func_art_jni_method_end_with_reference_PAL);
+AttrListPtr func_art_portable_jni_method_end_with_reference_PAL;
+func_art_portable_jni_method_end_with_reference->setAttributes(func_art_portable_jni_method_end_with_reference_PAL);
 
-Function* func_art_jni_method_end_with_reference_synchronized = mod->getFunction("art_jni_method_end_with_reference_synchronized");
-if (!func_art_jni_method_end_with_reference_synchronized) {
-func_art_jni_method_end_with_reference_synchronized = Function::Create(
+Function* func_art_portable_jni_method_end_with_reference_synchronized = mod->getFunction("art_portable_jni_method_end_with_reference_synchronized");
+if (!func_art_portable_jni_method_end_with_reference_synchronized) {
+func_art_portable_jni_method_end_with_reference_synchronized = Function::Create(
  /*Type=*/FuncTy_38,
  /*Linkage=*/GlobalValue::ExternalLinkage,
- /*Name=*/"art_jni_method_end_with_reference_synchronized", mod); // (external, no body)
-func_art_jni_method_end_with_reference_synchronized->setCallingConv(CallingConv::C);
+ /*Name=*/"art_portable_jni_method_end_with_reference_synchronized", mod); // (external, no body)
+func_art_portable_jni_method_end_with_reference_synchronized->setCallingConv(CallingConv::C);
 }
-AttrListPtr func_art_jni_method_end_with_reference_synchronized_PAL;
-func_art_jni_method_end_with_reference_synchronized->setAttributes(func_art_jni_method_end_with_reference_synchronized_PAL);
+AttrListPtr func_art_portable_jni_method_end_with_reference_synchronized_PAL;
+func_art_portable_jni_method_end_with_reference_synchronized->setAttributes(func_art_portable_jni_method_end_with_reference_synchronized_PAL);
 
-Function* func_art_is_exception_pending_from_code = mod->getFunction("art_is_exception_pending_from_code");
-if (!func_art_is_exception_pending_from_code) {
-func_art_is_exception_pending_from_code = Function::Create(
+Function* func_art_portable_is_exception_pending_from_code = mod->getFunction("art_portable_is_exception_pending_from_code");
+if (!func_art_portable_is_exception_pending_from_code) {
+func_art_portable_is_exception_pending_from_code = Function::Create(
  /*Type=*/FuncTy_39,
  /*Linkage=*/GlobalValue::ExternalLinkage,
- /*Name=*/"art_is_exception_pending_from_code", mod); // (external, no body)
-func_art_is_exception_pending_from_code->setCallingConv(CallingConv::C);
+ /*Name=*/"art_portable_is_exception_pending_from_code", mod); // (external, no body)
+func_art_portable_is_exception_pending_from_code->setCallingConv(CallingConv::C);
 }
-AttrListPtr func_art_is_exception_pending_from_code_PAL;
-func_art_is_exception_pending_from_code->setAttributes(func_art_is_exception_pending_from_code_PAL);
+AttrListPtr func_art_portable_is_exception_pending_from_code_PAL;
+func_art_portable_is_exception_pending_from_code->setAttributes(func_art_portable_is_exception_pending_from_code_PAL);
 
-Function* func_art_mark_gc_card_from_code = mod->getFunction("art_mark_gc_card_from_code");
-if (!func_art_mark_gc_card_from_code) {
-func_art_mark_gc_card_from_code = Function::Create(
+Function* func_art_portable_mark_gc_card_from_code = mod->getFunction("art_portable_mark_gc_card_from_code");
+if (!func_art_portable_mark_gc_card_from_code) {
+func_art_portable_mark_gc_card_from_code = Function::Create(
  /*Type=*/FuncTy_5,
  /*Linkage=*/GlobalValue::ExternalLinkage,
- /*Name=*/"art_mark_gc_card_from_code", mod); // (external, no body)
-func_art_mark_gc_card_from_code->setCallingConv(CallingConv::C);
+ /*Name=*/"art_portable_mark_gc_card_from_code", mod); // (external, no body)
+func_art_portable_mark_gc_card_from_code->setCallingConv(CallingConv::C);
 }
-AttrListPtr func_art_mark_gc_card_from_code_PAL;
-func_art_mark_gc_card_from_code->setAttributes(func_art_mark_gc_card_from_code_PAL);
+AttrListPtr func_art_portable_mark_gc_card_from_code_PAL;
+func_art_portable_mark_gc_card_from_code->setAttributes(func_art_portable_mark_gc_card_from_code_PAL);
 
-Function* func_art_proxy_invoke_handler_from_code = mod->getFunction("art_proxy_invoke_handler_from_code");
-if (!func_art_proxy_invoke_handler_from_code) {
-func_art_proxy_invoke_handler_from_code = Function::Create(
+Function* func_art_portable_proxy_invoke_handler_from_code = mod->getFunction("art_portable_proxy_invoke_handler_from_code");
+if (!func_art_portable_proxy_invoke_handler_from_code) {
+func_art_portable_proxy_invoke_handler_from_code = Function::Create(
  /*Type=*/FuncTy_40,
  /*Linkage=*/GlobalValue::ExternalLinkage,
- /*Name=*/"art_proxy_invoke_handler_from_code", mod); // (external, no body)
-func_art_proxy_invoke_handler_from_code->setCallingConv(CallingConv::C);
+ /*Name=*/"art_portable_proxy_invoke_handler_from_code", mod); // (external, no body)
+func_art_portable_proxy_invoke_handler_from_code->setCallingConv(CallingConv::C);
 }
-AttrListPtr func_art_proxy_invoke_handler_from_code_PAL;
-func_art_proxy_invoke_handler_from_code->setAttributes(func_art_proxy_invoke_handler_from_code_PAL);
+AttrListPtr func_art_portable_proxy_invoke_handler_from_code_PAL;
+func_art_portable_proxy_invoke_handler_from_code->setAttributes(func_art_portable_proxy_invoke_handler_from_code_PAL);
 
 // Global Variable Declarations
 
diff --git a/src/compiler_llvm/procedure_linkage_table.cc b/src/compiler_llvm/procedure_linkage_table.cc
index 51d6cd2..b78db4e 100644
--- a/src/compiler_llvm/procedure_linkage_table.cc
+++ b/src/compiler_llvm/procedure_linkage_table.cc
@@ -113,7 +113,7 @@
 
   for (size_t i = 0; i < art_runtime_func_count; ++i, stub_ptr += stub_size) {
     const char* name = art_runtime_func_name_list[i];
-    void* func = art_find_runtime_support_func(NULL, name);
+    void* func = art_portable_find_runtime_support_func(NULL, name);
     DCHECK(func != NULL);
     CreateStub(stub_ptr, func);
   }
@@ -144,7 +144,7 @@
   }
 
   for (size_t i = 0; i < crt_count; ++i, stub_ptr += stub_size) {
-    void* func = art_find_runtime_support_func(NULL, crt_name_list[i]);
+    void* func = art_portable_find_runtime_support_func(NULL, crt_name_list[i]);
     DCHECK(func != NULL);
     CreateStub(stub_ptr, func);
   }
diff --git a/src/compiler_llvm/runtime_support_func_list.h b/src/compiler_llvm/runtime_support_func_list.h
index b27754e..a58b061 100644
--- a/src/compiler_llvm/runtime_support_func_list.h
+++ b/src/compiler_llvm/runtime_support_func_list.h
@@ -15,62 +15,62 @@
  */
 
 #define RUNTIME_SUPPORT_FUNC_LIST(V) \
-  V(LockObject, art_lock_object_from_code) \
-  V(UnlockObject, art_unlock_object_from_code) \
-  V(GetCurrentThread, art_get_current_thread_from_code) \
-  V(SetCurrentThread, art_set_current_thread_from_code) \
-  V(PushShadowFrame, art_push_shadow_frame_from_code) \
-  V(PopShadowFrame, art_pop_shadow_frame_from_code) \
-  V(TestSuspend, art_test_suspend_from_code) \
-  V(ThrowException, art_throw_exception_from_code) \
-  V(ThrowStackOverflowException, art_throw_stack_overflow_from_code) \
-  V(ThrowNullPointerException, art_throw_null_pointer_exception_from_code) \
-  V(ThrowDivZeroException, art_throw_div_zero_from_code) \
-  V(ThrowIndexOutOfBounds, art_throw_array_bounds_from_code) \
-  V(InitializeTypeAndVerifyAccess, art_initialize_type_and_verify_access_from_code) \
-  V(InitializeType, art_initialize_type_from_code) \
-  V(IsAssignable, art_is_assignable_from_code) \
-  V(CheckCast, art_check_cast_from_code) \
-  V(CheckPutArrayElement, art_check_put_array_element_from_code) \
-  V(AllocObject, art_alloc_object_from_code) \
-  V(AllocObjectWithAccessCheck, art_alloc_object_from_code_with_access_check) \
-  V(AllocArray, art_alloc_array_from_code) \
-  V(AllocArrayWithAccessCheck, art_alloc_array_from_code_with_access_check) \
-  V(CheckAndAllocArray, art_check_and_alloc_array_from_code) \
-  V(CheckAndAllocArrayWithAccessCheck, art_check_and_alloc_array_from_code_with_access_check) \
-  V(FindStaticMethodWithAccessCheck, art_find_static_method_from_code_with_access_check) \
-  V(FindDirectMethodWithAccessCheck, art_find_direct_method_from_code_with_access_check) \
-  V(FindVirtualMethodWithAccessCheck, art_find_virtual_method_from_code_with_access_check) \
-  V(FindSuperMethodWithAccessCheck, art_find_super_method_from_code_with_access_check) \
-  V(FindInterfaceMethodWithAccessCheck, art_find_interface_method_from_code_with_access_check) \
-  V(FindInterfaceMethod, art_find_interface_method_from_code) \
-  V(ResolveString, art_resolve_string_from_code) \
-  V(Set32Static, art_set32_static_from_code) \
-  V(Set64Static, art_set64_static_from_code) \
-  V(SetObjectStatic, art_set_obj_static_from_code) \
-  V(Get32Static, art_get32_static_from_code) \
-  V(Get64Static, art_get64_static_from_code) \
-  V(GetObjectStatic, art_get_obj_static_from_code) \
-  V(Set32Instance, art_set32_instance_from_code) \
-  V(Set64Instance, art_set64_instance_from_code) \
-  V(SetObjectInstance, art_set_obj_instance_from_code) \
-  V(Get32Instance, art_get32_instance_from_code) \
-  V(Get64Instance, art_get64_instance_from_code) \
-  V(GetObjectInstance, art_get_obj_instance_from_code) \
-  V(InitializeStaticStorage, art_initialize_static_storage_from_code) \
-  V(FillArrayData, art_fill_array_data_from_code) \
-  V(GetAndClearException, art_get_and_clear_exception) \
-  V(IsExceptionPending, art_is_exception_pending_from_code) \
-  V(FindCatchBlock, art_find_catch_block_from_code) \
-  V(MarkGCCard, art_mark_gc_card_from_code) \
-  V(ProxyInvokeHandler, art_proxy_invoke_handler_from_code) \
+  V(LockObject, art_portable_lock_object_from_code) \
+  V(UnlockObject, art_portable_unlock_object_from_code) \
+  V(GetCurrentThread, art_portable_get_current_thread_from_code) \
+  V(SetCurrentThread, art_portable_set_current_thread_from_code) \
+  V(PushShadowFrame, art_portable_push_shadow_frame_from_code) \
+  V(PopShadowFrame, art_portable_pop_shadow_frame_from_code) \
+  V(TestSuspend, art_portable_test_suspend_from_code) \
+  V(ThrowException, art_portable_throw_exception_from_code) \
+  V(ThrowStackOverflowException, art_portable_throw_stack_overflow_from_code) \
+  V(ThrowNullPointerException, art_portable_throw_null_pointer_exception_from_code) \
+  V(ThrowDivZeroException, art_portable_throw_div_zero_from_code) \
+  V(ThrowIndexOutOfBounds, art_portable_throw_array_bounds_from_code) \
+  V(InitializeTypeAndVerifyAccess, art_portable_initialize_type_and_verify_access_from_code) \
+  V(InitializeType, art_portable_initialize_type_from_code) \
+  V(IsAssignable, art_portable_is_assignable_from_code) \
+  V(CheckCast, art_portable_check_cast_from_code) \
+  V(CheckPutArrayElement, art_portable_check_put_array_element_from_code) \
+  V(AllocObject, art_portable_alloc_object_from_code) \
+  V(AllocObjectWithAccessCheck, art_portable_alloc_object_from_code_with_access_check) \
+  V(AllocArray, art_portable_alloc_array_from_code) \
+  V(AllocArrayWithAccessCheck, art_portable_alloc_array_from_code_with_access_check) \
+  V(CheckAndAllocArray, art_portable_check_and_alloc_array_from_code) \
+  V(CheckAndAllocArrayWithAccessCheck, art_portable_check_and_alloc_array_from_code_with_access_check) \
+  V(FindStaticMethodWithAccessCheck, art_portable_find_static_method_from_code_with_access_check) \
+  V(FindDirectMethodWithAccessCheck, art_portable_find_direct_method_from_code_with_access_check) \
+  V(FindVirtualMethodWithAccessCheck, art_portable_find_virtual_method_from_code_with_access_check) \
+  V(FindSuperMethodWithAccessCheck, art_portable_find_super_method_from_code_with_access_check) \
+  V(FindInterfaceMethodWithAccessCheck, art_portable_find_interface_method_from_code_with_access_check) \
+  V(FindInterfaceMethod, art_portable_find_interface_method_from_code) \
+  V(ResolveString, art_portable_resolve_string_from_code) \
+  V(Set32Static, art_portable_set32_static_from_code) \
+  V(Set64Static, art_portable_set64_static_from_code) \
+  V(SetObjectStatic, art_portable_set_obj_static_from_code) \
+  V(Get32Static, art_portable_get32_static_from_code) \
+  V(Get64Static, art_portable_get64_static_from_code) \
+  V(GetObjectStatic, art_portable_get_obj_static_from_code) \
+  V(Set32Instance, art_portable_set32_instance_from_code) \
+  V(Set64Instance, art_portable_set64_instance_from_code) \
+  V(SetObjectInstance, art_portable_set_obj_instance_from_code) \
+  V(Get32Instance, art_portable_get32_instance_from_code) \
+  V(Get64Instance, art_portable_get64_instance_from_code) \
+  V(GetObjectInstance, art_portable_get_obj_instance_from_code) \
+  V(InitializeStaticStorage, art_portable_initialize_static_storage_from_code) \
+  V(FillArrayData, art_portable_fill_array_data_from_code) \
+  V(GetAndClearException, art_portable_get_and_clear_exception) \
+  V(IsExceptionPending, art_portable_is_exception_pending_from_code) \
+  V(FindCatchBlock, art_portable_find_catch_block_from_code) \
+  V(MarkGCCard, art_portable_mark_gc_card_from_code) \
+  V(ProxyInvokeHandler, art_portable_proxy_invoke_handler_from_code) \
   V(art_d2l, art_d2l) \
   V(art_d2i, art_d2i) \
   V(art_f2l, art_f2l) \
   V(art_f2i, art_f2i) \
-  V(JniMethodStart,                        art_jni_method_start) \
-  V(JniMethodStartSynchronized,            art_jni_method_start_synchronized) \
-  V(JniMethodEnd,                          art_jni_method_end) \
-  V(JniMethodEndSynchronized,              art_jni_method_end_synchronized) \
-  V(JniMethodEndWithReference,             art_jni_method_end_with_reference) \
-  V(JniMethodEndWithReferenceSynchronized, art_jni_method_end_with_reference_synchronized)
+  V(JniMethodStart,                        art_portable_jni_method_start) \
+  V(JniMethodStartSynchronized,            art_portable_jni_method_start_synchronized) \
+  V(JniMethodEnd,                          art_portable_jni_method_end) \
+  V(JniMethodEndSynchronized,              art_portable_jni_method_end_synchronized) \
+  V(JniMethodEndWithReference,             art_portable_jni_method_end_with_reference) \
+  V(JniMethodEndWithReferenceSynchronized, art_portable_jni_method_end_with_reference_synchronized)
diff --git a/src/compiler_llvm/runtime_support_llvm.cc b/src/compiler_llvm/runtime_support_llvm.cc
index d0fe4c3..ccda55c 100644
--- a/src/compiler_llvm/runtime_support_llvm.cc
+++ b/src/compiler_llvm/runtime_support_llvm.cc
@@ -48,7 +48,9 @@
 #include <stdint.h>
 #include <stdlib.h>
 
-namespace art {
+using namespace art;
+
+extern "C" {
 
 class ShadowFrameCopyVisitor : public StackVisitor {
  public:
@@ -105,20 +107,20 @@
 // Thread
 //----------------------------------------------------------------------------
 
-Thread* art_get_current_thread_from_code() {
+Thread* art_portable_get_current_thread_from_code() {
 #if defined(__arm__) || defined(__i386__)
   LOG(FATAL) << "UNREACHABLE";
 #endif
   return Thread::Current();
 }
 
-void* art_set_current_thread_from_code(void* thread_object_addr) {
+void* art_portable_set_current_thread_from_code(void* thread_object_addr) {
   // Hijacked to set r9 on ARM.
   LOG(FATAL) << "UNREACHABLE";
   return NULL;
 }
 
-void art_lock_object_from_code(mirror::Object* obj, Thread* thread)
+void art_portable_lock_object_from_code(mirror::Object* obj, Thread* thread)
     EXCLUSIVE_LOCK_FUNCTION(monitor_lock_) {
   DCHECK(obj != NULL);        // Assumed to have been checked before entry
   obj->MonitorEnter(thread);  // May block
@@ -127,14 +129,14 @@
   DCHECK(!thread->IsExceptionPending());
 }
 
-void art_unlock_object_from_code(mirror::Object* obj, Thread* thread)
+void art_portable_unlock_object_from_code(mirror::Object* obj, Thread* thread)
     UNLOCK_FUNCTION(monitor_lock_) {
   DCHECK(obj != NULL);  // Assumed to have been checked before entry
   // MonitorExit may throw exception
   obj->MonitorExit(thread);
 }
 
-void art_test_suspend_from_code(Thread* thread)
+void art_portable_test_suspend_from_code(Thread* thread)
     SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
   CheckSuspend(thread);
   if (thread->ReadFlag(kEnterInterpreter)) {
@@ -146,19 +148,21 @@
   }
 }
 
-ShadowFrame* art_push_shadow_frame_from_code(Thread* thread, ShadowFrame* new_shadow_frame,
-                                             mirror::AbstractMethod* method, uint32_t num_vregs) {
+ShadowFrame* art_portable_push_shadow_frame_from_code(Thread* thread,
+                                              ShadowFrame* new_shadow_frame,
+                                              mirror::AbstractMethod* method,
+                                              uint32_t num_vregs) {
   ShadowFrame* old_frame = thread->PushShadowFrame(new_shadow_frame);
   new_shadow_frame->SetMethod(method);
   new_shadow_frame->SetNumberOfVRegs(num_vregs);
   return old_frame;
 }
 
-void art_pop_shadow_frame_from_code(void*) {
+void art_portable_pop_shadow_frame_from_code(void*) {
   LOG(FATAL) << "Implemented by IRBuilder.";
 }
 
-void art_mark_gc_card_from_code(void *, void*) {
+void art_portable_mark_gc_card_from_code(void *, void*) {
   LOG(FATAL) << "Implemented by IRBuilder.";
 }
 
@@ -166,45 +170,45 @@
 // Exception
 //----------------------------------------------------------------------------
 
-bool art_is_exception_pending_from_code() {
+bool art_portable_is_exception_pending_from_code() {
   LOG(FATAL) << "Implemented by IRBuilder.";
   return false;
 }
 
-void art_throw_div_zero_from_code() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
+void art_portable_throw_div_zero_from_code() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
   Thread::Current()->ThrowNewException("Ljava/lang/ArithmeticException;",
                                        "divide by zero");
 }
 
-void art_throw_array_bounds_from_code(int32_t index, int32_t length)
+void art_portable_throw_array_bounds_from_code(int32_t index, int32_t length)
     SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
   Thread::Current()->ThrowNewExceptionF("Ljava/lang/ArrayIndexOutOfBoundsException;",
                                         "length=%d; index=%d", length, index);
 }
 
-void art_throw_no_such_method_from_code(int32_t method_idx)
+void art_portable_throw_no_such_method_from_code(int32_t method_idx)
     SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
   // We need the calling method as context for the method_idx.
   mirror::AbstractMethod* method = Thread::Current()->GetCurrentMethod();
   ThrowNoSuchMethodError(method_idx, method);
 }
 
-void art_throw_null_pointer_exception_from_code(uint32_t dex_pc)
+void art_portable_throw_null_pointer_exception_from_code(uint32_t dex_pc)
     SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
   mirror::AbstractMethod* throw_method =
       Thread::Current()->GetManagedStack()->GetTopShadowFrame()->GetMethod();
   ThrowNullPointerExceptionFromDexPC(throw_method, dex_pc);
 }
 
-void art_throw_stack_overflow_from_code() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
+void art_portable_throw_stack_overflow_from_code() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
   ThrowStackOverflowError(Thread::Current());
 }
 
-void art_throw_exception_from_code(mirror::Object* exception) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
+void art_portable_throw_exception_from_code(mirror::Object* exception) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
   Thread::Current()->DeliverException(static_cast<mirror::Throwable*>(exception));
 }
 
-void* art_get_and_clear_exception(Thread* self)
+void* art_portable_get_and_clear_exception(Thread* self)
     SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
   DCHECK(self->IsExceptionPending());
   mirror::Throwable* exception = self->GetException();
@@ -212,7 +216,7 @@
   return exception;
 }
 
-int32_t art_find_catch_block_from_code(mirror::AbstractMethod* current_method, uint32_t ti_offset)
+int32_t art_portable_find_catch_block_from_code(mirror::AbstractMethod* current_method, uint32_t ti_offset)
     SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
   mirror::Throwable* exception = Thread::Current()->GetException();
   // Check for magic deoptimization exception.
@@ -253,48 +257,48 @@
 // Object Space
 //----------------------------------------------------------------------------
 
-mirror::Object* art_alloc_object_from_code(uint32_t type_idx,
-                                   mirror::AbstractMethod* referrer,
-                                   Thread* thread)
+mirror::Object* art_portable_alloc_object_from_code(uint32_t type_idx,
+                                            mirror::AbstractMethod* referrer,
+                                            Thread* thread)
     SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
   return AllocObjectFromCode(type_idx, referrer, thread, false);
 }
 
-mirror::Object* art_alloc_object_from_code_with_access_check(uint32_t type_idx,
-                                                     mirror::AbstractMethod* referrer,
-                                                     Thread* thread)
+mirror::Object* art_portable_alloc_object_from_code_with_access_check(uint32_t type_idx,
+                                                              mirror::AbstractMethod* referrer,
+                                                              Thread* thread)
     SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
   return AllocObjectFromCode(type_idx, referrer, thread, true);
 }
 
-mirror::Object* art_alloc_array_from_code(uint32_t type_idx,
-                                  mirror::AbstractMethod* referrer,
-                                  uint32_t length,
-                                  Thread* self)
+mirror::Object* art_portable_alloc_array_from_code(uint32_t type_idx,
+                                           mirror::AbstractMethod* referrer,
+                                           uint32_t length,
+                                           Thread* self)
     SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
   return AllocArrayFromCode(type_idx, referrer, length, self, false);
 }
 
-mirror::Object* art_alloc_array_from_code_with_access_check(uint32_t type_idx,
-                                                    mirror::AbstractMethod* referrer,
-                                                    uint32_t length,
-                                                    Thread* self)
+mirror::Object* art_portable_alloc_array_from_code_with_access_check(uint32_t type_idx,
+                                                             mirror::AbstractMethod* referrer,
+                                                             uint32_t length,
+                                                             Thread* self)
     SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
   return AllocArrayFromCode(type_idx, referrer, length, self, true);
 }
 
-mirror::Object* art_check_and_alloc_array_from_code(uint32_t type_idx,
-                                            mirror::AbstractMethod* referrer,
-                                            uint32_t length,
-                                            Thread* thread)
+mirror::Object* art_portable_check_and_alloc_array_from_code(uint32_t type_idx,
+                                                     mirror::AbstractMethod* referrer,
+                                                     uint32_t length,
+                                                     Thread* thread)
     SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
   return CheckAndAllocArrayFromCode(type_idx, referrer, length, thread, false);
 }
 
-mirror::Object* art_check_and_alloc_array_from_code_with_access_check(uint32_t type_idx,
-                                                              mirror::AbstractMethod* referrer,
-                                                              uint32_t length,
-                                                              Thread* thread)
+mirror::Object* art_portable_check_and_alloc_array_from_code_with_access_check(uint32_t type_idx,
+                                                                       mirror::AbstractMethod* referrer,
+                                                                       uint32_t length,
+                                                                       Thread* thread)
     SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
   return CheckAndAllocArrayFromCode(type_idx, referrer, length, thread, true);
 }
@@ -324,84 +328,84 @@
   return method;
 }
 
-mirror::Object* art_find_static_method_from_code_with_access_check(uint32_t method_idx,
-                                                           mirror::Object* this_object,
-                                                           mirror::AbstractMethod* referrer,
-                                                           Thread* thread)
+mirror::Object* art_portable_find_static_method_from_code_with_access_check(uint32_t method_idx,
+                                                                    mirror::Object* this_object,
+                                                                    mirror::AbstractMethod* referrer,
+                                                                    Thread* thread)
     SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
   return FindMethodHelper(method_idx, this_object, referrer, true, kStatic, thread);
 }
 
-mirror::Object* art_find_direct_method_from_code_with_access_check(uint32_t method_idx,
-                                                           mirror::Object* this_object,
-                                                           mirror::AbstractMethod* referrer,
-                                                           Thread* thread)
+mirror::Object* art_portable_find_direct_method_from_code_with_access_check(uint32_t method_idx,
+                                                                    mirror::Object* this_object,
+                                                                    mirror::AbstractMethod* referrer,
+                                                                    Thread* thread)
     SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
   return FindMethodHelper(method_idx, this_object, referrer, true, kDirect, thread);
 }
 
-mirror::Object* art_find_virtual_method_from_code_with_access_check(uint32_t method_idx,
-                                                            mirror::Object* this_object,
-                                                            mirror::AbstractMethod* referrer,
-                                                            Thread* thread)
+mirror::Object* art_portable_find_virtual_method_from_code_with_access_check(uint32_t method_idx,
+                                                                     mirror::Object* this_object,
+                                                                     mirror::AbstractMethod* referrer,
+                                                                     Thread* thread)
     SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
   return FindMethodHelper(method_idx, this_object, referrer, true, kVirtual, thread);
 }
 
-mirror::Object* art_find_super_method_from_code_with_access_check(uint32_t method_idx,
-                                                          mirror::Object* this_object,
-                                                          mirror::AbstractMethod* referrer,
-                                                          Thread* thread)
+mirror::Object* art_portable_find_super_method_from_code_with_access_check(uint32_t method_idx,
+                                                                   mirror::Object* this_object,
+                                                                   mirror::AbstractMethod* referrer,
+                                                                   Thread* thread)
     SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
   return FindMethodHelper(method_idx, this_object, referrer, true, kSuper, thread);
 }
 
 mirror::Object*
-art_find_interface_method_from_code_with_access_check(uint32_t method_idx,
-                                                      mirror::Object* this_object,
-                                                      mirror::AbstractMethod* referrer,
-                                                      Thread* thread)
+art_portable_find_interface_method_from_code_with_access_check(uint32_t method_idx,
+                                                       mirror::Object* this_object,
+                                                       mirror::AbstractMethod* referrer,
+                                                       Thread* thread)
     SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
   return FindMethodHelper(method_idx, this_object, referrer, true, kInterface, thread);
 }
 
-mirror::Object* art_find_interface_method_from_code(uint32_t method_idx,
-                                            mirror::Object* this_object,
-                                            mirror::AbstractMethod* referrer,
-                                            Thread* thread)
+mirror::Object* art_portable_find_interface_method_from_code(uint32_t method_idx,
+                                                     mirror::Object* this_object,
+                                                     mirror::AbstractMethod* referrer,
+                                                     Thread* thread)
     SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
   return FindMethodHelper(method_idx, this_object, referrer, false, kInterface, thread);
 }
 
-mirror::Object* art_initialize_static_storage_from_code(uint32_t type_idx,
-                                                mirror::AbstractMethod* referrer,
-                                                Thread* thread)
+mirror::Object* art_portable_initialize_static_storage_from_code(uint32_t type_idx,
+                                                         mirror::AbstractMethod* referrer,
+                                                         Thread* thread)
     SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
   return ResolveVerifyAndClinit(type_idx, referrer, thread, true, false);
 }
 
-mirror::Object* art_initialize_type_from_code(uint32_t type_idx,
-                                      mirror::AbstractMethod* referrer,
-                                      Thread* thread)
+mirror::Object* art_portable_initialize_type_from_code(uint32_t type_idx,
+                                               mirror::AbstractMethod* referrer,
+                                               Thread* thread)
     SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
   return ResolveVerifyAndClinit(type_idx, referrer, thread, false, false);
 }
 
-mirror::Object* art_initialize_type_and_verify_access_from_code(uint32_t type_idx,
-                                                        mirror::AbstractMethod* referrer,
-                                                        Thread* thread)
+mirror::Object* art_portable_initialize_type_and_verify_access_from_code(uint32_t type_idx,
+                                                                 mirror::AbstractMethod* referrer,
+                                                                 Thread* thread)
     SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
   // Called when caller isn't guaranteed to have access to a type and the dex cache may be
   // unpopulated
   return ResolveVerifyAndClinit(type_idx, referrer, thread, false, true);
 }
 
-mirror::Object* art_resolve_string_from_code(mirror::AbstractMethod* referrer, uint32_t string_idx)
+mirror::Object* art_portable_resolve_string_from_code(mirror::AbstractMethod* referrer, uint32_t string_idx)
     SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
   return ResolveStringFromCode(referrer, string_idx);
 }
 
-int32_t art_set32_static_from_code(uint32_t field_idx, mirror::AbstractMethod* referrer, int32_t new_value)
+int32_t art_portable_set32_static_from_code(uint32_t field_idx, mirror::AbstractMethod* referrer, int32_t new_value)
     SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
   mirror::Field* field = FindFieldFast(field_idx, referrer, StaticPrimitiveWrite, sizeof(uint32_t));
   if (LIKELY(field != NULL)) {
@@ -417,7 +421,7 @@
   return -1;
 }
 
-int32_t art_set64_static_from_code(uint32_t field_idx, mirror::AbstractMethod* referrer, int64_t new_value)
+int32_t art_portable_set64_static_from_code(uint32_t field_idx, mirror::AbstractMethod* referrer, int64_t new_value)
     SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
   mirror::Field* field = FindFieldFast(field_idx, referrer, StaticPrimitiveWrite, sizeof(uint64_t));
   if (LIKELY(field != NULL)) {
@@ -433,7 +437,7 @@
   return -1;
 }
 
-int32_t art_set_obj_static_from_code(uint32_t field_idx, mirror::AbstractMethod* referrer, mirror::Object* new_value)
+int32_t art_portable_set_obj_static_from_code(uint32_t field_idx, mirror::AbstractMethod* referrer, mirror::Object* new_value)
     SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
   mirror::Field* field = FindFieldFast(field_idx, referrer, StaticObjectWrite, sizeof(mirror::Object*));
   if (LIKELY(field != NULL)) {
@@ -449,7 +453,7 @@
   return -1;
 }
 
-int32_t art_get32_static_from_code(uint32_t field_idx, mirror::AbstractMethod* referrer)
+int32_t art_portable_get32_static_from_code(uint32_t field_idx, mirror::AbstractMethod* referrer)
     SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
   mirror::Field* field = FindFieldFast(field_idx, referrer, StaticPrimitiveRead, sizeof(uint32_t));
   if (LIKELY(field != NULL)) {
@@ -463,7 +467,7 @@
   return 0;
 }
 
-int64_t art_get64_static_from_code(uint32_t field_idx, mirror::AbstractMethod* referrer)
+int64_t art_portable_get64_static_from_code(uint32_t field_idx, mirror::AbstractMethod* referrer)
     SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
   mirror::Field* field = FindFieldFast(field_idx, referrer, StaticPrimitiveRead, sizeof(uint64_t));
   if (LIKELY(field != NULL)) {
@@ -477,7 +481,7 @@
   return 0;
 }
 
-mirror::Object* art_get_obj_static_from_code(uint32_t field_idx, mirror::AbstractMethod* referrer)
+mirror::Object* art_portable_get_obj_static_from_code(uint32_t field_idx, mirror::AbstractMethod* referrer)
     SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
   mirror::Field* field = FindFieldFast(field_idx, referrer, StaticObjectRead, sizeof(mirror::Object*));
   if (LIKELY(field != NULL)) {
@@ -491,7 +495,7 @@
   return 0;
 }
 
-int32_t art_set32_instance_from_code(uint32_t field_idx, mirror::AbstractMethod* referrer,
+int32_t art_portable_set32_instance_from_code(uint32_t field_idx, mirror::AbstractMethod* referrer,
                                      mirror::Object* obj, uint32_t new_value)
     SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
   mirror::Field* field = FindFieldFast(field_idx, referrer, InstancePrimitiveWrite, sizeof(uint32_t));
@@ -508,8 +512,8 @@
   return -1;
 }
 
-int32_t art_set64_instance_from_code(uint32_t field_idx, mirror::AbstractMethod* referrer,
-                                     mirror::Object* obj, int64_t new_value)
+int32_t art_portable_set64_instance_from_code(uint32_t field_idx, mirror::AbstractMethod* referrer,
+                                      mirror::Object* obj, int64_t new_value)
     SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
   mirror::Field* field = FindFieldFast(field_idx, referrer, InstancePrimitiveWrite, sizeof(uint64_t));
   if (LIKELY(field != NULL)) {
@@ -525,8 +529,8 @@
   return -1;
 }
 
-int32_t art_set_obj_instance_from_code(uint32_t field_idx, mirror::AbstractMethod* referrer,
-                                       mirror::Object* obj, mirror::Object* new_value)
+int32_t art_portable_set_obj_instance_from_code(uint32_t field_idx, mirror::AbstractMethod* referrer,
+                                        mirror::Object* obj, mirror::Object* new_value)
     SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
   mirror::Field* field = FindFieldFast(field_idx, referrer, InstanceObjectWrite, sizeof(mirror::Object*));
   if (LIKELY(field != NULL)) {
@@ -542,7 +546,7 @@
   return -1;
 }
 
-int32_t art_get32_instance_from_code(uint32_t field_idx, mirror::AbstractMethod* referrer, mirror::Object* obj)
+int32_t art_portable_get32_instance_from_code(uint32_t field_idx, mirror::AbstractMethod* referrer, mirror::Object* obj)
     SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
   mirror::Field* field = FindFieldFast(field_idx, referrer, InstancePrimitiveRead, sizeof(uint32_t));
   if (LIKELY(field != NULL)) {
@@ -556,7 +560,7 @@
   return 0;
 }
 
-int64_t art_get64_instance_from_code(uint32_t field_idx, mirror::AbstractMethod* referrer, mirror::Object* obj)
+int64_t art_portable_get64_instance_from_code(uint32_t field_idx, mirror::AbstractMethod* referrer, mirror::Object* obj)
     SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
   mirror::Field* field = FindFieldFast(field_idx, referrer, InstancePrimitiveRead, sizeof(uint64_t));
   if (LIKELY(field != NULL)) {
@@ -570,7 +574,7 @@
   return 0;
 }
 
-mirror::Object* art_get_obj_instance_from_code(uint32_t field_idx, mirror::AbstractMethod* referrer, mirror::Object* obj)
+mirror::Object* art_portable_get_obj_instance_from_code(uint32_t field_idx, mirror::AbstractMethod* referrer, mirror::Object* obj)
     SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
   mirror::Field* field = FindFieldFast(field_idx, referrer, InstanceObjectRead, sizeof(mirror::Object*));
   if (LIKELY(field != NULL)) {
@@ -584,12 +588,12 @@
   return 0;
 }
 
-void art_fill_array_data_from_code(mirror::AbstractMethod* method, uint32_t dex_pc,
-                                   mirror::Array* array, uint32_t payload_offset)
+void art_portable_fill_array_data_from_code(mirror::AbstractMethod* method, uint32_t dex_pc,
+                                    mirror::Array* array, uint32_t payload_offset)
     SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
   // Test: Is array equal to null? (Guard NullPointerException)
   if (UNLIKELY(array == NULL)) {
-    art_throw_null_pointer_exception_from_code(dex_pc);
+    art_portable_throw_null_pointer_exception_from_code(dex_pc);
     return;
   }
 
@@ -610,7 +614,7 @@
   uint32_t array_len = static_cast<uint32_t>(array->GetLength());
   if (UNLIKELY(array_len < payload->element_count)) {
     int32_t last_index = payload->element_count - 1;
-    art_throw_array_bounds_from_code(array_len, last_index);
+    art_portable_throw_array_bounds_from_code(array_len, last_index);
     return;
   }
 
@@ -625,14 +629,14 @@
 // Type checking, in the nature of casting
 //----------------------------------------------------------------------------
 
-int32_t art_is_assignable_from_code(const mirror::Class* dest_type, const mirror::Class* src_type)
+int32_t art_portable_is_assignable_from_code(const mirror::Class* dest_type, const mirror::Class* src_type)
     SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
   DCHECK(dest_type != NULL);
   DCHECK(src_type != NULL);
   return dest_type->IsAssignableFrom(src_type) ? 1 : 0;
 }
 
-void art_check_cast_from_code(const mirror::Class* dest_type, const mirror::Class* src_type)
+void art_portable_check_cast_from_code(const mirror::Class* dest_type, const mirror::Class* src_type)
     SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
   DCHECK(dest_type->IsClass()) << PrettyClass(dest_type);
   DCHECK(src_type->IsClass()) << PrettyClass(src_type);
@@ -644,7 +648,7 @@
   }
 }
 
-void art_check_put_array_element_from_code(const mirror::Object* element, const mirror::Object* array)
+void art_portable_check_put_array_element_from_code(const mirror::Object* element, const mirror::Object* array)
     SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
   if (element == NULL) {
     return;
@@ -668,7 +672,7 @@
 //----------------------------------------------------------------------------
 
 // Called on entry to JNI, transition out of Runnable and release share of mutator_lock_.
-uint32_t art_jni_method_start(Thread* self)
+uint32_t art_portable_jni_method_start(Thread* self)
     UNLOCK_FUNCTION(GlobalSynchronizatio::mutator_lock_) {
   JNIEnvExt* env = self->GetJniEnv();
   uint32_t saved_local_ref_cookie = env->local_ref_cookie;
@@ -677,10 +681,10 @@
   return saved_local_ref_cookie;
 }
 
-uint32_t art_jni_method_start_synchronized(jobject to_lock, Thread* self)
+uint32_t art_portable_jni_method_start_synchronized(jobject to_lock, Thread* self)
     UNLOCK_FUNCTION(Locks::mutator_lock_) {
   self->DecodeJObject(to_lock)->MonitorEnter(self);
-  return art_jni_method_start(self);
+  return art_portable_jni_method_start(self);
 }
 
 static inline void PopLocalReferences(uint32_t saved_local_ref_cookie, Thread* self) {
@@ -689,23 +693,24 @@
   env->local_ref_cookie = saved_local_ref_cookie;
 }
 
-void art_jni_method_end(uint32_t saved_local_ref_cookie, Thread* self)
+void art_portable_jni_method_end(uint32_t saved_local_ref_cookie, Thread* self)
     SHARED_LOCK_FUNCTION(Locks::mutator_lock_) {
   self->TransitionFromSuspendedToRunnable();
   PopLocalReferences(saved_local_ref_cookie, self);
 }
 
 
-void art_jni_method_end_synchronized(uint32_t saved_local_ref_cookie, jobject locked,
-                                     Thread* self)
+void art_portable_jni_method_end_synchronized(uint32_t saved_local_ref_cookie,
+                                      jobject locked,
+                                      Thread* self)
     SHARED_LOCK_FUNCTION(Locks::mutator_lock_) {
   self->TransitionFromSuspendedToRunnable();
   UnlockJniSynchronizedMethod(locked, self);  // Must decode before pop.
   PopLocalReferences(saved_local_ref_cookie, self);
 }
 
-mirror::Object* art_jni_method_end_with_reference(jobject result, uint32_t saved_local_ref_cookie,
-                                          Thread* self)
+mirror::Object* art_portable_jni_method_end_with_reference(jobject result, uint32_t saved_local_ref_cookie,
+                                                   Thread* self)
     SHARED_LOCK_FUNCTION(Locks::mutator_lock_) {
   self->TransitionFromSuspendedToRunnable();
   mirror::Object* o = self->DecodeJObject(result);  // Must decode before pop.
@@ -720,9 +725,9 @@
   return o;
 }
 
-mirror::Object* art_jni_method_end_with_reference_synchronized(jobject result,
-                                                       uint32_t saved_local_ref_cookie,
-                                                       jobject locked, Thread* self)
+mirror::Object* art_portable_jni_method_end_with_reference_synchronized(jobject result,
+                                                                uint32_t saved_local_ref_cookie,
+                                                                jobject locked, Thread* self)
     SHARED_LOCK_FUNCTION(Locks::mutator_lock_) {
   self->TransitionFromSuspendedToRunnable();
   UnlockJniSynchronizedMethod(locked, self);  // Must decode before pop.
@@ -747,8 +752,8 @@
 COMPILER_RUNTIME_FUNC_LIST_NATIVE(EXTERNAL_LINKAGE)
 #undef EXTERNAL_LINKAGE
 
-static void* art_find_compiler_runtime_func(const char* name) {
-// TODO: If target support some math func, use the target's version. (e.g. art_d2i -> __aeabi_d2iz)
+static void* art_portable_find_compiler_runtime_func(const char* name) {
+// TODO: If target support some math func, use the target's version. (e.g. art_portable_d2i -> __aeabi_d2iz)
   static const char* const names[] = {
 #define DEFINE_ENTRY(NAME, RETURN_TYPE, ...) #NAME ,
     COMPILER_RUNTIME_FUNC_LIST_NATIVE(DEFINE_ENTRY)
@@ -781,7 +786,7 @@
 // Handler for invocation on proxy methods. Create a boxed argument array and invoke the invocation
 // handler which is a field within the proxy object receiver. The var args encode the arguments
 // with the last argument being a pointer to a JValue to store the result in.
-void art_proxy_invoke_handler_from_code(mirror::AbstractMethod* proxy_method, ...)
+void art_portable_proxy_invoke_handler_from_code(mirror::AbstractMethod* proxy_method, ...)
     SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
   va_list ap;
   va_start(ap, proxy_method);
@@ -855,7 +860,7 @@
   }
 }
 
-void* art_find_runtime_support_func(void* context, const char* name) {
+void* art_portable_find_runtime_support_func(void* context, const char* name) {
   struct func_entry_t {
     const char* name;
     size_t name_len;
@@ -872,7 +877,7 @@
   static size_t const tab_size = sizeof(tab) / sizeof(struct func_entry_t);
 
   // Search the compiler runtime (such as __divdi3)
-  void* result = art_find_compiler_runtime_func(name);
+  void* result = art_portable_find_compiler_runtime_func(name);
   if (result != NULL) {
     return result;
   }
@@ -892,4 +897,4 @@
   return 0;
 }
 
-}  // namespace art
+}  // extern "C"
diff --git a/src/compiler_llvm/runtime_support_llvm.h b/src/compiler_llvm/runtime_support_llvm.h
index bb0473b..af99842 100644
--- a/src/compiler_llvm/runtime_support_llvm.h
+++ b/src/compiler_llvm/runtime_support_llvm.h
@@ -17,59 +17,14 @@
 #ifndef ART_SRC_COMPILER_LLVM_RUNTIME_SUPPORT_LLVM_H_
 #define ART_SRC_COMPILER_LLVM_RUNTIME_SUPPORT_LLVM_H_
 
-#include <stdint.h>
-
-namespace art {
-namespace mirror {
-class AbstractMethod;
-class Object;
-}  // namespace mirror
-
-class ShadowFrame;
-class Thread;
-
-//----------------------------------------------------------------------------
-// Thread
-//----------------------------------------------------------------------------
-
-ShadowFrame* art_push_shadow_frame_from_code(Thread* thread, ShadowFrame* new_shadow_frame,
-                                             mirror::AbstractMethod* method, uint32_t num_vregs);
-
-void art_pop_shadow_frame_from_code(void*);
-
-
-//----------------------------------------------------------------------------
-// Exception
-//----------------------------------------------------------------------------
-
-bool art_is_exception_pending_from_code();
-
-void art_throw_div_zero_from_code();
-
-void art_throw_array_bounds_from_code(int32_t length, int32_t index);
-
-void art_throw_no_such_method_from_code(int32_t method_idx);
-
-void art_throw_null_pointer_exception_from_code(uint32_t dex_pc);
-
-void art_throw_stack_overflow_from_code();
-
-void art_throw_exception_from_code(mirror::Object* exception);
-
-int32_t art_find_catch_block_from_code(mirror::AbstractMethod* current_method,
-                                       uint32_t ti_offset);
-
-
-void art_test_suspend_from_code(Thread* thread);
-
-void* art_set_current_thread_from_code(void* thread_object_addr);
+extern "C" {
 
 //----------------------------------------------------------------------------
 // Runtime Support Function Lookup Callback
 //----------------------------------------------------------------------------
 
-void* art_find_runtime_support_func(void* context, const char* name);
+void* art_portable_find_runtime_support_func(void* context, const char* name);
 
-}  // namespace art
+}  // extern "C"
 
 #endif  // ART_SRC_COMPILER_LLVM_RUNTIME_SUPPORT_LLVM_H_
diff --git a/src/oat/runtime/arm/context_arm.cc b/src/oat/runtime/arm/context_arm.cc
index 2e76050..4612986 100644
--- a/src/oat/runtime/arm/context_arm.cc
+++ b/src/oat/runtime/arm/context_arm.cc
@@ -83,7 +83,7 @@
   gprs_[R3] = NULL;
 }
 
-extern "C" void art_do_long_jump(uint32_t*, uint32_t*);
+extern "C" void art_quick_do_long_jump(uint32_t*, uint32_t*);
 
 void ArmContext::DoLongJump() {
   uintptr_t gprs[16];
@@ -95,7 +95,7 @@
     fprs[i] = fprs_[i] != NULL ? *fprs_[i] : ArmContext::kBadGprBase + i;
   }
   DCHECK_EQ(reinterpret_cast<uintptr_t>(Thread::Current()), gprs[TR]);
-  art_do_long_jump(gprs, fprs);
+  art_quick_do_long_jump(gprs, fprs);
 }
 
 }  // namespace arm
diff --git a/src/oat/runtime/arm/oat_support_entrypoints_arm.cc b/src/oat/runtime/arm/oat_support_entrypoints_arm.cc
index dea2600..58341bf 100644
--- a/src/oat/runtime/arm/oat_support_entrypoints_arm.cc
+++ b/src/oat/runtime/arm/oat_support_entrypoints_arm.cc
@@ -20,52 +20,52 @@
 namespace art {
 
 // Alloc entrypoints.
-extern "C" void* art_alloc_array_from_code(uint32_t, void*, int32_t);
-extern "C" void* art_alloc_array_from_code_with_access_check(uint32_t, void*, int32_t);
-extern "C" void* art_alloc_object_from_code(uint32_t type_idx, void* method);
-extern "C" void* art_alloc_object_from_code_with_access_check(uint32_t type_idx, void* method);
-extern "C" void* art_check_and_alloc_array_from_code(uint32_t, void*, int32_t);
-extern "C" void* art_check_and_alloc_array_from_code_with_access_check(uint32_t, void*, int32_t);
+extern "C" void* art_quick_alloc_array_from_code(uint32_t, void*, int32_t);
+extern "C" void* art_quick_alloc_array_from_code_with_access_check(uint32_t, void*, int32_t);
+extern "C" void* art_quick_alloc_object_from_code(uint32_t type_idx, void* method);
+extern "C" void* art_quick_alloc_object_from_code_with_access_check(uint32_t type_idx, void* method);
+extern "C" void* art_quick_check_and_alloc_array_from_code(uint32_t, void*, int32_t);
+extern "C" void* art_quick_check_and_alloc_array_from_code_with_access_check(uint32_t, void*, int32_t);
 
 // Cast entrypoints.
 extern "C" uint32_t artIsAssignableFromCode(const mirror::Class* klass,
                                             const mirror::Class* ref_class);
-extern "C" void art_can_put_array_element_from_code(void*, void*);
-extern "C" void art_check_cast_from_code(void*, void*);
+extern "C" void art_quick_can_put_array_element_from_code(void*, void*);
+extern "C" void art_quick_check_cast_from_code(void*, void*);
 
 // Debug entrypoints.
 extern void DebugMe(mirror::AbstractMethod* method, uint32_t info);
-extern "C" void art_update_debugger(void*, void*, int32_t, void*);
+extern "C" void art_quick_update_debugger(void*, void*, int32_t, void*);
 
 // DexCache entrypoints.
-extern "C" void* art_initialize_static_storage_from_code(uint32_t, void*);
-extern "C" void* art_initialize_type_from_code(uint32_t, void*);
-extern "C" void* art_initialize_type_and_verify_access_from_code(uint32_t, void*);
-extern "C" void* art_resolve_string_from_code(void*, uint32_t);
+extern "C" void* art_quick_initialize_static_storage_from_code(uint32_t, void*);
+extern "C" void* art_quick_initialize_type_from_code(uint32_t, void*);
+extern "C" void* art_quick_initialize_type_and_verify_access_from_code(uint32_t, void*);
+extern "C" void* art_quick_resolve_string_from_code(void*, uint32_t);
 
 // Exception entrypoints.
 extern "C" void* GetAndClearException(Thread*);
 
 // Field entrypoints.
-extern "C" int art_set32_instance_from_code(uint32_t, void*, int32_t);
-extern "C" int art_set32_static_from_code(uint32_t, int32_t);
-extern "C" int art_set64_instance_from_code(uint32_t, void*, int64_t);
-extern "C" int art_set64_static_from_code(uint32_t, int64_t);
-extern "C" int art_set_obj_instance_from_code(uint32_t, void*, void*);
-extern "C" int art_set_obj_static_from_code(uint32_t, void*);
-extern "C" int32_t art_get32_instance_from_code(uint32_t, void*);
-extern "C" int32_t art_get32_static_from_code(uint32_t);
-extern "C" int64_t art_get64_instance_from_code(uint32_t, void*);
-extern "C" int64_t art_get64_static_from_code(uint32_t);
-extern "C" void* art_get_obj_instance_from_code(uint32_t, void*);
-extern "C" void* art_get_obj_static_from_code(uint32_t);
+extern "C" int art_quick_set32_instance_from_code(uint32_t, void*, int32_t);
+extern "C" int art_quick_set32_static_from_code(uint32_t, int32_t);
+extern "C" int art_quick_set64_instance_from_code(uint32_t, void*, int64_t);
+extern "C" int art_quick_set64_static_from_code(uint32_t, int64_t);
+extern "C" int art_quick_set_obj_instance_from_code(uint32_t, void*, void*);
+extern "C" int art_quick_set_obj_static_from_code(uint32_t, void*);
+extern "C" int32_t art_quick_get32_instance_from_code(uint32_t, void*);
+extern "C" int32_t art_quick_get32_static_from_code(uint32_t);
+extern "C" int64_t art_quick_get64_instance_from_code(uint32_t, void*);
+extern "C" int64_t art_quick_get64_static_from_code(uint32_t);
+extern "C" void* art_quick_get_obj_instance_from_code(uint32_t, void*);
+extern "C" void* art_quick_get_obj_static_from_code(uint32_t);
 
 // FillArray entrypoint.
-extern "C" void art_handle_fill_data_from_code(void*, void*);
+extern "C" void art_quick_handle_fill_data_from_code(void*, void*);
 
 // Lock entrypoints.
-extern "C" void art_lock_object_from_code(void*);
-extern "C" void art_unlock_object_from_code(void*);
+extern "C" void art_quick_lock_object_from_code(void*);
+extern "C" void art_quick_unlock_object_from_code(void*);
 
 // Math entrypoints.
 extern int32_t CmpgDouble(double a, double b);
@@ -90,87 +90,87 @@
 
 // Long long arithmetics - REM_LONG[_2ADDR] and DIV_LONG[_2ADDR]
 extern "C" int64_t __aeabi_ldivmod(int64_t, int64_t);
-extern "C" int64_t art_mul_long(int64_t, int64_t);
-extern "C" uint64_t art_shl_long(uint64_t, uint32_t);
-extern "C" uint64_t art_shr_long(uint64_t, uint32_t);
-extern "C" uint64_t art_ushr_long(uint64_t, uint32_t);
+extern "C" int64_t art_quick_mul_long(int64_t, int64_t);
+extern "C" uint64_t art_quick_shl_long(uint64_t, uint32_t);
+extern "C" uint64_t art_quick_shr_long(uint64_t, uint32_t);
+extern "C" uint64_t art_quick_ushr_long(uint64_t, uint32_t);
 
 // Intrinsic entrypoints.
 extern "C" int32_t __memcmp16(void*, void*, int32_t);
-extern "C" int32_t art_indexof(void*, uint32_t, uint32_t, uint32_t);
-extern "C" int32_t art_string_compareto(void*, void*);
+extern "C" int32_t art_quick_indexof(void*, uint32_t, uint32_t, uint32_t);
+extern "C" int32_t art_quick_string_compareto(void*, void*);
 
 // Invoke entrypoints.
 const void* UnresolvedDirectMethodTrampolineFromCode(mirror::AbstractMethod*,
                                                      mirror::AbstractMethod**, Thread*,
                                                      Runtime::TrampolineType);
-extern "C" void art_invoke_direct_trampoline_with_access_check(uint32_t, void*);
-extern "C" void art_invoke_interface_trampoline(uint32_t, void*);
-extern "C" void art_invoke_interface_trampoline_with_access_check(uint32_t, void*);
-extern "C" void art_invoke_static_trampoline_with_access_check(uint32_t, void*);
-extern "C" void art_invoke_super_trampoline_with_access_check(uint32_t, void*);
-extern "C" void art_invoke_virtual_trampoline_with_access_check(uint32_t, void*);
+extern "C" void art_quick_invoke_direct_trampoline_with_access_check(uint32_t, void*);
+extern "C" void art_quick_invoke_interface_trampoline(uint32_t, void*);
+extern "C" void art_quick_invoke_interface_trampoline_with_access_check(uint32_t, void*);
+extern "C" void art_quick_invoke_static_trampoline_with_access_check(uint32_t, void*);
+extern "C" void art_quick_invoke_super_trampoline_with_access_check(uint32_t, void*);
+extern "C" void art_quick_invoke_virtual_trampoline_with_access_check(uint32_t, void*);
 
 // Thread entrypoints.
 extern void CheckSuspendFromCode(Thread* thread);
-extern "C" void art_test_suspend();
+extern "C" void art_quick_test_suspend();
 
 // Throw entrypoints.
 extern void ThrowAbstractMethodErrorFromCode(mirror::AbstractMethod* method, Thread* thread,
                                              mirror::AbstractMethod** sp);
-extern "C" void art_deliver_exception_from_code(void*);
-extern "C" void art_throw_array_bounds_from_code(int32_t index, int32_t limit);
-extern "C" void art_throw_div_zero_from_code();
-extern "C" void art_throw_no_such_method_from_code(int32_t method_idx);
-extern "C" void art_throw_null_pointer_exception_from_code();
-extern "C" void art_throw_stack_overflow_from_code(void*);
+extern "C" void art_quick_deliver_exception_from_code(void*);
+extern "C" void art_quick_throw_array_bounds_from_code(int32_t index, int32_t limit);
+extern "C" void art_quick_throw_div_zero_from_code();
+extern "C" void art_quick_throw_no_such_method_from_code(int32_t method_idx);
+extern "C" void art_quick_throw_null_pointer_exception_from_code();
+extern "C" void art_quick_throw_stack_overflow_from_code(void*);
 
 // Instrumentation entrypoints.
-extern "C" void art_instrumentation_entry_from_code(void*);
-extern "C" void art_instrumentation_exit_from_code();
-extern "C" void art_interpreter_entry(void*);
-extern "C" void art_deoptimize();
+extern "C" void art_quick_instrumentation_entry_from_code(void*);
+extern "C" void art_quick_instrumentation_exit_from_code();
+extern "C" void art_quick_interpreter_entry(void*);
+extern "C" void art_quick_deoptimize();
 
 void InitEntryPoints(EntryPoints* points) {
   // Alloc
-  points->pAllocArrayFromCode = art_alloc_array_from_code;
-  points->pAllocArrayFromCodeWithAccessCheck = art_alloc_array_from_code_with_access_check;
-  points->pAllocObjectFromCode = art_alloc_object_from_code;
-  points->pAllocObjectFromCodeWithAccessCheck = art_alloc_object_from_code_with_access_check;
-  points->pCheckAndAllocArrayFromCode = art_check_and_alloc_array_from_code;
-  points->pCheckAndAllocArrayFromCodeWithAccessCheck = art_check_and_alloc_array_from_code_with_access_check;
+  points->pAllocArrayFromCode = art_quick_alloc_array_from_code;
+  points->pAllocArrayFromCodeWithAccessCheck = art_quick_alloc_array_from_code_with_access_check;
+  points->pAllocObjectFromCode = art_quick_alloc_object_from_code;
+  points->pAllocObjectFromCodeWithAccessCheck = art_quick_alloc_object_from_code_with_access_check;
+  points->pCheckAndAllocArrayFromCode = art_quick_check_and_alloc_array_from_code;
+  points->pCheckAndAllocArrayFromCodeWithAccessCheck = art_quick_check_and_alloc_array_from_code_with_access_check;
 
   // Cast
   points->pInstanceofNonTrivialFromCode = artIsAssignableFromCode;
-  points->pCanPutArrayElementFromCode = art_can_put_array_element_from_code;
-  points->pCheckCastFromCode = art_check_cast_from_code;
+  points->pCanPutArrayElementFromCode = art_quick_can_put_array_element_from_code;
+  points->pCheckCastFromCode = art_quick_check_cast_from_code;
 
   // Debug
   points->pDebugMe = DebugMe;
   points->pUpdateDebuggerFromCode = NULL; // Controlled by SetDebuggerUpdatesEnabled.
 
   // DexCache
-  points->pInitializeStaticStorage = art_initialize_static_storage_from_code;
-  points->pInitializeTypeAndVerifyAccessFromCode = art_initialize_type_and_verify_access_from_code;
-  points->pInitializeTypeFromCode = art_initialize_type_from_code;
-  points->pResolveStringFromCode = art_resolve_string_from_code;
+  points->pInitializeStaticStorage = art_quick_initialize_static_storage_from_code;
+  points->pInitializeTypeAndVerifyAccessFromCode = art_quick_initialize_type_and_verify_access_from_code;
+  points->pInitializeTypeFromCode = art_quick_initialize_type_from_code;
+  points->pResolveStringFromCode = art_quick_resolve_string_from_code;
 
   // Field
-  points->pSet32Instance = art_set32_instance_from_code;
-  points->pSet32Static = art_set32_static_from_code;
-  points->pSet64Instance = art_set64_instance_from_code;
-  points->pSet64Static = art_set64_static_from_code;
-  points->pSetObjInstance = art_set_obj_instance_from_code;
-  points->pSetObjStatic = art_set_obj_static_from_code;
-  points->pGet32Instance = art_get32_instance_from_code;
-  points->pGet64Instance = art_get64_instance_from_code;
-  points->pGetObjInstance = art_get_obj_instance_from_code;
-  points->pGet32Static = art_get32_static_from_code;
-  points->pGet64Static = art_get64_static_from_code;
-  points->pGetObjStatic = art_get_obj_static_from_code;
+  points->pSet32Instance = art_quick_set32_instance_from_code;
+  points->pSet32Static = art_quick_set32_static_from_code;
+  points->pSet64Instance = art_quick_set64_instance_from_code;
+  points->pSet64Static = art_quick_set64_static_from_code;
+  points->pSetObjInstance = art_quick_set_obj_instance_from_code;
+  points->pSetObjStatic = art_quick_set_obj_static_from_code;
+  points->pGet32Instance = art_quick_get32_instance_from_code;
+  points->pGet64Instance = art_quick_get64_instance_from_code;
+  points->pGetObjInstance = art_quick_get_obj_instance_from_code;
+  points->pGet32Static = art_quick_get32_static_from_code;
+  points->pGet64Static = art_quick_get64_static_from_code;
+  points->pGetObjStatic = art_quick_get_obj_static_from_code;
 
   // FillArray
-  points->pHandleFillArrayDataFromCode = art_handle_fill_data_from_code;
+  points->pHandleFillArrayDataFromCode = art_quick_handle_fill_data_from_code;
 
   // JNI
   points->pFindNativeMethod = FindNativeMethod;
@@ -182,8 +182,8 @@
   points->pJniMethodEndWithReferenceSynchronized = JniMethodEndWithReferenceSynchronized;
 
   // Locks
-  points->pLockObjectFromCode = art_lock_object_from_code;
-  points->pUnlockObjectFromCode = art_unlock_object_from_code;
+  points->pLockObjectFromCode = art_quick_lock_object_from_code;
+  points->pUnlockObjectFromCode = art_quick_unlock_object_from_code;
 
   // Math
   points->pCmpgDouble = CmpgDouble;
@@ -202,58 +202,58 @@
   points->pF2l = art_f2l;
   points->pLdiv = __aeabi_ldivmod;
   points->pLdivmod = __aeabi_ldivmod;  // result returned in r2:r3
-  points->pLmul = art_mul_long;
-  points->pShlLong = art_shl_long;
-  points->pShrLong = art_shr_long;
-  points->pUshrLong = art_ushr_long;
+  points->pLmul = art_quick_mul_long;
+  points->pShlLong = art_quick_shl_long;
+  points->pShrLong = art_quick_shr_long;
+  points->pUshrLong = art_quick_ushr_long;
 
   // Intrinsics
-  points->pIndexOf = art_indexof;
+  points->pIndexOf = art_quick_indexof;
   points->pMemcmp16 = __memcmp16;
-  points->pStringCompareTo = art_string_compareto;
+  points->pStringCompareTo = art_quick_string_compareto;
   points->pMemcpy = memcpy;
 
   // Invocation
   points->pUnresolvedDirectMethodTrampolineFromCode = UnresolvedDirectMethodTrampolineFromCode;
-  points->pInvokeDirectTrampolineWithAccessCheck = art_invoke_direct_trampoline_with_access_check;
-  points->pInvokeInterfaceTrampoline = art_invoke_interface_trampoline;
-  points->pInvokeInterfaceTrampolineWithAccessCheck = art_invoke_interface_trampoline_with_access_check;
-  points->pInvokeStaticTrampolineWithAccessCheck = art_invoke_static_trampoline_with_access_check;
-  points->pInvokeSuperTrampolineWithAccessCheck = art_invoke_super_trampoline_with_access_check;
-  points->pInvokeVirtualTrampolineWithAccessCheck = art_invoke_virtual_trampoline_with_access_check;
+  points->pInvokeDirectTrampolineWithAccessCheck = art_quick_invoke_direct_trampoline_with_access_check;
+  points->pInvokeInterfaceTrampoline = art_quick_invoke_interface_trampoline;
+  points->pInvokeInterfaceTrampolineWithAccessCheck = art_quick_invoke_interface_trampoline_with_access_check;
+  points->pInvokeStaticTrampolineWithAccessCheck = art_quick_invoke_static_trampoline_with_access_check;
+  points->pInvokeSuperTrampolineWithAccessCheck = art_quick_invoke_super_trampoline_with_access_check;
+  points->pInvokeVirtualTrampolineWithAccessCheck = art_quick_invoke_virtual_trampoline_with_access_check;
 
   // Thread
   points->pCheckSuspendFromCode = CheckSuspendFromCode;
-  points->pTestSuspendFromCode = art_test_suspend;
+  points->pTestSuspendFromCode = art_quick_test_suspend;
 
   // Throws
-  points->pDeliverException = art_deliver_exception_from_code;
+  points->pDeliverException = art_quick_deliver_exception_from_code;
   points->pThrowAbstractMethodErrorFromCode = ThrowAbstractMethodErrorFromCode;
-  points->pThrowArrayBoundsFromCode = art_throw_array_bounds_from_code;
-  points->pThrowDivZeroFromCode = art_throw_div_zero_from_code;
-  points->pThrowNoSuchMethodFromCode = art_throw_no_such_method_from_code;
-  points->pThrowNullPointerFromCode = art_throw_null_pointer_exception_from_code;
-  points->pThrowStackOverflowFromCode = art_throw_stack_overflow_from_code;
+  points->pThrowArrayBoundsFromCode = art_quick_throw_array_bounds_from_code;
+  points->pThrowDivZeroFromCode = art_quick_throw_div_zero_from_code;
+  points->pThrowNoSuchMethodFromCode = art_quick_throw_no_such_method_from_code;
+  points->pThrowNullPointerFromCode = art_quick_throw_null_pointer_exception_from_code;
+  points->pThrowStackOverflowFromCode = art_quick_throw_stack_overflow_from_code;
 };
 
 void ChangeDebuggerEntryPoint(EntryPoints* points, bool enabled) {
-  points->pUpdateDebuggerFromCode = (enabled ? art_update_debugger : NULL);
+  points->pUpdateDebuggerFromCode = (enabled ? art_quick_update_debugger : NULL);
 }
 
 uintptr_t GetInstrumentationExitPc() {
-  return reinterpret_cast<uintptr_t>(art_instrumentation_exit_from_code);
+  return reinterpret_cast<uintptr_t>(art_quick_instrumentation_exit_from_code);
 }
 
 uintptr_t GetDeoptimizationEntryPoint() {
-  return reinterpret_cast<uintptr_t>(art_deoptimize);
+  return reinterpret_cast<uintptr_t>(art_quick_deoptimize);
 }
 
 void* GetInstrumentationEntryPoint() {
-  return reinterpret_cast<void*>(art_instrumentation_entry_from_code);
+  return reinterpret_cast<void*>(art_quick_instrumentation_entry_from_code);
 }
 
 void* GetInterpreterEntryPoint() {
-  return reinterpret_cast<void*>(art_interpreter_entry);
+  return reinterpret_cast<void*>(art_quick_interpreter_entry);
 }
 
 }  // namespace art
diff --git a/src/oat/runtime/arm/runtime_support_arm.S b/src/oat/runtime/arm/runtime_support_arm.S
index 75039cf..5d2f1c8 100644
--- a/src/oat/runtime/arm/runtime_support_arm.S
+++ b/src/oat/runtime/arm/runtime_support_arm.S
@@ -120,33 +120,33 @@
      * Called by managed code, saves callee saves and then calls artThrowException
      * that will place a mock Method* at the bottom of the stack. Arg1 holds the exception.
      */
-ONE_ARG_RUNTIME_EXCEPTION art_deliver_exception_from_code, artDeliverExceptionFromCode
+ONE_ARG_RUNTIME_EXCEPTION art_quick_deliver_exception_from_code, artDeliverExceptionFromCode
 
     /*
      * Called by managed code to create and deliver a NullPointerException.
      */
-NO_ARG_RUNTIME_EXCEPTION art_throw_null_pointer_exception_from_code, artThrowNullPointerExceptionFromCode
+NO_ARG_RUNTIME_EXCEPTION art_quick_throw_null_pointer_exception_from_code, artThrowNullPointerExceptionFromCode
 
     /*
      * Called by managed code to create and deliver an ArithmeticException.
      */
-NO_ARG_RUNTIME_EXCEPTION art_throw_div_zero_from_code, artThrowDivZeroFromCode
+NO_ARG_RUNTIME_EXCEPTION art_quick_throw_div_zero_from_code, artThrowDivZeroFromCode
 
     /*
      * Called by managed code to create and deliver an ArrayIndexOutOfBoundsException. Arg1 holds
      * index, arg2 holds limit.
      */
-TWO_ARG_RUNTIME_EXCEPTION art_throw_array_bounds_from_code, artThrowArrayBoundsFromCode
+TWO_ARG_RUNTIME_EXCEPTION art_quick_throw_array_bounds_from_code, artThrowArrayBoundsFromCode
 
     /*
      * Called by managed code to create and deliver a StackOverflowError.
      */
-NO_ARG_RUNTIME_EXCEPTION art_throw_stack_overflow_from_code, artThrowStackOverflowFromCode
+NO_ARG_RUNTIME_EXCEPTION art_quick_throw_stack_overflow_from_code, artThrowStackOverflowFromCode
 
     /*
      * Called by managed code to create and deliver a NoSuchMethodError.
      */
-ONE_ARG_RUNTIME_EXCEPTION art_throw_no_such_method_from_code, artThrowNoSuchMethodFromCode
+ONE_ARG_RUNTIME_EXCEPTION art_quick_throw_no_such_method_from_code, artThrowNoSuchMethodFromCode
 
     /*
      * All generated callsites for interface invokes and invocation slow paths will load arguments
@@ -183,21 +183,21 @@
     DELIVER_PENDING_EXCEPTION
 .endm
 
-INVOKE_TRAMPOLINE art_invoke_interface_trampoline, artInvokeInterfaceTrampoline
-INVOKE_TRAMPOLINE art_invoke_interface_trampoline_with_access_check, artInvokeInterfaceTrampolineWithAccessCheck
+INVOKE_TRAMPOLINE art_quick_invoke_interface_trampoline, artInvokeInterfaceTrampoline
+INVOKE_TRAMPOLINE art_quick_invoke_interface_trampoline_with_access_check, artInvokeInterfaceTrampolineWithAccessCheck
 
-INVOKE_TRAMPOLINE art_invoke_static_trampoline_with_access_check, artInvokeStaticTrampolineWithAccessCheck
-INVOKE_TRAMPOLINE art_invoke_direct_trampoline_with_access_check, artInvokeDirectTrampolineWithAccessCheck
-INVOKE_TRAMPOLINE art_invoke_super_trampoline_with_access_check, artInvokeSuperTrampolineWithAccessCheck
-INVOKE_TRAMPOLINE art_invoke_virtual_trampoline_with_access_check, artInvokeVirtualTrampolineWithAccessCheck
+INVOKE_TRAMPOLINE art_quick_invoke_static_trampoline_with_access_check, artInvokeStaticTrampolineWithAccessCheck
+INVOKE_TRAMPOLINE art_quick_invoke_direct_trampoline_with_access_check, artInvokeDirectTrampolineWithAccessCheck
+INVOKE_TRAMPOLINE art_quick_invoke_super_trampoline_with_access_check, artInvokeSuperTrampolineWithAccessCheck
+INVOKE_TRAMPOLINE art_quick_invoke_virtual_trampoline_with_access_check, artInvokeVirtualTrampolineWithAccessCheck
 
-    .global art_update_debugger
+    .global art_quick_update_debugger
     .extern artUpdateDebuggerFromCode
     /*
      * On entry, r0 and r1 must be preserved, r2 is dex PC
      */
      ALIGN_FUNCTION_ENTRY
-art_update_debugger:
+art_quick_update_debugger:
     mov    r3, r0         @ stash away r0 so that it's saved as if it were an argument
     SETUP_REF_AND_ARGS_CALLEE_SAVE_FRAME
     mov    r0, r2         @ arg0 is dex PC
@@ -208,12 +208,12 @@
     mov    r0, r3         @ restore original r0
     bx     lr
 
-    .global art_do_long_jump
+    .global art_quick_do_long_jump
     /*
      * On entry r0 is uint32_t* gprs_ and r1 is uint32_t* fprs_
      */
      ALIGN_FUNCTION_ENTRY
-art_do_long_jump:
+art_quick_do_long_jump:
     vldm r1, {s0-s31}     @ load all fprs from argument fprs_
     ldr  r2, [r0, #60]    @ r2 = r15 (PC from gprs_ 60=4*15)
     add  r0, r0, #12      @ increment r0 to skip gprs_[0..2] 12=4*3
@@ -222,13 +222,13 @@
     mov  r1, #0
     bx   r2               @ do long jump
 
-    .global art_work_around_app_jni_bugs
+    .global art_quick_work_around_app_jni_bugs
     .extern artWorkAroundAppJniBugs
     /*
      * Entry point of native methods when JNI bug compatibility is enabled.
      */
     ALIGN_FUNCTION_ENTRY
-art_work_around_app_jni_bugs:
+art_quick_work_around_app_jni_bugs:
     @ save registers that may contain arguments and LR that will be crushed by a call
     push {r0-r3, lr}
     sub sp, #12      @ 3 words of space for alignment
@@ -240,14 +240,14 @@
     pop {r0-r3, lr}  @ restore possibly modified argument registers
     bx  r12          @ tail call into JNI routine
 
-    .global art_handle_fill_data_from_code
+    .global art_quick_handle_fill_data_from_code
     .extern artHandleFillArrayDataFromCode
     /*
      * Entry from managed code that calls artHandleFillArrayDataFromCode and delivers exception on
      * failure.
      */
     ALIGN_FUNCTION_ENTRY
-art_handle_fill_data_from_code:
+art_quick_handle_fill_data_from_code:
     SETUP_REF_ONLY_CALLEE_SAVE_FRAME  @ save callee saves in case exception allocation triggers GC
     mov    r2, r9                          @ pass Thread::Current
     mov    r3, sp                          @ pass SP
@@ -257,26 +257,26 @@
     bxeq   lr                              @ return on success
     DELIVER_PENDING_EXCEPTION
 
-    .global art_lock_object_from_code
+    .global art_quick_lock_object_from_code
     .extern artLockObjectFromCode
     /*
      * Entry from managed code that calls artLockObjectFromCode, may block for GC.
      */
     ALIGN_FUNCTION_ENTRY
-art_lock_object_from_code:
+art_quick_lock_object_from_code:
     SETUP_REF_ONLY_CALLEE_SAVE_FRAME  @ save callee saves in case we block
     mov    r1, r9                     @ pass Thread::Current
     mov    r2, sp                     @ pass SP
     bl     artLockObjectFromCode      @ (Object* obj, Thread*, SP)
     RESTORE_REF_ONLY_CALLEE_SAVE_FRAME_AND_RETURN
 
-    .global art_unlock_object_from_code
+    .global art_quick_unlock_object_from_code
     .extern artUnlockObjectFromCode
     /*
      * Entry from managed code that calls artUnlockObjectFromCode and delivers exception on failure.
      */
     ALIGN_FUNCTION_ENTRY
-art_unlock_object_from_code:
+art_quick_unlock_object_from_code:
     SETUP_REF_ONLY_CALLEE_SAVE_FRAME  @ save callee saves in case exception allocation triggers GC
     mov    r1, r9                   @ pass Thread::Current
     mov    r2, sp                   @ pass SP
@@ -286,13 +286,13 @@
     bxeq   lr                       @ return on success
     DELIVER_PENDING_EXCEPTION
 
-    .global art_check_cast_from_code
+    .global art_quick_check_cast_from_code
     .extern artCheckCastFromCode
     /*
      * Entry from managed code that calls artCheckCastFromCode and delivers exception on failure.
      */
     ALIGN_FUNCTION_ENTRY
-art_check_cast_from_code:
+art_quick_check_cast_from_code:
     SETUP_REF_ONLY_CALLEE_SAVE_FRAME    @ save callee saves in case exception allocation triggers GC
     mov    r2, r9                       @ pass Thread::Current
     mov    r3, sp                       @ pass SP
@@ -302,14 +302,14 @@
     bxeq   lr                           @ return on success
     DELIVER_PENDING_EXCEPTION
 
-    .global art_can_put_array_element_from_code
+    .global art_quick_can_put_array_element_from_code
     .extern artCanPutArrayElementFromCode
     /*
      * Entry from managed code that calls artCanPutArrayElementFromCode and delivers exception on
      * failure.
      */
     ALIGN_FUNCTION_ENTRY
-art_can_put_array_element_from_code:
+art_quick_can_put_array_element_from_code:
     SETUP_REF_ONLY_CALLEE_SAVE_FRAME    @ save callee saves in case exception allocation triggers GC
     mov    r2, r9                         @ pass Thread::Current
     mov    r3, sp                         @ pass SP
@@ -319,7 +319,7 @@
     bxeq   lr                             @ return on success
     DELIVER_PENDING_EXCEPTION
 
-    .global art_initialize_static_storage_from_code
+    .global art_quick_initialize_static_storage_from_code
     .extern artInitializeStaticStorageFromCode
     /*
      * Entry from managed code when uninitialized static storage, this stub will run the class
@@ -327,7 +327,7 @@
      * returned.
      */
     ALIGN_FUNCTION_ENTRY
-art_initialize_static_storage_from_code:
+art_quick_initialize_static_storage_from_code:
     SETUP_REF_ONLY_CALLEE_SAVE_FRAME           @ save callee saves in case of GC
     mov    r2, r9                              @ pass Thread::Current
     mov    r3, sp                              @ pass SP
@@ -338,13 +338,13 @@
     bxne   lr                                  @ return on success
     DELIVER_PENDING_EXCEPTION
 
-    .global art_initialize_type_from_code
+    .global art_quick_initialize_type_from_code
     .extern artInitializeTypeFromCode
     /*
      * Entry from managed code when dex cache misses for a type_idx
      */
     ALIGN_FUNCTION_ENTRY
-art_initialize_type_from_code:
+art_quick_initialize_type_from_code:
     SETUP_REF_ONLY_CALLEE_SAVE_FRAME           @ save callee saves in case of GC
     mov    r2, r9                              @ pass Thread::Current
     mov    r3, sp                              @ pass SP
@@ -355,14 +355,14 @@
     bxne   lr                                  @ return on success
     DELIVER_PENDING_EXCEPTION
 
-    .global art_initialize_type_and_verify_access_from_code
+    .global art_quick_initialize_type_and_verify_access_from_code
     .extern artInitializeTypeAndVerifyAccessFromCode
     /*
      * Entry from managed code when type_idx needs to be checked for access and dex cache may also
      * miss.
      */
     ALIGN_FUNCTION_ENTRY
-art_initialize_type_and_verify_access_from_code:
+art_quick_initialize_type_and_verify_access_from_code:
     SETUP_REF_ONLY_CALLEE_SAVE_FRAME           @ save callee saves in case of GC
     mov    r2, r9                              @ pass Thread::Current
     mov    r3, sp                              @ pass SP
@@ -373,13 +373,13 @@
     bxne   lr                                  @ return on success
     DELIVER_PENDING_EXCEPTION
 
-    .global art_get32_static_from_code
+    .global art_quick_get32_static_from_code
     .extern artGet32StaticFromCode
     /*
      * Called by managed code to resolve a static field and load a 32-bit primitive value.
      */
     ALIGN_FUNCTION_ENTRY
-art_get32_static_from_code:
+art_quick_get32_static_from_code:
     SETUP_REF_ONLY_CALLEE_SAVE_FRAME     @ save callee saves in case of GC
     ldr    r1, [sp, #32]                 @ pass referrer
     mov    r2, r9                        @ pass Thread::Current
@@ -391,13 +391,13 @@
     bxeq   lr                            @ return on success
     DELIVER_PENDING_EXCEPTION
 
-    .global art_get64_static_from_code
+    .global art_quick_get64_static_from_code
     .extern artGet64StaticFromCode
     /*
      * Called by managed code to resolve a static field and load a 64-bit primitive value.
      */
     ALIGN_FUNCTION_ENTRY
-art_get64_static_from_code:
+art_quick_get64_static_from_code:
     SETUP_REF_ONLY_CALLEE_SAVE_FRAME     @ save callee saves in case of GC
     ldr    r1, [sp, #32]                 @ pass referrer
     mov    r2, r9                        @ pass Thread::Current
@@ -409,13 +409,13 @@
     bxeq    lr                           @ return on success
     DELIVER_PENDING_EXCEPTION
 
-    .global art_get_obj_static_from_code
+    .global art_quick_get_obj_static_from_code
     .extern artGetObjStaticFromCode
     /*
      * Called by managed code to resolve a static field and load an object reference.
      */
     ALIGN_FUNCTION_ENTRY
-art_get_obj_static_from_code:
+art_quick_get_obj_static_from_code:
     SETUP_REF_ONLY_CALLEE_SAVE_FRAME     @ save callee saves in case of GC
     ldr    r1, [sp, #32]                 @ pass referrer
     mov    r2, r9                        @ pass Thread::Current
@@ -427,13 +427,13 @@
     bxeq   lr                            @ return on success
     DELIVER_PENDING_EXCEPTION
 
-    .global art_get32_instance_from_code
+    .global art_quick_get32_instance_from_code
     .extern artGet32InstanceFromCode
     /*
      * Called by managed code to resolve an instance field and load a 32-bit primitive value.
      */
     ALIGN_FUNCTION_ENTRY
-art_get32_instance_from_code:
+art_quick_get32_instance_from_code:
     SETUP_REF_ONLY_CALLEE_SAVE_FRAME     @ save callee saves in case of GC
     ldr    r2, [sp, #32]                 @ pass referrer
     mov    r3, r9                        @ pass Thread::Current
@@ -447,13 +447,13 @@
     bxeq   lr                            @ return on success
     DELIVER_PENDING_EXCEPTION
 
-    .global art_get64_instance_from_code
+    .global art_quick_get64_instance_from_code
     .extern artGet64InstanceFromCode
     /*
      * Called by managed code to resolve an instance field and load a 64-bit primitive value.
      */
     ALIGN_FUNCTION_ENTRY
-art_get64_instance_from_code:
+art_quick_get64_instance_from_code:
     SETUP_REF_ONLY_CALLEE_SAVE_FRAME     @ save callee saves in case of GC
     ldr    r2, [sp, #32]                 @ pass referrer
     mov    r3, r9                        @ pass Thread::Current
@@ -467,13 +467,13 @@
     bxeq    lr                           @ return on success
     DELIVER_PENDING_EXCEPTION
 
-    .global art_get_obj_instance_from_code
+    .global art_quick_get_obj_instance_from_code
     .extern artGetObjInstanceFromCode
     /*
      * Called by managed code to resolve an instance field and load an object reference.
      */
     ALIGN_FUNCTION_ENTRY
-art_get_obj_instance_from_code:
+art_quick_get_obj_instance_from_code:
     SETUP_REF_ONLY_CALLEE_SAVE_FRAME     @ save callee saves in case of GC
     ldr    r2, [sp, #32]                 @ pass referrer
     mov    r3, r9                        @ pass Thread::Current
@@ -487,13 +487,13 @@
     bxeq   lr                            @ return on success
     DELIVER_PENDING_EXCEPTION
 
-    .global art_set32_static_from_code
+    .global art_quick_set32_static_from_code
     .extern artSet32StaticFromCode
     /*
      * Called by managed code to resolve a static field and store a 32-bit primitive value.
      */
     ALIGN_FUNCTION_ENTRY
-art_set32_static_from_code:
+art_quick_set32_static_from_code:
     SETUP_REF_ONLY_CALLEE_SAVE_FRAME     @ save callee saves in case of GC
     ldr    r2, [sp, #32]                 @ pass referrer
     mov    r3, r9                        @ pass Thread::Current
@@ -506,14 +506,14 @@
     bxeq   lr                            @ return on success
     DELIVER_PENDING_EXCEPTION
 
-    .global art_set64_static_from_code
+    .global art_quick_set64_static_from_code
     .extern artSet64StaticFromCode
     /*
      * Called by managed code to resolve a static field and store a 64-bit primitive value.
      * On entry r0 holds field index, r1:r2 hold new_val
      */
     ALIGN_FUNCTION_ENTRY
-art_set64_static_from_code:
+art_quick_set64_static_from_code:
     SETUP_REF_ONLY_CALLEE_SAVE_FRAME     @ save callee saves in case of GC
     mov    r3, r2                        @ pass one half of wide argument
     mov    r2, r1                        @ pass other half of wide argument
@@ -528,13 +528,13 @@
     bxeq   lr                            @ return on success
     DELIVER_PENDING_EXCEPTION
 
-    .global art_set_obj_static_from_code
+    .global art_quick_set_obj_static_from_code
     .extern artSetObjStaticFromCode
     /*
      * Called by managed code to resolve a static field and store an object reference.
      */
     ALIGN_FUNCTION_ENTRY
-art_set_obj_static_from_code:
+art_quick_set_obj_static_from_code:
     SETUP_REF_ONLY_CALLEE_SAVE_FRAME     @ save callee saves in case of GC
     ldr    r2, [sp, #32]                 @ pass referrer
     mov    r3, r9                        @ pass Thread::Current
@@ -547,13 +547,13 @@
     bxeq   lr                            @ return on success
     DELIVER_PENDING_EXCEPTION
 
-    .global art_set32_instance_from_code
+    .global art_quick_set32_instance_from_code
     .extern artSet32InstanceFromCode
     /*
      * Called by managed code to resolve an instance field and store a 32-bit primitive value.
      */
     ALIGN_FUNCTION_ENTRY
-art_set32_instance_from_code:
+art_quick_set32_instance_from_code:
     SETUP_REF_ONLY_CALLEE_SAVE_FRAME     @ save callee saves in case of GC
     ldr    r3, [sp, #32]                 @ pass referrer
     mov    r12, sp                       @ save SP
@@ -566,13 +566,13 @@
     bxeq   lr                            @ return on success
     DELIVER_PENDING_EXCEPTION
 
-    .global art_set64_instance_from_code
+    .global art_quick_set64_instance_from_code
     .extern artSet32InstanceFromCode
     /*
      * Called by managed code to resolve an instance field and store a 64-bit primitive value.
      */
     ALIGN_FUNCTION_ENTRY
-art_set64_instance_from_code:
+art_quick_set64_instance_from_code:
     SETUP_REF_ONLY_CALLEE_SAVE_FRAME     @ save callee saves in case of GC
     mov    r12, sp                       @ save SP
     sub    sp, #8                        @ grow frame for alignment with stack args
@@ -584,13 +584,13 @@
     bxeq   lr                            @ return on success
     DELIVER_PENDING_EXCEPTION
 
-    .global art_set_obj_instance_from_code
+    .global art_quick_set_obj_instance_from_code
     .extern artSetObjInstanceFromCode
     /*
      * Called by managed code to resolve an instance field and store an object reference.
      */
     ALIGN_FUNCTION_ENTRY
-art_set_obj_instance_from_code:
+art_quick_set_obj_instance_from_code:
     SETUP_REF_ONLY_CALLEE_SAVE_FRAME     @ save callee saves in case of GC
     ldr    r3, [sp, #32]                 @ pass referrer
     mov    r12, sp                       @ save SP
@@ -603,7 +603,7 @@
     bxeq   lr                            @ return on success
     DELIVER_PENDING_EXCEPTION
 
-    .global art_resolve_string_from_code
+    .global art_quick_resolve_string_from_code
     .extern artResolveStringFromCode
     /*
      * Entry from managed code to resolve a string, this stub will allocate a String and deliver an
@@ -612,7 +612,7 @@
      * performed.
      */
     ALIGN_FUNCTION_ENTRY
-art_resolve_string_from_code:
+art_quick_resolve_string_from_code:
     SETUP_REF_ONLY_CALLEE_SAVE_FRAME  @ save callee saves in case of GC
     mov    r2, r9                     @ pass Thread::Current
     mov    r3, sp                     @ pass SP
@@ -623,13 +623,13 @@
     bxne   lr                         @ return on success
     DELIVER_PENDING_EXCEPTION
 
-    .global art_alloc_object_from_code
+    .global art_quick_alloc_object_from_code
     .extern artAllocObjectFromCode
     /*
      * Called by managed code to allocate an object
      */
     ALIGN_FUNCTION_ENTRY
-art_alloc_object_from_code:
+art_quick_alloc_object_from_code:
     SETUP_REF_ONLY_CALLEE_SAVE_FRAME  @ save callee saves in case of GC
     mov    r2, r9                     @ pass Thread::Current
     mov    r3, sp                     @ pass SP
@@ -639,14 +639,14 @@
     bxne   lr                         @ return on success
     DELIVER_PENDING_EXCEPTION
 
-    .global art_alloc_object_from_code_with_access_check
+    .global art_quick_alloc_object_from_code_with_access_check
     .extern artAllocObjectFromCodeWithAccessCheck
     /*
      * Called by managed code to allocate an object when the caller doesn't know whether it has
      * access to the created type.
      */
     ALIGN_FUNCTION_ENTRY
-art_alloc_object_from_code_with_access_check:
+art_quick_alloc_object_from_code_with_access_check:
     SETUP_REF_ONLY_CALLEE_SAVE_FRAME  @ save callee saves in case of GC
     mov    r2, r9                     @ pass Thread::Current
     mov    r3, sp                     @ pass SP
@@ -656,13 +656,13 @@
     bxne   lr                         @ return on success
     DELIVER_PENDING_EXCEPTION
 
-    .global art_alloc_array_from_code
+    .global art_quick_alloc_array_from_code
     .extern artAllocArrayFromCode
     /*
      * Called by managed code to allocate an array.
      */
     ALIGN_FUNCTION_ENTRY
-art_alloc_array_from_code:
+art_quick_alloc_array_from_code:
     SETUP_REF_ONLY_CALLEE_SAVE_FRAME  @ save callee saves in case of GC
     mov    r3, r9                     @ pass Thread::Current
     mov    r12, sp
@@ -675,14 +675,14 @@
     bxne   lr                         @ return on success
     DELIVER_PENDING_EXCEPTION
 
-    .global art_alloc_array_from_code_with_access_check
+    .global art_quick_alloc_array_from_code_with_access_check
     .extern artAllocArrayFromCodeWithAccessCheck
     /*
      * Called by managed code to allocate an array when the caller doesn't know whether it has
      * access to the created type.
      */
     ALIGN_FUNCTION_ENTRY
-art_alloc_array_from_code_with_access_check:
+art_quick_alloc_array_from_code_with_access_check:
     SETUP_REF_ONLY_CALLEE_SAVE_FRAME  @ save callee saves in case of GC
     mov    r3, r9                     @ pass Thread::Current
     mov    r12, sp
@@ -695,13 +695,13 @@
     bxne   lr                         @ return on success
     DELIVER_PENDING_EXCEPTION
 
-    .global art_check_and_alloc_array_from_code
+    .global art_quick_check_and_alloc_array_from_code
     .extern artCheckAndAllocArrayFromCode
     /*
      * Called by managed code to allocate an array in a special case for FILLED_NEW_ARRAY.
      */
     ALIGN_FUNCTION_ENTRY
-art_check_and_alloc_array_from_code:
+art_quick_check_and_alloc_array_from_code:
     SETUP_REF_ONLY_CALLEE_SAVE_FRAME  @ save callee saves in case of GC
     mov    r3, r9                     @ pass Thread::Current
     mov    r12, sp
@@ -714,13 +714,13 @@
     bxne   lr                         @ return on success
     DELIVER_PENDING_EXCEPTION
 
-    .global art_check_and_alloc_array_from_code_with_access_check
+    .global art_quick_check_and_alloc_array_from_code_with_access_check
     .extern artCheckAndAllocArrayFromCodeWithAccessCheck
     /*
      * Called by managed code to allocate an array in a special case for FILLED_NEW_ARRAY.
      */
     ALIGN_FUNCTION_ENTRY
-art_check_and_alloc_array_from_code_with_access_check:
+art_quick_check_and_alloc_array_from_code_with_access_check:
     SETUP_REF_ONLY_CALLEE_SAVE_FRAME  @ save callee saves in case of GC
     mov    r3, r9                     @ pass Thread::Current
     mov    r12, sp
@@ -733,13 +733,13 @@
     bxne   lr                         @ return on success
     DELIVER_PENDING_EXCEPTION
 
-    .global art_test_suspend
+    .global art_quick_test_suspend
     .extern artTestSuspendFromCode
     /*
      * Called by managed code when the value in rSUSPEND has been decremented to 0.
      */
     ALIGN_FUNCTION_ENTRY
-art_test_suspend:
+art_quick_test_suspend:
     ldrh    r0, [rSELF, #THREAD_FLAGS_OFFSET]
     mov    rSUSPEND, #SUSPEND_CHECK_INTERVAL  @ reset rSUSPEND to SUSPEND_CHECK_INTERVAL
     cmp    r0, #0                             @ check Thread::Current()->suspend_count_ == 0
@@ -750,7 +750,7 @@
     bl     artTestSuspendFromCode             @ (Thread*, SP)
     RESTORE_REF_ONLY_CALLEE_SAVE_FRAME_AND_RETURN
 
-    .global art_proxy_invoke_handler
+    .global art_quick_proxy_invoke_handler
     .extern artProxyInvokeHandler
     /*
      * Called by managed code that is attempting to call a method on a proxy class. On entry
@@ -758,7 +758,7 @@
      * frame size of the invoked proxy method agrees with a ref and args callee save frame.
      */
     ALIGN_FUNCTION_ENTRY
-art_proxy_invoke_handler:
+art_quick_proxy_invoke_handler:
     SETUP_REF_AND_ARGS_CALLEE_SAVE_FRAME
     str     r0, [sp, #0]           @ place proxy method at bottom of frame
     mov     r2, r9                 @ pass Thread::Current
@@ -771,10 +771,10 @@
     bxeq    lr                     @ return on success
     DELIVER_PENDING_EXCEPTION
 
-    .global art_interpreter_entry
+    .global art_quick_interpreter_entry
     .extern artInterpreterEntry
     ALIGN_FUNCTION_ENTRY
-art_interpreter_entry:
+art_quick_interpreter_entry:
     SETUP_REF_AND_ARGS_CALLEE_SAVE_FRAME
     str     r0, [sp, #0]           @ place proxy method at bottom of frame
     mov     r1, r9                 @ pass Thread::Current
@@ -787,15 +787,15 @@
     bxeq    lr                     @ return on success
     DELIVER_PENDING_EXCEPTION
 
-    .global art_instrumentation_entry_from_code
-    .global art_instrumentation_exit_from_code
+    .global art_quick_instrumentation_entry_from_code
+    .global art_quick_instrumentation_exit_from_code
     .extern artInstrumentationMethodEntryFromCode
     .extern artInstrumentationMethodExitFromCode
     /*
      * Routine that intercepts method calls and returns.
      */
     ALIGN_FUNCTION_ENTRY
-art_instrumentation_entry_from_code:
+art_quick_instrumentation_entry_from_code:
     mov   r12, sp        @ remember bottom of caller's frame
     push  {r0-r3}        @ save arguments (4 words)
     mov   r1, r9         @ pass Thread::Current
@@ -805,7 +805,7 @@
     mov   r12, r0        @ r12 holds reference to code
     pop   {r0-r3}        @ restore arguments
     blx   r12            @ call method
-art_instrumentation_exit_from_code:
+art_quick_instrumentation_exit_from_code:
     mov   r12, sp        @ remember bottom of caller's frame
     push  {r0-r1}        @ save return value
     sub   sp, #8         @ align stack
@@ -818,7 +818,7 @@
     pop   {r0, r1}       @ restore return value
     bx    r2             @ return
 
-    .global art_deoptimize
+    .global art_quick_deoptimize
     .extern artDeoptimize
     .extern artEnterInterpreterFromDeoptimize
     /*
@@ -828,7 +828,7 @@
      * set operation may have completed while a get operation needs writing back into the vregs.
      */
     ALIGN_FUNCTION_ENTRY
-art_deoptimize:
+art_quick_deoptimize:
     SETUP_REF_ONLY_CALLEE_SAVE_FRAME
     mov    r2, r9         @ Set up args.
     mov    r3, sp
@@ -845,7 +845,7 @@
     RESTORE_REF_ONLY_CALLEE_SAVE_FRAME
     bx lr                 @ Return to caller.
 
-    .global art_mul_long
+    .global art_quick_mul_long
     /*
      * Signed 64-bit integer multiply.
      *
@@ -866,7 +866,7 @@
      */
     /* mul-long vAA, vBB, vCC */
     ALIGN_FUNCTION_ENTRY
-art_mul_long:
+art_quick_mul_long:
     push    {r9 - r10}
     mul     ip, r2, r1                  @  ip<- ZxW
     umull   r9, r10, r2, r0             @  r9/r10 <- ZxX
@@ -877,7 +877,7 @@
     pop     {r9 - r10}
     bx      lr
 
-    .global art_shl_long
+    .global art_quick_shl_long
     /*
      * Long integer shift.  This is different from the generic 32/64-bit
      * binary operations because vAA/vBB are 64-bit but vCC (the shift
@@ -890,7 +890,7 @@
      */
     /* shl-long vAA, vBB, vCC */
     ALIGN_FUNCTION_ENTRY
-art_shl_long:
+art_quick_shl_long:
     and     r2, r2, #63                 @ r2<- r2 & 0x3f
     mov     r1, r1, asl r2              @  r1<- r1 << r2
     rsb     r3, r2, #32                 @  r3<- 32 - r2
@@ -900,7 +900,7 @@
     mov     r0, r0, asl r2              @  r0<- r0 << r2
     bx      lr
 
-    .global art_shr_long
+    .global art_quick_shr_long
     /*
      * Long integer shift.  This is different from the generic 32/64-bit
      * binary operations because vAA/vBB are 64-bit but vCC (the shift
@@ -913,7 +913,7 @@
      */
     /* shr-long vAA, vBB, vCC */
     ALIGN_FUNCTION_ENTRY
-art_shr_long:
+art_quick_shr_long:
     and     r2, r2, #63                 @ r0<- r0 & 0x3f
     mov     r0, r0, lsr r2              @  r0<- r2 >> r2
     rsb     r3, r2, #32                 @  r3<- 32 - r2
@@ -923,7 +923,7 @@
     mov     r1, r1, asr r2              @  r1<- r1 >> r2
     bx      lr
 
-    .global art_ushr_long
+    .global art_quick_ushr_long
     /*
      * Long integer shift.  This is different from the generic 32/64-bit
      * binary operations because vAA/vBB are 64-bit but vCC (the shift
@@ -936,7 +936,7 @@
      */
     /* ushr-long vAA, vBB, vCC */
     ALIGN_FUNCTION_ENTRY
-art_ushr_long:
+art_quick_ushr_long:
     and     r2, r2, #63                 @ r0<- r0 & 0x3f
     mov     r0, r0, lsr r2              @  r0<- r2 >> r2
     rsb     r3, r2, #32                 @  r3<- 32 - r2
@@ -947,8 +947,8 @@
     bx      lr
 
     .balign 4
-    .global art_indexof
-art_indexof:
+    .global art_quick_indexof
+art_quick_indexof:
     /*
      * String's indexOf.
      *
@@ -1061,9 +1061,9 @@
      */
 
     .balign 4
-    .global art_string_compareto
+    .global art_quick_string_compareto
     .extern __memcmp16
-art_string_compareto:
+art_quick_string_compareto:
     mov    r2, r0         @ this to r2, opening up r0 for return value
     subs   r0, r2, r1     @ Same?
     bxeq   lr
diff --git a/src/oat/runtime/mips/context_mips.cc b/src/oat/runtime/mips/context_mips.cc
index 36eb5b9..e1c6935 100644
--- a/src/oat/runtime/mips/context_mips.cc
+++ b/src/oat/runtime/mips/context_mips.cc
@@ -82,7 +82,7 @@
   gprs_[A3] = NULL;
 }
 
-extern "C" void art_do_long_jump(uint32_t*, uint32_t*);
+extern "C" void art_quick_do_long_jump(uint32_t*, uint32_t*);
 
 void MipsContext::DoLongJump() {
   uintptr_t gprs[kNumberOfCoreRegisters];
@@ -93,7 +93,7 @@
   for (size_t i = 0; i < kNumberOfFRegisters; ++i) {
     fprs[i] = fprs_[i] != NULL ? *fprs_[i] : MipsContext::kBadGprBase + i;
   }
-  art_do_long_jump(gprs, fprs);
+  art_quick_do_long_jump(gprs, fprs);
 }
 
 }  // namespace mips
diff --git a/src/oat/runtime/mips/oat_support_entrypoints_mips.cc b/src/oat/runtime/mips/oat_support_entrypoints_mips.cc
index 9c84a8f..ea861e8 100644
--- a/src/oat/runtime/mips/oat_support_entrypoints_mips.cc
+++ b/src/oat/runtime/mips/oat_support_entrypoints_mips.cc
@@ -20,52 +20,52 @@
 namespace art {
 
 // Alloc entrypoints.
-extern "C" void* art_alloc_array_from_code(uint32_t, void*, int32_t);
-extern "C" void* art_alloc_array_from_code_with_access_check(uint32_t, void*, int32_t);
-extern "C" void* art_alloc_object_from_code(uint32_t type_idx, void* method);
-extern "C" void* art_alloc_object_from_code_with_access_check(uint32_t type_idx, void* method);
-extern "C" void* art_check_and_alloc_array_from_code(uint32_t, void*, int32_t);
-extern "C" void* art_check_and_alloc_array_from_code_with_access_check(uint32_t, void*, int32_t);
+extern "C" void* art_quick_alloc_array_from_code(uint32_t, void*, int32_t);
+extern "C" void* art_quick_alloc_array_from_code_with_access_check(uint32_t, void*, int32_t);
+extern "C" void* art_quick_alloc_object_from_code(uint32_t type_idx, void* method);
+extern "C" void* art_quick_alloc_object_from_code_with_access_check(uint32_t type_idx, void* method);
+extern "C" void* art_quick_check_and_alloc_array_from_code(uint32_t, void*, int32_t);
+extern "C" void* art_quick_check_and_alloc_array_from_code_with_access_check(uint32_t, void*, int32_t);
 
 // Cast entrypoints.
 extern "C" uint32_t artIsAssignableFromCode(const mirror::Class* klass,
                                             const mirror::Class* ref_class);
-extern "C" void art_can_put_array_element_from_code(void*, void*);
-extern "C" void art_check_cast_from_code(void*, void*);
+extern "C" void art_quick_can_put_array_element_from_code(void*, void*);
+extern "C" void art_quick_check_cast_from_code(void*, void*);
 
 // Debug entrypoints.
 extern void DebugMe(mirror::AbstractMethod* method, uint32_t info);
-extern "C" void art_update_debugger(void*, void*, int32_t, void*);
+extern "C" void art_quick_update_debugger(void*, void*, int32_t, void*);
 
 // DexCache entrypoints.
-extern "C" void* art_initialize_static_storage_from_code(uint32_t, void*);
-extern "C" void* art_initialize_type_from_code(uint32_t, void*);
-extern "C" void* art_initialize_type_and_verify_access_from_code(uint32_t, void*);
-extern "C" void* art_resolve_string_from_code(void*, uint32_t);
+extern "C" void* art_quick_initialize_static_storage_from_code(uint32_t, void*);
+extern "C" void* art_quick_initialize_type_from_code(uint32_t, void*);
+extern "C" void* art_quick_initialize_type_and_verify_access_from_code(uint32_t, void*);
+extern "C" void* art_quick_resolve_string_from_code(void*, uint32_t);
 
 // Exception entrypoints.
 extern "C" void* GetAndClearException(Thread*);
 
 // Field entrypoints.
-extern "C" int art_set32_instance_from_code(uint32_t, void*, int32_t);
-extern "C" int art_set32_static_from_code(uint32_t, int32_t);
-extern "C" int art_set64_instance_from_code(uint32_t, void*, int64_t);
-extern "C" int art_set64_static_from_code(uint32_t, int64_t);
-extern "C" int art_set_obj_instance_from_code(uint32_t, void*, void*);
-extern "C" int art_set_obj_static_from_code(uint32_t, void*);
-extern "C" int32_t art_get32_instance_from_code(uint32_t, void*);
-extern "C" int32_t art_get32_static_from_code(uint32_t);
-extern "C" int64_t art_get64_instance_from_code(uint32_t, void*);
-extern "C" int64_t art_get64_static_from_code(uint32_t);
-extern "C" void* art_get_obj_instance_from_code(uint32_t, void*);
-extern "C" void* art_get_obj_static_from_code(uint32_t);
+extern "C" int art_quick_set32_instance_from_code(uint32_t, void*, int32_t);
+extern "C" int art_quick_set32_static_from_code(uint32_t, int32_t);
+extern "C" int art_quick_set64_instance_from_code(uint32_t, void*, int64_t);
+extern "C" int art_quick_set64_static_from_code(uint32_t, int64_t);
+extern "C" int art_quick_set_obj_instance_from_code(uint32_t, void*, void*);
+extern "C" int art_quick_set_obj_static_from_code(uint32_t, void*);
+extern "C" int32_t art_quick_get32_instance_from_code(uint32_t, void*);
+extern "C" int32_t art_quick_get32_static_from_code(uint32_t);
+extern "C" int64_t art_quick_get64_instance_from_code(uint32_t, void*);
+extern "C" int64_t art_quick_get64_static_from_code(uint32_t);
+extern "C" void* art_quick_get_obj_instance_from_code(uint32_t, void*);
+extern "C" void* art_quick_get_obj_static_from_code(uint32_t);
 
 // FillArray entrypoint.
-extern "C" void art_handle_fill_data_from_code(void*, void*);
+extern "C" void art_quick_handle_fill_data_from_code(void*, void*);
 
 // Lock entrypoints.
-extern "C" void art_lock_object_from_code(void*);
-extern "C" void art_unlock_object_from_code(void*);
+extern "C" void art_quick_lock_object_from_code(void*);
+extern "C" void art_quick_unlock_object_from_code(void*);
 
 // Math entrypoints.
 extern int32_t CmpgDouble(double a, double b);
@@ -93,86 +93,86 @@
 // Long long arithmetics - REM_LONG[_2ADDR] and DIV_LONG[_2ADDR]
 extern "C" int64_t __divdi3(int64_t, int64_t);
 extern "C" int64_t __moddi3(int64_t, int64_t);
-extern "C" uint64_t art_shl_long(uint64_t, uint32_t);
-extern "C" uint64_t art_shr_long(uint64_t, uint32_t);
-extern "C" uint64_t art_ushr_long(uint64_t, uint32_t);
+extern "C" uint64_t art_quick_shl_long(uint64_t, uint32_t);
+extern "C" uint64_t art_quick_shr_long(uint64_t, uint32_t);
+extern "C" uint64_t art_quick_ushr_long(uint64_t, uint32_t);
 
 // Intrinsic entrypoints.
 extern "C" int32_t __memcmp16(void*, void*, int32_t);
-extern "C" int32_t art_indexof(void*, uint32_t, uint32_t, uint32_t);
-extern "C" int32_t art_string_compareto(void*, void*);
+extern "C" int32_t art_quick_indexof(void*, uint32_t, uint32_t, uint32_t);
+extern "C" int32_t art_quick_string_compareto(void*, void*);
 
 // Invoke entrypoints.
 const void* UnresolvedDirectMethodTrampolineFromCode(mirror::AbstractMethod*,
                                                      mirror::AbstractMethod**, Thread*,
                                                      Runtime::TrampolineType);
-extern "C" void art_invoke_direct_trampoline_with_access_check(uint32_t, void*);
-extern "C" void art_invoke_interface_trampoline(uint32_t, void*);
-extern "C" void art_invoke_interface_trampoline_with_access_check(uint32_t, void*);
-extern "C" void art_invoke_static_trampoline_with_access_check(uint32_t, void*);
-extern "C" void art_invoke_super_trampoline_with_access_check(uint32_t, void*);
-extern "C" void art_invoke_virtual_trampoline_with_access_check(uint32_t, void*);
+extern "C" void art_quick_invoke_direct_trampoline_with_access_check(uint32_t, void*);
+extern "C" void art_quick_invoke_interface_trampoline(uint32_t, void*);
+extern "C" void art_quick_invoke_interface_trampoline_with_access_check(uint32_t, void*);
+extern "C" void art_quick_invoke_static_trampoline_with_access_check(uint32_t, void*);
+extern "C" void art_quick_invoke_super_trampoline_with_access_check(uint32_t, void*);
+extern "C" void art_quick_invoke_virtual_trampoline_with_access_check(uint32_t, void*);
 
 // Thread entrypoints.
 extern void CheckSuspendFromCode(Thread* thread);
-extern "C" void art_test_suspend();
+extern "C" void art_quick_test_suspend();
 
 // Throw entrypoints.
 extern void ThrowAbstractMethodErrorFromCode(mirror::AbstractMethod* method, Thread* thread,
                                              mirror::AbstractMethod** sp);
-extern "C" void art_deliver_exception_from_code(void*);
-extern "C" void art_throw_array_bounds_from_code(int32_t index, int32_t limit);
-extern "C" void art_throw_div_zero_from_code();
-extern "C" void art_throw_no_such_method_from_code(int32_t method_idx);
-extern "C" void art_throw_null_pointer_exception_from_code();
-extern "C" void art_throw_stack_overflow_from_code(void*);
+extern "C" void art_quick_deliver_exception_from_code(void*);
+extern "C" void art_quick_throw_array_bounds_from_code(int32_t index, int32_t limit);
+extern "C" void art_quick_throw_div_zero_from_code();
+extern "C" void art_quick_throw_no_such_method_from_code(int32_t method_idx);
+extern "C" void art_quick_throw_null_pointer_exception_from_code();
+extern "C" void art_quick_throw_stack_overflow_from_code(void*);
 
 // Instrumentation entrypoints.
-extern "C" void art_instrumentation_entry_from_code(void*);
-extern "C" void art_instrumentation_exit_from_code();
-extern "C" void art_interpreter_entry(void*);
-extern "C" void art_deoptimize();
+extern "C" void art_quick_instrumentation_entry_from_code(void*);
+extern "C" void art_quick_instrumentation_exit_from_code();
+extern "C" void art_quick_interpreter_entry(void*);
+extern "C" void art_quick_deoptimize();
 
 void InitEntryPoints(EntryPoints* points) {
   // Alloc
-  points->pAllocArrayFromCode = art_alloc_array_from_code;
-  points->pAllocArrayFromCodeWithAccessCheck = art_alloc_array_from_code_with_access_check;
-  points->pAllocObjectFromCode = art_alloc_object_from_code;
-  points->pAllocObjectFromCodeWithAccessCheck = art_alloc_object_from_code_with_access_check;
-  points->pCheckAndAllocArrayFromCode = art_check_and_alloc_array_from_code;
-  points->pCheckAndAllocArrayFromCodeWithAccessCheck = art_check_and_alloc_array_from_code_with_access_check;
+  points->pAllocArrayFromCode = art_quick_alloc_array_from_code;
+  points->pAllocArrayFromCodeWithAccessCheck = art_quick_alloc_array_from_code_with_access_check;
+  points->pAllocObjectFromCode = art_quick_alloc_object_from_code;
+  points->pAllocObjectFromCodeWithAccessCheck = art_quick_alloc_object_from_code_with_access_check;
+  points->pCheckAndAllocArrayFromCode = art_quick_check_and_alloc_array_from_code;
+  points->pCheckAndAllocArrayFromCodeWithAccessCheck = art_quick_check_and_alloc_array_from_code_with_access_check;
 
   // Cast
   points->pInstanceofNonTrivialFromCode = artIsAssignableFromCode;
-  points->pCanPutArrayElementFromCode = art_can_put_array_element_from_code;
-  points->pCheckCastFromCode = art_check_cast_from_code;
+  points->pCanPutArrayElementFromCode = art_quick_can_put_array_element_from_code;
+  points->pCheckCastFromCode = art_quick_check_cast_from_code;
 
   // Debug
   points->pDebugMe = DebugMe;
   points->pUpdateDebuggerFromCode = NULL; // Controlled by SetDebuggerUpdatesEnabled.
 
   // DexCache
-  points->pInitializeStaticStorage = art_initialize_static_storage_from_code;
-  points->pInitializeTypeAndVerifyAccessFromCode = art_initialize_type_and_verify_access_from_code;
-  points->pInitializeTypeFromCode = art_initialize_type_from_code;
-  points->pResolveStringFromCode = art_resolve_string_from_code;
+  points->pInitializeStaticStorage = art_quick_initialize_static_storage_from_code;
+  points->pInitializeTypeAndVerifyAccessFromCode = art_quick_initialize_type_and_verify_access_from_code;
+  points->pInitializeTypeFromCode = art_quick_initialize_type_from_code;
+  points->pResolveStringFromCode = art_quick_resolve_string_from_code;
 
   // Field
-  points->pSet32Instance = art_set32_instance_from_code;
-  points->pSet32Static = art_set32_static_from_code;
-  points->pSet64Instance = art_set64_instance_from_code;
-  points->pSet64Static = art_set64_static_from_code;
-  points->pSetObjInstance = art_set_obj_instance_from_code;
-  points->pSetObjStatic = art_set_obj_static_from_code;
-  points->pGet32Instance = art_get32_instance_from_code;
-  points->pGet64Instance = art_get64_instance_from_code;
-  points->pGetObjInstance = art_get_obj_instance_from_code;
-  points->pGet32Static = art_get32_static_from_code;
-  points->pGet64Static = art_get64_static_from_code;
-  points->pGetObjStatic = art_get_obj_static_from_code;
+  points->pSet32Instance = art_quick_set32_instance_from_code;
+  points->pSet32Static = art_quick_set32_static_from_code;
+  points->pSet64Instance = art_quick_set64_instance_from_code;
+  points->pSet64Static = art_quick_set64_static_from_code;
+  points->pSetObjInstance = art_quick_set_obj_instance_from_code;
+  points->pSetObjStatic = art_quick_set_obj_static_from_code;
+  points->pGet32Instance = art_quick_get32_instance_from_code;
+  points->pGet64Instance = art_quick_get64_instance_from_code;
+  points->pGetObjInstance = art_quick_get_obj_instance_from_code;
+  points->pGet32Static = art_quick_get32_static_from_code;
+  points->pGet64Static = art_quick_get64_static_from_code;
+  points->pGetObjStatic = art_quick_get_obj_static_from_code;
 
   // FillArray
-  points->pHandleFillArrayDataFromCode = art_handle_fill_data_from_code;
+  points->pHandleFillArrayDataFromCode = art_quick_handle_fill_data_from_code;
 
   // JNI
   points->pFindNativeMethod = FindNativeMethod;
@@ -184,8 +184,8 @@
   points->pJniMethodEndWithReferenceSynchronized = JniMethodEndWithReferenceSynchronized;
 
   // Locks
-  points->pLockObjectFromCode = art_lock_object_from_code;
-  points->pUnlockObjectFromCode = art_unlock_object_from_code;
+  points->pLockObjectFromCode = art_quick_lock_object_from_code;
+  points->pUnlockObjectFromCode = art_quick_unlock_object_from_code;
 
   // Math
   points->pCmpgDouble = CmpgDouble;
@@ -204,58 +204,58 @@
   points->pLdiv = artLdivFromCode;
   points->pLdivmod = artLdivmodFromCode;
   points->pLmul = artLmulFromCode;
-  points->pShlLong = art_shl_long;
-  points->pShrLong = art_shr_long;
-  points->pUshrLong = art_ushr_long;
+  points->pShlLong = art_quick_shl_long;
+  points->pShrLong = art_quick_shr_long;
+  points->pUshrLong = art_quick_ushr_long;
 
   // Intrinsics
-  points->pIndexOf = art_indexof;
+  points->pIndexOf = art_quick_indexof;
   points->pMemcmp16 = __memcmp16;
-  points->pStringCompareTo = art_string_compareto;
+  points->pStringCompareTo = art_quick_string_compareto;
   points->pMemcpy = memcpy;
 
   // Invocation
   points->pUnresolvedDirectMethodTrampolineFromCode = UnresolvedDirectMethodTrampolineFromCode;
-  points->pInvokeDirectTrampolineWithAccessCheck = art_invoke_direct_trampoline_with_access_check;
-  points->pInvokeInterfaceTrampoline = art_invoke_interface_trampoline;
-  points->pInvokeInterfaceTrampolineWithAccessCheck = art_invoke_interface_trampoline_with_access_check;
-  points->pInvokeStaticTrampolineWithAccessCheck = art_invoke_static_trampoline_with_access_check;
-  points->pInvokeSuperTrampolineWithAccessCheck = art_invoke_super_trampoline_with_access_check;
-  points->pInvokeVirtualTrampolineWithAccessCheck = art_invoke_virtual_trampoline_with_access_check;
+  points->pInvokeDirectTrampolineWithAccessCheck = art_quick_invoke_direct_trampoline_with_access_check;
+  points->pInvokeInterfaceTrampoline = art_quick_invoke_interface_trampoline;
+  points->pInvokeInterfaceTrampolineWithAccessCheck = art_quick_invoke_interface_trampoline_with_access_check;
+  points->pInvokeStaticTrampolineWithAccessCheck = art_quick_invoke_static_trampoline_with_access_check;
+  points->pInvokeSuperTrampolineWithAccessCheck = art_quick_invoke_super_trampoline_with_access_check;
+  points->pInvokeVirtualTrampolineWithAccessCheck = art_quick_invoke_virtual_trampoline_with_access_check;
 
   // Thread
   points->pCheckSuspendFromCode = CheckSuspendFromCode;
-  points->pTestSuspendFromCode = art_test_suspend;
+  points->pTestSuspendFromCode = art_quick_test_suspend;
 
   // Throws
-  points->pDeliverException = art_deliver_exception_from_code;
+  points->pDeliverException = art_quick_deliver_exception_from_code;
   points->pThrowAbstractMethodErrorFromCode = ThrowAbstractMethodErrorFromCode;
-  points->pThrowArrayBoundsFromCode = art_throw_array_bounds_from_code;
-  points->pThrowDivZeroFromCode = art_throw_div_zero_from_code;
-  points->pThrowNoSuchMethodFromCode = art_throw_no_such_method_from_code;
-  points->pThrowNullPointerFromCode = art_throw_null_pointer_exception_from_code;
-  points->pThrowStackOverflowFromCode = art_throw_stack_overflow_from_code;
+  points->pThrowArrayBoundsFromCode = art_quick_throw_array_bounds_from_code;
+  points->pThrowDivZeroFromCode = art_quick_throw_div_zero_from_code;
+  points->pThrowNoSuchMethodFromCode = art_quick_throw_no_such_method_from_code;
+  points->pThrowNullPointerFromCode = art_quick_throw_null_pointer_exception_from_code;
+  points->pThrowStackOverflowFromCode = art_quick_throw_stack_overflow_from_code;
 };
 
 void ChangeDebuggerEntryPoint(EntryPoints* points, bool enabled) {
-  points->pUpdateDebuggerFromCode = (enabled ? art_update_debugger : NULL);
+  points->pUpdateDebuggerFromCode = (enabled ? art_quick_update_debugger : NULL);
 }
 
 uintptr_t GetInstrumentationExitPc() {
-  return reinterpret_cast<uintptr_t>(art_instrumentation_exit_from_code);
+  return reinterpret_cast<uintptr_t>(art_quick_instrumentation_exit_from_code);
 }
 
 uintptr_t GetDeoptimizationEntryPoint() {
   UNIMPLEMENTED(FATAL);
-  return reinterpret_cast<uintptr_t>(art_deoptimize);
+  return reinterpret_cast<uintptr_t>(art_quick_deoptimize);
 }
 
 void* GetInstrumentationEntryPoint() {
-  return reinterpret_cast<void*>(art_instrumentation_entry_from_code);
+  return reinterpret_cast<void*>(art_quick_instrumentation_entry_from_code);
 }
 
 void* GetInterpreterEntryPoint() {
-  return reinterpret_cast<void*>(art_interpreter_entry);
+  return reinterpret_cast<void*>(art_quick_interpreter_entry);
 }
 
 }  // namespace art
diff --git a/src/oat/runtime/mips/runtime_support_mips.S b/src/oat/runtime/mips/runtime_support_mips.S
index b49d5a5..2f673e8 100644
--- a/src/oat/runtime/mips/runtime_support_mips.S
+++ b/src/oat/runtime/mips/runtime_support_mips.S
@@ -158,13 +158,13 @@
     DELIVER_PENDING_EXCEPTION
 .endm
 
-    .global art_update_debugger
+    .global art_quick_update_debugger
     .extern artUpdateDebuggerFromCode
     /*
      * On entry, $a0 and $a1 must be preserved, $a2 is dex PC
      */
     ALIGN_FUNCTION_ENTRY
-art_update_debugger:
+art_quick_update_debugger:
     GENERATE_GLOBAL_POINTER
     move    $a3, $a0        # stash away $a0 so that it's saved as if it were an argument
     SETUP_REF_AND_ARGS_CALLEE_SAVE_FRAME
@@ -177,13 +177,13 @@
     jr      $ra
     move    $a0, $a3        # restore original $a0
 
-    .global art_do_long_jump
+    .global art_quick_do_long_jump
     /*
      * On entry $a0 is uint32_t* gprs_ and $a1 is uint32_t* fprs_
      * FIXME: just guessing about the shape of the jmpbuf.  Where will pc be?
      */
     ALIGN_FUNCTION_ENTRY
-art_do_long_jump:
+art_quick_do_long_jump:
     l.s     $f0, 0($a1)
     l.s     $f1, 4($a1)
     l.s     $f2, 8($a1)
@@ -251,14 +251,14 @@
     jr      $ra                 # do long jump
     move    $v1, $zero
 
-    .global art_deliver_exception_from_code
+    .global art_quick_deliver_exception_from_code
     /*
      * Called by managed code, saves most registers (forms basis of long jump context) and passes
      * the bottom of the stack. artDeliverExceptionFromCode will place the callee save Method* at
      * the bottom of the thread. On entry r0 holds Throwable*
      */
     ALIGN_FUNCTION_ENTRY
-art_deliver_exception_from_code:
+art_quick_deliver_exception_from_code:
     GENERATE_GLOBAL_POINTER
     SETUP_SAVE_ALL_CALLEE_SAVE_FRAME
     move $a1, rSELF                 # pass Thread::Current
@@ -266,13 +266,13 @@
     jr   $t9                        # artDeliverExceptionFromCode(Throwable*, Thread*, $sp)
     move $a2, $sp                   # pass $sp
 
-    .global art_throw_null_pointer_exception_from_code
+    .global art_quick_throw_null_pointer_exception_from_code
     .extern artThrowNullPointerExceptionFromCode
     /*
      * Called by managed code to create and deliver a NullPointerException
      */
     ALIGN_FUNCTION_ENTRY
-art_throw_null_pointer_exception_from_code:
+art_quick_throw_null_pointer_exception_from_code:
     GENERATE_GLOBAL_POINTER
     SETUP_SAVE_ALL_CALLEE_SAVE_FRAME
     move $a0, rSELF                 # pass Thread::Current
@@ -280,13 +280,13 @@
     jr   $t9                        # artThrowNullPointerExceptionFromCode(Thread*, $sp)
     move $a1, $sp                   # pass $sp
 
-    .global art_throw_div_zero_from_code
+    .global art_quick_throw_div_zero_from_code
     .extern artThrowDivZeroFromCode
     /*
      * Called by managed code to create and deliver an ArithmeticException
      */
     ALIGN_FUNCTION_ENTRY
-art_throw_div_zero_from_code:
+art_quick_throw_div_zero_from_code:
     GENERATE_GLOBAL_POINTER
     SETUP_SAVE_ALL_CALLEE_SAVE_FRAME
     move $a0, rSELF                 # pass Thread::Current
@@ -294,13 +294,13 @@
     jr   $t9                        # artThrowDivZeroFromCode(Thread*, $sp)
     move $a1, $sp                   # pass $sp
 
-    .global art_throw_array_bounds_from_code
+    .global art_quick_throw_array_bounds_from_code
     .extern artThrowArrayBoundsFromCode
     /*
      * Called by managed code to create and deliver an ArrayIndexOutOfBoundsException
      */
     ALIGN_FUNCTION_ENTRY
-art_throw_array_bounds_from_code:
+art_quick_throw_array_bounds_from_code:
     GENERATE_GLOBAL_POINTER
     SETUP_SAVE_ALL_CALLEE_SAVE_FRAME
     move $a2, rSELF                 # pass Thread::Current
@@ -308,13 +308,13 @@
     jr   $t9                        # artThrowArrayBoundsFromCode(index, limit, Thread*, $sp)
     move $a3, $sp                   # pass $sp
 
-    .global art_throw_stack_overflow_from_code
+    .global art_quick_throw_stack_overflow_from_code
     .extern artThrowStackOverflowFromCode
     /*
      * Called by managed code to create and deliver a StackOverflowError.
      */
     ALIGN_FUNCTION_ENTRY
-art_throw_stack_overflow_from_code:
+art_quick_throw_stack_overflow_from_code:
     GENERATE_GLOBAL_POINTER
     SETUP_SAVE_ALL_CALLEE_SAVE_FRAME
     move $a0, rSELF                 # pass Thread::Current
@@ -322,13 +322,13 @@
     jr   $t9                        # artThrowStackOverflowFromCode(Thread*, $sp)
     move $a1, $sp                   # pass $sp
 
-    .global art_throw_no_such_method_from_code
+    .global art_quick_throw_no_such_method_from_code
     .extern artThrowNoSuchMethodFromCode
     /*
      * Called by managed code to create and deliver a NoSuchMethodError.
      */
     ALIGN_FUNCTION_ENTRY
-art_throw_no_such_method_from_code:
+art_quick_throw_no_such_method_from_code:
     GENERATE_GLOBAL_POINTER
     SETUP_SAVE_ALL_CALLEE_SAVE_FRAME
     move $a1, rSELF                 # pass Thread::Current
@@ -378,21 +378,21 @@
     DELIVER_PENDING_EXCEPTION
 .endm
 
-INVOKE_TRAMPOLINE art_invoke_interface_trampoline, artInvokeInterfaceTrampoline
-INVOKE_TRAMPOLINE art_invoke_interface_trampoline_with_access_check, artInvokeInterfaceTrampolineWithAccessCheck
+INVOKE_TRAMPOLINE art_quick_invoke_interface_trampoline, artInvokeInterfaceTrampoline
+INVOKE_TRAMPOLINE art_quick_invoke_interface_trampoline_with_access_check, artInvokeInterfaceTrampolineWithAccessCheck
 
-INVOKE_TRAMPOLINE art_invoke_static_trampoline_with_access_check, artInvokeStaticTrampolineWithAccessCheck
-INVOKE_TRAMPOLINE art_invoke_direct_trampoline_with_access_check, artInvokeDirectTrampolineWithAccessCheck
-INVOKE_TRAMPOLINE art_invoke_super_trampoline_with_access_check, artInvokeSuperTrampolineWithAccessCheck
-INVOKE_TRAMPOLINE art_invoke_virtual_trampoline_with_access_check, artInvokeVirtualTrampolineWithAccessCheck
+INVOKE_TRAMPOLINE art_quick_invoke_static_trampoline_with_access_check, artInvokeStaticTrampolineWithAccessCheck
+INVOKE_TRAMPOLINE art_quick_invoke_direct_trampoline_with_access_check, artInvokeDirectTrampolineWithAccessCheck
+INVOKE_TRAMPOLINE art_quick_invoke_super_trampoline_with_access_check, artInvokeSuperTrampolineWithAccessCheck
+INVOKE_TRAMPOLINE art_quick_invoke_virtual_trampoline_with_access_check, artInvokeVirtualTrampolineWithAccessCheck
 
-    .global art_work_around_app_jni_bugs
+    .global art_quick_work_around_app_jni_bugs
     .extern artWorkAroundAppJniBugs
     /*
      * Entry point of native methods when JNI bug compatibility is enabled.
      */
     ALIGN_FUNCTION_ENTRY
-art_work_around_app_jni_bugs:
+art_quick_work_around_app_jni_bugs:
     GENERATE_GLOBAL_POINTER
     # save registers that may contain arguments and LR that will be crushed by a call
     addiu    $sp, $sp, -32
@@ -413,14 +413,14 @@
     jr       $t9              # tail call into JNI routine
     addiu    $sp, $sp, 32
 
-    .global art_handle_fill_data_from_code
+    .global art_quick_handle_fill_data_from_code
     .extern artHandleFillArrayDataFromCode
     /*
      * Entry from managed code that calls artHandleFillArrayDataFromCode and delivers exception on
      * failure.
      */
     ALIGN_FUNCTION_ENTRY
-art_handle_fill_data_from_code:
+art_quick_handle_fill_data_from_code:
     GENERATE_GLOBAL_POINTER
     SETUP_REF_ONLY_CALLEE_SAVE_FRAME  # save callee saves in case exception allocation triggers GC
     move    $a2, rSELF                         # pass Thread::Current
@@ -428,13 +428,13 @@
     move    $a3, $sp                           # pass $sp
     RETURN_IF_ZERO
 
-    .global art_lock_object_from_code
+    .global art_quick_lock_object_from_code
     .extern artLockObjectFromCode
     /*
      * Entry from managed code that calls artLockObjectFromCode, may block for GC.
      */
     ALIGN_FUNCTION_ENTRY
-art_lock_object_from_code:
+art_quick_lock_object_from_code:
     GENERATE_GLOBAL_POINTER
     SETUP_REF_ONLY_CALLEE_SAVE_FRAME      # save callee saves in case we block
     move    $a1, rSELF                    # pass Thread::Current
@@ -442,13 +442,13 @@
     move    $a2, $sp                      # pass $sp
     RESTORE_REF_ONLY_CALLEE_SAVE_FRAME_AND_RETURN
 
-    .global art_unlock_object_from_code
+    .global art_quick_unlock_object_from_code
     .extern artUnlockObjectFromCode
     /*
      * Entry from managed code that calls artUnlockObjectFromCode and delivers exception on failure.
      */
     ALIGN_FUNCTION_ENTRY
-art_unlock_object_from_code:
+art_quick_unlock_object_from_code:
     GENERATE_GLOBAL_POINTER
     SETUP_REF_ONLY_CALLEE_SAVE_FRAME  # save callee saves in case exception allocation triggers GC
     move    $a1, rSELF                # pass Thread::Current
@@ -456,13 +456,13 @@
     move    $a2, $sp                  # pass $sp
     RETURN_IF_ZERO
 
-    .global art_check_cast_from_code
+    .global art_quick_check_cast_from_code
     .extern artCheckCastFromCode
     /*
      * Entry from managed code that calls artCheckCastFromCode and delivers exception on failure.
      */
     ALIGN_FUNCTION_ENTRY
-art_check_cast_from_code:
+art_quick_check_cast_from_code:
     GENERATE_GLOBAL_POINTER
     SETUP_REF_ONLY_CALLEE_SAVE_FRAME  # save callee saves in case exception allocation triggers GC
     move    $a2, rSELF                # pass Thread::Current
@@ -470,14 +470,14 @@
     move    $a3, $sp                  # pass $sp
     RETURN_IF_ZERO
 
-    .global art_can_put_array_element_from_code
+    .global art_quick_can_put_array_element_from_code
     .extern artCanPutArrayElementFromCode
     /*
      * Entry from managed code that calls artCanPutArrayElementFromCode and delivers exception on
      * failure.
      */
     ALIGN_FUNCTION_ENTRY
-art_can_put_array_element_from_code:
+art_quick_can_put_array_element_from_code:
     GENERATE_GLOBAL_POINTER
     SETUP_REF_ONLY_CALLEE_SAVE_FRAME    # save callee saves in case exception allocation triggers GC
     move    $a2, rSELF                     # pass Thread::Current
@@ -485,7 +485,7 @@
     move    $a3, $sp                       # pass $sp
     RETURN_IF_ZERO
 
-    .global art_initialize_static_storage_from_code
+    .global art_quick_initialize_static_storage_from_code
     .extern artInitializeStaticStorageFromCode
     /*
      * Entry from managed code when uninitialized static storage, this stub will run the class
@@ -493,7 +493,7 @@
      * returned.
      */
     ALIGN_FUNCTION_ENTRY
-art_initialize_static_storage_from_code:
+art_quick_initialize_static_storage_from_code:
     GENERATE_GLOBAL_POINTER
     SETUP_REF_ONLY_CALLEE_SAVE_FRAME            # save callee saves in case of GC
     move    $a2, rSELF                          # pass Thread::Current
@@ -502,13 +502,13 @@
     move    $a3, $sp                            # pass $sp
     RETURN_IF_NONZERO
 
-    .global art_initialize_type_from_code
+    .global art_quick_initialize_type_from_code
     .extern artInitializeTypeFromCode
     /*
      * Entry from managed code when dex cache misses for a type_idx.
      */
     ALIGN_FUNCTION_ENTRY
-art_initialize_type_from_code:
+art_quick_initialize_type_from_code:
     GENERATE_GLOBAL_POINTER
     SETUP_REF_ONLY_CALLEE_SAVE_FRAME           # save callee saves in case of GC
     move    $a2, rSELF                         # pass Thread::Current
@@ -517,14 +517,14 @@
     move    $a3, $sp                           # pass $sp
     RETURN_IF_NONZERO
 
-    .global art_initialize_type_and_verify_access_from_code
+    .global art_quick_initialize_type_and_verify_access_from_code
     .extern artInitializeTypeAndVerifyAccessFromCode
     /*
      * Entry from managed code when type_idx needs to be checked for access and dex cache may also
      * miss.
      */
     ALIGN_FUNCTION_ENTRY
-art_initialize_type_and_verify_access_from_code:
+art_quick_initialize_type_and_verify_access_from_code:
     GENERATE_GLOBAL_POINTER
     SETUP_REF_ONLY_CALLEE_SAVE_FRAME           # save callee saves in case of GC
     move    $a2, rSELF                         # pass Thread::Current
@@ -533,13 +533,13 @@
     move    $a3, $sp                           # pass $sp
     RETURN_IF_NONZERO
 
-    .global art_get32_static_from_code
+    .global art_quick_get32_static_from_code
     .extern artGet32StaticFromCode
     /*
      * Called by managed code to resolve a static field and load a 32-bit primitive value.
      */
     ALIGN_FUNCTION_ENTRY
-art_get32_static_from_code:
+art_quick_get32_static_from_code:
     GENERATE_GLOBAL_POINTER
     SETUP_REF_ONLY_CALLEE_SAVE_FRAME     # save callee saves in case of GC
     lw     $a1, 64($sp)                  # pass referrer's Method*
@@ -548,13 +548,13 @@
     move   $a3, $sp                      # pass $sp
     RETURN_IF_NO_EXCEPTION
 
-    .global art_get64_static_from_code
+    .global art_quick_get64_static_from_code
     .extern artGet64StaticFromCode
     /*
      * Called by managed code to resolve a static field and load a 64-bit primitive value.
      */
     ALIGN_FUNCTION_ENTRY
-art_get64_static_from_code:
+art_quick_get64_static_from_code:
     GENERATE_GLOBAL_POINTER
     SETUP_REF_ONLY_CALLEE_SAVE_FRAME     # save callee saves in case of GC
     lw     $a1, 64($sp)                  # pass referrer's Method*
@@ -563,13 +563,13 @@
     move   $a3, $sp                      # pass $sp
     RETURN_IF_NO_EXCEPTION
 
-    .global art_get_obj_static_from_code
+    .global art_quick_get_obj_static_from_code
     .extern artGetObjStaticFromCode
     /*
      * Called by managed code to resolve a static field and load an object reference.
      */
     ALIGN_FUNCTION_ENTRY
-art_get_obj_static_from_code:
+art_quick_get_obj_static_from_code:
     GENERATE_GLOBAL_POINTER
     SETUP_REF_ONLY_CALLEE_SAVE_FRAME     # save callee saves in case of GC
     lw     $a1, 64($sp)                  # pass referrer's Method*
@@ -578,13 +578,13 @@
     move   $a3, $sp                      # pass $sp
     RETURN_IF_NO_EXCEPTION
 
-    .global art_get32_instance_from_code
+    .global art_quick_get32_instance_from_code
     .extern artGet32InstanceFromCode
     /*
      * Called by managed code to resolve an instance field and load a 32-bit primitive value.
      */
     ALIGN_FUNCTION_ENTRY
-art_get32_instance_from_code:
+art_quick_get32_instance_from_code:
     GENERATE_GLOBAL_POINTER
     SETUP_REF_ONLY_CALLEE_SAVE_FRAME     # save callee saves in case of GC
     lw     $a2, 64($sp)                  # pass referrer's Method*
@@ -593,13 +593,13 @@
     sw     $sp, 16($sp)                  # pass $sp
     RETURN_IF_NO_EXCEPTION
 
-    .global art_get64_instance_from_code
+    .global art_quick_get64_instance_from_code
     .extern artGet64InstanceFromCode
     /*
      * Called by managed code to resolve an instance field and load a 64-bit primitive value.
      */
     ALIGN_FUNCTION_ENTRY
-art_get64_instance_from_code:
+art_quick_get64_instance_from_code:
     GENERATE_GLOBAL_POINTER
     SETUP_REF_ONLY_CALLEE_SAVE_FRAME     # save callee saves in case of GC
     lw     $a2, 64($sp)                  # pass referrer's Method*
@@ -608,13 +608,13 @@
     sw     $sp, 16($sp)                  # pass $sp
     RETURN_IF_NO_EXCEPTION
 
-    .global art_get_obj_instance_from_code
+    .global art_quick_get_obj_instance_from_code
     .extern artGetObjInstanceFromCode
     /*
      * Called by managed code to resolve an instance field and load an object reference.
      */
     ALIGN_FUNCTION_ENTRY
-art_get_obj_instance_from_code:
+art_quick_get_obj_instance_from_code:
     GENERATE_GLOBAL_POINTER
     SETUP_REF_ONLY_CALLEE_SAVE_FRAME     # save callee saves in case of GC
     lw     $a2, 64($sp)                  # pass referrer's Method*
@@ -623,13 +623,13 @@
     sw     $sp, 16($sp)                  # pass $sp
     RETURN_IF_NO_EXCEPTION
 
-    .global art_set32_static_from_code
+    .global art_quick_set32_static_from_code
     .extern artSet32StaticFromCode
     /*
      * Called by managed code to resolve a static field and store a 32-bit primitive value.
      */
     ALIGN_FUNCTION_ENTRY
-art_set32_static_from_code:
+art_quick_set32_static_from_code:
     GENERATE_GLOBAL_POINTER
     SETUP_REF_ONLY_CALLEE_SAVE_FRAME     # save callee saves in case of GC
     lw     $a2, 64($sp)                  # pass referrer's Method*
@@ -638,13 +638,13 @@
     sw     $sp, 16($sp)                  # pass $sp
     RETURN_IF_ZERO
 
-    .global art_set64_static_from_code
+    .global art_quick_set64_static_from_code
     .extern artSet32StaticFromCode
     /*
      * Called by managed code to resolve a static field and store a 64-bit primitive value.
      */
     ALIGN_FUNCTION_ENTRY
-art_set64_static_from_code:
+art_quick_set64_static_from_code:
     GENERATE_GLOBAL_POINTER
     SETUP_REF_ONLY_CALLEE_SAVE_FRAME     # save callee saves in case of GC
     lw     $a1, 64($sp)                  # pass referrer's Method*
@@ -653,13 +653,13 @@
     sw     $sp, 20($sp)                  # pass $sp
     RETURN_IF_ZERO
 
-    .global art_set_obj_static_from_code
+    .global art_quick_set_obj_static_from_code
     .extern artSetObjStaticFromCode
     /*
      * Called by managed code to resolve a static field and store an object reference.
      */
     ALIGN_FUNCTION_ENTRY
-art_set_obj_static_from_code:
+art_quick_set_obj_static_from_code:
     GENERATE_GLOBAL_POINTER
     SETUP_REF_ONLY_CALLEE_SAVE_FRAME     # save callee saves in case of GC
     lw     $a2, 64($sp)                  # pass referrer's Method*
@@ -668,13 +668,13 @@
     sw     $sp, 16($sp)                  # pass $sp
     RETURN_IF_ZERO
 
-    .global art_set32_instance_from_code
+    .global art_quick_set32_instance_from_code
     .extern artSet32InstanceFromCode
     /*
      * Called by managed code to resolve an instance field and store a 32-bit primitive value.
      */
     ALIGN_FUNCTION_ENTRY
-art_set32_instance_from_code:
+art_quick_set32_instance_from_code:
     GENERATE_GLOBAL_POINTER
     SETUP_REF_ONLY_CALLEE_SAVE_FRAME     # save callee saves in case of GC
     lw     $a3, 64($sp)                  # pass referrer's Method*
@@ -683,13 +683,13 @@
     sw     $sp, 20($sp)                  # pass $sp
     RETURN_IF_ZERO
 
-    .global art_set64_instance_from_code
+    .global art_quick_set64_instance_from_code
     .extern artSet32InstanceFromCode
     /*
      * Called by managed code to resolve an instance field and store a 64-bit primitive value.
      */
     ALIGN_FUNCTION_ENTRY
-art_set64_instance_from_code:
+art_quick_set64_instance_from_code:
     GENERATE_GLOBAL_POINTER
     SETUP_REF_ONLY_CALLEE_SAVE_FRAME     # save callee saves in case of GC
     sw     rSELF, 16($sp)                # pass Thread::Current
@@ -697,13 +697,13 @@
     sw     $sp, 20($sp)                  # pass $sp
     RETURN_IF_ZERO
 
-    .global art_set_obj_instance_from_code
+    .global art_quick_set_obj_instance_from_code
     .extern artSetObjInstanceFromCode
     /*
      * Called by managed code to resolve an instance field and store an object reference.
      */
     ALIGN_FUNCTION_ENTRY
-art_set_obj_instance_from_code:
+art_quick_set_obj_instance_from_code:
     GENERATE_GLOBAL_POINTER
     SETUP_REF_ONLY_CALLEE_SAVE_FRAME     # save callee saves in case of GC
     lw     $a3, 64($sp)                  # pass referrer's Method*
@@ -712,7 +712,7 @@
     sw     $sp, 20($sp)                  # pass $sp
     RETURN_IF_ZERO
 
-    .global art_resolve_string_from_code
+    .global art_quick_resolve_string_from_code
     .extern artResolveStringFromCode
     /*
      * Entry from managed code to resolve a string, this stub will allocate a String and deliver an
@@ -721,7 +721,7 @@
      * performed.
      */
     ALIGN_FUNCTION_ENTRY
-art_resolve_string_from_code:
+art_quick_resolve_string_from_code:
     GENERATE_GLOBAL_POINTER
     SETUP_REF_ONLY_CALLEE_SAVE_FRAME  # save callee saves in case of GC
     move    $a2, rSELF                # pass Thread::Current
@@ -730,13 +730,13 @@
     move    $a3, $sp                  # pass $sp
     RETURN_IF_NONZERO
 
-    .global art_alloc_object_from_code
+    .global art_quick_alloc_object_from_code
     .extern artAllocObjectFromCode
     /*
      * Called by managed code to allocate an object.
      */
     ALIGN_FUNCTION_ENTRY
-art_alloc_object_from_code:
+art_quick_alloc_object_from_code:
     GENERATE_GLOBAL_POINTER
     SETUP_REF_ONLY_CALLEE_SAVE_FRAME  # save callee saves in case of GC
     move    $a2, rSELF                # pass Thread::Current
@@ -744,14 +744,14 @@
     move    $a3, $sp                  # pass $sp
     RETURN_IF_NONZERO
 
-    .global art_alloc_object_from_code_with_access_check
+    .global art_quick_alloc_object_from_code_with_access_check
     .extern artAllocObjectFromCodeWithAccessCheck
     /*
      * Called by managed code to allocate an object when the caller doesn't know whether it has
      * access to the created type.
      */
     ALIGN_FUNCTION_ENTRY
-art_alloc_object_from_code_with_access_check:
+art_quick_alloc_object_from_code_with_access_check:
     GENERATE_GLOBAL_POINTER
     SETUP_REF_ONLY_CALLEE_SAVE_FRAME  # save callee saves in case of GC
     move    $a2, rSELF                # pass Thread::Current
@@ -759,13 +759,13 @@
     move    $a3, $sp                  # pass $sp
     RETURN_IF_NONZERO
 
-    .global art_alloc_array_from_code
+    .global art_quick_alloc_array_from_code
     .extern artAllocArrayFromCode
     /*
      * Called by managed code to allocate an array.
      */
     ALIGN_FUNCTION_ENTRY
-art_alloc_array_from_code:
+art_quick_alloc_array_from_code:
     GENERATE_GLOBAL_POINTER
     SETUP_REF_ONLY_CALLEE_SAVE_FRAME  # save callee saves in case of GC
     move    $a3, rSELF                # pass Thread::Current
@@ -774,14 +774,14 @@
     sw      $sp, 16($sp)              # pass $sp
     RETURN_IF_NONZERO
 
-    .global art_alloc_array_from_code_with_access_check
+    .global art_quick_alloc_array_from_code_with_access_check
     .extern artAllocArrayFromCodeWithAccessCheck
     /*
      * Called by managed code to allocate an array when the caller doesn't know whether it has
      * access to the created type.
      */
     ALIGN_FUNCTION_ENTRY
-art_alloc_array_from_code_with_access_check:
+art_quick_alloc_array_from_code_with_access_check:
     GENERATE_GLOBAL_POINTER
     SETUP_REF_ONLY_CALLEE_SAVE_FRAME  # save callee saves in case of GC
     move    $a3, rSELF                # pass Thread::Current
@@ -790,13 +790,13 @@
     sw      $sp, 16($sp)              # pass $sp
     RETURN_IF_NONZERO
 
-    .global art_check_and_alloc_array_from_code
+    .global art_quick_check_and_alloc_array_from_code
     .extern artCheckAndAllocArrayFromCode
     /*
      * Called by managed code to allocate an array in a special case for FILLED_NEW_ARRAY.
      */
     ALIGN_FUNCTION_ENTRY
-art_check_and_alloc_array_from_code:
+art_quick_check_and_alloc_array_from_code:
     GENERATE_GLOBAL_POINTER
     SETUP_REF_ONLY_CALLEE_SAVE_FRAME  # save callee saves in case of GC
     move    $a3, rSELF                # pass Thread::Current
@@ -805,13 +805,13 @@
     sw      $sp, 16($sp)              # pass $sp
     RETURN_IF_NONZERO
 
-    .global art_check_and_alloc_array_from_code_with_access_check
+    .global art_quick_check_and_alloc_array_from_code_with_access_check
     .extern artCheckAndAllocArrayFromCodeWithAccessCheck
     /*
      * Called by managed code to allocate an array in a special case for FILLED_NEW_ARRAY.
      */
     ALIGN_FUNCTION_ENTRY
-art_check_and_alloc_array_from_code_with_access_check:
+art_quick_check_and_alloc_array_from_code_with_access_check:
     GENERATE_GLOBAL_POINTER
     SETUP_REF_ONLY_CALLEE_SAVE_FRAME  # save callee saves in case of GC
     move    $a3, rSELF                # pass Thread::Current
@@ -820,13 +820,13 @@
     sw      $sp, 16($sp)              # pass $sp
     RETURN_IF_NONZERO
 
-    .global art_test_suspend
+    .global art_quick_test_suspend
     .extern artTestSuspendFromCode
     /*
      * Called by managed code when the value in rSUSPEND has been decremented to 0.
      */
     ALIGN_FUNCTION_ENTRY
-art_test_suspend:
+art_quick_test_suspend:
     GENERATE_GLOBAL_POINTER
     lh     $a0, THREAD_FLAGS_OFFSET(rSELF)
     bnez   $a0, 1f
@@ -840,14 +840,14 @@
     move   $a1, $sp
     RESTORE_REF_ONLY_CALLEE_SAVE_FRAME_AND_RETURN
 
-    .global art_proxy_invoke_handler
+    .global art_quick_proxy_invoke_handler
     .extern artProxyInvokeHandler
     /*
      * Called by managed code that is attempting to call a method on a proxy class. On entry
      * r0 holds the proxy method; r1, r2 and r3 may contain arguments.
      */
     ALIGN_FUNCTION_ENTRY
-art_proxy_invoke_handler:
+art_quick_proxy_invoke_handler:
     GENERATE_GLOBAL_POINTER
     SETUP_REF_AND_ARGS_CALLEE_SAVE_FRAME
     sw      $a0, 0($sp)            # place proxy method at bottom of frame
@@ -863,10 +863,10 @@
 1:
     DELIVER_PENDING_EXCEPTION
 
-    .global art_interpreter_entry
+    .global art_quick_interpreter_entry
     .extern artInterpreterEntry
     ALIGN_FUNCTION_ENTRY
-art_interpreter_entry:
+art_quick_interpreter_entry:
     GENERATE_GLOBAL_POINTER
     SETUP_REF_AND_ARGS_CALLEE_SAVE_FRAME
     sw      $a0, 0($sp)            # place proxy method at bottom of frame
@@ -882,15 +882,15 @@
 1:
     DELIVER_PENDING_EXCEPTION
 
-    .global art_instrumentation_entry_from_code
-    .global art_instrumentation_exit_from_code
+    .global art_quick_instrumentation_entry_from_code
+    .global art_quick_instrumentation_exit_from_code
     .extern artInstrumentationMethodEntryFromCode
     .extern artInstrumentationMethodExitFromCode
     /*
      * Routine that intercepts method calls and returns.
      */
     ALIGN_FUNCTION_ENTRY
-art_instrumentation_entry_from_code:
+art_quick_instrumentation_entry_from_code:
     GENERATE_GLOBAL_POINTER
     move     $t0, $sp       # remember bottom of caller's frame
     addiu    $sp, $sp, -16  # save arguments (4 words)
@@ -910,7 +910,7 @@
     jalr     $t9            # call method
     addiu    $sp, $sp, 16
     /* intentional fallthrough */
-art_instrumentation_exit_from_code:
+art_quick_instrumentation_exit_from_code:
     addiu    $t9, $ra, 4    # put current address into $t9 to rebuild $gp
     GENERATE_GLOBAL_POINTER
     move     $t0, $sp       # remember bottom of caller's frame
@@ -927,7 +927,7 @@
     jr       $t0            # return
     addiu    $sp, $sp, 16
 
-    .global art_deoptimize
+    .global art_quick_deoptimize
     .extern artDeoptimize
     .extern artEnterInterpreterFromDeoptimize
     /*
@@ -937,7 +937,7 @@
      * set operation may have completed while a get operation needs writing back into the vregs.
      */
     ALIGN_FUNCTION_ENTRY
-art_deoptimize:
+art_quick_deoptimize:
     GENERATE_GLOBAL_POINTER
     SETUP_REF_ONLY_CALLEE_SAVE_FRAME
     move     $a0, $v0       # pass first half of return value
@@ -959,7 +959,7 @@
     jr       $ra            # Return to caller.
     nop
 
-    .global art_shl_long
+    .global art_quick_shl_long
     /*
      * Long integer shift.  This is different from the generic 32/64-bit
      * binary operations because vAA/vBB are 64-bit but vCC (the shift
@@ -971,7 +971,7 @@
      *   $a2: shift count
      */
     ALIGN_FUNCTION_ENTRY
-art_shl_long:
+art_quick_shl_long:
     /* shl-long vAA, vBB, vCC */
     sll     $v0, $a0, $a2                    #  rlo<- alo << (shift&31)
     not     $v1, $a2                         #  rhi<- 31-shift  (shift is 5b)
@@ -984,7 +984,7 @@
     jr      $ra
     movn    $v0, $zero, $a2                  #  rlo<- 0  (if shift&0x20)
 
-    .global art_shr_long
+    .global art_quick_shr_long
     /*
      * Long integer shift.  This is different from the generic 32/64-bit
      * binary operations because vAA/vBB are 64-bit but vCC (the shift
@@ -996,7 +996,7 @@
      *   $a2: shift count
      */
     ALIGN_FUNCTION_ENTRY
-art_shr_long:
+art_quick_shr_long:
     sra     $v1, $a1, $a2                    #  rhi<- ahi >> (shift&31)
     srl     $v0, $a0, $a2                    #  rlo<- alo >> (shift&31)
     sra     $a3, $a1, 31                     #  $a3<- sign(ah)
@@ -1009,7 +1009,7 @@
     jr      $ra
     movn    $v1, $a3, $a2                    #  rhi<- sign(ahi) (if shift&0x20)
 
-    .global art_ushr_long
+    .global art_quick_ushr_long
     /*
      * Long integer shift.  This is different from the generic 32/64-bit
      * binary operations because vAA/vBB are 64-bit but vCC (the shift
@@ -1022,7 +1022,7 @@
      */
     /* ushr-long vAA, vBB, vCC */
     ALIGN_FUNCTION_ENTRY
-art_ushr_long:
+art_quick_ushr_long:
     srl     $v1, $a1, $a2                    #  rhi<- ahi >> (shift&31)
     srl     $v0, $a0, $a2                    #  rlo<- alo >> (shift&31)
     not     $a0, $a2                         #  alo<- 31-shift (shift is 5b)
@@ -1034,14 +1034,14 @@
     jr      $ra
     movn    $v1, $zero, $a2                  #  rhi<- 0 (if shift&0x20)
 
-    .global art_indexof
+    .global art_quick_indexof
     ALIGN_FUNCTION_ENTRY
-art_indexof:
+art_quick_indexof:
     jr $ra
     nop
 
-    .global art_string_compareto
+    .global art_quick_string_compareto
     ALIGN_FUNCTION_ENTRY
-art_string_compareto:
+art_quick_string_compareto:
     jr $ra
     nop
diff --git a/src/oat/runtime/support_stubs.cc b/src/oat/runtime/support_stubs.cc
index 6a60e85..6565dfe 100644
--- a/src/oat/runtime/support_stubs.cc
+++ b/src/oat/runtime/support_stubs.cc
@@ -30,7 +30,7 @@
 #include "scoped_thread_state_change.h"
 
 // Architecture specific assembler helper to deliver exception.
-extern "C" void art_deliver_exception_from_code(void*);
+extern "C" void art_quick_deliver_exception_from_code(void*);
 
 namespace art {
 
@@ -239,7 +239,7 @@
   if (UNLIKELY(code == NULL)) {
     // Something went wrong in ResolveMethod or EnsureInitialized,
     // go into deliver exception with the pending exception in r0
-    code = reinterpret_cast<void*>(art_deliver_exception_from_code);
+    code = reinterpret_cast<void*>(art_quick_deliver_exception_from_code);
     regs[0] = reinterpret_cast<uintptr_t>(thread->GetException());
     thread->ClearException();
   } else {
diff --git a/src/oat/runtime/x86/oat_support_entrypoints_x86.cc b/src/oat/runtime/x86/oat_support_entrypoints_x86.cc
index 48ec5bf..a7c518a 100644
--- a/src/oat/runtime/x86/oat_support_entrypoints_x86.cc
+++ b/src/oat/runtime/x86/oat_support_entrypoints_x86.cc
@@ -20,142 +20,142 @@
 namespace art {
 
 // Alloc entrypoints.
-extern "C" void* art_alloc_array_from_code(uint32_t, void*, int32_t);
-extern "C" void* art_alloc_array_from_code_with_access_check(uint32_t, void*, int32_t);
-extern "C" void* art_alloc_object_from_code(uint32_t type_idx, void* method);
-extern "C" void* art_alloc_object_from_code_with_access_check(uint32_t type_idx, void* method);
-extern "C" void* art_check_and_alloc_array_from_code(uint32_t, void*, int32_t);
-extern "C" void* art_check_and_alloc_array_from_code_with_access_check(uint32_t, void*, int32_t);
+extern "C" void* art_quick_alloc_array_from_code(uint32_t, void*, int32_t);
+extern "C" void* art_quick_alloc_array_from_code_with_access_check(uint32_t, void*, int32_t);
+extern "C" void* art_quick_alloc_object_from_code(uint32_t type_idx, void* method);
+extern "C" void* art_quick_alloc_object_from_code_with_access_check(uint32_t type_idx, void* method);
+extern "C" void* art_quick_check_and_alloc_array_from_code(uint32_t, void*, int32_t);
+extern "C" void* art_quick_check_and_alloc_array_from_code_with_access_check(uint32_t, void*, int32_t);
 
 // Cast entrypoints.
-extern "C" uint32_t art_is_assignable_from_code(const mirror::Class* klass,
+extern "C" uint32_t art_quick_is_assignable_from_code(const mirror::Class* klass,
                                                 const mirror::Class* ref_class);
-extern "C" void art_can_put_array_element_from_code(void*, void*);
-extern "C" void art_check_cast_from_code(void*, void*);
+extern "C" void art_quick_can_put_array_element_from_code(void*, void*);
+extern "C" void art_quick_check_cast_from_code(void*, void*);
 
 // Debug entrypoints.
 extern void DebugMe(mirror::AbstractMethod* method, uint32_t info);
-extern "C" void art_update_debugger(void*, void*, int32_t, void*);
+extern "C" void art_quick_update_debugger(void*, void*, int32_t, void*);
 
 // DexCache entrypoints.
-extern "C" void* art_initialize_static_storage_from_code(uint32_t, void*);
-extern "C" void* art_initialize_type_from_code(uint32_t, void*);
-extern "C" void* art_initialize_type_and_verify_access_from_code(uint32_t, void*);
-extern "C" void* art_resolve_string_from_code(void*, uint32_t);
+extern "C" void* art_quick_initialize_static_storage_from_code(uint32_t, void*);
+extern "C" void* art_quick_initialize_type_from_code(uint32_t, void*);
+extern "C" void* art_quick_initialize_type_and_verify_access_from_code(uint32_t, void*);
+extern "C" void* art_quick_resolve_string_from_code(void*, uint32_t);
 
 // Field entrypoints.
-extern "C" int art_set32_instance_from_code(uint32_t, void*, int32_t);
-extern "C" int art_set32_static_from_code(uint32_t, int32_t);
-extern "C" int art_set64_instance_from_code(uint32_t, void*, int64_t);
-extern "C" int art_set64_static_from_code(uint32_t, int64_t);
-extern "C" int art_set_obj_instance_from_code(uint32_t, void*, void*);
-extern "C" int art_set_obj_static_from_code(uint32_t, void*);
-extern "C" int32_t art_get32_instance_from_code(uint32_t, void*);
-extern "C" int32_t art_get32_static_from_code(uint32_t);
-extern "C" int64_t art_get64_instance_from_code(uint32_t, void*);
-extern "C" int64_t art_get64_static_from_code(uint32_t);
-extern "C" void* art_get_obj_instance_from_code(uint32_t, void*);
-extern "C" void* art_get_obj_static_from_code(uint32_t);
+extern "C" int art_quick_set32_instance_from_code(uint32_t, void*, int32_t);
+extern "C" int art_quick_set32_static_from_code(uint32_t, int32_t);
+extern "C" int art_quick_set64_instance_from_code(uint32_t, void*, int64_t);
+extern "C" int art_quick_set64_static_from_code(uint32_t, int64_t);
+extern "C" int art_quick_set_obj_instance_from_code(uint32_t, void*, void*);
+extern "C" int art_quick_set_obj_static_from_code(uint32_t, void*);
+extern "C" int32_t art_quick_get32_instance_from_code(uint32_t, void*);
+extern "C" int32_t art_quick_get32_static_from_code(uint32_t);
+extern "C" int64_t art_quick_get64_instance_from_code(uint32_t, void*);
+extern "C" int64_t art_quick_get64_static_from_code(uint32_t);
+extern "C" void* art_quick_get_obj_instance_from_code(uint32_t, void*);
+extern "C" void* art_quick_get_obj_static_from_code(uint32_t);
 
 // FillArray entrypoint.
-extern "C" void art_handle_fill_data_from_code(void*, void*);
+extern "C" void art_quick_handle_fill_data_from_code(void*, void*);
 
 // Lock entrypoints.
-extern "C" void art_lock_object_from_code(void*);
-extern "C" void art_unlock_object_from_code(void*);
+extern "C" void art_quick_lock_object_from_code(void*);
+extern "C" void art_quick_unlock_object_from_code(void*);
 
 // Math entrypoints.
-extern "C" double art_fmod_from_code(double, double);
-extern "C" float art_fmodf_from_code(float, float);
-extern "C" double art_l2d_from_code(int64_t);
-extern "C" float art_l2f_from_code(int64_t);
-extern "C" int64_t art_d2l_from_code(double);
-extern "C" int64_t art_f2l_from_code(float);
-extern "C" int32_t art_idivmod_from_code(int32_t, int32_t);
-extern "C" int64_t art_ldiv_from_code(int64_t, int64_t);
-extern "C" int64_t art_ldivmod_from_code(int64_t, int64_t);
-extern "C" int64_t art_lmul_from_code(int64_t, int64_t);
-extern "C" uint64_t art_lshl_from_code(uint64_t, uint32_t);
-extern "C" uint64_t art_lshr_from_code(uint64_t, uint32_t);
-extern "C" uint64_t art_lushr_from_code(uint64_t, uint32_t);
+extern "C" double art_quick_fmod_from_code(double, double);
+extern "C" float art_quick_fmodf_from_code(float, float);
+extern "C" double art_quick_l2d_from_code(int64_t);
+extern "C" float art_quick_l2f_from_code(int64_t);
+extern "C" int64_t art_quick_d2l_from_code(double);
+extern "C" int64_t art_quick_f2l_from_code(float);
+extern "C" int32_t art_quick_idivmod_from_code(int32_t, int32_t);
+extern "C" int64_t art_quick_ldiv_from_code(int64_t, int64_t);
+extern "C" int64_t art_quick_ldivmod_from_code(int64_t, int64_t);
+extern "C" int64_t art_quick_lmul_from_code(int64_t, int64_t);
+extern "C" uint64_t art_quick_lshl_from_code(uint64_t, uint32_t);
+extern "C" uint64_t art_quick_lshr_from_code(uint64_t, uint32_t);
+extern "C" uint64_t art_quick_lushr_from_code(uint64_t, uint32_t);
 
 // Intrinsic entrypoints.
-extern "C" int32_t art_memcmp16(void*, void*, int32_t);
-extern "C" int32_t art_indexof(void*, uint32_t, uint32_t, uint32_t);
-extern "C" int32_t art_string_compareto(void*, void*);
-extern "C" void* art_memcpy(void*, const void*, size_t);
+extern "C" int32_t art_quick_memcmp16(void*, void*, int32_t);
+extern "C" int32_t art_quick_indexof(void*, uint32_t, uint32_t, uint32_t);
+extern "C" int32_t art_quick_string_compareto(void*, void*);
+extern "C" void* art_quick_memcpy(void*, const void*, size_t);
 
 // Invoke entrypoints.
 const void* UnresolvedDirectMethodTrampolineFromCode(mirror::AbstractMethod*,
                                                      mirror::AbstractMethod**, Thread*,
                                                      Runtime::TrampolineType);
-extern "C" void art_invoke_direct_trampoline_with_access_check(uint32_t, void*);
-extern "C" void art_invoke_interface_trampoline(uint32_t, void*);
-extern "C" void art_invoke_interface_trampoline_with_access_check(uint32_t, void*);
-extern "C" void art_invoke_static_trampoline_with_access_check(uint32_t, void*);
-extern "C" void art_invoke_super_trampoline_with_access_check(uint32_t, void*);
-extern "C" void art_invoke_virtual_trampoline_with_access_check(uint32_t, void*);
+extern "C" void art_quick_invoke_direct_trampoline_with_access_check(uint32_t, void*);
+extern "C" void art_quick_invoke_interface_trampoline(uint32_t, void*);
+extern "C" void art_quick_invoke_interface_trampoline_with_access_check(uint32_t, void*);
+extern "C" void art_quick_invoke_static_trampoline_with_access_check(uint32_t, void*);
+extern "C" void art_quick_invoke_super_trampoline_with_access_check(uint32_t, void*);
+extern "C" void art_quick_invoke_virtual_trampoline_with_access_check(uint32_t, void*);
 
 // Thread entrypoints.
 extern void CheckSuspendFromCode(Thread* thread);
-extern "C" void art_test_suspend();
+extern "C" void art_quick_test_suspend();
 
 // Throw entrypoints.
 extern void ThrowAbstractMethodErrorFromCode(mirror::AbstractMethod* method, Thread* thread,
                                              mirror::AbstractMethod** sp);
-extern "C" void art_deliver_exception_from_code(void*);
-extern "C" void art_throw_array_bounds_from_code(int32_t index, int32_t limit);
-extern "C" void art_throw_div_zero_from_code();
-extern "C" void art_throw_no_such_method_from_code(int32_t method_idx);
-extern "C" void art_throw_null_pointer_exception_from_code();
-extern "C" void art_throw_stack_overflow_from_code(void*);
+extern "C" void art_quick_deliver_exception_from_code(void*);
+extern "C" void art_quick_throw_array_bounds_from_code(int32_t index, int32_t limit);
+extern "C" void art_quick_throw_div_zero_from_code();
+extern "C" void art_quick_throw_no_such_method_from_code(int32_t method_idx);
+extern "C" void art_quick_throw_null_pointer_exception_from_code();
+extern "C" void art_quick_throw_stack_overflow_from_code(void*);
 
 // Instrumentation entrypoints.
-extern "C" void art_instrumentation_entry_from_code(void*);
-extern "C" void art_instrumentation_exit_from_code();
-extern "C" void art_interpreter_entry(void*);
-extern "C" void art_deoptimize();
+extern "C" void art_quick_instrumentation_entry_from_code(void*);
+extern "C" void art_quick_instrumentation_exit_from_code();
+extern "C" void art_quick_interpreter_entry(void*);
+extern "C" void art_quick_deoptimize();
 
 void InitEntryPoints(EntryPoints* points) {
   // Alloc
-  points->pAllocArrayFromCode = art_alloc_array_from_code;
-  points->pAllocArrayFromCodeWithAccessCheck = art_alloc_array_from_code_with_access_check;
-  points->pAllocObjectFromCode = art_alloc_object_from_code;
-  points->pAllocObjectFromCodeWithAccessCheck = art_alloc_object_from_code_with_access_check;
-  points->pCheckAndAllocArrayFromCode = art_check_and_alloc_array_from_code;
-  points->pCheckAndAllocArrayFromCodeWithAccessCheck = art_check_and_alloc_array_from_code_with_access_check;
+  points->pAllocArrayFromCode = art_quick_alloc_array_from_code;
+  points->pAllocArrayFromCodeWithAccessCheck = art_quick_alloc_array_from_code_with_access_check;
+  points->pAllocObjectFromCode = art_quick_alloc_object_from_code;
+  points->pAllocObjectFromCodeWithAccessCheck = art_quick_alloc_object_from_code_with_access_check;
+  points->pCheckAndAllocArrayFromCode = art_quick_check_and_alloc_array_from_code;
+  points->pCheckAndAllocArrayFromCodeWithAccessCheck = art_quick_check_and_alloc_array_from_code_with_access_check;
 
   // Cast
-  points->pInstanceofNonTrivialFromCode = art_is_assignable_from_code;
-  points->pCanPutArrayElementFromCode = art_can_put_array_element_from_code;
-  points->pCheckCastFromCode = art_check_cast_from_code;
+  points->pInstanceofNonTrivialFromCode = art_quick_is_assignable_from_code;
+  points->pCanPutArrayElementFromCode = art_quick_can_put_array_element_from_code;
+  points->pCheckCastFromCode = art_quick_check_cast_from_code;
 
   // Debug
   points->pDebugMe = DebugMe;
   points->pUpdateDebuggerFromCode = NULL; // Controlled by SetDebuggerUpdatesEnabled.
 
   // DexCache
-  points->pInitializeStaticStorage = art_initialize_static_storage_from_code;
-  points->pInitializeTypeAndVerifyAccessFromCode = art_initialize_type_and_verify_access_from_code;
-  points->pInitializeTypeFromCode = art_initialize_type_from_code;
-  points->pResolveStringFromCode = art_resolve_string_from_code;
+  points->pInitializeStaticStorage = art_quick_initialize_static_storage_from_code;
+  points->pInitializeTypeAndVerifyAccessFromCode = art_quick_initialize_type_and_verify_access_from_code;
+  points->pInitializeTypeFromCode = art_quick_initialize_type_from_code;
+  points->pResolveStringFromCode = art_quick_resolve_string_from_code;
 
   // Field
-  points->pSet32Instance = art_set32_instance_from_code;
-  points->pSet32Static = art_set32_static_from_code;
-  points->pSet64Instance = art_set64_instance_from_code;
-  points->pSet64Static = art_set64_static_from_code;
-  points->pSetObjInstance = art_set_obj_instance_from_code;
-  points->pSetObjStatic = art_set_obj_static_from_code;
-  points->pGet32Instance = art_get32_instance_from_code;
-  points->pGet64Instance = art_get64_instance_from_code;
-  points->pGetObjInstance = art_get_obj_instance_from_code;
-  points->pGet32Static = art_get32_static_from_code;
-  points->pGet64Static = art_get64_static_from_code;
-  points->pGetObjStatic = art_get_obj_static_from_code;
+  points->pSet32Instance = art_quick_set32_instance_from_code;
+  points->pSet32Static = art_quick_set32_static_from_code;
+  points->pSet64Instance = art_quick_set64_instance_from_code;
+  points->pSet64Static = art_quick_set64_static_from_code;
+  points->pSetObjInstance = art_quick_set_obj_instance_from_code;
+  points->pSetObjStatic = art_quick_set_obj_static_from_code;
+  points->pGet32Instance = art_quick_get32_instance_from_code;
+  points->pGet64Instance = art_quick_get64_instance_from_code;
+  points->pGetObjInstance = art_quick_get_obj_instance_from_code;
+  points->pGet32Static = art_quick_get32_static_from_code;
+  points->pGet64Static = art_quick_get64_static_from_code;
+  points->pGetObjStatic = art_quick_get_obj_static_from_code;
 
   // FillArray
-  points->pHandleFillArrayDataFromCode = art_handle_fill_data_from_code;
+  points->pHandleFillArrayDataFromCode = art_quick_handle_fill_data_from_code;
 
   // JNI
   points->pFindNativeMethod = FindNativeMethod;
@@ -167,77 +167,77 @@
   points->pJniMethodEndWithReferenceSynchronized = JniMethodEndWithReferenceSynchronized;
 
   // Locks
-  points->pLockObjectFromCode = art_lock_object_from_code;
-  points->pUnlockObjectFromCode = art_unlock_object_from_code;
+  points->pLockObjectFromCode = art_quick_lock_object_from_code;
+  points->pUnlockObjectFromCode = art_quick_unlock_object_from_code;
 
   // Math
   //points->pCmpgDouble = NULL; // Not needed on x86.
   //points->pCmpgFloat = NULL; // Not needed on x86.
   //points->pCmplDouble = NULL; // Not needed on x86.
   //points->pCmplFloat = NULL; // Not needed on x86.
-  points->pFmod = art_fmod_from_code;
-  points->pL2d = art_l2d_from_code;
-  points->pFmodf = art_fmodf_from_code;
-  points->pL2f = art_l2f_from_code;
+  points->pFmod = art_quick_fmod_from_code;
+  points->pL2d = art_quick_l2d_from_code;
+  points->pFmodf = art_quick_fmodf_from_code;
+  points->pL2f = art_quick_l2f_from_code;
   //points->pD2iz = NULL; // Not needed on x86.
   //points->pF2iz = NULL; // Not needed on x86.
-  points->pIdivmod = art_idivmod_from_code;
-  points->pD2l = art_d2l_from_code;
-  points->pF2l = art_f2l_from_code;
-  points->pLdiv = art_ldiv_from_code;
-  points->pLdivmod = art_ldivmod_from_code;
-  points->pLmul = art_lmul_from_code;
-  points->pShlLong = art_lshl_from_code;
-  points->pShrLong = art_lshr_from_code;
-  points->pUshrLong = art_lushr_from_code;
+  points->pIdivmod = art_quick_idivmod_from_code;
+  points->pD2l = art_quick_d2l_from_code;
+  points->pF2l = art_quick_f2l_from_code;
+  points->pLdiv = art_quick_ldiv_from_code;
+  points->pLdivmod = art_quick_ldivmod_from_code;
+  points->pLmul = art_quick_lmul_from_code;
+  points->pShlLong = art_quick_lshl_from_code;
+  points->pShrLong = art_quick_lshr_from_code;
+  points->pUshrLong = art_quick_lushr_from_code;
 
   // Intrinsics
-  points->pIndexOf = art_indexof;
-  points->pMemcmp16 = art_memcmp16;
-  points->pStringCompareTo = art_string_compareto;
-  points->pMemcpy = art_memcpy;
+  points->pIndexOf = art_quick_indexof;
+  points->pMemcmp16 = art_quick_memcmp16;
+  points->pStringCompareTo = art_quick_string_compareto;
+  points->pMemcpy = art_quick_memcpy;
 
   // Invocation
   points->pUnresolvedDirectMethodTrampolineFromCode = UnresolvedDirectMethodTrampolineFromCode;
-  points->pInvokeDirectTrampolineWithAccessCheck = art_invoke_direct_trampoline_with_access_check;
-  points->pInvokeInterfaceTrampoline = art_invoke_interface_trampoline;
-  points->pInvokeInterfaceTrampolineWithAccessCheck = art_invoke_interface_trampoline_with_access_check;
-  points->pInvokeStaticTrampolineWithAccessCheck = art_invoke_static_trampoline_with_access_check;
-  points->pInvokeSuperTrampolineWithAccessCheck = art_invoke_super_trampoline_with_access_check;
-  points->pInvokeVirtualTrampolineWithAccessCheck = art_invoke_virtual_trampoline_with_access_check;
+  points->pInvokeDirectTrampolineWithAccessCheck = art_quick_invoke_direct_trampoline_with_access_check;
+  points->pInvokeInterfaceTrampoline = art_quick_invoke_interface_trampoline;
+  points->pInvokeInterfaceTrampolineWithAccessCheck = art_quick_invoke_interface_trampoline_with_access_check;
+  points->pInvokeStaticTrampolineWithAccessCheck = art_quick_invoke_static_trampoline_with_access_check;
+  points->pInvokeSuperTrampolineWithAccessCheck = art_quick_invoke_super_trampoline_with_access_check;
+  points->pInvokeVirtualTrampolineWithAccessCheck = art_quick_invoke_virtual_trampoline_with_access_check;
 
   // Thread
   points->pCheckSuspendFromCode = CheckSuspendFromCode;
-  points->pTestSuspendFromCode = art_test_suspend;
+  points->pTestSuspendFromCode = art_quick_test_suspend;
 
   // Throws
-  points->pDeliverException = art_deliver_exception_from_code;
+  points->pDeliverException = art_quick_deliver_exception_from_code;
   points->pThrowAbstractMethodErrorFromCode = ThrowAbstractMethodErrorFromCode;
-  points->pThrowArrayBoundsFromCode = art_throw_array_bounds_from_code;
-  points->pThrowDivZeroFromCode = art_throw_div_zero_from_code;
-  points->pThrowNoSuchMethodFromCode = art_throw_no_such_method_from_code;
-  points->pThrowNullPointerFromCode = art_throw_null_pointer_exception_from_code;
-  points->pThrowStackOverflowFromCode = art_throw_stack_overflow_from_code;
+  points->pThrowArrayBoundsFromCode = art_quick_throw_array_bounds_from_code;
+  points->pThrowDivZeroFromCode = art_quick_throw_div_zero_from_code;
+  points->pThrowNoSuchMethodFromCode = art_quick_throw_no_such_method_from_code;
+  points->pThrowNullPointerFromCode = art_quick_throw_null_pointer_exception_from_code;
+  points->pThrowStackOverflowFromCode = art_quick_throw_stack_overflow_from_code;
 };
 
 void ChangeDebuggerEntryPoint(EntryPoints* points, bool enabled) {
-  points->pUpdateDebuggerFromCode = (enabled ? art_update_debugger : NULL);
+  points->pUpdateDebuggerFromCode = (enabled ? art_quick_update_debugger : NULL);
 }
 
 uintptr_t GetInstrumentationExitPc() {
-  return reinterpret_cast<uintptr_t>(art_instrumentation_exit_from_code);
+  return reinterpret_cast<uintptr_t>(art_quick_instrumentation_exit_from_code);
 }
 
 uintptr_t GetDeoptimizationEntryPoint() {
-  return reinterpret_cast<uintptr_t>(art_deoptimize);
+  return reinterpret_cast<uintptr_t>(art_quick_deoptimize);
 }
 
 void* GetInstrumentationEntryPoint() {
-  return reinterpret_cast<void*>(art_instrumentation_entry_from_code);
+  return reinterpret_cast<void*>(art_quick_instrumentation_entry_from_code);
 }
 
 void* GetInterpreterEntryPoint() {
-  return reinterpret_cast<void*>(art_interpreter_entry);
+  return reinterpret_cast<void*>(art_quick_interpreter_entry);
 }
 
 }  // namespace art
diff --git a/src/oat/runtime/x86/runtime_support_x86.S b/src/oat/runtime/x86/runtime_support_x86.S
index 400ae2f..44a8fb6 100644
--- a/src/oat/runtime/x86/runtime_support_x86.S
+++ b/src/oat/runtime/x86/runtime_support_x86.S
@@ -175,34 +175,34 @@
     /*
      * Called by managed code to create and deliver a NullPointerException.
      */
-NO_ARG_RUNTIME_EXCEPTION art_throw_null_pointer_exception_from_code, artThrowNullPointerExceptionFromCode
+NO_ARG_RUNTIME_EXCEPTION art_quick_throw_null_pointer_exception_from_code, artThrowNullPointerExceptionFromCode
 
     /*
      * Called by managed code to create and deliver an ArithmeticException.
      */
-NO_ARG_RUNTIME_EXCEPTION art_throw_div_zero_from_code, artThrowDivZeroFromCode
+NO_ARG_RUNTIME_EXCEPTION art_quick_throw_div_zero_from_code, artThrowDivZeroFromCode
 
     /*
      * Called by managed code to create and deliver a StackOverflowError.
      */
-NO_ARG_RUNTIME_EXCEPTION art_throw_stack_overflow_from_code, artThrowStackOverflowFromCode
+NO_ARG_RUNTIME_EXCEPTION art_quick_throw_stack_overflow_from_code, artThrowStackOverflowFromCode
 
     /*
      * Called by managed code, saves callee saves and then calls artThrowException
      * that will place a mock Method* at the bottom of the stack. Arg1 holds the exception.
      */
-ONE_ARG_RUNTIME_EXCEPTION art_deliver_exception_from_code, artDeliverExceptionFromCode
+ONE_ARG_RUNTIME_EXCEPTION art_quick_deliver_exception_from_code, artDeliverExceptionFromCode
 
     /*
      * Called by managed code to create and deliver a NoSuchMethodError.
      */
-ONE_ARG_RUNTIME_EXCEPTION art_throw_no_such_method_from_code, artThrowNoSuchMethodFromCode
+ONE_ARG_RUNTIME_EXCEPTION art_quick_throw_no_such_method_from_code, artThrowNoSuchMethodFromCode
 
     /*
      * Called by managed code to create and deliver an ArrayIndexOutOfBoundsException. Arg1 holds
      * index, arg2 holds limit.
      */
-TWO_ARG_RUNTIME_EXCEPTION art_throw_array_bounds_from_code, artThrowArrayBoundsFromCode
+TWO_ARG_RUNTIME_EXCEPTION art_quick_throw_array_bounds_from_code, artThrowArrayBoundsFromCode
 
     /*
      * All generated callsites for interface invokes and invocation slow paths will load arguments
@@ -260,13 +260,13 @@
     DELIVER_PENDING_EXCEPTION
 END_MACRO
 
-INVOKE_TRAMPOLINE art_invoke_interface_trampoline, artInvokeInterfaceTrampoline
-INVOKE_TRAMPOLINE art_invoke_interface_trampoline_with_access_check, artInvokeInterfaceTrampolineWithAccessCheck
+INVOKE_TRAMPOLINE art_quick_invoke_interface_trampoline, artInvokeInterfaceTrampoline
+INVOKE_TRAMPOLINE art_quick_invoke_interface_trampoline_with_access_check, artInvokeInterfaceTrampolineWithAccessCheck
 
-INVOKE_TRAMPOLINE art_invoke_static_trampoline_with_access_check, artInvokeStaticTrampolineWithAccessCheck
-INVOKE_TRAMPOLINE art_invoke_direct_trampoline_with_access_check, artInvokeDirectTrampolineWithAccessCheck
-INVOKE_TRAMPOLINE art_invoke_super_trampoline_with_access_check, artInvokeSuperTrampolineWithAccessCheck
-INVOKE_TRAMPOLINE art_invoke_virtual_trampoline_with_access_check, artInvokeVirtualTrampolineWithAccessCheck
+INVOKE_TRAMPOLINE art_quick_invoke_static_trampoline_with_access_check, artInvokeStaticTrampolineWithAccessCheck
+INVOKE_TRAMPOLINE art_quick_invoke_direct_trampoline_with_access_check, artInvokeDirectTrampolineWithAccessCheck
+INVOKE_TRAMPOLINE art_quick_invoke_super_trampoline_with_access_check, artInvokeSuperTrampolineWithAccessCheck
+INVOKE_TRAMPOLINE art_quick_invoke_virtual_trampoline_with_access_check, artInvokeVirtualTrampolineWithAccessCheck
 
 MACRO3(NO_ARG_DOWNCALL, c_name, cxx_name, return_macro)
     .globl VAR(c_name, 0)
@@ -362,22 +362,22 @@
     DELIVER_PENDING_EXCEPTION
 END_MACRO
 
-TWO_ARG_DOWNCALL art_alloc_object_from_code, artAllocObjectFromCode, RETURN_IF_EAX_NOT_ZERO
-TWO_ARG_DOWNCALL art_alloc_object_from_code_with_access_check, artAllocObjectFromCodeWithAccessCheck, RETURN_IF_EAX_NOT_ZERO
-THREE_ARG_DOWNCALL art_alloc_array_from_code, artAllocArrayFromCode, RETURN_IF_EAX_NOT_ZERO
-THREE_ARG_DOWNCALL art_alloc_array_from_code_with_access_check, artAllocArrayFromCodeWithAccessCheck, RETURN_IF_EAX_NOT_ZERO
-THREE_ARG_DOWNCALL art_check_and_alloc_array_from_code, artCheckAndAllocArrayFromCode, RETURN_IF_EAX_NOT_ZERO
-THREE_ARG_DOWNCALL art_check_and_alloc_array_from_code_with_access_check, artCheckAndAllocArrayFromCodeWithAccessCheck, RETURN_IF_EAX_NOT_ZERO
+TWO_ARG_DOWNCALL art_quick_alloc_object_from_code, artAllocObjectFromCode, RETURN_IF_EAX_NOT_ZERO
+TWO_ARG_DOWNCALL art_quick_alloc_object_from_code_with_access_check, artAllocObjectFromCodeWithAccessCheck, RETURN_IF_EAX_NOT_ZERO
+THREE_ARG_DOWNCALL art_quick_alloc_array_from_code, artAllocArrayFromCode, RETURN_IF_EAX_NOT_ZERO
+THREE_ARG_DOWNCALL art_quick_alloc_array_from_code_with_access_check, artAllocArrayFromCodeWithAccessCheck, RETURN_IF_EAX_NOT_ZERO
+THREE_ARG_DOWNCALL art_quick_check_and_alloc_array_from_code, artCheckAndAllocArrayFromCode, RETURN_IF_EAX_NOT_ZERO
+THREE_ARG_DOWNCALL art_quick_check_and_alloc_array_from_code_with_access_check, artCheckAndAllocArrayFromCodeWithAccessCheck, RETURN_IF_EAX_NOT_ZERO
 
-TWO_ARG_DOWNCALL art_resolve_string_from_code, artResolveStringFromCode, RETURN_IF_EAX_NOT_ZERO
-TWO_ARG_DOWNCALL art_initialize_static_storage_from_code, artInitializeStaticStorageFromCode, RETURN_IF_EAX_NOT_ZERO
-TWO_ARG_DOWNCALL art_initialize_type_from_code, artInitializeTypeFromCode, RETURN_IF_EAX_NOT_ZERO
-TWO_ARG_DOWNCALL art_initialize_type_and_verify_access_from_code, artInitializeTypeAndVerifyAccessFromCode, RETURN_IF_EAX_NOT_ZERO
+TWO_ARG_DOWNCALL art_quick_resolve_string_from_code, artResolveStringFromCode, RETURN_IF_EAX_NOT_ZERO
+TWO_ARG_DOWNCALL art_quick_initialize_static_storage_from_code, artInitializeStaticStorageFromCode, RETURN_IF_EAX_NOT_ZERO
+TWO_ARG_DOWNCALL art_quick_initialize_type_from_code, artInitializeTypeFromCode, RETURN_IF_EAX_NOT_ZERO
+TWO_ARG_DOWNCALL art_quick_initialize_type_and_verify_access_from_code, artInitializeTypeAndVerifyAccessFromCode, RETURN_IF_EAX_NOT_ZERO
 
     /*
      * On entry, eax and ecx must be preserved, edx is dex PC
      */
-DEFINE_FUNCTION art_update_debugger
+DEFINE_FUNCTION art_quick_update_debugger
     mov %eax, %ebx                // stash away eax so that it's saved as if it were an argument
     SETUP_REF_AND_ARGS_CALLEE_SAVE_FRAME
     subl LITERAL(4), %esp         // alignment padding
@@ -390,12 +390,12 @@
     mov %ebx, %eax                // restore original eax
     ret
 
-ONE_ARG_DOWNCALL art_lock_object_from_code, artLockObjectFromCode, ret
-ONE_ARG_DOWNCALL art_unlock_object_from_code, artUnlockObjectFromCode, RETURN_IF_EAX_ZERO
+ONE_ARG_DOWNCALL art_quick_lock_object_from_code, artLockObjectFromCode, ret
+ONE_ARG_DOWNCALL art_quick_unlock_object_from_code, artUnlockObjectFromCode, RETURN_IF_EAX_ZERO
 
-TWO_ARG_DOWNCALL art_handle_fill_data_from_code, artHandleFillArrayDataFromCode, RETURN_IF_EAX_ZERO
+TWO_ARG_DOWNCALL art_quick_handle_fill_data_from_code, artHandleFillArrayDataFromCode, RETURN_IF_EAX_ZERO
 
-DEFINE_FUNCTION art_is_assignable_from_code
+DEFINE_FUNCTION art_quick_is_assignable_from_code
     pushl %eax                    // alignment padding
     pushl %ecx                    // pass arg2
     pushl %eax                    // pass arg1
@@ -403,7 +403,7 @@
     addl LITERAL(12), %esp        // pop arguments
     ret
 
-DEFINE_FUNCTION art_memcpy
+DEFINE_FUNCTION art_quick_memcpy
     pushl %edx                    // pass arg3
     pushl %ecx                    // pass arg2
     pushl %eax                    // pass arg1
@@ -411,12 +411,12 @@
     addl LITERAL(12), %esp        // pop arguments
     ret
 
-TWO_ARG_DOWNCALL art_check_cast_from_code, artCheckCastFromCode, RETURN_IF_EAX_ZERO
-TWO_ARG_DOWNCALL art_can_put_array_element_from_code, artCanPutArrayElementFromCode, RETURN_IF_EAX_ZERO
+TWO_ARG_DOWNCALL art_quick_check_cast_from_code, artCheckCastFromCode, RETURN_IF_EAX_ZERO
+TWO_ARG_DOWNCALL art_quick_can_put_array_element_from_code, artCanPutArrayElementFromCode, RETURN_IF_EAX_ZERO
 
-NO_ARG_DOWNCALL art_test_suspend, artTestSuspendFromCode, ret
+NO_ARG_DOWNCALL art_quick_test_suspend, artTestSuspendFromCode, ret
 
-DEFINE_FUNCTION art_fmod_from_code
+DEFINE_FUNCTION art_quick_fmod_from_code
     subl LITERAL(12), %esp        // alignment padding
     pushl %ebx                    // pass arg4 b.hi
     pushl %edx                    // pass arg3 b.lo
@@ -428,7 +428,7 @@
     addl LITERAL(28), %esp        // pop arguments
     ret
 
-DEFINE_FUNCTION art_fmodf_from_code
+DEFINE_FUNCTION art_quick_fmodf_from_code
     pushl %eax                    // alignment padding
     pushl %ecx                    // pass arg2 b
     pushl %eax                    // pass arg1 a
@@ -438,7 +438,7 @@
     addl LITERAL(12), %esp        // pop arguments
     ret
 
-DEFINE_FUNCTION art_l2d_from_code
+DEFINE_FUNCTION art_quick_l2d_from_code
     pushl %eax                    // alignment padding
     pushl %ecx                    // pass arg2 a.hi
     pushl %eax                    // pass arg1 a.lo
@@ -448,7 +448,7 @@
     addl LITERAL(12), %esp        // pop arguments
     ret
 
-DEFINE_FUNCTION art_l2f_from_code
+DEFINE_FUNCTION art_quick_l2f_from_code
     pushl %eax                    // alignment padding
     pushl %ecx                    // pass arg2 a.hi
     pushl %eax                    // pass arg1 a.lo
@@ -458,7 +458,7 @@
     addl LITERAL(12), %esp        // pop arguments
     ret
 
-DEFINE_FUNCTION art_d2l_from_code
+DEFINE_FUNCTION art_quick_d2l_from_code
     pushl %eax                    // alignment padding
     pushl %ecx                    // pass arg2 a.hi
     pushl %eax                    // pass arg1 a.lo
@@ -466,14 +466,14 @@
     addl LITERAL(12), %esp        // pop arguments
     ret
 
-DEFINE_FUNCTION art_f2l_from_code
+DEFINE_FUNCTION art_quick_f2l_from_code
     subl LITERAL(8), %esp         // alignment padding
     pushl %eax                    // pass arg1 a
     call SYMBOL(art_f2l)          // (jfloat a)
     addl LITERAL(12), %esp        // pop arguments
     ret
 
-DEFINE_FUNCTION art_idivmod_from_code
+DEFINE_FUNCTION art_quick_idivmod_from_code
     cmpl LITERAL(0x80000000), %eax
     je check_arg2  // special case
 args_ok:
@@ -486,7 +486,7 @@
     xorl %edx, %edx
     ret         // eax already holds min int
 
-DEFINE_FUNCTION art_ldiv_from_code
+DEFINE_FUNCTION art_quick_ldiv_from_code
     subl LITERAL(12), %esp        // alignment padding
     pushl %ebx                    // pass arg4 b.hi
     pushl %edx                    // pass arg3 b.lo
@@ -496,7 +496,7 @@
     addl LITERAL(28), %esp        // pop arguments
     ret
 
-DEFINE_FUNCTION art_ldivmod_from_code
+DEFINE_FUNCTION art_quick_ldivmod_from_code
     subl LITERAL(12), %esp        // alignment padding
     pushl %ebx                    // pass arg4 b.hi
     pushl %edx                    // pass arg3 b.lo
@@ -506,7 +506,7 @@
     addl LITERAL(28), %esp        // pop arguments
     ret
 
-DEFINE_FUNCTION art_lmul_from_code
+DEFINE_FUNCTION art_quick_lmul_from_code
     subl LITERAL(12), %esp        // alignment padding
     pushl %ebx                    // pass arg4 b.hi
     pushl %edx                    // pass arg3 b.lo
@@ -516,7 +516,7 @@
     addl LITERAL(28), %esp        // pop arguments
     ret
 
-DEFINE_FUNCTION art_lshl_from_code
+DEFINE_FUNCTION art_quick_lshl_from_code
     // ecx:eax << edx
     xchg %edx, %ecx
     shld %cl,%eax,%edx
@@ -528,7 +528,7 @@
 1:
     ret
 
-DEFINE_FUNCTION art_lshr_from_code
+DEFINE_FUNCTION art_quick_lshr_from_code
     // ecx:eax >> edx
     xchg %edx, %ecx
     shrd %cl,%edx,%eax
@@ -540,7 +540,7 @@
 1:
     ret
 
-DEFINE_FUNCTION art_lushr_from_code
+DEFINE_FUNCTION art_quick_lushr_from_code
     // ecx:eax >>> edx
     xchg %edx, %ecx
     shrd %cl,%edx,%eax
@@ -552,7 +552,7 @@
 1:
     ret
 
-DEFINE_FUNCTION art_set32_instance_from_code
+DEFINE_FUNCTION art_quick_set32_instance_from_code
     SETUP_REF_ONLY_CALLEE_SAVE_FRAME       // save ref containing registers for GC
     mov %esp, %ebx                // remember SP
     subl LITERAL(8), %esp         // alignment padding
@@ -568,7 +568,7 @@
     RESTORE_REF_ONLY_CALLEE_SAVE_FRAME     // restore frame up to return address
     RETURN_IF_EAX_ZERO            // return or deliver exception
 
-DEFINE_FUNCTION art_set64_instance_from_code
+DEFINE_FUNCTION art_quick_set64_instance_from_code
     SETUP_REF_ONLY_CALLEE_SAVE_FRAME       // save ref containing registers for GC
     subl LITERAL(8), %esp         // alignment padding
     pushl %esp                    // pass SP-8
@@ -583,7 +583,7 @@
     RESTORE_REF_ONLY_CALLEE_SAVE_FRAME     // restore frame up to return address
     RETURN_IF_EAX_ZERO            // return or deliver exception
 
-DEFINE_FUNCTION art_set_obj_instance_from_code
+DEFINE_FUNCTION art_quick_set_obj_instance_from_code
     SETUP_REF_ONLY_CALLEE_SAVE_FRAME       // save ref containing registers for GC
     mov %esp, %ebx                // remember SP
     subl LITERAL(8), %esp         // alignment padding
@@ -599,7 +599,7 @@
     RESTORE_REF_ONLY_CALLEE_SAVE_FRAME     // restore frame up to return address
     RETURN_IF_EAX_ZERO            // return or deliver exception
 
-DEFINE_FUNCTION art_get32_instance_from_code
+DEFINE_FUNCTION art_quick_get32_instance_from_code
     SETUP_REF_ONLY_CALLEE_SAVE_FRAME       // save ref containing registers for GC
     mov %esp, %ebx                // remember SP
     mov 32(%esp), %edx            // get referrer
@@ -614,7 +614,7 @@
     RESTORE_REF_ONLY_CALLEE_SAVE_FRAME     // restore frame up to return address
     RETURN_OR_DELIVER_PENDING_EXCEPTION    // return or deliver exception
 
-DEFINE_FUNCTION art_get64_instance_from_code
+DEFINE_FUNCTION art_quick_get64_instance_from_code
     SETUP_REF_ONLY_CALLEE_SAVE_FRAME       // save ref containing registers for GC
     mov %esp, %ebx                // remember SP
     mov 32(%esp), %edx            // get referrer
@@ -629,7 +629,7 @@
     RESTORE_REF_ONLY_CALLEE_SAVE_FRAME     // restore frame up to return address
     RETURN_OR_DELIVER_PENDING_EXCEPTION    // return or deliver exception
 
-DEFINE_FUNCTION art_get_obj_instance_from_code
+DEFINE_FUNCTION art_quick_get_obj_instance_from_code
     SETUP_REF_ONLY_CALLEE_SAVE_FRAME       // save ref containing registers for GC
     mov %esp, %ebx                // remember SP
     mov 32(%esp), %edx            // get referrer
@@ -644,7 +644,7 @@
     RESTORE_REF_ONLY_CALLEE_SAVE_FRAME     // restore frame up to return address
     RETURN_OR_DELIVER_PENDING_EXCEPTION    // return or deliver exception
 
-DEFINE_FUNCTION art_set32_static_from_code
+DEFINE_FUNCTION art_quick_set32_static_from_code
     SETUP_REF_ONLY_CALLEE_SAVE_FRAME       // save ref containing registers for GC
     mov %esp, %ebx                // remember SP
     mov 32(%esp), %edx            // get referrer
@@ -659,7 +659,7 @@
     RESTORE_REF_ONLY_CALLEE_SAVE_FRAME     // restore frame up to return address
     RETURN_IF_EAX_ZERO            // return or deliver exception
 
-DEFINE_FUNCTION art_set64_static_from_code
+DEFINE_FUNCTION art_quick_set64_static_from_code
     SETUP_REF_ONLY_CALLEE_SAVE_FRAME       // save ref containing registers for GC
     mov %esp, %ebx                // remember SP
     subl LITERAL(8), %esp         // alignment padding
@@ -675,7 +675,7 @@
     RESTORE_REF_ONLY_CALLEE_SAVE_FRAME     // restore frame up to return address
     RETURN_IF_EAX_ZERO            // return or deliver exception
 
-DEFINE_FUNCTION art_set_obj_static_from_code
+DEFINE_FUNCTION art_quick_set_obj_static_from_code
     SETUP_REF_ONLY_CALLEE_SAVE_FRAME       // save ref containing registers for GC
     mov %esp, %ebx                // remember SP
     mov 32(%esp), %edx            // get referrer
@@ -690,7 +690,7 @@
     RESTORE_REF_ONLY_CALLEE_SAVE_FRAME     // restore frame up to return address
     RETURN_IF_EAX_ZERO            // return or deliver exception
 
-DEFINE_FUNCTION art_get32_static_from_code
+DEFINE_FUNCTION art_quick_get32_static_from_code
     SETUP_REF_ONLY_CALLEE_SAVE_FRAME       // save ref containing registers for GC
     mov %esp, %edx                // remember SP
     mov 32(%esp), %ecx            // get referrer
@@ -703,7 +703,7 @@
     RESTORE_REF_ONLY_CALLEE_SAVE_FRAME     // restore frame up to return address
     RETURN_OR_DELIVER_PENDING_EXCEPTION    // return or deliver exception
 
-DEFINE_FUNCTION art_get64_static_from_code
+DEFINE_FUNCTION art_quick_get64_static_from_code
     SETUP_REF_ONLY_CALLEE_SAVE_FRAME       // save ref containing registers for GC
     mov %esp, %edx                // remember SP
     mov 32(%esp), %ecx            // get referrer
@@ -716,7 +716,7 @@
     RESTORE_REF_ONLY_CALLEE_SAVE_FRAME     // restore frame up to return address
     RETURN_OR_DELIVER_PENDING_EXCEPTION    // return or deliver exception
 
-DEFINE_FUNCTION art_get_obj_static_from_code
+DEFINE_FUNCTION art_quick_get_obj_static_from_code
     SETUP_REF_ONLY_CALLEE_SAVE_FRAME       // save ref containing registers for GC
     mov %esp, %edx                // remember SP
     mov 32(%esp), %ecx            // get referrer
@@ -729,7 +729,7 @@
     RESTORE_REF_ONLY_CALLEE_SAVE_FRAME     // restore frame up to return address
     RETURN_OR_DELIVER_PENDING_EXCEPTION    // return or deliver exception
 
-DEFINE_FUNCTION art_proxy_invoke_handler
+DEFINE_FUNCTION art_quick_proxy_invoke_handler
     SETUP_REF_AND_ARGS_CALLEE_SAVE_FRAME   // save frame and Method*
     pushl %esp                    // pass SP
     pushl %fs:THREAD_SELF_OFFSET  // pass Thread::Current()
@@ -742,7 +742,7 @@
     addl LITERAL(44), %esp        // pop arguments
     RETURN_OR_DELIVER_PENDING_EXCEPTION    // return or deliver exception
 
-DEFINE_FUNCTION art_interpreter_entry
+DEFINE_FUNCTION art_quick_interpreter_entry
     SETUP_REF_AND_ARGS_CALLEE_SAVE_FRAME   // save frame and Method*
     pushl %eax                    // alignment padding
     pushl %esp                    // pass SP
@@ -758,7 +758,7 @@
     /*
      * Routine that intercepts method calls and returns.
      */
-DEFINE_FUNCTION art_instrumentation_entry_from_code
+DEFINE_FUNCTION art_quick_instrumentation_entry_from_code
     xchgl %eax, (%esp)            // place LR in eax, save eax
     pushl %ecx                    // save ecx
     pushl %edx                    // save edx
@@ -775,10 +775,10 @@
     movl  (%esp), %ecx            // restore ecx (without popping)
     movl  %eax, (%esp)            // place method's code pointer on stack
     movl  4(%esp), %eax           // restore eax (without popping)
-    movl  LITERAL(SYMBOL(art_instrumentation_exit_from_code)), 4(%esp)
+    movl  LITERAL(SYMBOL(art_quick_instrumentation_exit_from_code)), 4(%esp)
                                   // place instrumentation exit as return pc
     ret                           // call method (and pop)
-DEFINE_FUNCTION art_instrumentation_exit_from_code
+DEFINE_FUNCTION art_quick_instrumentation_exit_from_code
     mov   %esp, %ecx              // remember bottom of caller's frame
     pushl %edx                    // save return value
     pushl %eax                    // save other half of return value
@@ -798,7 +798,7 @@
      * registers depending on how complete the operation is when we safepoint - for example, a
      * set operation may have completed while a get operation needs writing back into the vregs.
      */
-DEFINE_FUNCTION art_deoptimize
+DEFINE_FUNCTION art_quick_deoptimize
     SETUP_REF_ONLY_CALLEE_SAVE_FRAME
     pushl %esp                    // pass SP
     pushl %fs:THREAD_SELF_OFFSET  // pass Thread::Current()
@@ -826,7 +826,7 @@
      *    ecx:   char to match (known <= 0xFFFF)
      *    edx:   Starting offset in string data
      */
-DEFINE_FUNCTION art_indexof
+DEFINE_FUNCTION art_quick_indexof
     pushl %edi                    // push callee save reg
     mov STRING_COUNT_OFFSET(%eax), %ebx
     mov STRING_VALUE_OFFSET(%eax), %edi
@@ -874,7 +874,7 @@
      *    eax:   this string object (known non-null)
      *    ecx:   comp string object (known non-null)
      */
-DEFINE_FUNCTION art_string_compareto
+DEFINE_FUNCTION art_quick_string_compareto
     pushl %esi                    // push callee save reg
     pushl %edi                    // push callee save reg
     mov STRING_COUNT_OFFSET(%eax), %edx
@@ -920,4 +920,4 @@
 END_MACRO
 
     // TODO: implement these!
-UNIMPLEMENTED art_memcmp16
+UNIMPLEMENTED art_quick_memcmp16
diff --git a/src/runtime_support.h b/src/runtime_support.h
index 09ca0aa..1c6c38c 100644
--- a/src/runtime_support.h
+++ b/src/runtime_support.h
@@ -31,7 +31,7 @@
 #include "thread.h"
 
 extern "C" void art_interpreter_invoke_handler();
-extern "C" void art_proxy_invoke_handler();
+extern "C" void art_quick_proxy_invoke_handler();
 extern "C" void art_work_around_app_jni_bugs();
 
 extern "C" double art_l2d(int64_t l);