Merge "Add some comments to describe assembly #defines." into dalvik-dev
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/codegen/mir_to_gbc.cc b/src/compiler/codegen/mir_to_gbc.cc
index ba90269..79ac242 100644
--- a/src/compiler/codegen/mir_to_gbc.cc
+++ b/src/compiler/codegen/mir_to_gbc.cc
@@ -1018,7 +1018,7 @@
}
EmitPopShadowFrame(cu);
cu->irb->CreateRet(GetLLVMValue(cu, rl_src[0].orig_sreg));
- DCHECK(bb->has_return);
+ bb->has_return = true;
}
break;
@@ -1028,7 +1028,7 @@
}
EmitPopShadowFrame(cu);
cu->irb->CreateRetVoid();
- DCHECK(bb->has_return);
+ bb->has_return = true;
}
break;
diff --git a/src/compiler/frontend.cc b/src/compiler/frontend.cc
index 6eb117a..44baea2 100644
--- a/src/compiler/frontend.cc
+++ b/src/compiler/frontend.cc
@@ -972,7 +972,6 @@
cur_block = ProcessCanBranch(cu.get(), cur_block, insn, cur_offset,
width, flags, code_ptr, code_end);
} else if (flags & Instruction::kReturn) {
- cur_block->has_return = true;
cur_block->fall_through = exit_block;
InsertGrowableList(cu.get(), exit_block->predecessors,
reinterpret_cast<uintptr_t>(cur_block));
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);