You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@harmony.apache.org by na...@apache.org on 2007/01/14 19:13:55 UTC
svn commit: r496108 [3/4] - in /harmony/enhanced/drlvm/trunk/vm: include/
include/open/ vmcore/include/
Modified: harmony/enhanced/drlvm/trunk/vm/include/open/vm.h
URL: http://svn.apache.org/viewvc/harmony/enhanced/drlvm/trunk/vm/include/open/vm.h?view=diff&rev=496108&r1=496107&r2=496108
==============================================================================
--- harmony/enhanced/drlvm/trunk/vm/include/open/vm.h (original)
+++ harmony/enhanced/drlvm/trunk/vm/include/open/vm.h Sun Jan 14 10:13:53 2007
@@ -1,6 +1,6 @@
/*
* Licensed to the Apache Software Foundation (ASF) under one or more
- * contributor license agreements. See the NOTICE file distributed with
+ * contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
@@ -14,17 +14,12 @@
* See the License for the specific language governing permissions and
* limitations under the License.
*/
+
/**
- * @author Intel, Alexei Fedotov
- * @version $Revision: 1.1.2.2.4.3 $
+ * These are the functions that a VM built as a DLL must export.
+ * Some functions may be optional and are marked as such.
*/
-
-//
-// These are the functions that a VM built as a DLL must export.
-// Some functions may be optional and are marked as such.
-//
-
#ifndef _VM_EXPORT_H
#define _VM_EXPORT_H
@@ -40,8 +35,10 @@
extern "C" {
#endif
-// This structure is meant to be opaque. External modules should not
-// attempt to directly access any of its fields.
+/**
+ * This structure is meant to be opaque. External modules should not.
+ */
+ attempt to directly access any of its fields.
typedef struct ChaClassIterator {
Class_Handle _root_class;
Class_Handle _current;
@@ -49,8 +46,10 @@
} ChaClassIterator;
-// This structure is meant to be opaque. External modules should not
-// attempt to directly access any of its fields.
+/**
+ * This structure is meant to be opaque. External modules should not.
+ */
+ attempt to directly access any of its fields.
typedef struct ChaMethodIterator {
Method_Handle _method;
Method_Handle _current;
@@ -58,629 +57,919 @@
} ChaMethodIterator;
-/////////////////////////////////////////////////////////////////
-// begin class-related functions.
-
+/**
+ * Begin class-related functions.
+ */
-// Returns a handle for the object class. For Java applications, it's
-// java.lang.Object.
+/**
+ * @return A handle for the <code>Object</code> class. For Java applications, it's
+ * <code>java.lang.Object</code>.
+ */
VMEXPORT Class_Handle get_system_object_class();
-// Returns a handle for the class class. For Java applications, it's
-// java.lang.Class.
+/**
+ * @return A handle for the <code>Class</code> class. For Java applications, it's
+ * <code>java.lang.Class</code>.
+ */
VMEXPORT Class_Handle get_system_class_class();
-// Returns a handle for the string class. For Java applications, it's
-// java.lang.String.
+/**
+ * @return A handle for the string class. For Java applications, it's
+ * java.lang.String.
+ */
+
VMEXPORT Class_Handle get_system_string_class();
-// Loads a class of a given name. If a class cannot be loaded, returns NULL
+/**
+ * Loads a class of a given name.
+ *
+ * @return <code>NULL</code> if a class cannot be loaded.
+ */
+
VMEXPORT Class_Handle
class_load_class_by_name_using_bootstrap_class_loader(const char *name);
-// The following three functions will be eventually renamed to
-// class_is_final, class_is_abstract and class_is_interface,
-// but right now that would conflict with the names of some internal macros.
+/**
+ * The following three functions will be eventually renamed to
+ * \arg <code>class_is_final</code>
+ * \arg <code>class_is_abstract</code>
+ * \arg <code>class_is_interface</code>
+ * but right now that would conflict
+ * with the names of some internal macros.
+ */
+
VMEXPORT Boolean class_property_is_final(Class_Handle ch);
VMEXPORT Boolean class_property_is_abstract(Class_Handle ch);
VMEXPORT Boolean class_property_is_interface2(Class_Handle ch);
-// Returns TRUE if th class is likely to be used as an exception object.
-// This is a hint only. If the result is FALSE, the class may still
-// be used for exceptions but it is less likely.
+/**
+ * @return <code>TRUE</code> if the class is likely to be used as an exception object.
+ * This is a hint only. If the result is <code>FALSE</code>, the class may still
+ * be used for exceptions but it is less likely.
+ */
VMEXPORT Boolean class_hint_is_exceptiontype(Class_Handle ch);
-// Returns TRUE if the class is a value type.
-VMEXPORT Boolean class_is_valuetype(Class_Handle ch);
+/**
+ * @return <code>TRUE</code> if the class is a value type.
+ */
+ VMEXPORT Boolean class_is_valuetype(Class_Handle ch);
-// Return TRUE if the class represents an enum. For Java 1.4 always returns FALSE.
+/**
+ * @return <code>TRUE</code> if the class represents an enum.
+ * For Java 1.4 always returns <code>FALSE</code>.
+ */
VMEXPORT Boolean class_is_enum(Class_Handle ch);
-// This function can only be called if (class_is_enum(ch) == TRUE)
-// The returned value is the type of the underlying int type.
+/**
+ * This function can only be called if (<code>class_is_enum(ch)</code> == <code>TRUE</code>)
+ * The returned value is the type of the underlying int type.
+ */
VMEXPORT VM_Data_Type class_get_enum_int_type(Class_Handle ch);
-// Returns TRUE if the class represents a primitive type (int, float, etc.)
-VMEXPORT Boolean class_is_primitive(Class_Handle ch);
+/**
+ * @return <code>TRUE</code> if the class represents a primitive type (int, float, etc.)
+ */
+ VMEXPORT Boolean class_is_primitive(Class_Handle ch);
-// Returns the name of the class.
-VMEXPORT const char *class_get_name(Class_Handle ch);
+/**
+ * @return The name of the class.
+ */
+ VMEXPORT const char *class_get_name(Class_Handle ch);
-// Returns the name of the package containing the class.
-VMEXPORT const char *class_get_package_name(Class_Handle ch);
+/**
+ * @return The name of the package containing the class.
+ */
+ VMEXPORT const char *class_get_package_name(Class_Handle ch);
-// Returns the super class of the current class.
-// Returns NULL for the system object class, i.e.
-// class_get_super_class(get_system_object_class()) == NULL
+/**
+ * The super class of the current class.
+ * @return <code>NULL</code> for the system object class, i.e.
+ * <code>class_get_super_class</code>(get_system_object_class()) == NULL
+ */
VMEXPORT Class_Handle class_get_super_class(Class_Handle ch);
-// Return the vtable handle of the given class.
-VMEXPORT VTable_Handle class_get_vtable(Class_Handle ch);
+/**
+ * @return The vtable handle of the given class.
+ */
+ VMEXPORT VTable_Handle class_get_vtable(Class_Handle ch);
-// Returns the allocation handle to be used for the object allocation
-// routines, given a class handle.
+/**
+ * @return The allocation handle to be used for the object allocation
+ * routines, given a class handle.
+ */
VMEXPORT Allocation_Handle class_get_allocation_handle(Class_Handle ch);
-// Returns the class handle corresponding to a given allocation handle.
+/**
+ * @return The class handle corresponding to a given allocation handle.
+ */
VMEXPORT Class_Handle allocation_handle_get_class(Allocation_Handle ah);
-// Return an VM_Data_Type value for a given class.
-VMEXPORT VM_Data_Type class_get_primitive_type_of_class(Class_Handle ch);
+/**
+ * @return An <code>VM_Data_Type</code> value for a given class.
+ */
+ VMEXPORT VM_Data_Type class_get_primitive_type_of_class(Class_Handle ch);
-// Return a class corresponding to a primitive type. For all primitive types t
-// t == class_get_primitive_type_of_class(class_get_class_of_primitive_type(t))
-VMEXPORT Class_Handle class_get_class_of_primitive_type(VM_Data_Type typ);
+/**
+ * @return A class corresponding to a primitive type. For all primitive types t
+ * t == <code>class_get_primitive_type_of_class(class_get_class_of_primitive_type(t))</code>
+ */
+ VMEXPORT Class_Handle class_get_class_of_primitive_type(VM_Data_Type typ);
-// Returns TRUE is the class is an array.
+/**
+ * @return <code>TRUE</code> is the class is an array.
+ */
VMEXPORT Boolean class_is_array(Class_Handle ch);
-// Returns TRUE if class s is assignment compatible with class t.
+/**
+ * @return <code>TRUE</code> if class <code>s</code> is assignment
+ * compatible with class <code>t</code>.
+ */
VMEXPORT Boolean class_is_instanceof(Class_Handle s, Class_Handle t);
-// Given a class handle cl construct a class handle of the type
-// representing array of cl. If class cl is value type, assume
-// that the element is a reference to a boxed instance of that type.
-VMEXPORT Class_Handle class_get_array_of_class(Class_Handle ch);
-
-// Given a class handle cl construct a class handle of the type
-// representing array of cl. Class cl is assumed to be a
-// value type. Return NULL if cl is not a value type.
-VMEXPORT Class_Handle class_get_array_of_unboxed(Class_Handle ch);
-
-// For a class that is an array return the type info for the elements
-// of the array
-VMEXPORT Type_Info_Handle class_get_element_type_info(Class_Handle ch);
-
-// Returns TRUE if the class is already fully initialized.
-VMEXPORT Boolean class_is_initialized(Class_Handle ch);
-
-// Returns TRUE if the class is neither initialized nor in the process
-// of being initialized. The intention is that the JIT will emit a call
-// to VM_RT_INITIALIZE_CLASS before every access to a static field in
-// Java.
-VMEXPORT Boolean class_needs_initialization(Class_Handle ch);
-
-// For Java returns FALSE.
-VMEXPORT Boolean class_is_before_field_init(Class_Handle ch);
-
-// Number of instance fields defined in a class. That doesn't include
-// inherited fields.
-VMEXPORT unsigned class_num_instance_fields(Class_Handle ch);
-
-// Get the handle for a field. If idx is greater than or equal to
-// class_num_instance_fields, return NULL.
-// The value of idx indexes into the fields defined in this class and
-// doesn't include inherited fields.
-VMEXPORT Field_Handle class_get_instance_field(Class_Handle ch, unsigned idx);
+/**
+ * Given a class handle <code>cl</code> construct a class handle of the type
+ * representing array of <code>cl</code>. If class cl is value type, assume
+ * that the element is a reference to a boxed instance of that type.
+ */
+ VMEXPORT Class_Handle class_get_array_of_class(Class_Handle ch);
-// Number of instance fields defined in a class. This number includes
-// inherited fields.
-VMEXPORT unsigned class_num_instance_fields_recursive(Class_Handle ch);
+/**
+ * Given a class handle <code>cl</code> construct a class handle of the type
+ * representing array of <code>cl</code>. Class <code>cl</code> is assumed to be a
+ * value type.
+ *
+ * @return <code>NULL</code> if cl is not a value type.
+ */
+ VMEXPORT Class_Handle class_get_array_of_unboxed(Class_Handle ch);
-// Get the handle for a field. If idx is greater than or equal to
-// class_num_instance_fields_recursive, return NULL.
-// The value of idx indexes into the set of fields that includes both fields
-// defined in this class and inherited fields.
-VMEXPORT Field_Handle class_get_instance_field_recursive(Class_Handle ch, unsigned idx);
+/**
+ * @return For a class that is an array return the type info for the elements
+ * of the array.
+ */
+ VMEXPORT Type_Info_Handle class_get_element_type_info(Class_Handle ch);
-// Number of methods declared in the class
-VMEXPORT unsigned class_get_number_methods(Class_Handle ch);
+ /**
+ * @return <code>TRUE</code> if the class is already fully initialized.
+ */
+ VMEXPORT Boolean class_is_initialized(Class_Handle ch);
-// Get handle for a method declared in class
-VMEXPORT Method_Handle class_get_method(Class_Handle ch, unsigned index);
+/**
+ * @return <code>TRUE</code> if the class is neither initialized nor in the process
+ * of being initialized. The intention is that the JIT will emit a call
+ * to <code>VM_RT_INITIALIZE_CLASS</code> before every access to a static
+ * field in Java.
+ */
+ VMEXPORT Boolean class_needs_initialization(Class_Handle ch);
+/**
+ * For Java returns <code>FALSE</code>.
+ */
+ VMEXPORT Boolean class_is_before_field_init(Class_Handle ch);
-// Returns TRUE if all instances of this class are pinned.
-VMEXPORT Boolean class_is_pinned(Class_Handle ch);
+/**
+ * Number of instance fields defined in a class. That doesn't include
+ * inherited fields.
+ */
+ VMEXPORT unsigned class_num_instance_fields(Class_Handle ch);
-// Returns TRUE if all instances of this class are pinned.
-VMEXPORT void* class_alloc_via_classloader(Class_Handle ch, int32 size);
+/**
+ * Get the handle for a field. If <code>idx</code> is greater than or equal to
+ * <code>class_num_instance_fields</code>.
+ *
+ * @return <code>NULL</code>
+ *
+ * The value of idx indexes into the fields defined in this class and
+ * doesn't include inherited fields.
+ */
+ VMEXPORT Field_Handle class_get_instance_field(Class_Handle ch, unsigned idx);
+
+/**
+ * Number of instance fields defined in a class. This number includes
+ * inherited fields.
+ */
-// Returns TRUE if this is an array of primitives.
-VMEXPORT Boolean class_is_non_ref_array(Class_Handle ch);
+VMEXPORT unsigned class_num_instance_fields_recursive(Class_Handle ch);
+/**
+ * Get the handle for a field.
+ *
+ * @return <code>NULL</code> if idx is greater than or equal to
+ * <code>class_num_instance_fields_recursive</code>.
+ *
+ * The value of idx indexes into the set of fields that includes both fields
+ * defined in this class and inherited fields.
+ */
+VMEXPORT Field_Handle class_get_instance_field_recursive(Class_Handle ch, unsigned idx);
+
+/**
+ * Number of methods declared in the class.
+ */
+ VMEXPORT unsigned class_get_number_methods(Class_Handle ch);
+
+/**
+ * Get handle for a method declared in class.
+ */
+ VMEXPORT Method_Handle class_get_method(Class_Handle ch, unsigned index);
+
+/**
+ * @return <code>TRUE</code> if all instances of this class are pinned.
+ */
+ VMEXPORT Boolean class_is_pinned(Class_Handle ch);
-// Returns TRUE if the class has a non-trivial finalizer.
-VMEXPORT Boolean class_is_finalizable(Class_Handle ch);
-// This exactly what I want.
-// Get the alignment of the class.
-VMEXPORT unsigned class_get_alignment(Class_Handle ch);
+/**
+ * @return <code>TRUE</code> if all instances of this class are pinned.
+ */
+ VMEXPORT void* class_alloc_via_classloader(Class_Handle ch, int32 size);
-// Get the alignment of the class when it's unboxed.
-VMEXPORT unsigned class_get_alignment_unboxed(Class_Handle ch);
+/**
+ * @return <code>TRUE</code> if this is an array of primitives.
+ */
+ VMEXPORT Boolean class_is_non_ref_array(Class_Handle ch);
-// For a class handle that represents and array, return the size of the
-// element of the array.
-VMEXPORT unsigned class_element_size(Class_Handle ch);
+/**
+ * @return <code>TRUE</code> if the class has a non-trivial finalizer.
+ */
+ VMEXPORT Boolean class_is_finalizable(Class_Handle ch);
-// Return the size in bytes of an instance in the heap.
-VMEXPORT unsigned class_get_boxed_data_size(Class_Handle ch);
+/**
+ * This exactly what I want.
+ * Get the alignment of the class.
+ */
+ VMEXPORT unsigned class_get_alignment(Class_Handle ch);
-// Return the offset to the start of user data form the start of a boxed
-// instance.
-VMEXPORT unsigned class_get_unboxed_data_offset(Class_Handle ch);
+/**
+ * Get the alignment of the class when it's unboxed.
+ */
+ VMEXPORT unsigned class_get_alignment_unboxed(Class_Handle ch);
-// Return the class of the array element of the given class.
-// The behavior is undefined if the parameter does not represent
-// an array class.
-VMEXPORT Class_Handle class_get_array_element_class(Class_Handle ch);
+/**
+ * @return For a class handle that represents and array, return the size of the
+ * element of the array.
+ */
+ VMEXPORT unsigned class_element_size(Class_Handle ch);
-// Returns the offset from the start of the vtable at which the
-// superclass hierarchy is stored. This is for use with fast type
-// checking.
-VMEXPORT int vtable_get_super_array_offset();
+/**
+ * @return The size in bytes of an instance in the heap.
+ */
+ VMEXPORT unsigned class_get_boxed_data_size(Class_Handle ch);
-// Returns class handle given object's VTable_Handle.
-VMEXPORT Class_Handle vtable_get_class(VTable_Handle vh);
+/**
+ * @return The offset to the start of user data form the start of a boxed
+ * instance.
+ */
+ VMEXPORT unsigned class_get_unboxed_data_offset(Class_Handle ch);
-// Returns the number of superclass hierarchy elements that are
-// stored within the vtable. This is for use with fast type checking.
-VMEXPORT int vm_max_fast_instanceof_depth();
+/**
+ * @return The class of the array element of the given class.
+ *
+ * The behavior is undefined if the parameter does not represent
+ * an array class.
+ */
+ VMEXPORT Class_Handle class_get_array_element_class(Class_Handle ch);
+/**
+ * @return The offset from the start of the vtable at which the
+ * superclass hierarchy is stored. This is for use with fast type
+ * checking.
+ */
+ VMEXPORT int vtable_get_super_array_offset();
-/////////////////////////////////////////////////////////////////
-// begin class iterator related functions.
+/**
+ * @return Class handle given object's <code>VTable_Handle</code>.
+ */
+ VMEXPORT Class_Handle vtable_get_class(VTable_Handle vh);
-// Initializes the CHA_Class_Iterator, to iterate over all classes that
-// descend from root_class, including root_class itself.
-// Returns TRUE if iteration is supported over root_class, FALSE if not.
-VMEXPORT Boolean class_iterator_initialize(ChaClassIterator*, Class_Handle root_class);
+/**
+ * @return The number of superclass hierarchy elements that are
+ * stored within the vtable. This is for use with fast type checking.
+ */
+ VMEXPORT int vm_max_fast_instanceof_depth();
-// Returns the current class of the iterator. NULL is returned if
-// therea are no more classes.
-VMEXPORT Class_Handle class_iterator_get_current(ChaClassIterator*);
-// Advances the iterator.
-VMEXPORT void class_iterator_advance(ChaClassIterator*);
+////
+// begin class iterator related functions.
+////
+/**
+ * Initializes the <code>CHA_Class_Iterator</code>, to iterate over all
+ * classes that descend from <code>root_class</code>, including
+ * <code>root_class</code> itself.
+ *
+ * @return <code>TRUE</code> if iteration is supported over
+ * <code>root_class</code>, <code>FALSE</code> if not.
+ */
+ VMEXPORT Boolean class_iterator_initialize(ChaClassIterator*, Class_Handle root_class);
-/////////////////////////////////////////////////////////////////
-// begin inner-class related functions.
+/**
+ * @return The current class of the iterator. <code>NULL</code> if
+ * there are no more classes.
+ */
+ VMEXPORT Class_Handle class_iterator_get_current(ChaClassIterator*);
-// Returns TRUE the number of inner classes
-VMEXPORT unsigned class_number_inner_classes(Class_Handle ch);
+/**
+ * Advances the iterator.
+ */
+ VMEXPORT void class_iterator_advance(ChaClassIterator*);
-// Returns TRUE if an inner class is public
-VMEXPORT Boolean class_is_inner_class_public(Class_Handle ch, unsigned idx);
+////
+// begin inner-class related functions.
+///
-// Return an inner class
-VMEXPORT Class_Handle class_get_inner_class(Class_Handle ch, unsigned idx);
+/**
+ * @return <code>TRUE</code> the number of inner classes.
+ */
+ VMEXPORT unsigned class_number_inner_classes(Class_Handle ch);
-// Return the class that declared this one, or NULL if top-level class
-VMEXPORT Class_Handle class_get_declaring_class(Class_Handle ch);
+/**
+ * @return <code>TRUE</code> if an inner class is public.
+ */
+ VMEXPORT Boolean class_is_inner_class_public(Class_Handle ch, unsigned idx);
+/**
+ * @return an inner class
+ */
+ VMEXPORT Class_Handle class_get_inner_class(Class_Handle ch, unsigned idx);
-// end inner-class related functions.
-/////////////////////////////////////////////////////////////////
+/**
+ * @return the class that declared this one, or <code>NULL</code> if top-level class
+ */
+ VMEXPORT Class_Handle class_get_declaring_class(Class_Handle ch);
+///
// end class-related functions.
-/////////////////////////////////////////////////////////////////
-
+///
+////
+// end class-related functions.
+////
-/////////////////////////////////////////////////////////////////
+////
// begin field-related functions.
+////
+/**
+ * @return <code>TRUE</code> is the field is static.
+ */
+ VMEXPORT Boolean field_is_static(Field_Handle fh);
-// Returns TRUE is the field is static.
-VMEXPORT Boolean field_is_static(Field_Handle fh);
-
-// Returns the type info that represents the type of the field.
-VMEXPORT Type_Info_Handle field_get_type_info_of_field_value(Field_Handle fh);
+/**
+ * @return The type info that represents the type of the field.
+ */
+ VMEXPORT Type_Info_Handle field_get_type_info_of_field_value(Field_Handle fh);
-// Returns the class that represents the type of the field.
-VMEXPORT Class_Handle field_get_class_of_field_value(Field_Handle fh);
+/**
+ * @return The class that represents the type of the field.
+ */
+ VMEXPORT Class_Handle field_get_class_of_field_value(Field_Handle fh);
-// Returns the class that defined that field.
-VMEXPORT Class_Handle field_get_class(Field_Handle fh);
+/**
+ * @return The class that defined that field.
+ */
+ VMEXPORT Class_Handle field_get_class(Field_Handle fh);
-// Returns TRUE if the field is of a reference type.
-// This function doesn't cause resolution of the class of the field.
-VMEXPORT Boolean field_is_reference(Field_Handle fh);
+/**
+ * @return <code>TRUE</code> if the field is of a reference type.
+ *
+ * This function doesn't cause resolution of the class of the field.
+ */
+ VMEXPORT Boolean field_is_reference(Field_Handle fh);
-// Returns TRUE if the field is literal. In Java, it means that the
-// field had the ConstantValue attribute set (JVMS2, Section 4.7.2).
-VMEXPORT Boolean field_is_literal(Field_Handle fh);
+/**
+ * @return <code>TRUE</code> if the field is literal. In Java, it means that the
+ * field had the ConstantValue attribute set (JVMS2, Section 4.7.2).
+ */
+ VMEXPORT Boolean field_is_literal(Field_Handle fh);
-// For Java always FALSE.
-VMEXPORT Boolean field_is_unmanaged_static(Field_Handle fh);
+/**
+ * For Java always <code>FALSE</code>.
+ */
+ VMEXPORT Boolean field_is_unmanaged_static(Field_Handle fh);
-// Returns the offset to an instance field.
-VMEXPORT unsigned field_get_offset(Field_Handle fh);
+/**
+ * @return The offset to an instance field.
+ */
+ VMEXPORT unsigned field_get_offset(Field_Handle fh);
-// Returns an address of a static field.
-VMEXPORT void *field_get_address(Field_Handle fh);
+/**
+ * @return An address of a static field.
+ */
+ VMEXPORT void *field_get_address(Field_Handle fh);
-// Returns a name of the field.
-VMEXPORT const char *field_get_name(Field_Handle fh);
+/**
+ * @return A name of the field.
+ */
+ VMEXPORT const char *field_get_name(Field_Handle fh);
-// Returns the field descriptor. The descriptor is a string representation
-// of the field types as defined by the
-// JVM spec.
-VMEXPORT const char *field_get_descriptor(Field_Handle fh);
+/**
+ * @return The field descriptor. The descriptor is a string representation
+ * of the field types as defined by the JVM spec.
+ */
+ VMEXPORT const char *field_get_descriptor(Field_Handle fh);
-// Returns TRUE if the field is final.
-VMEXPORT Boolean field_is_final(Field_Handle fh);
+/**
+ * @return <code>TRUE</code> if the field is final.
+ */
+ VMEXPORT Boolean field_is_final(Field_Handle fh);
-// Returns TRUE if the field is volatile.
-VMEXPORT Boolean field_is_volatile(Field_Handle fh);
+/**
+ * @return <code>TRUE</code> if the field is volatile.
+ */
+ VMEXPORT Boolean field_is_volatile(Field_Handle fh);
-// Returns TRUE if the field is private.
-VMEXPORT Boolean field_is_private(Field_Handle fh);
+/**
+ * @return <code>TRUE</code> if the field is private.
+ */
+ VMEXPORT Boolean field_is_private(Field_Handle fh);
/**
- * Returns the address and bit mask, for the flag which determine whether field
- * access event should be sent. JIT may use the following expression to
- * determine if specified field access should be tracked:
- * ( **address & *mask != 0 )
- * @param field - handle of the field
- * @param[out] address - pointer to the address of the byte which contains the flag
- * @param[out] mask - pointer to the bit mask of the flag
+ * @return The address and bit mask, for the flag which determine whether field
+ * access event should be sent. JIT may use the following expression to
+ * determine if specified field access should be tracked:
+ * ( **address & *mask != 0 )
+ *
+ * @param field - handle of the field
+ * @param[out] address - pointer to the address of the byte which contains the flag
+ * @param[out] mask - pointer to the bit mask of the flag
*/
VMEXPORT void
field_get_track_access_flag(Field_Handle field, char** address, char* mask);
/**
- * Returns the address and bit mask, for the flag which determine whether field
- * modification event should be sent. JIT may use the following expression to
- * determine if specified field modification should be tracked:
- * ( **address & *mask != 0 )
- * @param field - handle of the field
- * @param[out] address - pointer to the address of the byte which contains the flag
- * @param[out] mask - pointer to the bit mask of the flag
+ * @return the address and bit mask, for the flag which determine whether field
+ * modification event should be sent. JIT may use the following expression to
+ * determine if specified field modification should be tracked:
+ * ( **address & *mask != 0 )
+ *
+ * @param field - handle of the field
+ * @param[out] address - pointer to the address of the byte which contains the flag
+ * @param[out] mask - pointer to the bit mask of the flag
*/
VMEXPORT void
field_get_track_modification_flag(Field_Handle field, char** address,
char* mask);
-
+////
// end field-related functions.
-/////////////////////////////////////////////////////////////////
+////
-
-
-/////////////////////////////////////////////////////////////////
+////
// begin method-related functions.
+////
-
-// Returns TRUE if this a Java method. Every Java JIT must call this
-// function before compiling a method and return JIT_FAILURE if
-// method_is_java returned FALSE.
+/**
+ * @return <code>TRUE</code> if this a Java method. Every Java JIT must call this
+ * function before compiling a method and return <code>JIT_FAILURE</code> if
+ * <code>method_is_java</code> returned <code>FALSE</code>.
+ */
VMEXPORT Boolean method_is_java(Method_Handle mh);
-// Returns the method name.
+/**
+ * @return The method name.
+ */
VMEXPORT const char *method_get_name(Method_Handle mh);
-// Returns the method descriptor. The descriptor is a string representation
-// of the parameter and return value types as defined by the
-// JVM spec.
+/**
+ * @return The method descriptor. The descriptor is a string representation
+ * of the parameter and return value types as defined by the JVM spec.
+ */
VMEXPORT const char *method_get_descriptor(Method_Handle mh);
-// Returns a class in which the method is declared.
+/**
+ * @return A class in which the method is declared.
+ */
VMEXPORT Class_Handle method_get_class(Method_Handle mh);
-// Returns TRUE if the method is private.
+/**
+ * @return <code>TRUE</code> if the method is private.
+ */
VMEXPORT Boolean method_is_private(Method_Handle mh);
-// Returns TRUE if the method is static.
+/**
+ * @return <code>TRUE</code> if the method is static.
+ */
VMEXPORT Boolean method_is_static(Method_Handle mh);
-// Returns TRUE if the method is final.
+/**
+ * @return <code>TRUE</code> if the method is final.
+ */
VMEXPORT Boolean method_is_final(Method_Handle mh);
-// Returns TRUE if the method is native.
+/**
+ * @return <code>TRUE</code> if the method is native.
+ */
VMEXPORT Boolean method_is_native(Method_Handle mh);
-// Returns TRUE if the method is synchronized.
+/**
+ * @return <code>TRUE</code> if the method is synchronized.
+ */
VMEXPORT Boolean method_is_synchronized(Method_Handle mh);
-// Returns TRUE if the method is abstract.
+/**
+ * @return <code>TRUE</code> if the method is abstract.
+ */
VMEXPORT Boolean method_is_abstract(Method_Handle mh);
-// Java methods may have a flag set to indicate that floating point operations
-// must be performed in the strict mode. method_is_strict() returns TRUE is
-// the ACC_STRICT flag is set for a Java method and FALSE otherwise.
+/**
+ * Java methods may have a flag set to indicate that floating point operations
+ * must be performed in the strict mode.
+ *
+ * @return <code>method_is_strict()</code> returns <code>TRUE</code> if
+ * the ACC_STRICT flag is set for a Java method and <code>FALSE</code> otherwise.
+ */
VMEXPORT Boolean method_is_strict(Method_Handle m);
-// Returns TRUE if the method has been overriden in a subclass and FALSE
-// otherwise. Note that if method_is_overridden returns FALSE, loading
-// of a subclass later in the execution of the program may change invalidate
-// this condition. If a JIT uses method_is_overridden to implement
-// unconditional inlining, it must be prepared to patch the code later
-// (see vm_register_jit_overridden_method_callback).
+/**
+ * @return <code>TRUE</code> if the method has been overriden in a subclass
+ * and <code>FALSE</code> otherwise.
+ *
+ * @note If <code>method_is_overridden</code> returns <code>FALSE</code>, loading
+ * of a subclass later in the execution of the program may change
+ * invalidate this condition. If a JIT uses <code>method_is_overridden</code>
+ * to implement unconditional inlining, it must be prepared to patch the code later
+ * (see <code>vm_register_jit_overridden_method_callback</code>).
+ */
VMEXPORT Boolean method_is_overridden(Method_Handle m);
-// Returns TRUE if the method should not be inlined. There may also
-// be other reasons why a method shouldn't be inlined, e.g., native methods
-// can't be inlined and in Java you can't inlined methods that are
-// loaded by a different class loader than the caller.
-// Always FALSE for Java.
+/**
+ * @return <code>TRUE</code> if the method should not be inlined. There may also
+ * be other reasons why a method shouldn't be inlined, e.g., native methods
+ * can't be inlined and in Java you can't inlined methods that are
+ * loaded by a different class loader than the caller.
+ * Always <code>FALSE</code> for Java.
+ */
VMEXPORT Boolean method_is_no_inlining(Method_Handle mh);
-// Always FALSE for Java.
+/**
+ * Always <code>FALSE</code> for Java.
+ */
VMEXPORT Boolean method_is_require_security_object(Method_Handle mh);
-// Return a signature that can be used to iterate over method's arguments
-// and query the type of the method result.
+/**
+ * @return A signature that can be used to iterate over method's arguments
+ * and query the type of the method result.
+ */
VMEXPORT Method_Signature_Handle method_get_signature(Method_Handle mh);
-// Class ch is a subclass of method_get_class(mh). The function returns a method handle
-// for an accessible method overriding mh in ch or in its closest superclass that overrides mh.
-// Class ch must be a class not an interface.
+/**
+ * Class <code>ch</code> is a subclass of <code>method_get_class(mh)</code>.
+ * The function returns a method handle for an accessible method overriding
+ * <code>mh</code> in <code>ch</code> or in its closest superclass that overrides
+ * <code>mh</code>.
+ * Class <code>ch</code> must be a class not an interface.
+ */
VMEXPORT Method_Handle method_find_overridden_method(Class_Handle ch, Method_Handle mh);
-
-/////////////////////////////////////////////////////////////////
+////
// begin method iterator related functions.
+///
-// Initializes the CHA_Method_Iterator, to iterate over all methods that
-// match the method signature and descend from root_class (including root_class itself).
-// Returns TRUE if iteration is supported over root_class, FALSE if not.
+/**
+ * Initializes the <code>CHA_Method_Iterator</code>, to iterate over all methods that
+ * match the method signature and descend from <code>root_class</code>
+ * (including <code>root_class</code> itself).
+ *
+ * @return <code>TRUE</code> if iteration is supported over <code>root_class</code>,
+ * <code>FALSE</code> if not.
+ */
VMEXPORT Boolean method_iterator_initialize(ChaMethodIterator*, Method_Handle method, Class_Handle root_class);
-// Returns the current method of the iterator. NULL is returned if
-// therea are no more methods.
+/**
+ * @return The current method of the iterator. <code>NULL</code> is returned if
+ * therea are no more methods.
+ */
VMEXPORT Method_Handle method_iterator_get_current(ChaMethodIterator*);
-// Advances the iterator.
+/**
+ * Advances the iterator.
+ */
VMEXPORT void method_iterator_advance(ChaMethodIterator*);
-
-///////////////////////////////////////////////////////
+////
// begin method signature-related functions.
+////
-// Returns the method descriptor for a given method signature.
-// See method_get_descriptor().
+/**
+ * @return The method descriptor for a given method signature.
+ * See <code>method_get_descriptor()</code>.
+ */
VMEXPORT const char *method_sig_get_descriptor(Method_Signature_Handle s);
-// Return a signature that can be used to iterate over method's arguments
-// and query the type of the method result.
-// Java doesn't have standalone signatures, so for Java, always return NULL.
+/**
+ * Return a signature that can be used to iterate over method's arguments
+ * and query the type of the method result.
+ * Java doesn't have standalone signatures, so for Java, always return <code>NULL</code>.
+ */
VMEXPORT Method_Signature_Handle method_standalone_signature(Class_Handle ch,
unsigned idx);
+////
// end method signature-related functions.
-///////////////////////////////////////////////////////
+////
-
-///////////////////////////////////////////////////////
+////
// begin local variables-related functions.
+///
-// Returns the number of local variables defined for the method.
+/**
+ * @return the number of local variables defined for the method.
+ */
VMEXPORT unsigned method_vars_get_number(Method_Handle mh);
-// Return the type info of the local variable number idx.
-// Since local variables are not typed in Java. this function
-// always returns NULL for Java methods.
+/**
+ * Return the type info of the local variable number idx.
+ * Since local variables are not typed in Java. this function
+ * always returns <code>NULL</code> for Java methods.
+ */
VMEXPORT Type_Info_Handle method_vars_get_type_info(Method_Handle mh,
unsigned idx);
-
-// Returns TRUE if the local variable is a managed pointer.
+/**
+ * @return <code>TRUE</code> if the local variable is a managed pointer.
+ */
VMEXPORT Boolean method_vars_is_managed_pointer(Method_Handle mh, unsigned idx);
-// Returns TRUE if the local variable is pinned.
+/**
+ * @return <code>TRUE</code> if the local variable is pinned.
+ */
VMEXPORT Boolean method_vars_is_pinned(Method_Handle mh, unsigned idx);
-// end local variables-related functions.
-///////////////////////////////////////////////////////
-
+/**
+ * end local variables-related functions.
+ */
-///////////////////////////////////////////////////////
-// begin argument-related functions.
+/**
+ * begin argument-related functions.
+ */
-// Returns the number of arguments defined for the method.
-// This number automatically includes the this pointer (if present).
+/**
+ * @return the number of arguments defined for the method.
+ * This number automatically includes the this pointer (if present).
+ */
VMEXPORT unsigned method_args_get_number(Method_Signature_Handle msh);
VMEXPORT Boolean method_args_has_this(Method_Signature_Handle msh);
-// Return the class handle of the argument number idx.
-// That's true even for primitive types like int or float.
+/**
+ * Return the class handle of the argument number idx.
+ * That's <code>TRUE</code> even for primitive types like int or float.
+ */
VMEXPORT Type_Info_Handle method_args_get_type_info(Method_Signature_Handle msh,
unsigned idx);
-
-// Returns TRUE if the argument is a managed pointer.
+/**
+ * @return <code>TRUE</code> if the argument is a managed pointer.
+ */
VMEXPORT Boolean method_args_is_managed_pointer(Method_Signature_Handle msh, unsigned idx);
+////
// end argument-related functions.
-///////////////////////////////////////////////////////
+////
-
-///////////////////////////////////////////////////////
+////
// begin return value-related functions.
-
+////
VMEXPORT Type_Info_Handle method_ret_type_get_type_info(Method_Signature_Handle msh);
-// Returns TRUE if the return value is a managed pointer.
+/**
+ * @return <code>TRUE</code> if the return value is a managed pointer.
+ */
VMEXPORT Boolean method_ret_type_is_managed_pointer(Method_Signature_Handle msh);
+////
// end return value-related functions.
-///////////////////////////////////////////////////////
-
+////
+////
// end method-related functions.
-/////////////////////////////////////////////////////////////////
+////
-
-
-///////////////////////////////////////////////////////
+////
// begin type info-related functions.
+////
-// Array shapes and custom modifiers are not implemented yet.
-
-// If type info is a reference, type_info_get_class will return the class
-// of the reference.
+/**
+ * Array shapes and custom modifiers are not implemented yet.
+ *
+ * If type info is a reference, <code>type_info_get_class</code>
+ * will return the class of the reference.
+ */
VMEXPORT Boolean type_info_is_reference(Type_Info_Handle tih);
-// If type info is unboxed, type_info_get_class will return the class
-// of the unboxed type and class_is_primitive will return its VM_Data_Type.
+/**
+ * If type info is unboxed, <code>type_info_get_class</code>
+ * will return the class of the unboxed type and <code>class_is_primitive<code>
+ * will return its <code>VM_Data_Type</code>.
+ */
VMEXPORT Boolean type_info_is_unboxed(Type_Info_Handle tih);
-// Returns TRUE if the type is a primitive type. type_info_is_primitive does
-// not cause resolution in contrast to the otherwise equivalentcall sequence
-// suggested in the description of type_info_is_unboxed (i.e.
-// type_info_is_unboxed-->type_info_get_class-->class_is_primitive).
+/**
+ * @return <code>TRUE</code> if the type is a primitive type.
+ * <code>type_info_is_primitive</code> does
+ * not cause resolution in contrast to the otherwise equivalentcall sequence
+ * suggested in the description of <code>type_info_is_unboxed</code>
+ * (i.e. <code>type_info_is_unboxed-->type_info_get_class-->class_is_primitive</code>).
+ */
VMEXPORT Boolean type_info_is_primitive(Type_Info_Handle tih);
-// If TRUE, then
-// type_info_get_type_info returns the type info that the pointer
-// points to.
+/**
+ * If <code>TRUE</code>, then <code>type_info_get_type_info</code>
+ * returns the type info that the pointer points to.
+ */
VMEXPORT Boolean type_info_is_unmanaged_pointer(Type_Info_Handle tih);
-// For a return value a type can be void when it is not an unmanaged pointer.
-// In all other contexts, if type_info_is_void is TRUE then
-// type_info_is_unmanaged_pointer is TRUE too.
+/**
+ * For a return value a type can be void when it is not an unmanaged pointer.
+ * In all other contexts, if <code>type_info_is_void</code> is <code>TRUE</code> then
+ * <code>type_info_is_unmanaged_pointer</code> is <code>TRUE</code> too.
+ */
VMEXPORT Boolean type_info_is_void(Type_Info_Handle tih);
-// If TRUE, use type_info_get_method_sig to retrieve the method signature.
+/**
+ * If <code>TRUE</code>, use <code>type_info_get_method_sig</code> to
+ * retrieve the method signature.
+ */
VMEXPORT Boolean type_info_is_method_pointer(Type_Info_Handle tih);
-// Is it a vector, i.e., a one-dimensional, zero-based array.
+/**
+ * Is it a vector, i.e., a one-dimensional, zero-based array.
+ */
VMEXPORT Boolean type_info_is_vector(Type_Info_Handle tih);
-// Is it a general array, i.e., either multidimensional or non zero-based.
-// Returns FALSE for vectors. Always FALSE for Java.
+/**
+ * Is it a general array, i.e., either multidimensional or non zero-based.
+ *
+ * @return <code>FALSE</code> for vectors. Always <code>FALSE</code> for Java.
+ */
VMEXPORT Boolean type_info_is_general_array(Type_Info_Handle tih);
-// Get the class if type_info_is_reference or type_info_is_unboxed
-// returned TRUE. If the type info is a vector or a general array, return the
-// class handle for the array type (not the element type).
+/**
+ * Get the class if <code>type_info_is_reference</code> or
+ * <code>type_info_is_unboxed</code> returned <code>TRUE</code>.
+ * If the type info is a vector or a general array, return the
+ * class handle for the array type (not the element type).
+ */
VMEXPORT Class_Handle type_info_get_class(Type_Info_Handle tih);
-// Get the method signature if type_info_is_method_pointer returned TRUE.
+/**
+ * Get the method signature if <code>type_info_is_method_pointer</code>
+ * returned <code>TRUE</code>.
+ */
VMEXPORT Method_Signature_Handle type_info_get_method_sig(Type_Info_Handle tih);
-// Get recursively type info if type_info_is_unmanaged_pointer,
-// type_info_is_vector or type_info_is_general_array returned TRUE.
+/**
+ * Get recursively type info if <code>type_info_is_unmanaged_pointer</code>,
+ * <code>type_info_is_vector</code> or <code>type_info_is_general_array</code>
+ * returned <code>TRUE</code>.
+ */
VMEXPORT Type_Info_Handle type_info_get_type_info(Type_Info_Handle tih);
-// Return an VM_Data_Type corresponding to a type info.
-// This function is provided for convenience as it can be implemented in terms
-// of other functions provided in this interface.
+/**
+ * Return an <code>VM_Data_Type</code> corresponding to a type info.
+ * This function is provided for convenience as it can be implemented in terms
+ * of other functions provided in this interface.
+ */
VMEXPORT VM_Data_Type type_info_get_type(Type_Info_Handle tih);
+////
// end type info-related functions.
-///////////////////////////////////////////////////////
-
-
+////
-/////////////////////////////////////////////////////////////////
+////
// begin vector layout functions.
+////
-// Vectors are one-dimensional, zero-based arrays. All Java "arrays" are
-// vectors.
-// Functions provided in this section do not work on multidimensional or
-// non-zero based arrays (i.e. arrays with a lower bound that is non-zero
-// for at least one of the dimensions.
-
+/**
+ * Vectors are one-dimensional, zero-based arrays. All Java
+ * <code>arrays</code> are vectors.
+ * Functions provided in this section do not work on multidimensional or
+ * non-zero based arrays (i.e. arrays with a lower bound that is non-zero
+ * for at least one of the dimensions.
+ */
-// Return the offset to the length field of the array. That field has
-// the same offset for vectors of all types.
+/**
+ * Return the offset to the length field of the array. That field has
+ * the same offset for vectors of all types.
+ */
VMEXPORT int vector_length_offset();
-// Deprecated. Please use vector_length_offset instead.
-//VMEXPORT int array_length_offset();
+/**
+ * Deprecated. Please use <code>vector_length_offset</code> instead.
+ */
+VMEXPORT int array_length_offset();
-// Return the offset to the first element of the vector of the given type.
-// This function is provided for the cases when the class handle of the
-// element is not available.
+/**
+ * Return the offset to the first element of the vector of the given type.
+ * This function is provided for the cases when the class handle of the
+ * element is not available.
+ */
VMEXPORT int vector_first_element_offset(VM_Data_Type element_type);
-// Deprecated. Please use vector_first_element_offset instead.
-//VMEXPORT int array_first_element_offset(VM_Data_Type element_type);
+/**
+ * Deprecated. Please use <code>vector_first_element_offset</code> instead.
+ */
+VMEXPORT int array_first_element_offset(VM_Data_Type element_type);
-// Return the offset to the first element of the vector of the given type.
-// Assume that the elements are boxed. Byte offset.
+
+/**
+ * Return the offset to the first element of the vector of the given type.
+ * Assume that the elements are boxed. Byte offset.
+ */
VMEXPORT int vector_first_element_offset_class_handle(Class_Handle element_type);
VMEXPORT int vector_first_element_offset_vtable_handle(VTable_Handle element_type);
-// Deprecated. Please use vector_first_element_offset_class_handle instead.
-//VMEXPORT int array_first_element_offset_class_handle(Class_Handle element_type);
+/**
+ * Deprecated. Please use <code>vector_first_element_offset_class_handle</code> instead.
+ */
+VMEXPORT int array_first_element_offset_class_handle(Class_Handle element_type);
-// Return the offset to the first element of the vector of the given type.
-// If the class is a value type, assume that elements are unboxed.
-// If the class is not a value type, assume that elements are references.
+/**
+ * Return the offset to the first element of the vector of the given type.
+ * If the class is a value type, assume that elements are unboxed.
+ * If the class is not a value type, assume that elements are references.
+ */
VMEXPORT int vector_first_element_offset_unboxed(Class_Handle element_type);
-// Deprecated. Please use vector_first_element_offset_unboxed instead.
-//VMEXPORT int array_first_element_offset_unboxed(Class_Handle element_type);
+/**
+ * Deprecated. Please use <code>vector_first_element_offset_unboxed</code> instead.
+ */
+VMEXPORT int array_first_element_offset_unboxed(Class_Handle element_type);
-// Return the length of a vector. The caller must ensure that GC will not
-// move or deallocate the vector while vector_get_length() is active.
+/**
+ * Return the length of a vector. The caller must ensure that GC will not
+ * move or deallocate the vector while vector_get_length() is active.
+ */
VMEXPORT int32 vector_get_length(Vector_Handle vector);
-// Return the address to an element of a vector of references.
-// The caller must ensure that GC will not move or deallocate the vector
-// while vector_get_element_address_ref() is active.
+/**
+ * Return the address to an element of a vector of references.
+ * The caller must ensure that GC will not move or deallocate the vector
+ * while vector_get_element_address_ref() is active.
+ */
VMEXPORT Managed_Object_Handle *
vector_get_element_address_ref(Vector_Handle vector, int32 idx);
-// Return the size of a vector of a given number of elements.
-// The size is rounded up to take alignment into account.
+/**
+ * Return the size of a vector of a given number of elements.
+ * The size is rounded up to take alignment into account.
+ */
VMEXPORT unsigned vm_vector_size(Class_Handle vector_class, int length);
-
+////
// end vector layout functions.
-/////////////////////////////////////////////////////////////////
-
-
+////
-/////////////////////////////////////////////////////////////////
+////
// begin miscellaneous functions.
+////
-
-// Returns TRUE if references within objects and vector elements are
-// to be treated as offsets rather than raw pointers.
+/**
+ * @return <code>TRUE</code> if references within objects and vector elements are
+ * to be treated as offsets rather than raw pointers.
+ */
VMEXPORT Boolean vm_references_are_compressed();
-// Returns the starting address of the GC heap.
+/**
+ * @return The starting address of the GC heap.
+ */
VMEXPORT void *vm_heap_base_address();
-// Returns the ending address of the GC heap.
+/**
+ * @return The ending address of the GC heap.
+ */
VMEXPORT void *vm_heap_ceiling_address();
-// Returns TRUE if vtable pointers within objects are to be treated
-// as offsets rather than raw pointers.
+/**
+ * @return <code>TRUE</code> if vtable pointers within objects are to be treated
+ * as offsets rather than raw pointers.
+ */
VMEXPORT Boolean vm_vtable_pointers_are_compressed();
-// Returns the offset to the vtable pointer in an object.
+/**
+ * @return The offset to the vtable pointer in an object.
+ */
VMEXPORT int object_get_vtable_offset();
-// Returns the base address of the vtable memory area. This value will
-// never change and can be cached at startup.
+/**
+ * @return The base address of the vtable memory area. This value will
+ * never change and can be cached at startup.
+ */
VMEXPORT POINTER_SIZE_INT vm_get_vtable_base();
-// Returns the width in bytes (e.g. 4 or 8) of the vtable type
-// information in each object's header. This is typically used
-// by the JIT for generating type-checking code, e.g. for inlined
-// type checks or for inlining of virtual methods.
+/**
+ * @return The width in bytes (e.g. 4 or 8) of the vtable type
+ * information in each object's header. This is typically used
+ * by the JIT for generating type-checking code, e.g. for inlined
+ * type checks or for inlining of virtual methods.
+ */
VMEXPORT unsigned vm_get_vtable_ptr_size();
-// Returns a printable signature. The character buffer is owned by the
-// caller. Call free_string_buffer to reclaim the memory.
+/**
+ * @return A printable signature. The character buffer is owned by the
+ * caller. Call <code>free_string_buffer</code> to reclaim the memory.
+ */
VMEXPORT char *method_sig_get_string(Method_Signature_Handle msh);
-// Free a string buffer returned by method_sig_get_string.
+/**
+ * Free a string buffer returned by <code>method_sig_get_string</code>.
+ */
VMEXPORT void free_string_buffer(char *buffer);
@@ -690,42 +979,69 @@
JAVA_PROPERTIES = 1
} PropertyTable;
-//Sets the property for table_number property table. NULL value is supported.
+/**
+ * Sets the property for <code>table_number</code> property table. <code>NULL</code> value is supported.
+ */
VMEXPORT void set_property(const char* key, const char* value, PropertyTable table_number);
-//Returns the value of the property from table_number property table if it
-//has been set by set_property function. Otherwise returns NULL.
+/**
+ * @return The value of the property from <code>table_number</code> property table if it
+ * has been set by <code>set_property</code> function. Otherwise <code>NULL</code>.
+ */
VMEXPORT char* get_property(const char* key, PropertyTable table_number);
-//Safety frees memory of value returned by get_property function.
+/**
+ * Safety frees memory of value returned by <code>get_property</code> function.
+ */
VMEXPORT void destroy_property_value(char* value);
-//Checks if the property is set. Return:
-// -1 if table_number is incorrect.
-// 1 if property is set in table_number property table.
-// 0 otherwise.
+/**
+ * Checks if the property is set.
+ *
+ * @return -1 if <code>table_number</code> is incorrect.<BR>
+ * 1 if property is set in <code>table_number</code> property table.<BR>
+ * 0 otherwise.
+ */
VMEXPORT int is_property_set(const char* key, PropertyTable table_number);
-//Unsets the property in table_number property table.
+/**
+ * Unsets the property in <code>table_number</code> property table.
+ */
VMEXPORT void unset_property(const char* key, PropertyTable table_number);
-//Returns an array of keys from table_number properties table.
+/**
+ * @return An array of keys from <code>table_number</code> properties table.
+ */
VMEXPORT char** get_properties_keys(PropertyTable table_number);
-//Returns an array of keys which start with specified prefix from table_number properties table.
+/**
+ * @return An array of keys which start with specified prefix from
+ * <code>table_number</code> properties table.
+ */
VMEXPORT char** get_properties_keys_staring_with(const char* prefix, PropertyTable table_number);
-//Safety frees array of keys memory which returned by get_properties_keys
-//or get_properties_keys_staring_with functions.
+/**
+ * Safety frees array of keys memory which returned by <code>get_properties_keys</code>
+ * or <code>get_properties_keys_staring_with</code> functions.
+ */
VMEXPORT void destroy_properties_keys(char** keys);
-//Tries to interpret property value as Boolean and returns it. In case of failure returns default_value.
+/**
+ * Tries to interpret property value as <code>Boolean</code> and returns it.
+ * In case of failure returns <code>default_value</code>.
+ */
VMEXPORT Boolean get_boolean_property(const char* property, Boolean default_value, PropertyTable table_number);
-//Tries to interpret property value as int and returns it. In case of failure returns default_value.
+/**
+ * Tries to interpret property value as <code>int</code> and returns it. In case of failure
+ * returns <code>default_value</code>.
+ */
VMEXPORT int get_int_property(const char *property_name, int default_value, PropertyTable table_number);
+
+
+////
// end miscellaneous functions.
-/////////////////////////////////////////////////////////////////
+////
#ifdef __cplusplus
}
Modified: harmony/enhanced/drlvm/trunk/vm/include/open/vm_gc.h
URL: http://svn.apache.org/viewvc/harmony/enhanced/drlvm/trunk/vm/include/open/vm_gc.h?view=diff&rev=496108&r1=496107&r2=496108
==============================================================================
--- harmony/enhanced/drlvm/trunk/vm/include/open/vm_gc.h (original)
+++ harmony/enhanced/drlvm/trunk/vm/include/open/vm_gc.h Sun Jan 14 10:13:53 2007
@@ -14,10 +14,7 @@
* See the License for the specific language governing permissions and
* limitations under the License.
*/
-/**
- * @author Intel, Salikh Zakirov
- * @version $Revision: 1.1.2.1.4.3 $
- */
+
#ifndef _OPEN_VM_GC_H
#define _OPEN_VM_GC_H
@@ -38,24 +35,22 @@
/**
- * @return the number of bytes allocated by VM in VTable
+ * @return The number of bytes allocated by VM in VTable
* for use by GC.
*/
VMEXPORT size_t vm_number_of_gc_bytes_in_vtable();
/**
- * @return the number of bytes allocated by VM in thread-local
+ * @return The number of bytes allocated by VM in thread-local
* storage for use by GC.
*/
VMEXPORT size_t vm_number_of_gc_bytes_in_thread_local();
/**
- * @return the pointer to thread-local area of current thread.
+ * @return The pointer to thread-local area of current thread.
*/
VMEXPORT void *vm_get_gc_thread_local();
-VMEXPORT size_t vm_get_gc_thread_local_offset();
-
/**
* Acquire the lock that guards all GC-related operations in the VM.
@@ -67,7 +62,7 @@
/**
- * Release the system-wide lock acquired by vm_gc_lock_enum().
+ * Release the system-wide lock acquired by <code>vm_gc_lock_enum()</code>.
* The thread is marked as unsafe for root set enumeration.
*/
VMEXPORT void vm_gc_unlock_enum();
@@ -94,7 +89,8 @@
* GC calls this function in stop the world state when all live objects
* are marked. This is the callback to classloader allowing it to
* gather needed statics for class unloading.
- * See also gc interface functions: gc_get_next_live_object(void *iterator)
+ *
+ * @sa gc interface functions: gc_get_next_live_object(void *iterator)
*/
VMEXPORT void vm_classloader_iterate_objects(void *iterator);
@@ -103,12 +99,20 @@
* one object. The GC aborts heap iteration if this function
* returns false.
*
- * @return true to continue heap iteration, false to abort
- * @see gc.h#gc_iterate_heap()
+ * @return <code>TRUE</code> to continue heap iteration, <code>FALSE</code> to abort
+ *
+ * @sa gc.h#gc_iterate_heap()
*/
VMEXPORT bool vm_iterate_object(Managed_Object_Handle object);
/**
+ * GC calls this function for each live object it finds in heap.
+ * This is used for finding unreferenced class loaders for class
+ * unloading.
+ */
+VMEXPORT void vm_notify_live_object_class(Class_Handle);
+
+/**
* GC calls this function to hint VM that finalizers may need to be run
* and references enqueued. This method is guaranteed not to hold global
* GC lock.
@@ -127,29 +131,29 @@
nill = 0,
/**
- * thread is stopped for root set enumeration,
+ * Thread is stopped for root set enumeration,
* as is the whole world (all managed threads).
*/
enumerate_the_universe,
/**
- * thread is stopped for root set enumeration
+ * Thread is stopped for root set enumeration
*/
java_suspend_one_thread,
/**
- * thread is stopped by java debugger.
+ * Thread is stopped by java debugger.
*/
java_debugger
};
/**
- * @return thread safepoint state.
+ * @return Thread safepoint state.
*/
VMEXPORT enum safepoint_state get_global_safepoint_status();
/**
- * @return TRUE if no apparent trash was found in the object.
+ * @return <code>TRUE</code> if no apparent trash was found in the object.
*
* Used for debugging.
*/
@@ -176,16 +180,12 @@
*/
VMEXPORT void vm_finalize_object(Managed_Object_Handle p_obj);
-VMEXPORT void set_native_finalizer_thread_flag(Boolean flag);
-
/**
* GC should call this function when an phantom reference object
* is to be enqueued, i.e. when the reference is not reachable anymore.
*/
VMEXPORT void vm_enqueue_reference(Managed_Object_Handle p_obj);
-VMEXPORT void set_native_ref_enqueue_thread_flag(Boolean flag);
-
enum WeakReferenceType {
NOT_REFERENCE = 0,
WEAK_REFERENCE,
@@ -203,39 +203,42 @@
/*
* Returns handle of a class for a specified vtable
+ *
* @param vh - handle of vtable to retrieve class for
+ *
* @return class handle for a specified vtable
*/
VMEXPORT Class_Handle vtable_get_class(VTable_Handle vh);
/**
* Notifies VM that live object of this class was found in the heap
+ *
* @param clss - class of live object in Java heap
- **/
+ */
VMEXPORT void vm_notify_live_object_class(Class_Handle clss);
/**
* Returns the offset of the referent field
- * in the java.lang.ref.Reference object.
+ * in the <code>java.lang.ref.Reference</code> object.
*
* clss is assumed to represent the reference object,
* i.e. class_is_reference() returned non-zero value.
*
- * @note the returned value is most probably a constant,
+ * @note The returned value is most probably a constant,
* and is not dependent on the clss.
*
- * @note this interface allows only one non-strong (i.e. weak
+ * @note This interface allows only one non-strong (i.e. weak
* soft or phantom) reference per object.
* It seems to be sufficient for JVM Spec.
*/
VMEXPORT int class_get_referent_offset(Class_Handle clss);
-#define CL_PROP_ALIGNMENT_MASK 0x00FFF ///< @see class_properties
-#define CL_PROP_NON_REF_ARRAY_MASK 0x01000 ///< @see class_properties
-#define CL_PROP_ARRAY_MASK 0x02000 ///< @see class_properties
-#define CL_PROP_PINNED_MASK 0x04000 ///< @see class_properties
-#define CL_PROP_FINALIZABLE_MASK 0x08000 ///< @see class_properties
+#define CL_PROP_ALIGNMENT_MASK 0x00FFF ///< @sa <code>class_properties</code>
+#define CL_PROP_NON_REF_ARRAY_MASK 0x01000 ///< @sa <code>class_properties</code>
+#define CL_PROP_ARRAY_MASK 0x02000 ///< @sa <code>class_properties</code>
+#define CL_PROP_PINNED_MASK 0x04000 ///< @sa <code>class_properties</code>
+#define CL_PROP_FINALIZABLE_MASK 0x08000 ///< @sa <code>class_properties</code>
/**
Modified: harmony/enhanced/drlvm/trunk/vm/include/open/vm_util.h
URL: http://svn.apache.org/viewvc/harmony/enhanced/drlvm/trunk/vm/include/open/vm_util.h?view=diff&rev=496108&r1=496107&r2=496108
==============================================================================
--- harmony/enhanced/drlvm/trunk/vm/include/open/vm_util.h (original)
+++ harmony/enhanced/drlvm/trunk/vm/include/open/vm_util.h Sun Jan 14 10:13:53 2007
@@ -14,11 +14,6 @@
* See the License for the specific language governing permissions and
* limitations under the License.
*/
-/**
- * @author Intel, Alexei Fedotov
- * @version $Revision: 1.1.2.2.4.3 $
- */
-
#ifndef _VM_UTILS_H_
#define _VM_UTILS_H_
@@ -59,16 +54,17 @@
extern VTable *cached_object_array_vtable_ptr;
-
-
-////////////////////////////////////////////////////////////////////////////
-// Runtime support functions exported directly, because they may be called
-// from native code.
-////////////////////////////////////////////////////////////////////////////
+/**
+ * Runtime support functions exported directly, because they
+ * may be called from native code.
+ */
Boolean class_is_subtype(Class *sub, Class *super);
-// Like class_is_subtype, but sub must not be an interface class.
+/**
+ * Like <code>class_is_subtype</code>, but <code>sub</code> must not be an
+ * interface class.
+ */
Boolean class_is_subtype_fast(VTable *sub, Class *super);
@@ -155,17 +151,18 @@
/**
* @brief Generates an VM's helper to invoke the provided function.
*
- * The helper takes 'void*' parameter which is passed to the function after
- * some preparation made (namely GC and stack info are prepared to allow GC
- * to work properly).
+ * The helper takes the <code>void*</code> parameter, which is passed
+ * to the function after some preparation made (namely GC and stack
+ * info are prepared to allow GC to work properly).
*
- * The function must follow stdcall convention, which takes 'void*' and
- * returns 'void*', so does the helper.
+ * The function must follow stdcall convention, which takes <code>void*</code> and
+ * returns <code>void*</code>, so does the helper.
* On a return from the function, the helper checks whether an exception
* was raised for the current thread, and rethrows it if necessary.
*/
VMEXPORT void * vm_create_helper_for_function(void* (*fptr)(void*));
#endif /* #ifndef _VM_UTILS_H_ */
+
Modified: harmony/enhanced/drlvm/trunk/vm/vmcore/include/exceptions.h
URL: http://svn.apache.org/viewvc/harmony/enhanced/drlvm/trunk/vm/vmcore/include/exceptions.h?view=diff&rev=496108&r1=496107&r2=496108
==============================================================================
--- harmony/enhanced/drlvm/trunk/vm/vmcore/include/exceptions.h (original)
+++ harmony/enhanced/drlvm/trunk/vm/vmcore/include/exceptions.h Sun Jan 14 10:13:53 2007
@@ -1,10 +1,10 @@
/*
* Licensed to the Apache Software Foundation (ASF) under one or more
- * contributor license agreements. See the NOTICE file distributed with
+ * contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
- * the License. You may obtain a copy of the License at
+ * the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
@@ -14,10 +14,7 @@
* See the License for the specific language governing permissions and
* limitations under the License.
*/
-/**
- * @author Intel, Pavel Afremov
- * @version $Revision: 1.1.2.1.4.3 $
- */
+
#ifndef _EXCEPTIONS_H_
#define _EXCEPTIONS_H_
@@ -27,27 +24,22 @@
#include "open/types.h"
/**
-@file
-\ref exceptions
-*/
+ * @file
+ * ref exceptions
+ */
/**
-@page exceptions Exceptions subsystem
-
-\section exn_introduction Introduction
-The functions to work with exceptions are described in exceptions.h.
-
-\section exn_issues Issues
-
-\li Interaction with JIT and runtime helpers? -salikh
-\li Interaction with JIT is implemented via rth_wrap_exn_throw stubs. -pavel.n.afremov
-\li Existing interface is currently included.
-
-*/
-
+ \ page page1 exceptions Exceptions subsystem
+ \section section1 exn_introduction Introduction
+ The functions to work with exceptions are described in exceptions.h.
+ \section section1 exn_issues Issues
+ \li Interaction with JIT and runtime helpers? -salikh
+ \li Interaction with JIT is implemented via rth_wrap_exn_throw stubs. -pavel.n.afremov
+ \li Existing interface is currently included.
+ */
/**
- * Returns the thread-local exception object
- * or NULL if no exception occured.
+ * @return The thread-local exception object, or <code>NULL</code> if no
+ * exception occured.
*/
VMEXPORT jthrowable exn_get();
@@ -56,21 +48,23 @@
/**
- * Returns true if the thread-local exception object is set.
+ * @return <code>TRUE</code> if the thread-local exception object is set.
*/
VMEXPORT bool exn_raised();
/**
* Clears the thread-local exception object.
*
- * @note rename of clear_current_thread_exception(). It may be eliminated if
- * exn_catch() will be used and will clean thread exception.
+ * @note Rename of <code>clear_current_thread_exception()</code>.
+ * It may be eliminated if exn_catch() will be
+ * used and will clean thread exception.
*/
VMEXPORT void exn_clear();
/**
* Creates exception object.
*/
+
//FIXME LAZY EXCEPTION (2006.05.06)
// Maybe change to exn_object_create (whole 7)
jthrowable exn_create(Exception* exception);
@@ -101,21 +95,22 @@
VMEXPORT jthrowable exn_create(const char* exc_name, const char* message, jthrowable cause);
/**
- * Returns true if frame is unwindable and false if isn't.
+ * @return <code>TRUE</code> if frame is unwindable and false if isn't.
*/
VMEXPORT bool is_unwindable();
/**
* Sets unwindable property of frame. If frame is unwindable property
* should be true and should be false if frame isn't unwindable.
- * Returns previous value of unwindable property.
+ *
+ * @return Previous value of unwindable property.
*/
bool set_unwindable(bool unwindable);
/**
- * Throws an exception object
+ * Throws an exception object.
*
- * @note internal convenience function, may not be exposed to VMI interface.
+ * @note Internal convenience function, may not be exposed to VMI interface.
*/
void exn_throw_object(jthrowable exc_object);
@@ -123,7 +118,7 @@
* Throws an exceptionas lazy.
* Does not return in case of destructive exception propagation.
*
- * @note internal convenience function, may not be exposed to VMI interface.
+ * @note Internal convenience function, may not be exposed to VMI interface.
*/
void exn_throw_by_class(Class* exc_class);
void exn_throw_by_class(Class* exc_class, jthrowable exc_cause);
@@ -158,15 +153,15 @@
/**
* Sets exceptions as a thread local exception.
*
- * @note explicit non-destructive semantics should be deduced from context.
+ * @note Explicit non-destructive semantics should be deduced from context.
*/
VMEXPORT void exn_raise_object(jthrowable exc_object);
/**
* Sets exception lazy as a thread local exception.
*
- * @note internal convenience function, may not be exposed to VMI interface.
- * @note explicit non-destructive semantics should be deduced from context.
+ * @note Internal convenience function, may not be exposed to VMI interface.
+ * @note Explicit non-destructive semantics should be deduced from context.
*/
void exn_raise_by_class(Class* exc_class);
void exn_raise_by_class(Class* exc_class, jthrowable exc_cause);
@@ -177,28 +172,28 @@
/**
* Sets exception lazy as a thread local exception.
*
- * @note explicit non-destructive semantics should be deduced from context.
+ * @note Explicit non-destructive semantics should be deduced from context.
*/
VMEXPORT void exn_raise_by_name(const char* exception_name);
/**
* Sets exception lazy as a thread local exception.
*
- * @note explicit non-destructive semantics should be deduced from context.
+ * @note Explicit non-destructive semantics should be deduced from context.
*/
VMEXPORT void exn_raise_by_name(const char* exception_name, jthrowable exc_cause);
/**
* Sets exception lazy as a thread local exception.
*
- * @note explicit non-destructive semantics should be deduced from context.
+ * @note Explicit non-destructive semantics should be deduced from context.
*/
VMEXPORT void exn_raise_by_name(const char* exception_name, const char* message);
/**
* Sets exception lazy as a thread local exception.
*
- * @note explicit non-destructive semantics should be deduced from context.
+ * @note Explicit non-destructive semantics should be deduced from context.
*/
VMEXPORT void exn_raise_by_name(const char* exception_name, const char* message,
jthrowable exc_cause);
@@ -208,27 +203,27 @@
* After this returns true. If unwinding is happnened control coming back into
* this function, and after this it returns false.
*
- * @note experimental
+ * @note Experimental.
*/
bool exn_function_try();
/**
- * pops dummy non-unwindable stack frame
+ * Pops dummy non-unwindable stack frame.
*
- * returns the current thread exception object
- * or NULL if no exception occured.
+ * @retur The current thread exception object, or <code>NULL</code>
+ * if no exception occured.
*
- * @note experimental
+ * @note Experimental.
*/
jthrowable exn_function_catch();
/**
- * Wrapper for exn_function_try.
+ * Wrapper for <code>exn_function_try</code>.
*/
#define exn_try (if (exn_function_try()))
/**
- * Wrapper for exn_function_catch.
+ * Wrapper for <code>exn_function_catch</code>.
*/
#define exn_catch (th) (if ( th = exn_function_catch()))
@@ -256,16 +251,21 @@
struct ManagedObject;
-//**** Stack Trace support
+/**
+ * Stack Trace support
+ */
-// Print the stack trace stored in the exception object to the given file.
+/**
+ * Print the stack trace stored in the exception object to the given file.
+ */
void exn_print_stack_trace(FILE* f, jthrowable exc);
void print_uncaught_exception_message(FILE *f, char* context_message, jthrowable exc);
-//**** Native code exception support
-
+/**
+ * Native code exception support
+ */
void exn_rethrow();
void exn_rethrow_if_pending();
Modified: harmony/enhanced/drlvm/trunk/vm/vmcore/include/jit_export.h
URL: http://svn.apache.org/viewvc/harmony/enhanced/drlvm/trunk/vm/vmcore/include/jit_export.h?view=diff&rev=496108&r1=496107&r2=496108
==============================================================================
--- harmony/enhanced/drlvm/trunk/vm/vmcore/include/jit_export.h (original)
+++ harmony/enhanced/drlvm/trunk/vm/vmcore/include/jit_export.h Sun Jan 14 10:13:53 2007
@@ -1,10 +1,10 @@
/*
* Licensed to the Apache Software Foundation (ASF) under one or more
- * contributor license agreements. See the NOTICE file distributed with
+ * contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
- * the License. You may obtain a copy of the License at
+ * the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
@@ -14,16 +14,11 @@
* See the License for the specific language governing permissions and
* limitations under the License.
*/
-/**
- * @author Intel, Alexei Fedotov
- * @version $Revision: 1.1.2.1.4.4 $
- */
-
-//
-// These are the functions that a JIT built as a DLL must export.
-// Some functions may be optional and are marked as such.
-//
+/**
+ * These are the functions that a JIT built as a DLL must export.
+ * Some functions may be optional and are marked as such.
+ */
#ifndef _JIT_EXPORT_H
#define _JIT_EXPORT_H
@@ -52,10 +47,11 @@
// Required functions.
////////////////////////////////////////////////////////
-//
-// Flags passed from the VM to the JIT.
-//
-// Max 32 bits, so that it fits in one word.
+/**
+ * Flags passed from the VM to the JIT.
+ *
+ * Max 32 bits, so that it fits in one word.
+ */
typedef
struct JIT_Flags {
@@ -76,71 +72,85 @@
* call a certain VM helpers at certain places in the code. For JIT,
* in particular, this means that it will have to generate additional
* code which will perform these calls.
-* <p>
+*
* Each of the requirement is associated with a corresponding ability of
* the EE to satisfy this requirement. So, elements of the struct should also
* be used to denote EE capabilities related to method execution.
-* <p>
+*
* If an element corresponds to a certain VM helper, concrete contract
* of calling this helper (arguments, etc.) can be found at the place of
* definition of this helper (or its ID) within present OPEN specification.
*/
typedef struct OpenMethodExecutionParams {
- /** call corresponding VM helper upon entry to the managed method */
+
+ /**
+ * Call corresponding VM helper upon entry to the managed method.
+ */
Boolean exe_notify_method_entry : 1;
- /** call corresponding VM helper upon exit from the managed method */
+ /**
+ * Call corresponding VM helper upon exit from the managed method.
+ */
Boolean exe_notify_method_exit : 1;
- /** call corresponding VM helper upon reading a value of a field which has <field access mask> set */
+ /**
+ * Call corresponding VM helper upon reading a value of a field which
+ * has <field access mask> set
+ */
+
Boolean exe_notify_field_access : 1;
- /** call corresponding VM helper upon setting a value of a field which has <field modification mask> set */
+ /**
+ * Call corresponding VM helper upon setting a value of a field which
+ * has <field modification mask> set.
+ */
Boolean exe_notify_field_modification : 1;
/**
- * call corresponding VM helper upon exception throw,
- * if by default the throw code does not enter any VM helper
- * (for example, in case of JIT optimizations)
- */
+ * Call corresponding VM helper upon exception throw,
+ * if by default the throw code does not enter any VM helper
+ * (for example, in case of JIT optimizations).
+ */
Boolean exe_notify_exception_throw : 1;
/**
- * call corresponding VM helper upon exception catch,
- * if by default the exception propagation code does not enter any VM helper
- * (for example, in case of JIT optimizations)
- */
+ * Call corresponding VM helper upon exception catch,
+ * if by default the exception propagation code does not enter any VM helper
+ * (for example, in case of JIT optimizations).
+ */
Boolean exe_notify_exception_catch : 1;
/**
- * call corresponding VM helper upon entering a monitor,
- * if by default the monitor enter code does not enter any VM helper
- * (for example, in case of JIT optimizations)
- */
+ * Call corresponding VM helper upon entering a monitor,
+ * if by default the monitor enter code does not enter any VM helper
+ * (for example, in case of JIT optimizations).
+ */
Boolean exe_notify_monitor_enter : 1;
/**
- * call corresponding VM helper upon exiting a monitor,
- * if by default the monitor exit code does not enter any VM helper
- * (for example, in case of JIT optimizations)
- */
+ * Call corresponding VM helper upon exiting a monitor,
+ * if by default the monitor exit code does not enter any VM helper
+ * (for example, in case of JIT optimizations).
+ */
Boolean exe_notify_monitor_exit : 1;
/**
- * call corresponding VM helper upon entering a contended monitor,
- * if by default the contended monitor enter code does not enter any VM helper
- * (for example, in case of JIT optimizations)
- */
+ * Call corresponding VM helper upon entering a contended monitor,
+ * if by default the contended monitor enter code does not enter any VM helper
+ * (for example, in case of JIT optimizations).
+ */
Boolean exe_notify_contended_monitor_enter : 1;
/**
- * call corresponding VM helper upon exiting a contended monitor,
- * if by default the contended monitor exit code does not enter any VM helper
- * (for example, in case of JIT optimizations)
- */
+ * Call corresponding VM helper upon exiting a contended monitor,
+ * if by default the contended monitor exit code does not enter any VM helper
+ * (for example, in case of JIT optimizations).
+ */
Boolean exe_notify_contended_monitor_exit : 1;
- /** perform method in-lining during compilation (JIT-specific) */
+ /**
+ * Perform method in-lining during compilation (JIT-specific)
+ */
Boolean exe_do_method_inlining : 1;
/**
@@ -160,18 +170,20 @@
*/
Boolean exe_do_local_var_mapping : 1;
- /** call corresponding VM helper upon setting a value of any field of reference type */
+ /**
+ * Call corresponding VM helper upon setting a value of any field of reference type.
+ */
Boolean exe_insert_write_barriers : 1;
/**
* Provide possibility to obtain reference to the current 'this' object by
- * means of get_address_of_this method. Used for JVMTI debug support.
+ * means of <code>get_address_of_this</code> method. Used for JVMTI debug support.
*/
Boolean exe_provide_access_to_this : 1;
/**
* Provide restoring of arguments in the stack after the call
- * of the unwind_frame method so that method could be called again
+ * of the <code>unwind_frame</code> method so that method could be called again
* with the same arguments. Used for JVMTI debug support.
*/
Boolean exe_restore_context_after_unwind : 1;
@@ -197,14 +209,16 @@
JIT_Flags flags
);
-/**
+ /**
* Performs compilation of given method.
*
* @param method_handle - handle of the method to be compiled
- * @param compilation_params - compilation parameters. If NULL, default compilation parameters
- * should be used by the JIT (passed in the initialize function). If either of parameters is
- * not supported by the JIT, the function should return compilation failure.
- * @return compilation status
+ * @param compilation_params - compilation parameters. If <code>NULL</code>,
+ * default compilation parameters should be used by
+ * the JIT (passed in the initialize function).
+ * If either of parameters is not supported by the JIT,
+ * the function should return compilation failure.
+ * @return Compilation status.
*/
JITEXPORT JIT_Result JIT_compile_method_with_params(
JIT_Handle jit,
@@ -214,10 +228,10 @@
);
-/**
+ /**
* Retrieves method execution-related capabilities supported by the EE.
*
- * @return the set of supported capabilities
+ * @return The set of supported capabilities.
*/
JITEXPORT OpenMethodExecutionParams JIT_get_exe_capabilities (JIT_Handle jit);