You are viewing a plain text version of this content. The canonical link for it is here.
Posted to dev@harmony.apache.org by Mikhail Fursov <mi...@gmail.com> on 2008/03/07 16:49:11 UTC
Re: svn commit: r634547 [2/2] - in /harmony/enhanced/drlvm/trunk/vm: em/src/ include/open/ interpreter/src/ jitrino/src/codegenerator/ia32/ jitrino/src/codegenerator/ipf/ jitrino/src/jet/ jitrino/src/shared/ jitrino/src/vm/ vmcore/build/ vmcore/src/c
Alexey,
there is a problem with this commit.
Some of methods that returns Boolean (that is 'unsigned') are described as
'bool' in vm_interface.h
It's not the same and causes problems. For example I found that H2092 fails
now in debug mode on Linux because of 'field_is_volatile' method.
On Fri, Mar 7, 2008 at 11:59 AM, <va...@apache.org> wrote:
> Modified: harmony/enhanced/drlvm/trunk/vm/jitrino/src/vm/VMInterface.cpp
> URL:
> http://svn.apache.org/viewvc/harmony/enhanced/drlvm/trunk/vm/jitrino/src/vm/VMInterface.cpp?rev=634547&r1=634546&r2=634547&view=diff
>
> ==============================================================================
> --- harmony/enhanced/drlvm/trunk/vm/jitrino/src/vm/VMInterface.cpp
> (original)
> +++ harmony/enhanced/drlvm/trunk/vm/jitrino/src/vm/VMInterface.cpp Thu Mar
> 6 21:59:46 2008
> @@ -15,18 +15,11 @@
> * limitations under the License.
> */
>
> -/**
> - * @author Intel, Mikhail Y. Fursov
> - * @version $Revision: 1.36.8.4.4.4 $
> - */
> -
> #include <stdio.h>
> #include <stdlib.h>
> #include <iostream>
> #include <assert.h>
>
> -#include "open/hythread_ext.h"
> -
> #include "Type.h"
> #include "VMInterface.h"
> #include "CompilationContext.h"
> @@ -38,6 +31,395 @@
>
> namespace Jitrino {
>
> +vm_adaptor_t VMInterface::vm = 0;
> +
> +
> +static allocation_handle_get_class_t allocation_handle_get_class = 0;
> +
> +//Class
> +static class_get_array_element_class_t class_get_array_element_class =
> 0;
> +static class_get_array_element_size_t class_get_array_element_size = 0;
> +static class_get_array_of_class_t class_get_array_of_class = 0;
> +static class_get_element_type_info_t class_get_element_type_info = 0;
> +static class_get_name_t class_get_name = 0;
> +static class_get_super_class_t class_get_super_class = 0;
> +static class_get_depth_t class_get_depth = 0;
> +static class_get_vtable_t class_get_vtable = 0;
> +static class_get_allocation_handle_t class_get_allocation_handle = 0;
> +static class_get_boxed_data_size_t class_get_boxed_data_size = 0;
> +static class_get_num_array_dimensions_t class_get_num_array_dimensions =
> 0;
> +static class_get_class_of_primitive_type_t
> class_get_class_of_primitive_type = 0;
> +static class_get_const_string_intern_addr_t
> class_get_const_string_intern_addr = 0;
> +static class_get_const_type_t class_get_const_type = 0;
> +static class_get_const_addr_t class_get_const_addr = 0;
> +static class_get_method_by_name_t class_get_method_by_name = 0;
> +static class_get_field_by_name_t class_get_field_by_name = 0;
> +static class_get_class_loader_t class_get_class_loader = 0;
> +
> +static class_is_array_t class_is_array = 0;
> +static class_is_enum_t class_is_enum = 0;
> +static class_is_final_t class_is_final = 0; //class_property_is_final
> +static class_is_throwable_t class_is_throwable = 0;
> //class_hint_is_exceptiontype
> +static class_is_interface_t class_is_interface = 0;
> //class_property_is_interface2
> +static class_is_abstract_t class_is_abstract = 0;
> //class_property_is_abstract
> +static class_is_initialized_t class_is_initialized = 0;
> //class_needs_initialization && class_is_initialized()
> +static class_is_finalizable_t class_is_finalizable = 0;
> +static class_is_instanceof_t class_is_instanceof = 0;
> +static class_is_support_fast_instanceof_t
> class_is_support_fast_instanceof = 0;// class_get_fast_instanceof_flag
> +static class_is_primitive_t class_is_primitive = 0;
> +
> +static class_lookup_class_by_name_using_bootstrap_class_loader_t
> class_lookup_class_by_name_using_bootstrap_class_loader = 0;
> +static class_lookup_method_recursively_t class_lookup_method_recursively
> = 0;
> +
> +// Const Pool
> +static class_cp_get_field_type_t class_cp_get_field_type = 0;//
> VM_Data_Type class_get_cp_field_type(Class_Handle src_class, unsigned short
> cp_index);
> +static class_cp_get_entry_signature_t class_cp_get_entry_signature =
> 0;//const char* class_get_cp_entry_signature(Class_Handle src_class,
> unsigned short index); ? const char*
> const_pool_get_field_descriptor(Class_Handle cl, unsigned index);
> +static class_cp_is_entry_resolved_t class_cp_is_entry_resolved =
> 0;//bool class_is_cp_entry_resolved(Compile_Handle ch, Class_Handle clazz,
> unsigned cp_index);
> +static class_cp_get_class_name_t class_cp_get_class_name =0;//const
> char* const_pool_get_class_name(Class_Handle cl, unsigned index);
> +static class_cp_get_method_class_name_t class_cp_get_method_class_name =
> 0;//const char *const_pool_get_method_class_name(Class_Handle cl, unsigned
> index);
> +static class_cp_get_method_name_t class_cp_get_method_name = 0;//const
> char* const_pool_get_method_name(Class_Handle cl, unsigned index);
> +
> +
> +//Field
> +
> +static field_get_address_t field_get_address = 0;
> +static field_get_class_t field_get_class = 0;
> +static field_get_descriptor_t field_get_descriptor = 0;
> +static field_get_name_t field_get_name = 0;
> +static field_get_offset_t field_get_offset = 0;
> +static field_get_type_info_t field_get_type_info = 0;
> //field_get_type_info_of_field_value
> +static field_is_final_t field_is_final = 0;
> +static field_is_magic_t field_is_magic = 0; //Boolean
> field_is_magic(Field_Handle fh);
> +static field_is_private_t field_is_private = 0;
> +static field_is_static_t field_is_static = 0;
> +static field_is_volatile_t field_is_volatile = 0;
> +
> +//Method
> +
> +static method_get_overridden_method_t method_get_overridden_method =
> 0;//method_find_overridden_method
> +static method_get_info_block_jit_t method_get_info_block_jit = 0;
> +static method_get_info_block_size_jit_t method_get_info_block_size_jit =
> 0;
> +static method_get_name_t method_get_name = 0;
> +static method_get_descriptor_t method_get_descriptor = 0;
> +static method_get_byte_code_addr_t method_get_byte_code_addr = 0;
> +static method_get_byte_code_size_t method_get_byte_code_size = 0;
> +static method_get_max_stack_t method_get_max_stack = 0;
> +static method_get_num_handlers_t method_get_num_handlers = 0;
> +static method_get_offset_t method_get_offset = 0;
> +static method_get_indirect_address_t method_get_indirect_address = 0;
> +static method_get_native_func_addr_t method_get_native_func_addr = 0;
> +static method_vars_get_number_t method_vars_get_number = 0;
> +static method_args_get_number_t method_args_get_number = 0;
> +static method_args_get_type_info_t method_args_get_type_info = 0;
> +static method_ret_type_get_type_info_t method_ret_type_get_type_info =
> 0;
> +static method_get_signature_t method_get_signature = 0;
> +static method_get_class_t method_get_class = 0;
> +static method_get_handler_info_t method_get_handler_info = 0;
> +static method_get_code_block_addr_jit_new_t
> method_get_code_block_addr_jit_new = 0;
> +static method_get_code_block_size_jit_new_t
> method_get_code_block_size_jit_new = 0;
> +static method_get_side_effects_t method_get_side_effects = 0;
> +
> +static method_has_annotation_t method_has_annotation = 0;
> +static method_is_private_t method_is_private = 0;
> +static method_is_static_t method_is_static = 0;
> +static method_is_native_t method_is_native = 0;
> +static method_is_synchronized_t method_is_synchronized = 0;
> +static method_is_final_t method_is_final = 0;
> +static method_is_abstract_t method_is_abstract = 0;
> +static method_is_strict_t method_is_strict = 0;
> +static method_is_overridden_t method_is_overridden = 0;
> +static method_is_no_inlining_t method_is_no_inlining = 0;
> +
> +
> +static method_set_side_effects_t method_set_side_effects = 0;
> +static method_set_num_target_handlers_t method_set_num_target_handlers =
> 0;
> +static method_set_target_handler_info_t method_set_target_handler_info =
> 0;
> +
> +static method_lock_t method_lock = 0;
> +static method_unlock_t method_unlock = 0;
> +
> +static method_allocate_code_block_t method_allocate_code_block = 0;
> +static method_allocate_data_block_t method_allocate_data_block = 0;
> +static method_allocate_info_block_t method_allocate_info_block = 0;
> +static method_allocate_jit_data_block_t method_allocate_jit_data_block =
> 0;
> +
> +
> +//Object
> +static object_get_vtable_offset_t object_get_vtable_offset = 0;
> +
> +
> +//Resolve
> +static resolve_class_t resolve_class = 0;
> +static resolve_class_new_t resolve_class_new = 0;
> +static resolve_special_method_t resolve_special_method = 0;
> +static resolve_interface_method_t resolve_interface_method = 0;
> +static resolve_static_method_t resolve_static_method = 0;
> +static resolve_virtual_method_t resolve_virtual_method = 0;
> +static resolve_nonstatic_field_t resolve_nonstatic_field = 0;
> +static resolve_static_field_t resolve_static_field = 0;
> +
> +//Type Info
> +
> +static type_info_create_from_java_descriptor_t
> type_info_create_from_java_descriptor = 0;
> +static type_info_get_type_name_t type_info_get_type_name = 0;
> +static type_info_get_class_t type_info_get_class = 0;
> +static type_info_get_class_no_exn_t type_info_get_class_no_exn = 0;
> +static type_info_get_num_array_dimensions_t
> type_info_get_num_array_dimensions = 0;
> +static type_info_get_type_info_t type_info_get_type_info = 0;
> +
> +static type_info_is_void_t type_info_is_void = 0;
> +static type_info_is_reference_t type_info_is_reference = 0;
> +static type_info_is_resolved_t type_info_is_resolved = 0;
> +static type_info_is_primitive_t type_info_is_primitive = 0;
> +static type_info_is_vector_t type_info_is_vector = 0;
> +
> +//Vector
> +static vector_get_first_element_offset_t
> vector_get_first_element_offset = 0;
> //vector_first_element_offset_class_handle
> +static vector_get_length_offset_t vector_get_length_offset = 0;
> //vector_length_offset
> +
> +//Vm
> +static vm_tls_alloc_t vm_tls_alloc = 0; //IDATA VMCALL
> hythread_tls_alloc(hythread_tls_key_t *handle)
> +static vm_tls_get_offset_t vm_tls_get_offset = 0; //UDATA VMCALL
> hythread_tls_get_offset(hythread_tls_key_t key)
> +static vm_tls_get_request_offset_t vm_tls_get_request_offset = 0;
> //DATA VMCALL hythread_tls_get_request_offset
> +static vm_tls_is_fast_t vm_tls_is_fast = 0;//UDATA VMCALL
> hythread_uses_fast_tls
> +static vm_get_tls_offset_in_segment_t vm_get_tls_offset_in_segment =
> 0;//IDATA VMCALL hythread_get_hythread_offset_in_tls(void)
> +
> +static vm_properties_destroy_keys_t vm_properties_destroy_keys =
> 0;//void destroy_properties_keys(char** keys)
> +static vm_properties_destroy_value_t vm_properties_destroy_value =
> 0;//void destroy_property_value(char* value)
> +static vm_properties_get_keys_t vm_properties_get_keys = 0;//char**
> get_properties_keys(PropertyTable table_number);
> +static vm_properties_get_keys_starting_with_t
> vm_properties_get_keys_starting_with = 0;
> +static vm_properties_get_value_t vm_properties_get_value = 0;//char*
> get_property(const char* key, PropertyTable table_number)
> +
> +
> +static vm_get_system_object_class_t vm_get_system_object_class = 0; //
> get_system_object_class
> +static vm_get_system_class_class_t vm_get_system_class_class = 0; //
> get_system_class_class
> +static vm_get_system_string_class_t vm_get_system_string_class = 0; //
> get_system_string_class
> +static vm_get_vtable_base_t vm_get_vtable_base = 0; //POINTER_SIZE_INT
> vm_get_vtable_base()
> +static vm_get_heap_base_address_t vm_get_heap_base_address = 0;
> //vm_heap_base_address
> +static vm_get_heap_ceiling_address_t vm_get_heap_ceiling_address = 0;
> //vm_heap_ceiling_address
> +static vm_is_heap_compressed_t vm_is_heap_compressed =
> 0;//vm_references_are_compressed();
> +static vm_is_vtable_compressed_t vm_is_vtable_compressed =
> 0;//vm_vtable_pointers_are_compressed();
> +static vm_patch_code_block_t vm_patch_code_block = 0;
> +static vm_compile_method_t vm_compile_method = 0;
> +static vm_register_jit_extended_class_callback_t
> vm_register_jit_extended_class_callback = 0;
> +static vm_register_jit_overridden_method_callback_t
> vm_register_jit_overridden_method_callback = 0;
> +static vm_register_jit_recompiled_method_callback_t
> vm_register_jit_recompiled_method_callback = 0;
> +static vm_compiled_method_load_t vm_compiled_method_load = 0;
> +static vm_helper_get_addr_t vm_helper_get_addr = 0;
> +static vm_helper_get_addr_optimized_t vm_helper_get_addr_optimized = 0;
> +static vm_helper_get_by_name_t vm_helper_get_by_name = 0;
> +static vm_helper_get_calling_convention_t
> vm_helper_get_calling_convention = 0;
> +static vm_helper_get_interruptibility_kind_t
> vm_helper_get_interruptibility_kind = 0;
> +static vm_helper_get_magic_helper_t vm_helper_get_magic_helper = 0;
> +static vm_helper_get_name_t vm_helper_get_name = 0;
> +
> +//VTable
> +static vtable_get_class_t vtable_get_class = 0;
> +
> +static vm_enumerate_root_reference_t vm_enumerate_root_reference = 0;
> +static vm_enumerate_compressed_root_reference_t
> vm_enumerate_compressed_root_reference = 0;
> +static vm_enumerate_root_interior_pointer_t
> vm_enumerate_root_interior_pointer = 0;
> +
> +#undef GET_INTERFACE
> +
> +#define GET_INTERFACE(get_adapter, func_name) \
> + (func_name##_t)get_adapter(#func_name); assert(func_name)
> +
> +
> + bool VMInterface::setVmAdapter(vm_adaptor_t a) {
> + vm = a;
> + allocation_handle_get_class = GET_INTERFACE(vm,
> allocation_handle_get_class);
> +
> + //Class
> + class_get_array_element_class = GET_INTERFACE(vm,
> class_get_array_element_class);
> + class_get_array_element_size = GET_INTERFACE(vm,
> class_get_array_element_size);
> + class_get_array_of_class = GET_INTERFACE(vm,
> class_get_array_of_class);
> + class_get_element_type_info = GET_INTERFACE(vm,
> class_get_element_type_info);
> + class_get_name = GET_INTERFACE(vm, class_get_name);
> + class_get_super_class = GET_INTERFACE(vm, class_get_super_class);
> + class_get_depth = GET_INTERFACE(vm, class_get_depth);
> + class_get_vtable = GET_INTERFACE(vm, class_get_vtable);
> + class_get_allocation_handle = GET_INTERFACE(vm,
> class_get_allocation_handle);
> + class_get_boxed_data_size = GET_INTERFACE(vm,
> class_get_boxed_data_size);
> + class_get_num_array_dimensions = GET_INTERFACE(vm,
> class_get_num_array_dimensions);
> + class_get_class_of_primitive_type = GET_INTERFACE(vm,
> class_get_class_of_primitive_type);
> + class_get_const_string_intern_addr = GET_INTERFACE(vm,
> class_get_const_string_intern_addr);
> + class_get_const_type = GET_INTERFACE(vm, class_get_const_type);
> + class_get_const_addr = GET_INTERFACE(vm, class_get_const_addr);
> + class_get_method_by_name = GET_INTERFACE(vm,
> class_get_method_by_name);
> + class_get_field_by_name = GET_INTERFACE(vm,
> class_get_field_by_name);
> + class_get_class_loader = GET_INTERFACE(vm,
> class_get_class_loader);
> +
> + class_is_array = GET_INTERFACE(vm, class_is_array);
> + class_is_enum = GET_INTERFACE(vm, class_is_enum);
> + class_is_final = GET_INTERFACE(vm, class_is_final);
> + class_is_throwable = GET_INTERFACE(vm, class_is_throwable);
> + class_is_interface = GET_INTERFACE(vm, class_is_interface);
> + class_is_abstract = GET_INTERFACE(vm, class_is_abstract);
> + class_is_initialized = GET_INTERFACE(vm, class_is_initialized);
> + class_is_finalizable = GET_INTERFACE(vm, class_is_finalizable);
> + class_is_instanceof = GET_INTERFACE(vm, class_is_instanceof);
> + class_is_support_fast_instanceof = GET_INTERFACE(vm,
> class_is_support_fast_instanceof);
> + class_is_primitive = GET_INTERFACE(vm, class_is_primitive);
> +
> + class_lookup_class_by_name_using_bootstrap_class_loader =
> GET_INTERFACE(vm, class_lookup_class_by_name_using_bootstrap_class_loader);
> + class_lookup_method_recursively = GET_INTERFACE(vm,
> class_lookup_method_recursively);
> +
> + // Const Pool
> + class_cp_get_field_type = GET_INTERFACE(vm,
> class_cp_get_field_type);
> + class_cp_get_entry_signature = GET_INTERFACE(vm,
> class_cp_get_entry_signature);
> + class_cp_is_entry_resolved = GET_INTERFACE(vm,
> class_cp_is_entry_resolved);
> + class_cp_get_class_name = GET_INTERFACE(vm,
> class_cp_get_class_name);
> + class_cp_get_method_class_name = GET_INTERFACE(vm,
> class_cp_get_method_class_name);
> + class_cp_get_method_name = GET_INTERFACE(vm,
> class_cp_get_method_name);
> +
> +
> + //Field
> +
> + field_get_address = GET_INTERFACE(vm, field_get_address);
> + field_get_class = GET_INTERFACE(vm, field_get_class);
> + field_get_descriptor = GET_INTERFACE(vm, field_get_descriptor);
> + field_get_name = GET_INTERFACE(vm, field_get_name);
> + field_get_offset = GET_INTERFACE(vm, field_get_offset);
> + field_get_type_info = GET_INTERFACE(vm, field_get_type_info);
> + field_is_final = GET_INTERFACE(vm, field_is_final);
> + field_is_magic = GET_INTERFACE(vm, field_is_magic);
> + field_is_private = GET_INTERFACE(vm, field_is_private);
> + field_is_static = GET_INTERFACE(vm, field_is_static);
> + field_is_volatile = GET_INTERFACE(vm, field_is_volatile);
> +
> + //Method
> +
> + method_get_overridden_method = GET_INTERFACE(vm,
> method_get_overridden_method);
> + method_get_info_block_jit = GET_INTERFACE(vm,
> method_get_info_block_jit);
> + method_get_info_block_size_jit = GET_INTERFACE(vm,
> method_get_info_block_size_jit);
> + method_get_name = GET_INTERFACE(vm, method_get_name);
> + method_get_descriptor = GET_INTERFACE(vm, method_get_descriptor);
> + method_get_byte_code_addr = GET_INTERFACE(vm,
> method_get_byte_code_addr);
> + method_get_byte_code_size = GET_INTERFACE(vm,
> method_get_byte_code_size);
> + method_get_max_stack = GET_INTERFACE(vm, method_get_max_stack);
> + method_get_num_handlers = GET_INTERFACE(vm,
> method_get_num_handlers);
> + method_get_offset = GET_INTERFACE(vm, method_get_offset);
> + method_get_indirect_address = GET_INTERFACE(vm,
> method_get_indirect_address);
> + method_get_native_func_addr = GET_INTERFACE(vm,
> method_get_native_func_addr);
> + method_vars_get_number = GET_INTERFACE(vm,
> method_vars_get_number);
> + method_args_get_number = GET_INTERFACE(vm,
> method_args_get_number);
> + method_args_get_type_info = GET_INTERFACE(vm,
> method_args_get_type_info);
> + method_ret_type_get_type_info = GET_INTERFACE(vm,
> method_ret_type_get_type_info);
> + method_get_signature = GET_INTERFACE(vm, method_get_signature);
> + method_get_class = GET_INTERFACE(vm, method_get_class);
> + method_get_handler_info = GET_INTERFACE(vm,
> method_get_handler_info);
> + method_get_code_block_addr_jit_new = GET_INTERFACE(vm,
> method_get_code_block_addr_jit_new);
> + method_get_code_block_size_jit_new = GET_INTERFACE(vm,
> method_get_code_block_size_jit_new);
> + method_get_side_effects = GET_INTERFACE(vm,
> method_get_side_effects);
> +
> + method_has_annotation = GET_INTERFACE(vm, method_has_annotation);
> + method_is_private = GET_INTERFACE(vm, method_is_private);
> + method_is_static = GET_INTERFACE(vm, method_is_static);
> + method_is_native = GET_INTERFACE(vm, method_is_native);
> + method_is_synchronized = GET_INTERFACE(vm,
> method_is_synchronized);
> + method_is_final = GET_INTERFACE(vm, method_is_final);
> + method_is_abstract = GET_INTERFACE(vm, method_is_abstract);
> + method_is_strict = GET_INTERFACE(vm, method_is_strict);
> + method_is_overridden = GET_INTERFACE(vm, method_is_overridden);
> + method_is_no_inlining = GET_INTERFACE(vm, method_is_no_inlining);
> +
> +
> + method_set_side_effects = GET_INTERFACE(vm,
> method_set_side_effects);
> + method_set_num_target_handlers = GET_INTERFACE(vm,
> method_set_num_target_handlers);
> + method_set_target_handler_info = GET_INTERFACE(vm,
> method_set_target_handler_info);
> +
> + method_lock = GET_INTERFACE(vm, method_lock);
> + method_unlock = GET_INTERFACE(vm, method_unlock);
> +
> + method_allocate_code_block = GET_INTERFACE(vm,
> method_allocate_code_block);
> + method_allocate_data_block = GET_INTERFACE(vm,
> method_allocate_data_block);
> + method_allocate_info_block = GET_INTERFACE(vm,
> method_allocate_info_block);
> + method_allocate_jit_data_block = GET_INTERFACE(vm,
> method_allocate_jit_data_block);
> +
> +
> + //Object
> + object_get_vtable_offset = GET_INTERFACE(vm,
> object_get_vtable_offset);
> +
> +
> + //Resolve
> + resolve_class = GET_INTERFACE(vm, resolve_class);
> + resolve_class_new = GET_INTERFACE(vm, resolve_class_new);
> + resolve_special_method = GET_INTERFACE(vm,
> resolve_special_method);
> + resolve_interface_method = GET_INTERFACE(vm,
> resolve_interface_method);
> + resolve_static_method = GET_INTERFACE(vm, resolve_static_method);
> + resolve_virtual_method = GET_INTERFACE(vm,
> resolve_virtual_method);
> + resolve_nonstatic_field = GET_INTERFACE(vm,
> resolve_nonstatic_field);
> + resolve_static_field = GET_INTERFACE(vm, resolve_static_field);
> +
> + //Type Info
> +
> + type_info_create_from_java_descriptor = GET_INTERFACE(vm,
> type_info_create_from_java_descriptor);
> + type_info_get_type_name = GET_INTERFACE(vm,
> type_info_get_type_name);
> + type_info_get_class = GET_INTERFACE(vm, type_info_get_class);
> + type_info_get_class_no_exn = GET_INTERFACE(vm,
> type_info_get_class_no_exn);
> + type_info_get_num_array_dimensions = GET_INTERFACE(vm,
> type_info_get_num_array_dimensions);
> + type_info_get_type_info = GET_INTERFACE(vm,
> type_info_get_type_info);
> +
> + type_info_is_void = GET_INTERFACE(vm, type_info_is_void);
> + type_info_is_reference = GET_INTERFACE(vm,
> type_info_is_reference);
> + type_info_is_resolved = GET_INTERFACE(vm, type_info_is_resolved);
> + type_info_is_primitive = GET_INTERFACE(vm,
> type_info_is_primitive);
> + type_info_is_vector = GET_INTERFACE(vm, type_info_is_vector);
> +
> + //Vector
> + vector_get_first_element_offset = GET_INTERFACE(vm,
> vector_get_first_element_offset);
> + vector_get_length_offset = GET_INTERFACE(vm,
> vector_get_length_offset);
> +
> + //Vm
> + vm_tls_alloc = GET_INTERFACE(vm, vm_tls_alloc);
> + vm_tls_get_offset = GET_INTERFACE(vm, vm_tls_get_offset);
> + vm_tls_get_request_offset = GET_INTERFACE(vm,
> vm_tls_get_request_offset);
> + vm_tls_is_fast = GET_INTERFACE(vm, vm_tls_is_fast);
> + vm_get_tls_offset_in_segment = GET_INTERFACE(vm,
> vm_get_tls_offset_in_segment);
> +
> + vm_properties_destroy_keys = GET_INTERFACE(vm,
> vm_properties_destroy_keys);
> + vm_properties_destroy_value = GET_INTERFACE(vm,
> vm_properties_destroy_value);
> + vm_properties_get_keys = GET_INTERFACE(vm,
> vm_properties_get_keys);
> + vm_properties_get_keys_starting_with = GET_INTERFACE(vm,
> vm_properties_get_keys_starting_with);
> + vm_properties_get_value = GET_INTERFACE(vm,
> vm_properties_get_value);
> +
> +
> + vm_get_system_object_class = GET_INTERFACE(vm,
> vm_get_system_object_class);
> + vm_get_system_class_class = GET_INTERFACE(vm,
> vm_get_system_class_class);
> + vm_get_system_string_class = GET_INTERFACE(vm,
> vm_get_system_string_class);
> + vm_get_vtable_base = GET_INTERFACE(vm, vm_get_vtable_base);
> + vm_get_heap_base_address = GET_INTERFACE(vm,
> vm_get_heap_base_address);
> + vm_get_heap_ceiling_address = GET_INTERFACE(vm,
> vm_get_heap_ceiling_address);
> + vm_is_heap_compressed = GET_INTERFACE(vm, vm_is_heap_compressed);
> + vm_is_vtable_compressed = GET_INTERFACE(vm,
> vm_is_vtable_compressed);
> + vm_patch_code_block = GET_INTERFACE(vm, vm_patch_code_block);
> + vm_compile_method = GET_INTERFACE(vm, vm_compile_method);
> + vm_register_jit_extended_class_callback = GET_INTERFACE(vm,
> vm_register_jit_extended_class_callback);
> + vm_register_jit_overridden_method_callback = GET_INTERFACE(vm,
> vm_register_jit_overridden_method_callback);
> + vm_register_jit_recompiled_method_callback = GET_INTERFACE(vm,
> vm_register_jit_recompiled_method_callback);
> + vm_compiled_method_load = GET_INTERFACE(vm,
> vm_compiled_method_load);
> + vm_helper_get_addr = GET_INTERFACE(vm, vm_helper_get_addr);
> + vm_helper_get_addr_optimized = GET_INTERFACE(vm,
> vm_helper_get_addr_optimized);
> + vm_helper_get_by_name = GET_INTERFACE(vm, vm_helper_get_by_name);
> + vm_helper_get_calling_convention = GET_INTERFACE(vm,
> vm_helper_get_calling_convention);
> + vm_helper_get_interruptibility_kind = GET_INTERFACE(vm,
> vm_helper_get_interruptibility_kind);
> + vm_helper_get_magic_helper = GET_INTERFACE(vm,
> vm_helper_get_magic_helper);
> + vm_helper_get_name = GET_INTERFACE(vm, vm_helper_get_name);
> +
> + //VTable
> + vtable_get_class = GET_INTERFACE(vm, vtable_get_class);
> +
> + vm_enumerate_root_reference = GET_INTERFACE(vm,
> vm_enumerate_root_reference);
> + vm_enumerate_compressed_root_reference = GET_INTERFACE(vm,
> vm_enumerate_compressed_root_reference);
> + vm_enumerate_root_interior_pointer = GET_INTERFACE(vm,
> vm_enumerate_root_interior_pointer);
> +
> + return true;
> + }
> +
> + bool VMInterface::isValidFeature(const char* id) {
> + return NULL != vm(id);
> + }
>
>
>
> @@ -71,16 +453,16 @@
> // TODO: free TLS key on JIT deinitilization
> uint32
> VMInterface::flagTLSSuspendRequestOffset(){
> - return (uint32)hythread_tls_get_request_offset();
> + return (uint32)vm_tls_get_request_offset();
> }
>
> uint32
> VMInterface::flagTLSThreadStateOffset() {
> - static hythread_tls_key_t key = 0;
> + static UDATA key = 0;
> static size_t offset = 0;
> if (key == 0) {
> - hythread_tls_alloc(&key);
> - offset = hythread_tls_get_offset(key);
> + vm_tls_alloc(&key);
> + offset = vm_tls_get_offset(key);
> }
> assert(fit32(offset));
> return (uint32)offset;
> @@ -88,14 +470,23 @@
>
> int32
> VMInterface::getTLSBaseOffset() {
> - return (int32) hythread_get_hythread_offset_in_tls();
> + return (int32) vm_get_tls_offset_in_segment();
> }
>
> bool
> VMInterface::useFastTLSAccess() {
> - return 0 != hythread_uses_fast_tls();
> + return 0 != vm_tls_is_fast();
> }
>
> +bool
> +VMInterface::isVTableCompressed() {
> + return vm_is_vtable_compressed();
> +}
> +
> +bool
> +VMInterface::areReferencesCompressed() {
> + return vm_is_heap_compressed();
> +}
>
> //////////////////////////////////////////////////////////////////////////////
> ///////////////////////// VMTypeManager
> /////////////////////////////////////
>
> //////////////////////////////////////////////////////////////////////////////
> @@ -134,31 +525,26 @@
>
> void*
> VMInterface::getSystemObjectVMTypeHandle() {
> - return get_system_object_class();
> + return vm_get_system_object_class();
> }
>
> void*
> VMInterface::getSystemClassVMTypeHandle() {
> - return get_system_class_class();
> + return vm_get_system_class_class();
> }
>
> void*
> VMInterface::getSystemStringVMTypeHandle() {
> - return get_system_string_class();
> + return vm_get_system_string_class();
> }
>
> void*
> VMInterface::getArrayVMTypeHandle(void* elemVMTypeHandle,bool isUnboxed)
> {
> - if (isUnboxed)
> - return class_get_array_of_unboxed((Class_Handle)
> elemVMTypeHandle);
> + //if (isUnboxed)
> + // return class_get_array_of_unboxed((Class_Handle)
> elemVMTypeHandle);
> return class_get_array_of_class((Class_Handle) elemVMTypeHandle);
> }
>
> -const char*
> -VMInterface::getTypeNameQualifier(void* vmTypeHandle) {
> - return class_get_package_name((Class_Handle) vmTypeHandle);
> -}
> -
> void*
> VMInterface::getArrayElemVMTypeHandle(void* vmTypeHandle) {
> return class_get_array_element_class((Class_Handle) vmTypeHandle);
> @@ -185,17 +571,12 @@
>
> bool
> VMInterface::isLikelyExceptionType(void* vmTypeHandle) {
> - return class_hint_is_exceptiontype((Class_Handle)
> vmTypeHandle)?true:false;
> -}
> -
> -bool
> -VMInterface::isBeforeFieldInit(void* vmTypeHandle) {
> - return class_is_before_field_init((Class_Handle)
> vmTypeHandle)?true:false;
> + return class_is_throwable((Class_Handle) vmTypeHandle)?true:false;
> }
>
> bool
> VMInterface::getClassFastInstanceOfFlag(void* vmTypeHandle) {
> - return class_get_fast_instanceof_flag((Class_Handle)
> vmTypeHandle)?true:false;
> + return class_is_support_fast_instanceof((Class_Handle)
> vmTypeHandle)?true:false;
> }
>
> int
> @@ -205,14 +586,14 @@
>
> uint32
> VMInterface::getArrayLengthOffset() {
> - return vector_length_offset();
> + return vector_get_length_offset();
> }
>
> uint32
> VMInterface::getArrayElemOffset(void* vmElemTypeHandle,bool isUnboxed) {
> - if (isUnboxed)
> - return vector_first_element_offset_unboxed((Class_Handle)
> vmElemTypeHandle);
> - return vector_first_element_offset_class_handle((Class_Handle)
> vmElemTypeHandle);
> + //if (isUnboxed)
> + // return vector_first_element_offset_unboxed((Class_Handle)
> vmElemTypeHandle);
> + return vector_get_first_element_offset((Class_Handle)
> vmElemTypeHandle);
> }
>
> bool
> @@ -241,16 +622,16 @@
> return class_is_array((Class_Handle)vmTypeHandle)?true:false;
> }
> bool VMInterface::isFinalType(void* vmTypeHandle) {
> - return
> class_property_is_final((Class_Handle)vmTypeHandle)?true:false;
> + return class_is_final((Class_Handle)vmTypeHandle)?true:false;
> }
> bool VMInterface::isInterfaceType(void* vmTypeHandle) {
> - return
> class_property_is_interface2((Class_Handle)vmTypeHandle)?true:false;
> + return class_is_interface((Class_Handle)vmTypeHandle)?true:false;
> }
> bool VMInterface::isAbstractType(void* vmTypeHandle) {
> - return
> class_property_is_abstract((Class_Handle)vmTypeHandle)?true:false;
> + return class_is_abstract((Class_Handle)vmTypeHandle)?true:false;
> }
> bool VMInterface::needsInitialization(void* vmTypeHandle) {
> - return
> class_needs_initialization((Class_Handle)vmTypeHandle)?true:false;
> + return class_is_initialized((Class_Handle)vmTypeHandle)?false:true;
> }
> bool VMInterface::isFinalizable(void* vmTypeHandle) {
> return class_is_finalizable((Class_Handle)vmTypeHandle)?true:false;
> @@ -275,6 +656,11 @@
> return object_get_vtable_offset();
> }
>
> +uint64
> +VMInterface::getVTableBase() {
> + return (uint64)vm_get_vtable_base();
> +}
> +
> void* VMInterface::getTypeHandleFromAllocationHandle(void*
> vmAllocationHandle)
> {
> return
> allocation_handle_get_class((Allocation_Handle)vmAllocationHandle);
> @@ -286,6 +672,43 @@
> ///////////////////////// MethodDesc
> //////////////////////////////////////
>
> //////////////////////////////////////////////////////////////////////////////
>
> +MethodDesc::MethodDesc(Method_Handle m, JIT_Handle jit,
> CompilationInterface* ci, uint32 id)
> +: TypeMemberDesc(id, ci), drlMethod(m),
> +methodSig(method_get_signature(m)),
> +handleMap(NULL),
> +jitHandle(jit){}
> +
> +const char* MethodDesc::getName() const {return
> method_get_name(drlMethod);}
> +const char* MethodDesc::getSignatureString() const {return
> method_get_descriptor(drlMethod); }
> +
> +bool MethodDesc::isPrivate() const {return
> method_is_private(drlMethod)?true:false;}
> +bool MethodDesc::isStatic() const {return
> method_is_static(drlMethod)?true:false;}
> +bool MethodDesc::isInstance() const {return
> method_is_static(drlMethod)?false:true;}
> +bool MethodDesc::isNative() const {return
> method_is_native(drlMethod)?true:false;}
> +bool MethodDesc::isSynchronized() const {return
> method_is_synchronized(drlMethod)?true:false;}
> +bool MethodDesc::isFinal() const {return
> method_is_final(drlMethod)?true:false;}
> +bool MethodDesc::isVirtual() const {return isInstance() &&
> !isPrivate();}
> +bool MethodDesc::isAbstract() const {return
> method_is_abstract(drlMethod)?true:false;}
> +// FP strict
> +bool MethodDesc::isStrict() const {return
> method_is_strict(drlMethod)?true:false;}
> +bool MethodDesc::isClassInitializer() const {return
> strcmp(getName(), "<clinit>") == 0; }
> +bool MethodDesc::isInstanceInitializer() const {return
> strcmp(getName(), "<init>") == 0; }
> +
> +//
> +// Method info
> +//
> +
> +const Byte* MethodDesc::getByteCodes() const {return
> method_get_byte_code_addr(drlMethod);}
> +uint32 MethodDesc::getByteCodeSize() const {return (uint32)
> method_get_byte_code_size(drlMethod);}
> +uint16 MethodDesc::getMaxStack() const {return (uint16)
> method_get_max_stack(drlMethod);}
> +uint32 MethodDesc::getNumHandlers() const {return
> method_get_num_handlers(drlMethod);}
> +bool MethodDesc::isOverridden() const {return
> method_is_overridden(drlMethod)?true:false;}
> +uint32 MethodDesc::getOffset() const {return
> method_get_offset(drlMethod);}
> +void* MethodDesc::getIndirectAddress() const {return
> method_get_indirect_address(drlMethod);}
> +void* MethodDesc::getNativeAddress() const {return
> method_get_native_func_addr(drlMethod);}
> +
> +uint32 MethodDesc::getNumVars() const {return
> method_vars_get_number(drlMethod);}
> +
> uint32
> MethodDesc::getNumParams() const {
> return method_args_get_number(methodSig);
> @@ -334,20 +757,15 @@
> }
>
> bool
> -MethodDesc::isRequireSecObject() {
> - return method_is_require_security_object(drlMethod)?true:false;
> -}
> -
> -bool
> TypeMemberDesc::isParentClassIsLikelyExceptionType() const {
> Class_Handle ch = getParentHandle();
> - return class_hint_is_exceptiontype(ch);
> + return class_is_throwable(ch);
> }
>
> const char*
> CompilationInterface::getSignatureString(MethodDesc* enclosingMethodDesc,
> uint32 methodToken) {
> Class_Handle enclosingDrlVMClass =
> enclosingMethodDesc->getParentHandle();
> - return class_get_cp_entry_signature(enclosingDrlVMClass, (unsigned
> short)methodToken);
> + return class_cp_get_entry_signature(enclosingDrlVMClass, (unsigned
> short)methodToken);
> }
>
> Method_Side_Effects
> @@ -395,6 +813,21 @@
> ///////////////////////// FieldDesc
> ///////////////////////////////////////
>
> //////////////////////////////////////////////////////////////////////////////
>
> +const char* FieldDesc::getName() const {return
> field_get_name(drlField);}
> +const char* FieldDesc::getSignatureString() const {return
> field_get_descriptor(drlField); }
> +bool FieldDesc::isPrivate() const {return
> field_is_private(drlField)?true:false;}
> +bool FieldDesc::isStatic() const {return
> field_is_static(drlField)?true:false;}
> +//
> +// this field is constant after it is initialized
> +// can only be mutated by constructor (instance fields) or
> +// type initializer (static fields)
> +//
> +bool FieldDesc::isInitOnly() const {return
> field_is_final(drlField)?true:false;}
> +// accesses to field cannot be reordered or CSEed
> +bool FieldDesc::isVolatile() const {return
> field_is_volatile(drlField)?true:false;}
> +bool FieldDesc::isMagic() const {return
> field_is_magic(drlField)?true:false;}
> +void* FieldDesc::getAddress() const {return
> field_get_address(drlField);} // for static fields
> +
>
> Class_Handle FieldDesc::getParentHandle() const {
> return field_get_class(drlField);
> @@ -413,7 +846,7 @@
>
> Type*
> FieldDesc::getFieldType() {
> - Type_Info_Handle typeHandle =
> field_get_type_info_of_field_value(drlField);
> + Type_Info_Handle typeHandle = field_get_type_info(drlField);
> return compilationInterface->getTypeFromDrlVMTypeHandle(typeHandle);
> }
>
> @@ -422,31 +855,6 @@
> return field_get_offset(drlField);
> }
>
> -
>
> -//////////////////////////////////////////////////////////////////////////////
> -//////////////////////////// ClassHierachyMethodIterator
> //////////////////
>
> -//////////////////////////////////////////////////////////////////////////////
> -
> -ClassHierarchyMethodIterator::ClassHierarchyMethodIterator(
> - CompilationInterface& compilationInterface, ObjectType* objType,
> MethodDesc* methodDesc)
> - : compilationInterface(compilationInterface)
> -{
> - valid = method_iterator_initialize(&iterator,
> methodDesc->getMethodHandle(),
> - (Class_Handle) objType->getVMTypeHandle());
> -}
> -
> -bool ClassHierarchyMethodIterator::hasNext() const {
> - Method_Handle handle = method_iterator_get_current(&iterator);
> - return handle != NULL;
> -}
> -
> -MethodDesc*
> -ClassHierarchyMethodIterator::getNext() {
> - MethodDesc* desc = compilationInterface.getMethodDesc
> (method_iterator_get_current(&iterator));
> - method_iterator_advance(&iterator);
> - return desc;
> -}
> -
>
> //////////////////////////////////////////////////////////////////////////////
> //////////////////////////// CompilationInterface
> /////////////////////////
>
> //////////////////////////////////////////////////////////////////////////////
> @@ -524,7 +932,7 @@
>
> void*
> CompilationInterface::getRuntimeHelperAddress(VM_RT_SUPPORT id) {
> - return vm_get_rt_support_addr(id);
> + return vm_helper_get_addr(id);
> }
>
> void*
> @@ -532,7 +940,7 @@
> Class_Handle handle = NULL;
> if (type != NULL && type->isNamedType())
> handle = (Class_Handle) ((NamedType *)type)->getVMTypeHandle();
> - void* addr = vm_get_rt_support_addr_optimized(id, handle);
> + void* addr = vm_helper_get_addr_optimized(id, handle);
> assert(addr != NULL);
> return addr;
> }
> @@ -602,18 +1010,13 @@
> if (type->isUnresolvedType()) {
> return NULL;
> }
> - Method_Handle m = method_find_overridden_method((Class_Handle)
> type->getVMTypeHandle(),
> + Method_Handle m = method_get_overridden_method((Class_Handle)
> type->getVMTypeHandle(),
> methodDesc->getMethodHandle());
> if (!m)
> return NULL;
> return getMethodDesc(m);
> }
>
> -ClassHierarchyMethodIterator*
> -CompilationInterface::getClassHierarchyMethodIterator(ObjectType*
> baseType, MethodDesc* methodDesc) {
> - return new (getMemManager()) ClassHierarchyMethodIterator(*this,
> baseType, methodDesc);
> -}
> -
> void
> CompilationInterface::setNotifyWhenClassIsExtended(ObjectType * type,
> void *
> callbackData) {
> void * typeHandle = type->getVMTypeHandle();
> @@ -639,15 +1042,15 @@
> Method_Handle method = methodDesc->getMethodHandle();
> Method_Handle outer = outerDesc->getMethodHandle();
>
> - compiled_method_load(method, codeSize, codeAddr, mapLength,
> addrLocationMap, compileInfo, outer);
> + vm_compiled_method_load(method, codeSize, codeAddr, mapLength,
> addrLocationMap, compileInfo, outer);
> }
>
> void * VMInterface::getHeapBase() {
> - return vm_heap_base_address();
> + return vm_get_heap_base_address();
> }
>
> void * VMInterface::getHeapCeiling() {
> - return vm_heap_ceiling_address();
> + return vm_get_heap_ceiling_address();
> }
>
> ObjectType * CompilationInterface::findClassUsingBootstrapClassloader(
> const char * klassName ) {
> @@ -675,16 +1078,6 @@
> }
>
>
> -
> -
> -NamedType* MethodDesc::getThrowType(uint32 i) {
> - assert(i<=method_number_throws(drlMethod));
> - Class_Handle ch = method_get_throws(drlMethod, i);
> - assert(ch);
> - NamedType* res =
> compilationInterface->getTypeManager().getObjectType(ch);
> - return res;
> -}
> -
> bool MethodDesc::hasAnnotation(NamedType* type) const {
> return method_has_annotation(drlMethod,
> (Class_Handle)type->getVMTypeHandle());
> }
> @@ -794,8 +1187,8 @@
>
> NamedType* CompilationInterface::getNamedType(Class_Handle enclClass,
> uint32 cpIndex, ResolveNewCheck checkNew) {
> Class_Handle ch = NULL;
> - if (typeManager.isLazyResolutionMode() &&
> !class_is_cp_entry_resolved(compileHandle, enclClass, cpIndex)) {
> - const char* className = const_pool_get_class_name(enclClass,
> cpIndex);
> + if (typeManager.isLazyResolutionMode() &&
> !class_cp_is_entry_resolved(compileHandle, enclClass, cpIndex)) {
> + const char* className = class_cp_get_class_name(enclClass,
> cpIndex);
> bool forceResolve = VMMagicUtils::isVMMagicClass(className);
> if (!forceResolve) {
> return getUnresolvedType(typeManager, enclClass, cpIndex);
> @@ -825,7 +1218,7 @@
> CompilationInterface::getSpecialMethod(Class_Handle enclClass, uint32
> cpIndex) {
> Method_Handle res = NULL;
> bool lazy = typeManager.isLazyResolutionMode();
> - if (!lazy || class_is_cp_entry_resolved(compileHandle, enclClass,
> cpIndex)) {
> + if (!lazy || class_cp_is_entry_resolved(compileHandle, enclClass,
> cpIndex)) {
> res = resolve_special_method(compileHandle,enclClass, cpIndex);
> }
> if (!res) return NULL;
> @@ -836,7 +1229,7 @@
> CompilationInterface::getInterfaceMethod(Class_Handle enclClass, uint32
> cpIndex) {
> Method_Handle res = NULL;
> bool lazy = typeManager.isLazyResolutionMode();
> - if (!lazy || class_is_cp_entry_resolved(compileHandle, enclClass,
> cpIndex)) {
> + if (!lazy || class_cp_is_entry_resolved(compileHandle, enclClass,
> cpIndex)) {
> res = resolve_interface_method(compileHandle,enclClass, cpIndex);
> }
> if (!res) return NULL;
> @@ -847,7 +1240,7 @@
> CompilationInterface::getStaticMethod(Class_Handle enclClass, uint32
> cpIndex) {
> Method_Handle res = NULL;
> bool lazy = typeManager.isLazyResolutionMode();
> - if (!lazy || class_is_cp_entry_resolved(compileHandle, enclClass,
> cpIndex)) {
> + if (!lazy || class_cp_is_entry_resolved(compileHandle, enclClass,
> cpIndex)) {
> res = resolve_static_method(compileHandle,enclClass, cpIndex);
> }
> if (!res) return NULL;
> @@ -858,7 +1251,7 @@
> CompilationInterface::getVirtualMethod(Class_Handle enclClass, uint32
> cpIndex) {
> Method_Handle res = NULL;
> bool lazy = typeManager.isLazyResolutionMode();
> - if (!lazy || class_is_cp_entry_resolved(compileHandle, enclClass,
> cpIndex)) {
> + if (!lazy || class_cp_is_entry_resolved(compileHandle, enclClass,
> cpIndex)) {
> res = resolve_virtual_method(compileHandle,enclClass, cpIndex);
> }
> if (!res) return NULL;
> @@ -870,7 +1263,7 @@
> CompilationInterface::getNonStaticField(Class_Handle enclClass, uint32
> cpIndex, bool putfield) {
> Field_Handle res = NULL;
> bool lazy = typeManager.isLazyResolutionMode();
> - if (!lazy || class_is_cp_entry_resolved(compileHandle, enclClass,
> cpIndex)) {
> + if (!lazy || class_cp_is_entry_resolved(compileHandle, enclClass,
> cpIndex)) {
> res = resolve_nonstatic_field(compileHandle, enclClass, cpIndex,
> putfield);
> }
> if (!res) {
> @@ -884,7 +1277,7 @@
> CompilationInterface::getStaticField(Class_Handle enclClass, uint32
> cpIndex, bool putfield) {
> Field_Handle res = NULL;
> bool lazy = typeManager.isLazyResolutionMode();
> - if (!lazy || class_is_cp_entry_resolved(compileHandle, enclClass,
> cpIndex)) {
> + if (!lazy || class_cp_is_entry_resolved(compileHandle, enclClass,
> cpIndex)) {
> res = resolve_static_field(compileHandle, enclClass, cpIndex,
> putfield);
> }
> if (!res) {
> @@ -908,7 +1301,7 @@
>
> Type*
> CompilationInterface::getFieldType(Class_Handle enclClass, uint32
> cpIndex) {
> - Java_Type drlType = (Java_Type)class_get_cp_field_type(enclClass,
> (unsigned short)cpIndex);
> + Java_Type drlType = (Java_Type)class_cp_get_field_type(enclClass,
> (unsigned short)cpIndex);
> bool lazy = typeManager.isLazyResolutionMode();
> switch (drlType) {
> case JAVA_TYPE_BOOLEAN: return typeManager.getBooleanType();
> @@ -923,7 +1316,7 @@
>
> case JAVA_TYPE_CLASS:
> if (lazy) {
> - const char* fieldTypeName =
> const_pool_get_field_descriptor(enclClass, cpIndex);
> + const char* fieldTypeName =
> class_cp_get_entry_signature(enclClass, cpIndex);
> assert(fieldTypeName);
> return getTypeFromDescriptor(enclClass,
> fieldTypeName);
> }
> @@ -939,17 +1332,17 @@
>
> const char*
> CompilationInterface::getMethodName(Class_Handle enclClass, uint32
> cpIndex) {
> - return const_pool_get_method_name(enclClass, cpIndex);
> + return class_cp_get_method_name(enclClass, cpIndex);
> }
>
> const char*
> CompilationInterface::getMethodClassName(Class_Handle enclClass, uint32
> cpIndex) {
> - return const_pool_get_method_class_name(enclClass, cpIndex);
> + return class_cp_get_method_class_name(enclClass, cpIndex);
> }
>
> const char*
> CompilationInterface::getFieldSignature(Class_Handle enclClass, uint32
> cpIndex) {
> - return const_pool_get_field_descriptor(enclClass, cpIndex);
> + return class_cp_get_entry_signature(enclClass, cpIndex);
> }
>
> ::std::ostream& operator<<(::std::ostream& os, Method_Handle method) {
> @@ -961,11 +1354,11 @@
> VMPropertyIterator::VMPropertyIterator(
> MemoryManager& mm, const char* prefix): mm(mm), key(NULL),
> value(NULL), iterator(0)
> {
> - keys = get_properties_keys_staring_with(prefix, VM_PROPERTIES);
> + keys = vm_properties_get_keys_starting_with(prefix, VM_PROPERTIES);
> }
>
> VMPropertyIterator::~VMPropertyIterator() {
> - destroy_properties_keys(keys);
> + vm_properties_destroy_keys(keys);
> }
>
> bool
> @@ -974,10 +1367,34 @@
> return false;
> }
> key = mm.copy(keys[iterator]);
> - char* nval = get_property(keys[iterator++], VM_PROPERTIES);
> + char* nval = vm_properties_get_value(keys[iterator++],
> VM_PROPERTIES);
> value = mm.copy(nval);
> - destroy_property_value(nval);
> + vm_properties_destroy_value(nval);
> return true;
> +}
> +
> +void GCInterface::enumerateRootReference(void** reference) {
> + vm_enumerate_root_reference(reference, FALSE);
> +}
> +
> +void GCInterface::enumerateCompressedRootReference(uint32* reference) {
> + vm_enumerate_compressed_root_reference(reference, FALSE);
> +}
> +
> +void GCInterface::enumerateRootManagedReference(void** slotReference, int
> slotOffset) {
> + vm_enumerate_root_interior_pointer(slotReference, slotOffset, FALSE);
> +}
> +
> +void ThreadDumpEnumerator::enumerateRootReference(void** reference) {
> + //vm_check_if_monitor(reference, 0, 0, 0, FALSE, 1);
> +}
> +
> +void ThreadDumpEnumerator::enumerateCompressedRootReference(uint32*
> reference) {
> + //vm_check_if_monitor(0, 0, reference, 0, FALSE, 2);
> +}
> +
> +void ThreadDumpEnumerator::enumerateRootManagedReference(void**
> slotReference, int slotOffset) {
> + //vm_check_if_monitor(slotReference, 0, 0, slotOffset, FALSE, 3);
> }
>
> } //namespace Jitrino
>
> Modified: harmony/enhanced/drlvm/trunk/vm/jitrino/src/vm/VMInterface.h
> URL:
> http://svn.apache.org/viewvc/harmony/enhanced/drlvm/trunk/vm/jitrino/src/vm/VMInterface.h?rev=634547&r1=634546&r2=634547&view=diff
>
> ==============================================================================
> --- harmony/enhanced/drlvm/trunk/vm/jitrino/src/vm/VMInterface.h
> (original)
> +++ harmony/enhanced/drlvm/trunk/vm/jitrino/src/vm/VMInterface.h Thu Mar
> 6 21:59:46 2008
> @@ -19,10 +19,9 @@
> #define _VMINTERFACE_H_
>
> #include <ostream>
> -#include "open/em.h"
> #include "open/types.h"
> -#include "jit_runtime_support.h"
> -#include "jit_intf.h"
> +#include "open/ee_em_intf.h"
> +#include "open/vm_interface.h"
>
> namespace Jitrino {
>
> @@ -48,7 +47,6 @@
> static void* getSystemStringVMTypeHandle();
> static void* getArrayVMTypeHandle(void* elemVMTypeHandle,bool
> isUnboxed);
> static const char* getTypeName(void* vmTypeHandle);
> - static const char* getTypeNameQualifier(void* vmTypeHandle);
> static void* getSuperTypeVMTypeHandle(void* vmTypeHandle);
> static void* getArrayElemVMTypeHandle(void* vmTypeHandle);
> static bool isArrayType(void* vmTypeHandle);
> @@ -61,7 +59,6 @@
> static bool isAbstractType(void* vmTypeHandle);
> static bool needsInitialization(void* vmTypeHandle);
> static bool isFinalizable(void* vmTypeHandle);
> - static bool isBeforeFieldInit(void* vmTypeHandle);
> static bool getClassFastInstanceOfFlag(void* vmTypeHandle);
> static int getClassDepth(void* vmTypeHandle);
> static bool isInitialized(void* vmTypeHandle);
> @@ -84,7 +81,7 @@
>
>
> // returns true if vtable pointers are compressed
> - static bool areVTablePtrsCompressed() {return
> vm_vtable_pointers_are_compressed();}
> + static bool isVTableCompressed();
>
> // returns size of vtable pointer (currently 4 if compressed and 8
> otherwise)
> //static uint32 getVTablePtrSize() {return
> vm_get_vtable_ptr_size();}
> @@ -92,10 +89,10 @@
> // returns the offset of an object's virtual table
> static uint32 getVTableOffset();
> // returns the base for all vtables (addend to compressed vtable
> pointer)
> - static uint64 getVTableBase() {return vm_get_vtable_base();}
> + static uint64 getVTableBase();
>
> // returns true if instance fields that are references are compressed
> - static bool areReferencesCompressed() {return
> vm_references_are_compressed();}
> + static bool areReferencesCompressed();
>
> //
> // returns the base for the heap (addend to compressed heap
> references)
> @@ -105,6 +102,12 @@
>
>
> static void rewriteCodeBlock(Byte* codeBlock, Byte* newCode,
> size_t size);
> +
> + static bool setVmAdapter(vm_adaptor_t vm);
> + static bool isValidFeature(const char* id);
> +
> +protected:
> + static vm_adaptor_t vm;
> };
>
>
> @@ -145,24 +148,24 @@
> FieldDesc(Field_Handle field, CompilationInterface* ci, uint32 id)
> : TypeMemberDesc(id, ci), drlField(field) {}
>
> - const char* getName() const {return
> field_get_name(drlField);}
> - const char* getSignatureString() const {return
> field_get_descriptor(drlField); }
> + const char* getName() const;
> + const char* getSignatureString() const;
> void printFullName(::std::ostream &os);
> Class_Handle getParentHandle() const;
> - bool isPrivate() const {return
> field_is_private(drlField)?true:false;}
> - bool isStatic() const {return
> field_is_static(drlField)?true:false;}
> + bool isPrivate() const;
> + bool isStatic() const;
> //
> // this field is constant after it is initialized
> // can only be mutated by constructor (instance fields) or
> // type initializer (static fields)
> //
> - bool isInitOnly() const {return
> field_is_final(drlField)?true:false;}
> + bool isInitOnly() const;
> // accesses to field cannot be reordered or CSEed
> - bool isVolatile() const {return
> field_is_volatile(drlField)?true:false;}
> - bool isMagic() const {return
> field_is_magic(drlField)?true:false;}
> + bool isVolatile() const;
> + bool isMagic() const;
> Type* getFieldType();
> uint32 getOffset() const; // for non-static fields
> - void* getAddress() const {return
> field_get_address(drlField);} // for static fields
> + void* getAddress() const; // for static fields
> Field_Handle getFieldHandle() const {return drlField; }
>
> private:
> @@ -172,44 +175,37 @@
> ///Method representation for resolved methods
> class MethodDesc : public TypeMemberDesc {
> public:
> - MethodDesc(Method_Handle m, JIT_Handle jit, CompilationInterface* ci
> = NULL, uint32 id = 0)
> - : TypeMemberDesc(id, ci), drlMethod(m),
> - methodSig(method_get_signature(m)),
> - handleMap(NULL),
> - jitHandle(jit){}
> + MethodDesc(Method_Handle m, JIT_Handle jit, CompilationInterface* ci
> = NULL, uint32 id = 0);
>
> - const char* getName() const {return
> method_get_name(drlMethod);}
> - const char* getSignatureString() const {return
> method_get_descriptor(drlMethod); }
> + const char* getName() const;
> + const char* getSignatureString() const;
> void printFullName(::std::ostream& os);
> Class_Handle getParentHandle() const;
>
> - bool isPrivate() const {return
> method_is_private(drlMethod)?true:false;}
> - bool isStatic() const {return
> method_is_static(drlMethod)?true:false;}
> - bool isInstance() const {return
> method_is_static(drlMethod)?false:true;}
> - bool isNative() const {return
> method_is_native(drlMethod)?true:false;}
> - bool isSynchronized() const {return
> method_is_synchronized(drlMethod)?true:false;}
> + bool isPrivate() const;
> + bool isStatic() const;
> + bool isInstance() const;
> + bool isNative() const;
> + bool isSynchronized() const;
> bool isNoInlining() const;
> - bool isFinal() const {return
> method_is_final(drlMethod)?true:false;}
> - bool isVirtual() const {return isInstance() &&
> !isPrivate();}
> - bool isAbstract() const {return
> method_is_abstract(drlMethod)?true:false;}
> + bool isFinal() const;
> + bool isVirtual() const;
> + bool isAbstract() const;
> // FP strict
> - bool isStrict() const {return
> method_is_strict(drlMethod)?true:false;}
> - bool isRequireSecObject(); //FIXME drop???
> - bool isClassInitializer() const {return strcmp(getName(),
> "<clinit>") == 0; }
> - bool isInstanceInitializer() const {return
> strcmp(getName(), "<init>") == 0; }
> + bool isStrict() const;
> + bool isClassInitializer() const;
> + bool isInstanceInitializer() const;
>
> //
> // Method info
> //
>
> - const Byte* getByteCodes() const {return
> method_get_byte_code_addr(drlMethod);}
> - uint32 getByteCodeSize() const {return (uint32)
> method_get_byte_code_size(drlMethod);}
> - uint16 getMaxStack() const {return (uint16)
> method_get_max_stack(drlMethod);}
> - uint32 getNumHandlers() const {return
> method_get_num_handlers(drlMethod);}
> + const Byte* getByteCodes() const;
> + uint32 getByteCodeSize() const;
> + uint16 getMaxStack() const;
> + uint32 getNumHandlers() const;
> void getHandlerInfo(unsigned index, unsigned* beginOffset,
> unsigned* endOffset, unsigned* handlerOffset, unsigned*
> handlerClassIndex) const;
> - uint32 getNumThrows() const {return
> method_number_throws(drlMethod);}
> - NamedType* getThrowType(uint32 i);
> bool hasAnnotation(NamedType* type) const;
>
> //
> @@ -239,11 +235,12 @@
> //
> // DRL kernel
> //
> - bool isOverridden() const {return
> method_is_overridden(drlMethod)?true:false;}
> - uint32 getOffset() const {return
> method_get_offset(drlMethod);}
> - void* getIndirectAddress() const {return
> method_get_indirect_address(drlMethod);}
> + bool isOverridden() const;
> + uint32 getOffset() const;
> + void* getIndirectAddress() const;
> + void* getNativeAddress() const;
>
> - uint32 getNumVars() const {return
> method_vars_get_number(drlMethod);}
> + uint32 getNumVars() const;
>
> Method_Handle getMethodHandle() const {return drlMethod;}
>
> @@ -264,19 +261,6 @@
> JIT_Handle jitHandle;
> };
>
> -class ClassHierarchyMethodIterator {
> -public:
> - ClassHierarchyMethodIterator(CompilationInterface&
> compilationInterface, ObjectType* objType, MethodDesc* methodDesc);
> - bool isValid() const { return valid; }
> - bool hasNext() const;
> - MethodDesc* getNext();
> -
> -private:
> - CompilationInterface& compilationInterface;
> - bool valid;
> - ChaMethodIterator iterator;
> -};
> -
> enum ResolveNewCheck{ResolveNewCheck_NoCheck, ResolveNewCheck_DoCheck};
>
> class CompilationInterface {
> @@ -357,7 +341,6 @@
> // superclass of ch that overrides mh.
> MethodDesc* getOverriddenMethod(NamedType *type, MethodDesc *
> methodDesc);
>
> - ClassHierarchyMethodIterator*
> getClassHierarchyMethodIterator(ObjectType* baseType, MethodDesc*
> methodDesc);
>
> void* getStringInternAddr(MethodDesc* enclosingMethodDesc,
> uint32 stringToken);
> Type* getConstantType(MethodDesc* enclosingMethodDesc, uint32
> constantToken);
> @@ -479,17 +462,11 @@
> GCInterface(GC_Enumeration_Handle gcHandle) : gcHandle(gcHandle) {}
> virtual ~GCInterface() {}
>
> - virtual void enumerateRootReference(void** reference) {
> - vm_enumerate_root_reference(reference, FALSE);
> - }
> + virtual void enumerateRootReference(void** reference);
>
> - virtual void enumerateCompressedRootReference(uint32* reference) {
> - vm_enumerate_compressed_root_reference(reference, FALSE);
> - }
> + virtual void enumerateCompressedRootReference(uint32* reference);
>
> - virtual void enumerateRootManagedReference(void** slotReference, int
> slotOffset) {
> - vm_enumerate_root_interior_pointer(slotReference, slotOffset,
> FALSE);
> - }
> + virtual void enumerateRootManagedReference(void** slotReference, int
> slotOffset);
>
> private:
> GC_Enumeration_Handle gcHandle;
> @@ -500,17 +477,11 @@
> public:
> ThreadDumpEnumerator() : GCInterface(NULL) {}
>
> - virtual void enumerateRootReference(void** reference) {
> - vm_check_if_monitor(reference, 0, 0, 0, FALSE, 1);
> - }
> + virtual void enumerateRootReference(void** reference);
>
> - virtual void enumerateCompressedRootReference(uint32* reference) {
> - vm_check_if_monitor(0, 0, reference, 0, FALSE, 2);
> - }
> + virtual void enumerateCompressedRootReference(uint32* reference);
>
> - virtual void enumerateRootManagedReference(void** slotReference, int
> slotOffset) {
> - vm_check_if_monitor(slotReference, 0, 0, slotOffset, FALSE, 3);
> - }
> + virtual void enumerateRootManagedReference(void** slotReference, int
> slotOffset);
> };
>
> //
>
> Modified: harmony/enhanced/drlvm/trunk/vm/vmcore/build/vmcore.exp
> URL:
> http://svn.apache.org/viewvc/harmony/enhanced/drlvm/trunk/vm/vmcore/build/vmcore.exp?rev=634547&r1=634546&r2=634547&view=diff
>
> ==============================================================================
> --- harmony/enhanced/drlvm/trunk/vm/vmcore/build/vmcore.exp (original)
> +++ harmony/enhanced/drlvm/trunk/vm/vmcore/build/vmcore.exp Thu Mar 6
> 21:59:46 2008
> @@ -142,6 +142,7 @@
> get_system_object_class;
> get_system_string_class;
> get_thread_ptr;
> + get_vm_interface;
> initialize_arg_list_iterator;
> init_log_system;
> is_enabled;
>
> Modified:
> harmony/enhanced/drlvm/trunk/vm/vmcore/src/class_support/C_Interface.cpp
> URL:
> http://svn.apache.org/viewvc/harmony/enhanced/drlvm/trunk/vm/vmcore/src/class_support/C_Interface.cpp?rev=634547&r1=634546&r2=634547&view=diff
>
> ==============================================================================
> ---
> harmony/enhanced/drlvm/trunk/vm/vmcore/src/class_support/C_Interface.cpp
> (original)
> +++
> harmony/enhanced/drlvm/trunk/vm/vmcore/src/class_support/C_Interface.cpp Thu
> Mar 6 21:59:46 2008
> @@ -1464,16 +1464,11 @@
>
>
>
> -int vector_first_element_offset_class_handle(Class_Handle UNREF
> element_type)
> +int vector_first_element_offset_class_handle(Class_Handle element_type)
> {
> - return VM_VECTOR_FIRST_ELEM_OFFSET_REF;
> -} //vector_first_element_offset_class_handle
> -
> -int vector_first_element_offset_vtable_handle(VTable_Handle UNREF
> element_type)
> -{
> - return VM_VECTOR_FIRST_ELEM_OFFSET_REF;
> -} //vector_first_element_offset_class_handle
> -
> + return vector_first_element_offset_unboxed(element_type);
> + //return VM_VECTOR_FIRST_ELEM_OFFSET_REF;
> +}
>
> Boolean method_is_java(Method_Handle mh)
> {
>
> Modified: harmony/enhanced/drlvm/trunk/vm/vmcore/src/init/vm_init.cpp
> URL:
> http://svn.apache.org/viewvc/harmony/enhanced/drlvm/trunk/vm/vmcore/src/init/vm_init.cpp?rev=634547&r1=634546&r2=634547&view=diff
>
> ==============================================================================
> --- harmony/enhanced/drlvm/trunk/vm/vmcore/src/init/vm_init.cpp (original)
> +++ harmony/enhanced/drlvm/trunk/vm/vmcore/src/init/vm_init.cpp Thu Mar 6
> 21:59:46 2008
> @@ -120,6 +120,104 @@
> }
> } //create_instance_for_class
>
> +// VM adapter part
> +
> +static apr_dso_handle_t* get_harmonyvm_handle(){
> + apr_dso_handle_t* descriptor;
> + apr_pool_t* pool;
> + int ret = apr_pool_create(&pool, NULL);
> + assert(APR_SUCCESS == ret);
> + ret = apr_dso_load(&descriptor, PORT_DSO_NAME("harmonyvm"), pool);
> + assert(APR_SUCCESS == ret);
> + return descriptor;
> +}
> +
> +extern "C" VMEXPORT
> +void* get_vm_interface(const char* func_name){
> + static apr_dso_handle_t* descriptor = get_harmonyvm_handle();
> + void* p_func = NULL;
> + int ret = apr_dso_sym((apr_dso_handle_sym_t*) &p_func, descriptor,
> func_name);
> +
> + //assert(APR_SUCCESS == ret);
> +
> + //FIXME: temporary solution, should be fixed in next patch
> + if (p_func) {
> + return p_func;
> +
> + } else if (strcmp(func_name,"class_is_support_fast_instanceof") == 0)
> {
> + return (void*)class_get_fast_instanceof_flag;
> + } else if (strcmp(func_name,"class_is_final") == 0) {
> + return (void*)class_property_is_final;
> + } else if (strcmp(func_name,"class_is_throwable") == 0) {
> + return (void*)class_hint_is_exceptiontype;
> + } else if (strcmp(func_name,"class_is_interface") == 0) {
> + return (void*)class_property_is_interface2;
> + } else if (strcmp(func_name,"class_is_abstract") == 0) {
> + return (void*)class_property_is_abstract;
> + } else if (strcmp(func_name,"class_cp_get_field_type") == 0) {
> + return (void*)class_get_cp_field_type;
> + } else if (strcmp(func_name,"class_cp_get_entry_signature") == 0) {
> + return (void*)class_get_cp_entry_signature;
> + } else if (strcmp(func_name,"class_cp_get_method_class_name") == 0) {
> + return (void*)const_pool_get_method_class_name;
> + } else if (strcmp(func_name,"class_cp_get_method_name") == 0) {
> + return (void*)const_pool_get_method_name;
> + } else if (strcmp(func_name,"class_cp_is_entry_resolved") == 0) {
> + return (void*)class_is_cp_entry_resolved;
> + } else if (strcmp(func_name,"class_cp_get_class_name") == 0) {
> + return (void*)const_pool_get_class_name;
> + } else if (strcmp(func_name,"field_get_type_info") == 0) {
> + return (void*)field_get_type_info_of_field_value;
> + } else if (strcmp(func_name,"method_get_overridden_method") == 0) {
> + return (void*)method_find_overridden_method;
> + } else if (strcmp(func_name,"vector_get_first_element_offset") == 0)
> {
> + return (void*)vector_first_element_offset_class_handle;
> + } else if (strcmp(func_name,"vector_get_length_offset") == 0) {
> + return (void*)vector_length_offset;
> + } else if (strcmp(func_name,"vm_tls_alloc") == 0) {
> + return (void*)hythread_tls_alloc;
> + } else if (strcmp(func_name,"vm_tls_get_offset") == 0) {
> + return (void*)hythread_tls_get_offset;
> + } else if (strcmp(func_name,"vm_tls_get_request_offset") == 0) {
> + return (void*)hythread_tls_get_request_offset;
> + } else if (strcmp(func_name,"vm_tls_is_fast") == 0) {
> + return (void*)hythread_uses_fast_tls;
> + } else if (strcmp(func_name,"vm_get_tls_offset_in_segment") == 0) {
> + return (void*)hythread_get_hythread_offset_in_tls;
> + } else if (strcmp(func_name,"vm_get_system_object_class") == 0) {
> + return (void*)get_system_object_class;
> + } else if (strcmp(func_name,"vm_get_system_class_class") == 0) {
> + return (void*)get_system_class_class;
> + } else if (strcmp(func_name,"vm_get_system_string_class") == 0) {
> + return (void*)get_system_string_class;
> + } else if (strcmp(func_name,"vm_get_heap_base_address") == 0) {
> + return (void*)vm_heap_base_address;
> + } else if (strcmp(func_name,"vm_get_heap_ceiling_address") == 0) {
> + return (void*)vm_heap_ceiling_address;
> + } else if (strcmp(func_name,"vm_is_heap_compressed") == 0) {
> + return (void*)vm_references_are_compressed;
> + } else if (strcmp(func_name,"vm_is_vtable_compressed") == 0) {
> + return (void*)vm_vtable_pointers_are_compressed;
> + } else if (strcmp(func_name,"vm_compiled_method_load") == 0) {
> + return (void*)compiled_method_load;
> + } else if (strcmp(func_name,"vm_properties_destroy_keys") == 0) {
> + return (void*)destroy_properties_keys;
> + } else if (strcmp(func_name,"vm_properties_destroy_value") == 0) {
> + return (void*)destroy_property_value;
> + } else if (strcmp(func_name,"vm_properties_get_keys") == 0) {
> + return (void*)get_properties_keys;
> + } else if (strcmp(func_name,"vm_properties_get_keys_starting_with")
> == 0) {
> + return (void*)get_properties_keys_staring_with;
> + } else if (strcmp(func_name,"vm_properties_get_value") == 0) {
> + return (void*)get_property;
> + } else if (strcmp(func_name,"vm_helper_get_addr") == 0) {
> + return (void*)vm_get_rt_support_addr;
> + } else if (strcmp(func_name,"vm_helper_get_addr_optimized") == 0) {
> + return (void*)vm_get_rt_support_addr_optimized;
> + } else {
> + return NULL;
> + }
> +}
>
> #define GC_DLL_COMP PORT_DSO_NAME("gc_gen")
> #define GC_DLL_UNCOMP PORT_DSO_NAME("gc_gen_uncomp")
> @@ -151,7 +249,7 @@
> LWARN(13, "Cannot load EM component from {0}" << dll);
> return status;
> }
> -
> +
> status = vm_env->cm->CreateInstance(&(vm_env->em_instance), "em");
> if (status != JNI_OK) {
> LWARN(14, "Cannot instantiate EM");
>
>
>
--
Mikhail Fursov
Re: svn commit: r634547 [2/2] - in /harmony/enhanced/drlvm/trunk/vm: em/src/ include/open/ interpreter/src/ jitrino/src/codegenerator/ia32/ jitrino/src/codegenerator/ipf/ jitrino/src/jet/ jitrino/src/shared/ jitrino/src/vm/ vmcore/build/ vmcore/src/c
Posted by Alexei Fedotov <al...@gmail.com>.
Ilya,
Thanks for provoking me to share my observations about a way how we,
java people, use C.
I agree that at the first place the usage of names should be
conventional, and if you have code which is reusable for non-java
purposes then the name jboolean is definitely not the best choice. I
would not call our JIT reusable, and even most portlib functions have
a small chance of being reused in different projects because they were
built and selected to reflect java semantics at the first place. If
they are really reusable, do we have a patch suggesting them to be
added to APR?
For C++ code we may use bool, which is a part of C+ standard and that
is why it is quite conventional. For pure C interfaces using booleans
is not a typical practice. My honest believe is that using boolean
type is not a typical pattern of C programming, and hardcode C
programmers use ints, bit masks or bit fields instead. For example, to
indicate that an operation was successful, a C programmer would use an
integer return code with predefined semantics, eg ENOMEM would mean
that C heap is exhausted.
Another consideration is that C is usually used for compactness and
tends to avoid passing booleans backward and forward between
components. Consider strcmp call: it is mostly used to compare
strings, but returns integer to allow string alphabetical comparison.
Another example is initialization:
if (!is_initialized()) {
initizalize();
}
Instead of exposing two interface functions, one may choose exposing
one with the following semantics: initialize_if_not_initialized(). For
general compactness we use 0 for false, and some useful value for some
sort of true. This true has something descriptive about the truth it
represents. The malloc returns 0 for false, and a useful pointer
otherwise. All this helps to replace two interface function calls
(check + action) with one and minimize an interface. Generally if the
code is expected to look like conventional C, it's good to use C style
for interfaces.
It would be great to have portions of our code reused in other
projects, and if that projects expose a different semantics, I'm more
than ok to use coherent aligned semantics for that portions of code.
But in general JVM has java/C++/C semantics, and so
jboolean/bool/int/bit mask/bit field should be used unless the code
have a real different use case.
What do you think about it?
Thanks!
On Fri, Mar 7, 2008 at 7:08 PM, Ilya Berezhniuk
<il...@gmail.com> wrote:
> Alexei,
>
> I agree, these type and values look reasonable in the code related to Java.
> However, using them everywhere in C/C++ code is not feasible - I hate this.
> Specifically, JIT can be used for compiling a code not only from Java
> bytecodes...
>
> Thanks,
> Ilya.
>
> 2008/3/7, Alexei Fedotov <al...@gmail.com>:
>
>
> > Hello,
> > I vote for not using Boolean at all. jboolean is a part of the
> > standard we are implementing [1] while Boolean is not. The same
> > applies to JNI_TRUE/JNI_FALSE macros in favour of TRUE/FALSE.
> >
> > [1] http://java.sun.com/docs/books/jni/html/types.html
> >
> >
> > On Fri, Mar 7, 2008 at 6:49 PM, Mikhail Fursov <mi...@gmail.com> wrote:
> > > Alexey,
> > > there is a problem with this commit.
> > > Some of methods that returns Boolean (that is 'unsigned') are described as
> > > 'bool' in vm_interface.h
> > > It's not the same and causes problems. For example I found that H2092 fails
> >
> > [...]
> >
> > --
> > With best regards,
> >
> > Alexei
> >
>
--
With best regards,
Alexei
Re: svn commit: r634547 [2/2] - in /harmony/enhanced/drlvm/trunk/vm: em/src/ include/open/ interpreter/src/ jitrino/src/codegenerator/ia32/ jitrino/src/codegenerator/ipf/ jitrino/src/jet/ jitrino/src/shared/ jitrino/src/vm/ vmcore/build/ vmcore/src/c
Posted by Ilya Berezhniuk <il...@gmail.com>.
Alexei,
I agree, these type and values look reasonable in the code related to Java.
However, using them everywhere in C/C++ code is not feasible - I hate this.
Specifically, JIT can be used for compiling a code not only from Java
bytecodes...
Thanks,
Ilya.
2008/3/7, Alexei Fedotov <al...@gmail.com>:
> Hello,
> I vote for not using Boolean at all. jboolean is a part of the
> standard we are implementing [1] while Boolean is not. The same
> applies to JNI_TRUE/JNI_FALSE macros in favour of TRUE/FALSE.
>
> [1] http://java.sun.com/docs/books/jni/html/types.html
>
>
> On Fri, Mar 7, 2008 at 6:49 PM, Mikhail Fursov <mi...@gmail.com> wrote:
> > Alexey,
> > there is a problem with this commit.
> > Some of methods that returns Boolean (that is 'unsigned') are described as
> > 'bool' in vm_interface.h
> > It's not the same and causes problems. For example I found that H2092 fails
>
> [...]
>
> --
> With best regards,
>
> Alexei
>
Re: svn commit: r634547 [2/2] - in /harmony/enhanced/drlvm/trunk/vm: em/src/ include/open/ interpreter/src/ jitrino/src/codegenerator/ia32/ jitrino/src/codegenerator/ipf/ jitrino/src/jet/ jitrino/src/shared/ jitrino/src/vm/ vmcore/build/ vmcore/src/c
Posted by Alexei Fedotov <al...@gmail.com>.
Hello,
I vote for not using Boolean at all. jboolean is a part of the
standard we are implementing [1] while Boolean is not. The same
applies to JNI_TRUE/JNI_FALSE macros in favour of TRUE/FALSE.
[1] http://java.sun.com/docs/books/jni/html/types.html
On Fri, Mar 7, 2008 at 6:49 PM, Mikhail Fursov <mi...@gmail.com> wrote:
> Alexey,
> there is a problem with this commit.
> Some of methods that returns Boolean (that is 'unsigned') are described as
> 'bool' in vm_interface.h
> It's not the same and causes problems. For example I found that H2092 fails
[...]
--
With best regards,
Alexei
Re: svn commit: r634547 [2/2] - in /harmony/enhanced/drlvm/trunk/vm: em/src/ include/open/ interpreter/src/ jitrino/src/codegenerator/ia32/ jitrino/src/codegenerator/ipf/ jitrino/src/jet/ jitrino/src/shared/ jitrino/src/vm/ vmcore/build/ vmcore/src/c
Posted by Gregory Shimansky <gs...@apache.org>.
On 8 марта 2008 Ilya Berezhniuk wrote:
> Gregory,
>
> Yes, Boolean is a synthetic type, but it's defined as 'unsigned'.
> UDATA represents BOOLEAN type which is used in few places only for
> HyThread compatibility.
Ah I see. I've confused these boolean definitions. I am starting to think
we've got by far too many different booleans... :)
> I agree with some Alexei's thoughts: in pure C interface we can use
> C-style return values, i.e. use 0 as success (for boolean result) and
> 0 for failure (when a pointer should be returned).
>
> Thanks,
> Ilya.
>
> 2008/3/8, Gregory Shimansky <gs...@apache.org>:
> > On 7 марта 2008 Mikhail Fursov wrote:
> > > Alexey,
> > > there is a problem with this commit.
> > > Some of methods that returns Boolean (that is 'unsigned') are
> > > described as 'bool' in vm_interface.h
> > > It's not the same and causes problems. For example I found that H2092
> > > fails now in debug mode on Linux because of 'field_is_volatile'
> > > method.
> >
> > I see 3 different problems with 3 different used approaches
> >
> > 1. bool is a C++ type an cannot be used in a pure C interface. Don't
> > tell me about extended C standards. Period.
> > 2. Boolean is a synthetic type which is actually UDATA that corresponds
> > to POINTER_SIZE_INT and this means by far unoptimal decision for a type
> > that holds a single meaning bit.
> > 3. jboolean is a type defined for Java only.
> >
> > As long as we work on Java jboolean is the most universal definition
> > since it is actually specified. In case JIT code may be reused for other
> > code we might invent jitboolean to be equal in definition to jboolean
> > both in spec and code. I would vote for such approach.
> >
> > --
> >
> > Gregory
--
Gregory
Re: svn commit: r634547 [2/2] - in /harmony/enhanced/drlvm/trunk/vm: em/src/ include/open/ interpreter/src/ jitrino/src/codegenerator/ia32/ jitrino/src/codegenerator/ipf/ jitrino/src/jet/ jitrino/src/shared/ jitrino/src/vm/ vmcore/build/ vmcore/src/c
Posted by Ilya Berezhniuk <il...@gmail.com>.
Gregory,
Yes, Boolean is a synthetic type, but it's defined as 'unsigned'.
UDATA represents BOOLEAN type which is used in few places only for
HyThread compatibility.
I agree with some Alexei's thoughts: in pure C interface we can use
C-style return values, i.e. use 0 as success (for boolean result) and
0 for failure (when a pointer should be returned).
Thanks,
Ilya.
2008/3/8, Gregory Shimansky <gs...@apache.org>:
> On 7 марта 2008 Mikhail Fursov wrote:
> > Alexey,
> > there is a problem with this commit.
> > Some of methods that returns Boolean (that is 'unsigned') are described as
> > 'bool' in vm_interface.h
> > It's not the same and causes problems. For example I found that H2092 fails
> > now in debug mode on Linux because of 'field_is_volatile' method.
>
>
>
> I see 3 different problems with 3 different used approaches
>
> 1. bool is a C++ type an cannot be used in a pure C interface. Don't tell me
> about extended C standards. Period.
> 2. Boolean is a synthetic type which is actually UDATA that corresponds to
> POINTER_SIZE_INT and this means by far unoptimal decision for a type that
> holds a single meaning bit.
> 3. jboolean is a type defined for Java only.
>
> As long as we work on Java jboolean is the most universal definition since it
> is actually specified. In case JIT code may be reused for other code we might
> invent jitboolean to be equal in definition to jboolean both in spec and
> code. I would vote for such approach.
>
> --
>
> Gregory
>
Re: svn commit: r634547 [2/2] - in /harmony/enhanced/drlvm/trunk/vm: em/src/ include/open/ interpreter/src/ jitrino/src/codegenerator/ia32/ jitrino/src/codegenerator/ipf/ jitrino/src/jet/ jitrino/src/shared/ jitrino/src/vm/ vmcore/build/ vmcore/src/c
Posted by Gregory Shimansky <gs...@apache.org>.
On 7 марта 2008 Mikhail Fursov wrote:
> Alexey,
> there is a problem with this commit.
> Some of methods that returns Boolean (that is 'unsigned') are described as
> 'bool' in vm_interface.h
> It's not the same and causes problems. For example I found that H2092 fails
> now in debug mode on Linux because of 'field_is_volatile' method.
I see 3 different problems with 3 different used approaches
1. bool is a C++ type an cannot be used in a pure C interface. Don't tell me
about extended C standards. Period.
2. Boolean is a synthetic type which is actually UDATA that corresponds to
POINTER_SIZE_INT and this means by far unoptimal decision for a type that
holds a single meaning bit.
3. jboolean is a type defined for Java only.
As long as we work on Java jboolean is the most universal definition since it
is actually specified. In case JIT code may be reused for other code we might
invent jitboolean to be equal in definition to jboolean both in spec and
code. I would vote for such approach.
--
Gregory