From 7940e44f4517de5e2634a7e07d58d0fb26160513 Mon Sep 17 00:00:00 2001 From: Brian Carlstrom Date: Fri, 12 Jul 2013 13:46:57 -0700 Subject: Create separate Android.mk for main build targets The runtime, compiler, dex2oat, and oatdump now are in seperate trees to prevent dependency creep. They can now be individually built without rebuilding the rest of the art projects. dalvikvm and jdwpspy were already this way. Builds in the art directory should behave as before, building everything including tests. Change-Id: Ic6b1151e5ed0f823c3dd301afd2b13eb2d8feb81 --- compiler/llvm/generated/art_module.cc | 1096 +++++++++++++++++++++++++++++++++ 1 file changed, 1096 insertions(+) create mode 100644 compiler/llvm/generated/art_module.cc (limited to 'compiler/llvm/generated/art_module.cc') diff --git a/compiler/llvm/generated/art_module.cc b/compiler/llvm/generated/art_module.cc new file mode 100644 index 0000000000..bcd90b96a1 --- /dev/null +++ b/compiler/llvm/generated/art_module.cc @@ -0,0 +1,1096 @@ +// Generated with ./gen_art_module_cc.sh + + +#pragma GCC diagnostic ignored "-Wframe-larger-than=" +// TODO: Remove this pragma after llc can generate makeLLVMModuleContents() +// with smaller frame size. + +#include +#include +#include +#include + +#include + +using namespace llvm; + +namespace art { +namespace llvm { + + +// Generated by llvm2cpp - DO NOT MODIFY! + + +Module* makeLLVMModuleContents(Module *mod) { + +mod->setModuleIdentifier("art_module.ll"); + +// Type Definitions +std::vectorFuncTy_0_args; +StructType *StructTy_JavaObject = mod->getTypeByName("JavaObject"); +if (!StructTy_JavaObject) { +StructTy_JavaObject = StructType::create(mod->getContext(), "JavaObject"); +} +std::vectorStructTy_JavaObject_fields; +if (StructTy_JavaObject->isOpaque()) { +StructTy_JavaObject->setBody(StructTy_JavaObject_fields, /*isPacked=*/false); +} + +PointerType* PointerTy_1 = PointerType::get(StructTy_JavaObject, 0); + +FuncTy_0_args.push_back(PointerTy_1); +StructType *StructTy_ShadowFrame = mod->getTypeByName("ShadowFrame"); +if (!StructTy_ShadowFrame) { +StructTy_ShadowFrame = StructType::create(mod->getContext(), "ShadowFrame"); +} +std::vectorStructTy_ShadowFrame_fields; +StructTy_ShadowFrame_fields.push_back(IntegerType::get(mod->getContext(), 32)); +PointerType* PointerTy_2 = PointerType::get(StructTy_ShadowFrame, 0); + +StructTy_ShadowFrame_fields.push_back(PointerTy_2); +StructTy_ShadowFrame_fields.push_back(PointerTy_1); +StructTy_ShadowFrame_fields.push_back(IntegerType::get(mod->getContext(), 32)); +if (StructTy_ShadowFrame->isOpaque()) { +StructTy_ShadowFrame->setBody(StructTy_ShadowFrame_fields, /*isPacked=*/false); +} + + +FuncTy_0_args.push_back(PointerTy_2); +FunctionType* FuncTy_0 = FunctionType::get( + /*Result=*/Type::getVoidTy(mod->getContext()), + /*Params=*/FuncTy_0_args, + /*isVarArg=*/false); + +std::vectorFuncTy_3_args; +FunctionType* FuncTy_3 = FunctionType::get( + /*Result=*/PointerTy_1, + /*Params=*/FuncTy_3_args, + /*isVarArg=*/false); + +std::vectorFuncTy_4_args; +FuncTy_4_args.push_back(PointerTy_1); +FunctionType* FuncTy_4 = FunctionType::get( + /*Result=*/PointerTy_1, + /*Params=*/FuncTy_4_args, + /*isVarArg=*/false); + +std::vectorFuncTy_5_args; +FuncTy_5_args.push_back(PointerTy_1); +FuncTy_5_args.push_back(PointerTy_1); +FunctionType* FuncTy_5 = FunctionType::get( + /*Result=*/Type::getVoidTy(mod->getContext()), + /*Params=*/FuncTy_5_args, + /*isVarArg=*/false); + +std::vectorFuncTy_6_args; +FuncTy_6_args.push_back(PointerTy_1); +FunctionType* FuncTy_6 = FunctionType::get( + /*Result=*/Type::getVoidTy(mod->getContext()), + /*Params=*/FuncTy_6_args, + /*isVarArg=*/false); + +std::vectorFuncTy_7_args; +FuncTy_7_args.push_back(PointerTy_1); +FuncTy_7_args.push_back(PointerTy_2); +FuncTy_7_args.push_back(PointerTy_1); +FuncTy_7_args.push_back(IntegerType::get(mod->getContext(), 32)); +FunctionType* FuncTy_7 = FunctionType::get( + /*Result=*/PointerTy_2, + /*Params=*/FuncTy_7_args, + /*isVarArg=*/false); + +std::vectorFuncTy_8_args; +FuncTy_8_args.push_back(PointerTy_2); +FunctionType* FuncTy_8 = FunctionType::get( + /*Result=*/Type::getVoidTy(mod->getContext()), + /*Params=*/FuncTy_8_args, + /*isVarArg=*/false); + +std::vectorFuncTy_9_args; +FunctionType* FuncTy_9 = FunctionType::get( + /*Result=*/Type::getVoidTy(mod->getContext()), + /*Params=*/FuncTy_9_args, + /*isVarArg=*/false); + +std::vectorFuncTy_10_args; +FuncTy_10_args.push_back(IntegerType::get(mod->getContext(), 32)); +FuncTy_10_args.push_back(IntegerType::get(mod->getContext(), 32)); +FunctionType* FuncTy_10 = FunctionType::get( + /*Result=*/Type::getVoidTy(mod->getContext()), + /*Params=*/FuncTy_10_args, + /*isVarArg=*/false); + +std::vectorFuncTy_11_args; +FuncTy_11_args.push_back(IntegerType::get(mod->getContext(), 32)); +FunctionType* FuncTy_11 = FunctionType::get( + /*Result=*/Type::getVoidTy(mod->getContext()), + /*Params=*/FuncTy_11_args, + /*isVarArg=*/false); + +std::vectorFuncTy_12_args; +FuncTy_12_args.push_back(PointerTy_1); +FuncTy_12_args.push_back(IntegerType::get(mod->getContext(), 32)); +FunctionType* FuncTy_12 = FunctionType::get( + /*Result=*/IntegerType::get(mod->getContext(), 32), + /*Params=*/FuncTy_12_args, + /*isVarArg=*/false); + +std::vectorFuncTy_13_args; +FuncTy_13_args.push_back(IntegerType::get(mod->getContext(), 32)); +FuncTy_13_args.push_back(PointerTy_1); +FuncTy_13_args.push_back(PointerTy_1); +FunctionType* FuncTy_13 = FunctionType::get( + /*Result=*/PointerTy_1, + /*Params=*/FuncTy_13_args, + /*isVarArg=*/false); + +std::vectorFuncTy_14_args; +FuncTy_14_args.push_back(IntegerType::get(mod->getContext(), 32)); +FuncTy_14_args.push_back(PointerTy_1); +FuncTy_14_args.push_back(IntegerType::get(mod->getContext(), 32)); +FuncTy_14_args.push_back(PointerTy_1); +FunctionType* FuncTy_14 = FunctionType::get( + /*Result=*/PointerTy_1, + /*Params=*/FuncTy_14_args, + /*isVarArg=*/false); + +std::vectorFuncTy_15_args; +FuncTy_15_args.push_back(IntegerType::get(mod->getContext(), 32)); +FuncTy_15_args.push_back(PointerTy_1); +FunctionType* FuncTy_15 = FunctionType::get( + /*Result=*/Type::getVoidTy(mod->getContext()), + /*Params=*/FuncTy_15_args, + /*isVarArg=*/false); + +std::vectorFuncTy_16_args; +FuncTy_16_args.push_back(IntegerType::get(mod->getContext(), 32)); +FuncTy_16_args.push_back(PointerTy_1); +FuncTy_16_args.push_back(PointerTy_1); +FuncTy_16_args.push_back(PointerTy_1); +FunctionType* FuncTy_16 = FunctionType::get( + /*Result=*/PointerTy_1, + /*Params=*/FuncTy_16_args, + /*isVarArg=*/false); + +std::vectorFuncTy_17_args; +FuncTy_17_args.push_back(PointerTy_1); +FuncTy_17_args.push_back(IntegerType::get(mod->getContext(), 32)); +FunctionType* FuncTy_17 = FunctionType::get( + /*Result=*/PointerTy_1, + /*Params=*/FuncTy_17_args, + /*isVarArg=*/false); + +std::vectorFuncTy_18_args; +FuncTy_18_args.push_back(IntegerType::get(mod->getContext(), 32)); +FuncTy_18_args.push_back(PointerTy_1); +FuncTy_18_args.push_back(IntegerType::get(mod->getContext(), 32)); +FunctionType* FuncTy_18 = FunctionType::get( + /*Result=*/IntegerType::get(mod->getContext(), 32), + /*Params=*/FuncTy_18_args, + /*isVarArg=*/false); + +std::vectorFuncTy_19_args; +FuncTy_19_args.push_back(IntegerType::get(mod->getContext(), 32)); +FuncTy_19_args.push_back(PointerTy_1); +FuncTy_19_args.push_back(IntegerType::get(mod->getContext(), 64)); +FunctionType* FuncTy_19 = FunctionType::get( + /*Result=*/IntegerType::get(mod->getContext(), 32), + /*Params=*/FuncTy_19_args, + /*isVarArg=*/false); + +std::vectorFuncTy_20_args; +FuncTy_20_args.push_back(IntegerType::get(mod->getContext(), 32)); +FuncTy_20_args.push_back(PointerTy_1); +FuncTy_20_args.push_back(PointerTy_1); +FunctionType* FuncTy_20 = FunctionType::get( + /*Result=*/IntegerType::get(mod->getContext(), 32), + /*Params=*/FuncTy_20_args, + /*isVarArg=*/false); + +std::vectorFuncTy_21_args; +FuncTy_21_args.push_back(IntegerType::get(mod->getContext(), 32)); +FuncTy_21_args.push_back(PointerTy_1); +FunctionType* FuncTy_21 = FunctionType::get( + /*Result=*/IntegerType::get(mod->getContext(), 32), + /*Params=*/FuncTy_21_args, + /*isVarArg=*/false); + +std::vectorFuncTy_22_args; +FuncTy_22_args.push_back(IntegerType::get(mod->getContext(), 32)); +FuncTy_22_args.push_back(PointerTy_1); +FunctionType* FuncTy_22 = FunctionType::get( + /*Result=*/IntegerType::get(mod->getContext(), 64), + /*Params=*/FuncTy_22_args, + /*isVarArg=*/false); + +std::vectorFuncTy_23_args; +FuncTy_23_args.push_back(IntegerType::get(mod->getContext(), 32)); +FuncTy_23_args.push_back(PointerTy_1); +FunctionType* FuncTy_23 = FunctionType::get( + /*Result=*/PointerTy_1, + /*Params=*/FuncTy_23_args, + /*isVarArg=*/false); + +std::vectorFuncTy_24_args; +FuncTy_24_args.push_back(IntegerType::get(mod->getContext(), 32)); +FuncTy_24_args.push_back(PointerTy_1); +FuncTy_24_args.push_back(PointerTy_1); +FuncTy_24_args.push_back(IntegerType::get(mod->getContext(), 32)); +FunctionType* FuncTy_24 = FunctionType::get( + /*Result=*/IntegerType::get(mod->getContext(), 32), + /*Params=*/FuncTy_24_args, + /*isVarArg=*/false); + +std::vectorFuncTy_25_args; +FuncTy_25_args.push_back(IntegerType::get(mod->getContext(), 32)); +FuncTy_25_args.push_back(PointerTy_1); +FuncTy_25_args.push_back(PointerTy_1); +FuncTy_25_args.push_back(IntegerType::get(mod->getContext(), 64)); +FunctionType* FuncTy_25 = FunctionType::get( + /*Result=*/IntegerType::get(mod->getContext(), 32), + /*Params=*/FuncTy_25_args, + /*isVarArg=*/false); + +std::vectorFuncTy_26_args; +FuncTy_26_args.push_back(IntegerType::get(mod->getContext(), 32)); +FuncTy_26_args.push_back(PointerTy_1); +FuncTy_26_args.push_back(PointerTy_1); +FuncTy_26_args.push_back(PointerTy_1); +FunctionType* FuncTy_26 = FunctionType::get( + /*Result=*/IntegerType::get(mod->getContext(), 32), + /*Params=*/FuncTy_26_args, + /*isVarArg=*/false); + +std::vectorFuncTy_27_args; +FuncTy_27_args.push_back(IntegerType::get(mod->getContext(), 32)); +FuncTy_27_args.push_back(PointerTy_1); +FuncTy_27_args.push_back(PointerTy_1); +FunctionType* FuncTy_27 = FunctionType::get( + /*Result=*/IntegerType::get(mod->getContext(), 64), + /*Params=*/FuncTy_27_args, + /*isVarArg=*/false); + +std::vectorFuncTy_28_args; +FuncTy_28_args.push_back(PointerTy_1); +FuncTy_28_args.push_back(PointerTy_1); +FunctionType* FuncTy_28 = FunctionType::get( + /*Result=*/PointerTy_1, + /*Params=*/FuncTy_28_args, + /*isVarArg=*/false); + +std::vectorFuncTy_29_args; +FuncTy_29_args.push_back(PointerTy_1); +FuncTy_29_args.push_back(IntegerType::get(mod->getContext(), 32)); +FuncTy_29_args.push_back(PointerTy_1); +FuncTy_29_args.push_back(IntegerType::get(mod->getContext(), 32)); +FunctionType* FuncTy_29 = FunctionType::get( + /*Result=*/Type::getVoidTy(mod->getContext()), + /*Params=*/FuncTy_29_args, + /*isVarArg=*/false); + +std::vectorFuncTy_30_args; +FuncTy_30_args.push_back(PointerTy_1); +FuncTy_30_args.push_back(PointerTy_1); +FunctionType* FuncTy_30 = FunctionType::get( + /*Result=*/IntegerType::get(mod->getContext(), 32), + /*Params=*/FuncTy_30_args, + /*isVarArg=*/false); + +std::vectorFuncTy_31_args; +FuncTy_31_args.push_back(Type::getDoubleTy(mod->getContext())); +FunctionType* FuncTy_31 = FunctionType::get( + /*Result=*/IntegerType::get(mod->getContext(), 64), + /*Params=*/FuncTy_31_args, + /*isVarArg=*/false); + +std::vectorFuncTy_32_args; +FuncTy_32_args.push_back(Type::getDoubleTy(mod->getContext())); +FunctionType* FuncTy_32 = FunctionType::get( + /*Result=*/IntegerType::get(mod->getContext(), 32), + /*Params=*/FuncTy_32_args, + /*isVarArg=*/false); + +std::vectorFuncTy_33_args; +FuncTy_33_args.push_back(Type::getFloatTy(mod->getContext())); +FunctionType* FuncTy_33 = FunctionType::get( + /*Result=*/IntegerType::get(mod->getContext(), 64), + /*Params=*/FuncTy_33_args, + /*isVarArg=*/false); + +std::vectorFuncTy_34_args; +FuncTy_34_args.push_back(Type::getFloatTy(mod->getContext())); +FunctionType* FuncTy_34 = FunctionType::get( + /*Result=*/IntegerType::get(mod->getContext(), 32), + /*Params=*/FuncTy_34_args, + /*isVarArg=*/false); + +std::vectorFuncTy_35_args; +FuncTy_35_args.push_back(PointerTy_1); +FunctionType* FuncTy_35 = FunctionType::get( + /*Result=*/IntegerType::get(mod->getContext(), 32), + /*Params=*/FuncTy_35_args, + /*isVarArg=*/false); + +std::vectorFuncTy_36_args; +FuncTy_36_args.push_back(IntegerType::get(mod->getContext(), 32)); +FuncTy_36_args.push_back(PointerTy_1); +FuncTy_36_args.push_back(PointerTy_1); +FunctionType* FuncTy_36 = FunctionType::get( + /*Result=*/Type::getVoidTy(mod->getContext()), + /*Params=*/FuncTy_36_args, + /*isVarArg=*/false); + +std::vectorFuncTy_37_args; +FuncTy_37_args.push_back(PointerTy_1); +FuncTy_37_args.push_back(IntegerType::get(mod->getContext(), 32)); +FuncTy_37_args.push_back(PointerTy_1); +FunctionType* FuncTy_37 = FunctionType::get( + /*Result=*/PointerTy_1, + /*Params=*/FuncTy_37_args, + /*isVarArg=*/false); + +std::vectorFuncTy_38_args; +FuncTy_38_args.push_back(PointerTy_1); +FuncTy_38_args.push_back(IntegerType::get(mod->getContext(), 32)); +FuncTy_38_args.push_back(PointerTy_1); +FuncTy_38_args.push_back(PointerTy_1); +FunctionType* FuncTy_38 = FunctionType::get( + /*Result=*/PointerTy_1, + /*Params=*/FuncTy_38_args, + /*isVarArg=*/false); + +std::vectorFuncTy_39_args; +FunctionType* FuncTy_39 = FunctionType::get( + /*Result=*/IntegerType::get(mod->getContext(), 1), + /*Params=*/FuncTy_39_args, + /*isVarArg=*/false); + +std::vectorFuncTy_40_args; +FuncTy_40_args.push_back(PointerTy_1); +FunctionType* FuncTy_40 = FunctionType::get( + /*Result=*/Type::getVoidTy(mod->getContext()), + /*Params=*/FuncTy_40_args, + /*isVarArg=*/true); + + +// Function Declarations + +Function* func___art_type_list = mod->getFunction("__art_type_list"); +if (!func___art_type_list) { +func___art_type_list = Function::Create( + /*Type=*/FuncTy_0, + /*Linkage=*/GlobalValue::ExternalLinkage, + /*Name=*/"__art_type_list", mod); // (external, no body) +func___art_type_list->setCallingConv(CallingConv::C); +} +AttributeSet func___art_type_list_PAL; +func___art_type_list->setAttributes(func___art_type_list_PAL); + +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_portable_get_current_thread_from_code", mod); // (external, no body) +func_art_portable_get_current_thread_from_code->setCallingConv(CallingConv::C); +} +AttributeSet 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_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_portable_set_current_thread_from_code", mod); // (external, no body) +func_art_portable_set_current_thread_from_code->setCallingConv(CallingConv::C); +} +AttributeSet 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_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_portable_lock_object_from_code", mod); // (external, no body) +func_art_portable_lock_object_from_code->setCallingConv(CallingConv::C); +} +AttributeSet 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_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_portable_unlock_object_from_code", mod); // (external, no body) +func_art_portable_unlock_object_from_code->setCallingConv(CallingConv::C); +} +AttributeSet 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_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_portable_test_suspend_from_code", mod); // (external, no body) +func_art_portable_test_suspend_from_code->setCallingConv(CallingConv::C); +} +AttributeSet 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_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_portable_push_shadow_frame_from_code", mod); // (external, no body) +func_art_portable_push_shadow_frame_from_code->setCallingConv(CallingConv::C); +} +AttributeSet 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_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_portable_pop_shadow_frame_from_code", mod); // (external, no body) +func_art_portable_pop_shadow_frame_from_code->setCallingConv(CallingConv::C); +} +AttributeSet 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_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_portable_get_and_clear_exception", mod); // (external, no body) +func_art_portable_get_and_clear_exception->setCallingConv(CallingConv::C); +} +AttributeSet 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_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_portable_throw_div_zero_from_code", mod); // (external, no body) +func_art_portable_throw_div_zero_from_code->setCallingConv(CallingConv::C); +} +AttributeSet 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_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_portable_throw_array_bounds_from_code", mod); // (external, no body) +func_art_portable_throw_array_bounds_from_code->setCallingConv(CallingConv::C); +} +AttributeSet 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_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_portable_throw_no_such_method_from_code", mod); // (external, no body) +func_art_portable_throw_no_such_method_from_code->setCallingConv(CallingConv::C); +} +AttributeSet 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_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_portable_throw_null_pointer_exception_from_code", mod); // (external, no body) +func_art_portable_throw_null_pointer_exception_from_code->setCallingConv(CallingConv::C); +} +AttributeSet 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_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_portable_throw_stack_overflow_from_code", mod); // (external, no body) +func_art_portable_throw_stack_overflow_from_code->setCallingConv(CallingConv::C); +} +AttributeSet 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_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_portable_throw_exception_from_code", mod); // (external, no body) +func_art_portable_throw_exception_from_code->setCallingConv(CallingConv::C); +} +AttributeSet 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_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_portable_find_catch_block_from_code", mod); // (external, no body) +func_art_portable_find_catch_block_from_code->setCallingConv(CallingConv::C); +} +AttributeSet 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_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_portable_alloc_object_from_code", mod); // (external, no body) +func_art_portable_alloc_object_from_code->setCallingConv(CallingConv::C); +} +AttributeSet 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_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_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); +} +AttributeSet 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_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_portable_alloc_array_from_code", mod); // (external, no body) +func_art_portable_alloc_array_from_code->setCallingConv(CallingConv::C); +} +AttributeSet 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_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_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); +} +AttributeSet 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_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_portable_check_and_alloc_array_from_code", mod); // (external, no body) +func_art_portable_check_and_alloc_array_from_code->setCallingConv(CallingConv::C); +} +AttributeSet 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_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_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); +} +AttributeSet 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_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_portable_find_instance_field_from_code", mod); // (external, no body) +func_art_portable_find_instance_field_from_code->setCallingConv(CallingConv::C); +} +AttributeSet 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_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_portable_find_static_field_from_code", mod); // (external, no body) +func_art_portable_find_static_field_from_code->setCallingConv(CallingConv::C); +} +AttributeSet 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_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_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); +} +AttributeSet 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_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_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); +} +AttributeSet 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_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_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); +} +AttributeSet 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_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_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); +} +AttributeSet 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_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_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); +} +AttributeSet 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_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_portable_find_interface_method_from_code", mod); // (external, no body) +func_art_portable_find_interface_method_from_code->setCallingConv(CallingConv::C); +} +AttributeSet 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_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_portable_initialize_static_storage_from_code", mod); // (external, no body) +func_art_portable_initialize_static_storage_from_code->setCallingConv(CallingConv::C); +} +AttributeSet 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_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_portable_initialize_type_from_code", mod); // (external, no body) +func_art_portable_initialize_type_from_code->setCallingConv(CallingConv::C); +} +AttributeSet 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_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_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); +} +AttributeSet 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_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_portable_resolve_string_from_code", mod); // (external, no body) +func_art_portable_resolve_string_from_code->setCallingConv(CallingConv::C); +} +AttributeSet 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_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_portable_set32_static_from_code", mod); // (external, no body) +func_art_portable_set32_static_from_code->setCallingConv(CallingConv::C); +} +AttributeSet 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_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_portable_set64_static_from_code", mod); // (external, no body) +func_art_portable_set64_static_from_code->setCallingConv(CallingConv::C); +} +AttributeSet 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_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_portable_set_obj_static_from_code", mod); // (external, no body) +func_art_portable_set_obj_static_from_code->setCallingConv(CallingConv::C); +} +AttributeSet 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_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_portable_get32_static_from_code", mod); // (external, no body) +func_art_portable_get32_static_from_code->setCallingConv(CallingConv::C); +} +AttributeSet 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_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_portable_get64_static_from_code", mod); // (external, no body) +func_art_portable_get64_static_from_code->setCallingConv(CallingConv::C); +} +AttributeSet 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_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_portable_get_obj_static_from_code", mod); // (external, no body) +func_art_portable_get_obj_static_from_code->setCallingConv(CallingConv::C); +} +AttributeSet 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_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_portable_set32_instance_from_code", mod); // (external, no body) +func_art_portable_set32_instance_from_code->setCallingConv(CallingConv::C); +} +AttributeSet 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_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_portable_set64_instance_from_code", mod); // (external, no body) +func_art_portable_set64_instance_from_code->setCallingConv(CallingConv::C); +} +AttributeSet 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_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_portable_set_obj_instance_from_code", mod); // (external, no body) +func_art_portable_set_obj_instance_from_code->setCallingConv(CallingConv::C); +} +AttributeSet 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_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_portable_get32_instance_from_code", mod); // (external, no body) +func_art_portable_get32_instance_from_code->setCallingConv(CallingConv::C); +} +AttributeSet 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_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_portable_get64_instance_from_code", mod); // (external, no body) +func_art_portable_get64_instance_from_code->setCallingConv(CallingConv::C); +} +AttributeSet 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_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_portable_get_obj_instance_from_code", mod); // (external, no body) +func_art_portable_get_obj_instance_from_code->setCallingConv(CallingConv::C); +} +AttributeSet 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_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_portable_decode_jobject_in_thread", mod); // (external, no body) +func_art_portable_decode_jobject_in_thread->setCallingConv(CallingConv::C); +} +AttributeSet 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_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_portable_fill_array_data_from_code", mod); // (external, no body) +func_art_portable_fill_array_data_from_code->setCallingConv(CallingConv::C); +} +AttributeSet 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_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_portable_is_assignable_from_code", mod); // (external, no body) +func_art_portable_is_assignable_from_code->setCallingConv(CallingConv::C); +} +AttributeSet 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_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_portable_check_cast_from_code", mod); // (external, no body) +func_art_portable_check_cast_from_code->setCallingConv(CallingConv::C); +} +AttributeSet 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_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_portable_check_put_array_element_from_code", mod); // (external, no body) +func_art_portable_check_put_array_element_from_code->setCallingConv(CallingConv::C); +} +AttributeSet 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) { +func_art_d2l = Function::Create( + /*Type=*/FuncTy_31, + /*Linkage=*/GlobalValue::ExternalLinkage, + /*Name=*/"art_d2l", mod); // (external, no body) +func_art_d2l->setCallingConv(CallingConv::C); +} +AttributeSet func_art_d2l_PAL; +func_art_d2l->setAttributes(func_art_d2l_PAL); + +Function* func_art_d2i = mod->getFunction("art_d2i"); +if (!func_art_d2i) { +func_art_d2i = Function::Create( + /*Type=*/FuncTy_32, + /*Linkage=*/GlobalValue::ExternalLinkage, + /*Name=*/"art_d2i", mod); // (external, no body) +func_art_d2i->setCallingConv(CallingConv::C); +} +AttributeSet func_art_d2i_PAL; +func_art_d2i->setAttributes(func_art_d2i_PAL); + +Function* func_art_f2l = mod->getFunction("art_f2l"); +if (!func_art_f2l) { +func_art_f2l = Function::Create( + /*Type=*/FuncTy_33, + /*Linkage=*/GlobalValue::ExternalLinkage, + /*Name=*/"art_f2l", mod); // (external, no body) +func_art_f2l->setCallingConv(CallingConv::C); +} +AttributeSet func_art_f2l_PAL; +func_art_f2l->setAttributes(func_art_f2l_PAL); + +Function* func_art_f2i = mod->getFunction("art_f2i"); +if (!func_art_f2i) { +func_art_f2i = Function::Create( + /*Type=*/FuncTy_34, + /*Linkage=*/GlobalValue::ExternalLinkage, + /*Name=*/"art_f2i", mod); // (external, no body) +func_art_f2i->setCallingConv(CallingConv::C); +} +AttributeSet func_art_f2i_PAL; +func_art_f2i->setAttributes(func_art_f2i_PAL); + +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_portable_jni_method_start", mod); // (external, no body) +func_art_portable_jni_method_start->setCallingConv(CallingConv::C); +} +AttributeSet func_art_portable_jni_method_start_PAL; +func_art_portable_jni_method_start->setAttributes(func_art_portable_jni_method_start_PAL); + +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_portable_jni_method_start_synchronized", mod); // (external, no body) +func_art_portable_jni_method_start_synchronized->setCallingConv(CallingConv::C); +} +AttributeSet 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_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_portable_jni_method_end", mod); // (external, no body) +func_art_portable_jni_method_end->setCallingConv(CallingConv::C); +} +AttributeSet func_art_portable_jni_method_end_PAL; +func_art_portable_jni_method_end->setAttributes(func_art_portable_jni_method_end_PAL); + +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_portable_jni_method_end_synchronized", mod); // (external, no body) +func_art_portable_jni_method_end_synchronized->setCallingConv(CallingConv::C); +} +AttributeSet 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_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_portable_jni_method_end_with_reference", mod); // (external, no body) +func_art_portable_jni_method_end_with_reference->setCallingConv(CallingConv::C); +} +AttributeSet 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_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_portable_jni_method_end_with_reference_synchronized", mod); // (external, no body) +func_art_portable_jni_method_end_with_reference_synchronized->setCallingConv(CallingConv::C); +} +AttributeSet 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_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_portable_is_exception_pending_from_code", mod); // (external, no body) +func_art_portable_is_exception_pending_from_code->setCallingConv(CallingConv::C); +} +AttributeSet 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_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_portable_mark_gc_card_from_code", mod); // (external, no body) +func_art_portable_mark_gc_card_from_code->setCallingConv(CallingConv::C); +} +AttributeSet 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_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_portable_proxy_invoke_handler_from_code", mod); // (external, no body) +func_art_portable_proxy_invoke_handler_from_code->setCallingConv(CallingConv::C); +} +AttributeSet 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 + + +// Constant Definitions + +// Global Variable Definitions + +// Function Definitions + +return mod; + +} + +} // namespace llvm +} // namespace art -- cgit v1.2.3-59-g8ed1b From 7934ac288acfb2552bb0b06ec1f61e5820d924a4 Mon Sep 17 00:00:00 2001 From: Brian Carlstrom Date: Fri, 26 Jul 2013 10:54:15 -0700 Subject: Fix cpplint whitespace/comments issues Change-Id: Iae286862c85fb8fd8901eae1204cd6d271d69496 --- build/Android.cpplint.mk | 2 +- compiler/dex/arena_allocator.h | 2 +- compiler/dex/compiler_enums.h | 20 +- compiler/dex/dataflow_iterator.h | 2 +- compiler/dex/dex_to_dex_compiler.cc | 4 +- compiler/dex/frontend.cc | 56 +- compiler/dex/frontend.h | 2 +- compiler/dex/local_value_numbering.h | 2 +- compiler/dex/mir_graph.cc | 12 +- compiler/dex/mir_graph.h | 6 +- compiler/dex/mir_optimization.cc | 2 +- compiler/dex/portable/mir_to_gbc.cc | 6 +- compiler/dex/quick/arm/arm_lir.h | 28 +- compiler/dex/quick/arm/call_arm.cc | 6 +- compiler/dex/quick/arm/fp_arm.cc | 2 +- compiler/dex/quick/arm/int_arm.cc | 16 +- compiler/dex/quick/arm/target_arm.cc | 2 +- compiler/dex/quick/arm/utility_arm.cc | 6 +- compiler/dex/quick/codegen_util.cc | 2 +- compiler/dex/quick/gen_common.cc | 10 +- compiler/dex/quick/gen_invoke.cc | 14 +- compiler/dex/quick/mips/call_mips.cc | 2 +- compiler/dex/quick/mips/fp_mips.cc | 4 +- compiler/dex/quick/mips/int_mips.cc | 6 +- compiler/dex/quick/mips/mips_lir.h | 58 +- compiler/dex/quick/mips/target_mips.cc | 4 +- compiler/dex/quick/mips/utility_mips.cc | 2 +- compiler/dex/quick/mir_to_lir.h | 4 +- compiler/dex/quick/ralloc_util.cc | 10 +- compiler/dex/quick/x86/assemble_x86.cc | 4 +- compiler/dex/quick/x86/call_x86.cc | 2 +- compiler/dex/quick/x86/fp_x86.cc | 2 +- compiler/dex/quick/x86/target_x86.cc | 4 +- compiler/dex/quick/x86/utility_x86.cc | 10 +- compiler/dex/quick/x86/x86_lir.h | 36 +- compiler/dex/ssa_transformation.cc | 8 +- compiler/dex/vreg_analysis.cc | 2 +- compiler/driver/compiler_driver.cc | 808 ++++++++++----------- compiler/driver/dex_compilation_unit.cc | 2 +- compiler/driver/dex_compilation_unit.h | 2 +- compiler/elf_fixup.cc | 32 +- compiler/elf_writer_mclinker.h | 2 +- compiler/elf_writer_quick.cc | 4 +- compiler/image_writer.cc | 6 +- compiler/jni/portable/jni_compiler.cc | 14 +- compiler/llvm/backend_types.h | 4 +- compiler/llvm/compiler_llvm.cc | 8 +- compiler/llvm/compiler_llvm.h | 4 +- compiler/llvm/gbc_expander.cc | 46 +- compiler/llvm/generated/art_module.cc | 132 ++-- compiler/llvm/intrinsic_helper.cc | 4 +- compiler/llvm/intrinsic_helper.h | 4 +- compiler/llvm/ir_builder.cc | 4 +- compiler/llvm/ir_builder.h | 4 +- compiler/llvm/llvm_compilation_unit.cc | 12 +- compiler/llvm/llvm_compilation_unit.h | 6 +- compiler/llvm/md_builder.cc | 4 +- compiler/llvm/md_builder.h | 4 +- compiler/llvm/runtime_support_builder.cc | 4 +- compiler/llvm/runtime_support_builder.h | 4 +- compiler/llvm/runtime_support_builder_arm.cc | 6 +- compiler/llvm/runtime_support_builder_arm.h | 4 +- compiler/llvm/runtime_support_builder_thumb2.cc | 6 +- compiler/llvm/runtime_support_builder_thumb2.h | 4 +- compiler/llvm/runtime_support_builder_x86.cc | 4 +- compiler/llvm/runtime_support_builder_x86.h | 4 +- compiler/llvm/runtime_support_llvm_func.h | 6 +- compiler/sea_ir/code_gen.cc | 4 +- compiler/sea_ir/code_gen.h | 8 +- compiler/sea_ir/frontend.cc | 4 +- compiler/sea_ir/instruction_nodes.h | 6 +- compiler/sea_ir/instruction_tools.cc | 2 +- compiler/sea_ir/instruction_tools.h | 2 +- compiler/sea_ir/sea.cc | 28 +- compiler/sea_ir/sea.h | 4 +- compiler/sea_ir/sea_node.h | 2 +- compiler/sea_ir/visitor.h | 4 +- compiler/stubs/portable/stubs.cc | 14 +- compiler/stubs/quick/stubs.cc | 12 +- compiler/utils/scoped_hashtable.h | 2 +- compiler/utils/scoped_hashtable_test.cc | 2 +- dalvikvm/dalvikvm.cc | 2 +- dex2oat/dex2oat.cc | 6 +- jdwpspy/Net.cpp | 2 +- oatdump/oatdump.cc | 2 +- runtime/base/histogram_test.cc | 28 +- runtime/base/logging.cc | 2 +- runtime/base/logging.h | 4 +- runtime/base/macros.h | 2 +- runtime/base/mutex-inl.h | 2 +- runtime/base/mutex.cc | 10 +- runtime/base/unix_file/mapped_file_test.cc | 2 +- runtime/check_jni.cc | 56 +- runtime/class_linker.cc | 6 +- runtime/class_linker.h | 4 +- runtime/common_test.h | 8 +- runtime/compiled_method.cc | 2 +- runtime/debugger.cc | 44 +- runtime/debugger.h | 2 +- runtime/dex_file.cc | 2 +- runtime/dex_file.h | 2 +- runtime/dex_file_verifier.cc | 2 +- runtime/dex_instruction-inl.h | 8 +- runtime/dex_instruction.cc | 8 +- runtime/dex_instruction.h | 4 +- runtime/dex_instruction_list.h | 2 +- runtime/disassembler_arm.cc | 52 +- runtime/disassembler_mips.cc | 42 +- runtime/disassembler_x86.cc | 2 +- runtime/exception_test.cc | 2 +- runtime/gc/accounting/card_table.cc | 2 +- runtime/gc/accounting/space_bitmap-inl.h | 2 +- runtime/gc/collector/mark_sweep.cc | 4 +- runtime/gc/collector/mark_sweep.h | 2 +- runtime/gc/heap.cc | 2 +- runtime/gc/space/dlmalloc_space.cc | 4 +- runtime/gc/space/space.h | 2 +- runtime/hprof/hprof.cc | 18 +- runtime/indirect_reference_table.cc | 2 +- runtime/indirect_reference_table.h | 8 +- runtime/instrumentation.cc | 14 +- runtime/intern_table.cc | 8 +- runtime/intern_table_test.cc | 2 +- runtime/interpreter/interpreter.cc | 6 +- runtime/invoke_type.h | 10 +- runtime/jdwp/jdwp.h | 8 +- runtime/jdwp/jdwp_constants.h | 8 +- runtime/jdwp/jdwp_event.cc | 6 +- runtime/jdwp/jdwp_handler.cc | 6 +- runtime/jdwp/jdwp_priv.h | 4 +- runtime/jdwp/jdwp_request.cc | 2 +- runtime/jdwp/object_registry.cc | 6 +- runtime/jni_internal.cc | 26 +- runtime/jvalue.h | 4 +- runtime/locks.h | 2 +- runtime/log_severity.h | 2 +- runtime/mem_map.cc | 6 +- runtime/mirror/dex_cache.h | 2 +- runtime/mirror/field.cc | 2 +- runtime/mirror/throwable.h | 2 +- runtime/monitor.cc | 6 +- runtime/native/dalvik_system_VMDebug.cc | 4 +- runtime/native/dalvik_system_Zygote.cc | 2 +- runtime/native/java_lang_Thread.cc | 2 +- runtime/oat/runtime/arm/context_arm.cc | 2 +- runtime/oat/runtime/mips/context_mips.cc | 2 +- runtime/oat/runtime/support_interpreter.cc | 2 +- runtime/oat/runtime/support_jni.cc | 2 +- runtime/oat/runtime/support_stubs.cc | 4 +- .../oat/runtime/x86/oat_support_entrypoints_x86.cc | 12 +- runtime/oat_test.cc | 2 +- runtime/reference_table.cc | 2 +- runtime/reference_table.h | 2 +- runtime/reflection.cc | 2 +- runtime/runtime.cc | 32 +- runtime/runtime_linux.cc | 2 +- runtime/runtime_support.cc | 8 +- runtime/runtime_support_llvm_func_list.h | 2 +- runtime/safe_map.h | 2 +- runtime/scoped_thread_state_change.h | 2 +- runtime/signal_catcher.cc | 2 +- runtime/stack.cc | 8 +- runtime/stack.h | 6 +- runtime/thread.cc | 20 +- runtime/thread.h | 6 +- runtime/thread_linux.cc | 2 +- runtime/thread_list.cc | 6 +- runtime/thread_list.h | 4 +- runtime/thread_state.h | 40 +- runtime/trace.cc | 14 +- runtime/utils.cc | 34 +- runtime/verifier/dex_gc_map.h | 6 +- runtime/verifier/method_verifier.cc | 16 +- runtime/verifier/method_verifier.h | 22 +- runtime/verifier/reg_type_cache.cc | 2 +- runtime/verifier/reg_type_test.cc | 2 +- runtime/zip_archive.cc | 2 +- test/ReferenceMap/stack_walk_refmap_jni.cc | 44 +- test/StackWalk/stack_walk_jni.cc | 2 +- 179 files changed, 1208 insertions(+), 1208 deletions(-) (limited to 'compiler/llvm/generated/art_module.cc') diff --git a/build/Android.cpplint.mk b/build/Android.cpplint.mk index eabaf31cca..adb87cb4e9 100644 --- a/build/Android.cpplint.mk +++ b/build/Android.cpplint.mk @@ -15,7 +15,7 @@ # ART_CPPLINT := art/tools/cpplint.py -ART_CPPLINT_FILTER := --filter=-whitespace/comments,-whitespace/line_length,-build/include,-readability/function,-readability/streams,-readability/todo,-runtime/references,-runtime/sizeof,-runtime/threadsafe_fn,-runtime/printf +ART_CPPLINT_FILTER := --filter=-whitespace/line_length,-build/include,-readability/function,-readability/streams,-readability/todo,-runtime/references,-runtime/sizeof,-runtime/threadsafe_fn,-runtime/printf ART_CPPLINT_SRC := $(shell find art -name *.h -o -name *$(ART_CPP_EXTENSION) | grep -v art/compiler/llvm/generated/) # "mm cpplint-art" to verify we aren't regressing diff --git a/compiler/dex/arena_allocator.h b/compiler/dex/arena_allocator.h index 3bd733e753..e8e2c027d0 100644 --- a/compiler/dex/arena_allocator.h +++ b/compiler/dex/arena_allocator.h @@ -86,7 +86,7 @@ struct MemStats { explicit MemStats(const ArenaAllocator &arena) : arena_(arena) {} private: const ArenaAllocator &arena_; -}; // MemStats +}; // MemStats } // namespace art diff --git a/compiler/dex/compiler_enums.h b/compiler/dex/compiler_enums.h index 88240e8c40..97a682f2aa 100644 --- a/compiler/dex/compiler_enums.h +++ b/compiler/dex/compiler_enums.h @@ -48,7 +48,7 @@ enum SpecialTargetRegister { }; enum RegLocationType { - kLocDalvikFrame = 0, // Normal Dalvik register + kLocDalvikFrame = 0, // Normal Dalvik register kLocPhysReg, kLocCompilerTemp, kLocInvalid @@ -249,20 +249,20 @@ enum X86ConditionCode { kX86CondC = kX86CondB, // carry kX86CondNb = 0x3, // not-below - kX86CondAe = kX86CondNb, // above-equal - kX86CondNc = kX86CondNb, // not-carry + kX86CondAe = kX86CondNb, // above-equal + kX86CondNc = kX86CondNb, // not-carry kX86CondZ = 0x4, // zero kX86CondEq = kX86CondZ, // equal kX86CondNz = 0x5, // not-zero - kX86CondNe = kX86CondNz, // not-equal + kX86CondNe = kX86CondNz, // not-equal kX86CondBe = 0x6, // below-equal - kX86CondNa = kX86CondBe, // not-above + kX86CondNa = kX86CondBe, // not-above kX86CondNbe = 0x7, // not-below-equal - kX86CondA = kX86CondNbe,// above + kX86CondA = kX86CondNbe, // above kX86CondS = 0x8, // sign kX86CondNs = 0x9, // not-sign @@ -277,13 +277,13 @@ enum X86ConditionCode { kX86CondNge = kX86CondL, // not-greater-equal kX86CondNl = 0xd, // not-less-than - kX86CondGe = kX86CondNl, // not-greater-equal + kX86CondGe = kX86CondNl, // not-greater-equal kX86CondLe = 0xe, // less-than-equal - kX86CondNg = kX86CondLe, // not-greater + kX86CondNg = kX86CondLe, // not-greater kX86CondNle = 0xf, // not-less-than - kX86CondG = kX86CondNle,// greater + kX86CondG = kX86CondNle, // greater }; std::ostream& operator<<(std::ostream& os, const X86ConditionCode& kind); @@ -349,7 +349,7 @@ enum OpFeatureFlags { kIsIT, kMemLoad, kMemStore, - kPCRelFixup, // x86 FIXME: add NEEDS_FIXUP to instruction attributes. + kPCRelFixup, // x86 FIXME: add NEEDS_FIXUP to instruction attributes. kRegDef0, kRegDef1, kRegDefA, diff --git a/compiler/dex/dataflow_iterator.h b/compiler/dex/dataflow_iterator.h index 847a614727..da44ffd99c 100644 --- a/compiler/dex/dataflow_iterator.h +++ b/compiler/dex/dataflow_iterator.h @@ -80,7 +80,7 @@ namespace art { GrowableArray* block_id_list_; int idx_; bool changed_; - }; // DataflowIterator + }; // DataflowIterator class ReachableNodesIterator : public DataflowIterator { public: diff --git a/compiler/dex/dex_to_dex_compiler.cc b/compiler/dex/dex_to_dex_compiler.cc index 28c325726e..3c491ce20f 100644 --- a/compiler/dex/dex_to_dex_compiler.cc +++ b/compiler/dex/dex_to_dex_compiler.cc @@ -240,12 +240,12 @@ Instruction* DexCompiler::CompileCheckCast(Instruction* inst, uint32_t dex_pc) { // We are modifying 4 consecutive bytes. ScopedDexWriteAccess sdwa(GetModifiableDexFile(), inst, 4u); inst->SetOpcode(Instruction::NOP); - inst->SetVRegA_10x(0u); // keep compliant with verifier. + inst->SetVRegA_10x(0u); // keep compliant with verifier. // Get to next instruction which is the second half of check-cast and replace // it by a NOP. inst = const_cast(inst->Next()); inst->SetOpcode(Instruction::NOP); - inst->SetVRegA_10x(0u); // keep compliant with verifier. + inst->SetVRegA_10x(0u); // keep compliant with verifier. return inst; } diff --git a/compiler/dex/frontend.cc b/compiler/dex/frontend.cc index 113a80a96c..9cc4d18d37 100644 --- a/compiler/dex/frontend.cc +++ b/compiler/dex/frontend.cc @@ -72,37 +72,37 @@ extern "C" void ArtUnInitQuickCompilerContext(art::CompilerDriver& compiler) { } /* Default optimizer/debug setting for the compiler. */ -static uint32_t kCompilerOptimizerDisableFlags = 0 | // Disable specific optimizations +static uint32_t kCompilerOptimizerDisableFlags = 0 | // Disable specific optimizations (1 << kLoadStoreElimination) | - //(1 << kLoadHoisting) | - //(1 << kSuppressLoads) | - //(1 << kNullCheckElimination) | - //(1 << kPromoteRegs) | - //(1 << kTrackLiveTemps) | - //(1 << kSafeOptimizations) | - //(1 << kBBOpt) | - //(1 << kMatch) | - //(1 << kPromoteCompilerTemps) | + // (1 << kLoadHoisting) | + // (1 << kSuppressLoads) | + // (1 << kNullCheckElimination) | + // (1 << kPromoteRegs) | + // (1 << kTrackLiveTemps) | + // (1 << kSafeOptimizations) | + // (1 << kBBOpt) | + // (1 << kMatch) | + // (1 << kPromoteCompilerTemps) | 0; static uint32_t kCompilerDebugFlags = 0 | // Enable debug/testing modes - //(1 << kDebugDisplayMissingTargets) | - //(1 << kDebugVerbose) | - //(1 << kDebugDumpCFG) | - //(1 << kDebugSlowFieldPath) | - //(1 << kDebugSlowInvokePath) | - //(1 << kDebugSlowStringPath) | - //(1 << kDebugSlowestFieldPath) | - //(1 << kDebugSlowestStringPath) | - //(1 << kDebugExerciseResolveMethod) | - //(1 << kDebugVerifyDataflow) | - //(1 << kDebugShowMemoryUsage) | - //(1 << kDebugShowNops) | - //(1 << kDebugCountOpcodes) | - //(1 << kDebugDumpCheckStats) | - //(1 << kDebugDumpBitcodeFile) | - //(1 << kDebugVerifyBitcode) | - //(1 << kDebugShowSummaryMemoryUsage) | + // (1 << kDebugDisplayMissingTargets) | + // (1 << kDebugVerbose) | + // (1 << kDebugDumpCFG) | + // (1 << kDebugSlowFieldPath) | + // (1 << kDebugSlowInvokePath) | + // (1 << kDebugSlowStringPath) | + // (1 << kDebugSlowestFieldPath) | + // (1 << kDebugSlowestStringPath) | + // (1 << kDebugExerciseResolveMethod) | + // (1 << kDebugVerifyDataflow) | + // (1 << kDebugShowMemoryUsage) | + // (1 << kDebugShowNops) | + // (1 << kDebugCountOpcodes) | + // (1 << kDebugDumpCheckStats) | + // (1 << kDebugDumpBitcodeFile) | + // (1 << kDebugVerifyBitcode) | + // (1 << kDebugShowSummaryMemoryUsage) | 0; static CompiledMethod* CompileMethod(CompilerDriver& compiler, @@ -277,7 +277,7 @@ CompiledMethod* CompileOneMethod(CompilerDriver& compiler, #if defined(ART_USE_PORTABLE_COMPILER) , llvm_compilation_unit #endif - ); // NOLINT(whitespace/parens) + ); // NOLINT(whitespace/parens) } } // namespace art diff --git a/compiler/dex/frontend.h b/compiler/dex/frontend.h index a86338950c..5c68ab4244 100644 --- a/compiler/dex/frontend.h +++ b/compiler/dex/frontend.h @@ -102,7 +102,7 @@ class LLVMInfo { private: UniquePtr< ::llvm::LLVMContext> llvm_context_; - ::llvm::Module* llvm_module_; // Managed by context_. + ::llvm::Module* llvm_module_; // Managed by context_. UniquePtr intrinsic_helper_; UniquePtr ir_builder_; }; diff --git a/compiler/dex/local_value_numbering.h b/compiler/dex/local_value_numbering.h index e3fd7ad2da..33ca8f1ad8 100644 --- a/compiler/dex/local_value_numbering.h +++ b/compiler/dex/local_value_numbering.h @@ -137,6 +137,6 @@ class LocalValueNumbering { std::set null_checked_; }; -} // namespace art +} // namespace art #endif // ART_COMPILER_DEX_LOCAL_VALUE_NUMBERING_H_ diff --git a/compiler/dex/mir_graph.cc b/compiler/dex/mir_graph.cc index 264604c355..6b010ed9b3 100644 --- a/compiler/dex/mir_graph.cc +++ b/compiler/dex/mir_graph.cc @@ -972,23 +972,23 @@ char* MIRGraph::GetDalvikDisassembly(const MIR* mir) { } } switch (dalvik_format) { - case Instruction::k11n: // Add one immediate from vB + case Instruction::k11n: // Add one immediate from vB case Instruction::k21s: case Instruction::k31i: case Instruction::k21h: str.append(StringPrintf(", #%d", insn.vB)); break; - case Instruction::k51l: // Add one wide immediate + case Instruction::k51l: // Add one wide immediate str.append(StringPrintf(", #%lld", insn.vB_wide)); break; - case Instruction::k21c: // One register, one string/type/method index + case Instruction::k21c: // One register, one string/type/method index case Instruction::k31c: str.append(StringPrintf(", index #%d", insn.vB)); break; - case Instruction::k22c: // Two registers, one string/type/method index + case Instruction::k22c: // Two registers, one string/type/method index str.append(StringPrintf(", index #%d", insn.vC)); break; - case Instruction::k22s: // Add one immediate from vC + case Instruction::k22s: // Add one immediate from vC case Instruction::k22b: str.append(StringPrintf(", #%d", insn.vC)); break; @@ -1154,4 +1154,4 @@ BasicBlock* MIRGraph::NewMemBB(BBType block_type, int block_id) { return bb; } -} // namespace art +} // namespace art diff --git a/compiler/dex/mir_graph.h b/compiler/dex/mir_graph.h index 342d2a296a..e9ec949f23 100644 --- a/compiler/dex/mir_graph.h +++ b/compiler/dex/mir_graph.h @@ -273,7 +273,7 @@ struct RegLocation { unsigned fp:1; // Floating point? unsigned core:1; // Non-floating point? unsigned ref:1; // Something GC cares about. - unsigned high_word:1; // High word of pair? + unsigned high_word:1; // High word of pair? unsigned home:1; // Does this represent the home location? uint8_t low_reg; // First physical register. uint8_t high_reg; // 2nd physical register (if wide). @@ -650,7 +650,7 @@ class MIRGraph { BasicBlock* cur_block_; int num_blocks_; const DexFile::CodeItem* current_code_item_; - SafeMap block_map_; // FindBlock lookup cache. + SafeMap block_map_; // FindBlock lookup cache. std::vector m_units_; // List of methods included in this graph typedef std::pair MIRLocation; // Insert point, (m_unit_ index, offset) std::vector method_stack_; // Include stack @@ -659,7 +659,7 @@ class MIRGraph { int def_count_; // Used to estimate size of ssa name storage. int* opcode_count_; // Dex opcode coverage stats. int num_ssa_regs_; // Number of names following SSA transformation. - std::vector extended_basic_blocks_; // Heads of block "traces". + std::vector extended_basic_blocks_; // Heads of block "traces". int method_sreg_; unsigned int attributes_; Checkstats* checkstats_; diff --git a/compiler/dex/mir_optimization.cc b/compiler/dex/mir_optimization.cc index d79b26e4b9..a6314f4cab 100644 --- a/compiler/dex/mir_optimization.cc +++ b/compiler/dex/mir_optimization.cc @@ -845,7 +845,7 @@ bool MIRGraph::BuildExtendedBBList(struct BasicBlock* bb) { bb = NextDominatedBlock(bb); } } - return false; // Not iterative - return value will be ignored + return false; // Not iterative - return value will be ignored } diff --git a/compiler/dex/portable/mir_to_gbc.cc b/compiler/dex/portable/mir_to_gbc.cc index 6fc01bdff2..7831cf6f7a 100644 --- a/compiler/dex/portable/mir_to_gbc.cc +++ b/compiler/dex/portable/mir_to_gbc.cc @@ -1648,7 +1648,7 @@ bool MirConverter::BlockBitcodeConversion(BasicBlock* bb) { if (bb->block_type == kEntryBlock) { SetMethodInfo(); - { // Allocate shadowframe. + { // Allocate shadowframe. art::llvm::IntrinsicHelper::IntrinsicId id = art::llvm::IntrinsicHelper::AllocaShadowFrame; ::llvm::Function* func = intrinsic_helper_->GetIntrinsicFunction(id); @@ -1656,7 +1656,7 @@ bool MirConverter::BlockBitcodeConversion(BasicBlock* bb) { irb_->CreateCall(func, entries); } - { // Store arguments to vregs. + { // Store arguments to vregs. uint16_t arg_reg = cu_->num_regs; ::llvm::Function::arg_iterator arg_iter(func_->arg_begin()); @@ -1666,7 +1666,7 @@ bool MirConverter::BlockBitcodeConversion(BasicBlock* bb) { uint32_t shorty_size = strlen(shorty); CHECK_GE(shorty_size, 1u); - ++arg_iter; // skip method object + ++arg_iter; // skip method object if ((cu_->access_flags & kAccStatic) == 0) { SetVregOnValue(arg_iter, arg_reg); diff --git a/compiler/dex/quick/arm/arm_lir.h b/compiler/dex/quick/arm/arm_lir.h index 93fee05e4e..2f54190ae7 100644 --- a/compiler/dex/quick/arm/arm_lir.h +++ b/compiler/dex/quick/arm/arm_lir.h @@ -239,7 +239,7 @@ enum ArmShiftEncodings { */ enum ArmOpcode { kArmFirst = 0, - kArm16BitData = kArmFirst, // DATA [0] rd[15..0]. + kArm16BitData = kArmFirst, // DATA [0] rd[15..0]. kThumbAdcRR, // adc [0100000101] rm[5..3] rd[2..0]. kThumbAddRRI3, // add(1) [0001110] imm_3[8..6] rn[5..3] rd[2..0]*/ kThumbAddRI8, // add(2) [00110] rd[10..8] imm_8[7..0]. @@ -332,12 +332,12 @@ enum ArmOpcode { kThumb2VcvtDF, // vcvt.F32.F64 vd, vm [1110111010110111] vd[15..12] [10111100] vm[3..0]. kThumb2Vsqrts, // vsqrt.f32 vd, vm [1110111010110001] vd[15..12] [10101100] vm[3..0]. kThumb2Vsqrtd, // vsqrt.f64 vd, vm [1110111010110001] vd[15..12] [10111100] vm[3..0]. - kThumb2MovImmShift,// mov(T2) rd, # [11110] i [00001001111] imm3 rd[11..8] imm8. + kThumb2MovImmShift, // mov(T2) rd, # [11110] i [00001001111] imm3 rd[11..8] imm8. kThumb2MovImm16, // mov(T3) rd, # [11110] i [0010100] imm4 [0] imm3 rd[11..8] imm8. kThumb2StrRRI12, // str(Imm,T3) rd,[rn,#imm12] [111110001100] rn[19..16] rt[15..12] imm12[11..0]. kThumb2LdrRRI12, // str(Imm,T3) rd,[rn,#imm12] [111110001100] rn[19..16] rt[15..12] imm12[11..0]. - kThumb2StrRRI8Predec, // str(Imm,T4) rd,[rn,#-imm8] [111110000100] rn[19..16] rt[15..12] [1100] imm[7..0]*/ - kThumb2LdrRRI8Predec, // ldr(Imm,T4) rd,[rn,#-imm8] [111110000101] rn[19..16] rt[15..12] [1100] imm[7..0]*/ + kThumb2StrRRI8Predec, // str(Imm,T4) rd,[rn,#-imm8] [111110000100] rn[19..16] rt[15..12] [1100] imm[7..0]*/ + kThumb2LdrRRI8Predec, // ldr(Imm,T4) rd,[rn,#-imm8] [111110000101] rn[19..16] rt[15..12] [1100] imm[7..0]*/ kThumb2Cbnz, // cbnz rd,