harmony-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From nadi...@apache.org
Subject svn commit: r496108 [3/4] - in /harmony/enhanced/drlvm/trunk/vm: include/ include/open/ vmcore/include/
Date Sun, 14 Jan 2007 18:13:55 GMT
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);
 



Mime
View raw message