harmony-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From smish...@apache.org
Subject svn commit: r496237 [3/4] - in /harmony/enhanced/drlvm/trunk/vm: include/ include/open/ vmcore/include/
Date Mon, 15 Jan 2007 06:22:35 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=496237&r1=496236&r2=496237
==============================================================================
--- harmony/enhanced/drlvm/trunk/vm/include/open/vm.h (original)
+++ harmony/enhanced/drlvm/trunk/vm/include/open/vm.h Sun Jan 14 22:22:34 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,12 +14,17 @@
  *  See the License for the specific language governing permissions and
  *  limitations under the License.
  */
-
 /**
- * These are the functions that a VM built as a DLL must export.
- * Some functions may be optional and are marked as such.
+ * @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.
+//
+
 #ifndef _VM_EXPORT_H
 #define _VM_EXPORT_H
 
@@ -35,10 +40,8 @@
 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;
@@ -46,10 +49,8 @@
 } 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;
@@ -57,919 +58,629 @@
 } ChaMethodIterator;
 
 
-/**
- * Begin class-related functions.
- */
+/////////////////////////////////////////////////////////////////
+// begin class-related functions.
 
-/** 
- * @return A handle for the <code>Object</code> class. For Java applications, it's
- *         <code>java.lang.Object</code>.
- */ 
+
+// Returns a handle for the object class.  For Java applications, it's
+// java.lang.Object.
 VMEXPORT Class_Handle get_system_object_class();
 
-/** 
- * @return  A handle for the <code>Class</code> class. For Java applications, it's
- *          <code>java.lang.Class</code>.
- */
+// Returns a handle for the class class.  For Java applications, it's
+// java.lang.Class.
 VMEXPORT Class_Handle get_system_class_class();
 
-/** 
- * @return  A handle for the string class. For Java applications, it's
- *          java.lang.String.
- */
- 
+// Returns 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. 
- *
- * @return <code>NULL</code> if a class cannot be loaded.
- */
-
+// Loads a class of a given name.  If a class cannot be loaded, returns NULL
 VMEXPORT Class_Handle
 class_load_class_by_name_using_bootstrap_class_loader(const char *name);
 
-/** 
- * 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.
- */
-
+// 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.
 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);
 
-/**
- * @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.
- */
+// 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.
 VMEXPORT Boolean class_hint_is_exceptiontype(Class_Handle ch);
 
-/**
- * @return <code>TRUE</code> if the class is a value type.
- */
- VMEXPORT Boolean class_is_valuetype(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 represents an enum. 
- *         For Java 1.4 always returns <code>FALSE</code>.
- */
+// Return TRUE if the class represents an enum. For Java 1.4 always returns FALSE.
 VMEXPORT Boolean class_is_enum(Class_Handle ch);
 
-/**
- * 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.
- */
+// This function can only be called if (class_is_enum(ch) == TRUE)
+// The returned value is the type of the underlying int type.
 VMEXPORT VM_Data_Type class_get_enum_int_type(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 TRUE if the class represents a primitive type (int, float, etc.)
+VMEXPORT Boolean class_is_primitive(Class_Handle ch);
 
-/**
- * @return The name of the class.
- */
- VMEXPORT const char *class_get_name(Class_Handle ch);
+// Returns the name of the class.
+VMEXPORT const char *class_get_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 name of the package containing the class.
+VMEXPORT const char *class_get_package_name(Class_Handle ch);
 
-/**
- * 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
- */
+// 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
 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);
 
-/**
- * @return The allocation handle to be used for the object allocation
- *         routines, given a class handle.
- */
+// Returns 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);
 
-/**
- * @return The class handle corresponding to a given allocation handle.
- */
+// Returns the class handle corresponding to a given allocation handle.
 VMEXPORT Class_Handle allocation_handle_get_class(Allocation_Handle ah);
 
-/**
- * @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 an VM_Data_Type 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 == <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);
+// 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 <code>TRUE</code> is the class is an array.
- */
+// Returns TRUE is the class is an array.
 VMEXPORT Boolean class_is_array(Class_Handle ch);
 
-/** 
- * @return <code>TRUE</code> if class <code>s</code> is assignment 
- * compatible with class <code>t</code>.
- */ 
+// Returns TRUE if class s is assignment compatible with class t.
 VMEXPORT Boolean class_is_instanceof(Class_Handle s, Class_Handle t);
 
-/**
- * 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);
-
-/**
- * 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);
-
-/**
- * @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);
-
- /**
-  * @return <code>TRUE</code> if the class is already fully initialized.
-  */
-  VMEXPORT Boolean class_is_initialized(Class_Handle ch);
-
-/**
- * @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);
-
-/**
- * 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 <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.
- */
+// 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);
 
+// Number of instance fields defined in a class.  This number includes
+// inherited fields.
 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.
- */
+
+// 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);
 
-/**
- * Number of methods declared in the class.
- */
- VMEXPORT unsigned class_get_number_methods(Class_Handle ch);
+// 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);
+// 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);
 
-/**
- * @return <code>TRUE</code> if all instances of this class are pinned.
- */
- VMEXPORT void* class_alloc_via_classloader(Class_Handle ch, int32 size);
+// Returns TRUE if all instances of this class are pinned.
+VMEXPORT Boolean class_is_pinned(Class_Handle ch);
 
-/**
- * @return <code>TRUE</code> if this is an array of primitives.
- */
- VMEXPORT Boolean class_is_non_ref_array(Class_Handle ch);
+// Returns TRUE if all instances of this class are pinned.
+VMEXPORT void* class_alloc_via_classloader(Class_Handle ch, int32 size);
 
-/**
- * @return <code>TRUE</code> if the class has a non-trivial finalizer.
- */
- VMEXPORT Boolean class_is_finalizable(Class_Handle ch);
+// Returns TRUE if this is an array of primitives.
+VMEXPORT Boolean class_is_non_ref_array(Class_Handle ch);
 
-/**
- * This exactly what I want.
- * Get the alignment of the class.
- */
- VMEXPORT unsigned class_get_alignment(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);
 
-/**
- * Get the alignment of the class when it's unboxed.
- */
- VMEXPORT unsigned class_get_alignment_unboxed(Class_Handle ch);
+// Get the alignment of the class when it's unboxed.
+VMEXPORT unsigned class_get_alignment_unboxed(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);
+// 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 The size in bytes of an instance in the heap.
- */
- VMEXPORT unsigned class_get_boxed_data_size(Class_Handle ch);
+// Return the size in bytes of an instance in the heap.
+VMEXPORT unsigned class_get_boxed_data_size(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);
+// 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);
 
-/**
- * @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 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();
+// 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 Class handle given object's <code>VTable_Handle</code>.
- */ 
- VMEXPORT Class_Handle vtable_get_class(VTable_Handle vh);
+// Returns class handle given object's VTable_Handle.
+VMEXPORT Class_Handle vtable_get_class(VTable_Handle vh);
 
-/**
- * @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 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();
 
 
-////
+/////////////////////////////////////////////////////////////////
 // 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);
+// 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 current class of the iterator. <code>NULL</code> if
- *         there are no more classes.
- */
- VMEXPORT Class_Handle class_iterator_get_current(ChaClassIterator*);
+// 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*);
 
-/**
- * Advances the iterator.
- */
- VMEXPORT void class_iterator_advance(ChaClassIterator*);
 
-////
+/////////////////////////////////////////////////////////////////
 // begin inner-class related functions.
-///
 
-/**
- * @return <code>TRUE</code> the number of inner classes.
- */ 
- VMEXPORT unsigned class_number_inner_classes(Class_Handle ch);
+// Returns TRUE the number of inner classes
+VMEXPORT unsigned class_number_inner_classes(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);
+// Returns TRUE 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);
+// Return an inner class
+VMEXPORT Class_Handle class_get_inner_class(Class_Handle ch, unsigned idx);
 
-/**
- * @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);
+// Return the class that declared this one, or NULL if top-level class
+VMEXPORT Class_Handle class_get_declaring_class(Class_Handle ch);
 
 
-///
-// end class-related functions.
-///
+// end inner-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);
 
-/**
- * @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 TRUE is the field is static.
+VMEXPORT Boolean field_is_static(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 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 class that defined that field.
- */ 
- VMEXPORT Class_Handle field_get_class(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 <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 the class that defined that field.
+VMEXPORT Class_Handle field_get_class(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);
+// 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);
 
-/**
- * For Java always <code>FALSE</code>.
- */
- VMEXPORT Boolean field_is_unmanaged_static(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 The offset to an instance field.
- */
- VMEXPORT unsigned field_get_offset(Field_Handle fh);
+// For Java always FALSE.
+VMEXPORT Boolean field_is_unmanaged_static(Field_Handle fh);
 
-/**
- * @return An address of a static field.
- */
- VMEXPORT void *field_get_address(Field_Handle fh);
+// Returns the offset to an instance field.
+VMEXPORT unsigned field_get_offset(Field_Handle fh);
 
-/**
- * @return A name of the field.
- */ 
- VMEXPORT const char *field_get_name(Field_Handle fh);
+// Returns an address of a static field.
+VMEXPORT void *field_get_address(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 a name of the field.
+VMEXPORT const char *field_get_name(Field_Handle fh);
 
-/**
- * @return <code>TRUE</code> if the field is final.
- */
- VMEXPORT Boolean field_is_final(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 <code>TRUE</code> if the field is volatile.
- */ 
- VMEXPORT Boolean field_is_volatile(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 private.
- */ 
- VMEXPORT Boolean field_is_private(Field_Handle fh);
+// Returns TRUE 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 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
+ * 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
  */
 VMEXPORT void
 field_get_track_access_flag(Field_Handle field, char** address, char* mask);
 
 /**
- * @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
+ * 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
  */
 VMEXPORT void
 field_get_track_modification_flag(Field_Handle field, char** address,
                                   char* mask);
 
-////
+
 // end field-related functions.
-////
+/////////////////////////////////////////////////////////////////
 
-////
+
+
+/////////////////////////////////////////////////////////////////
 // begin method-related functions.
-////
 
-/**
- * @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>.
- */ 
+
+// 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.
 VMEXPORT Boolean method_is_java(Method_Handle mh);
 
-/**
- * @return The method name.
- */
+// Returns the method name.
 VMEXPORT const char  *method_get_name(Method_Handle mh);
 
-/**
- * @return The method descriptor. The descriptor is a string representation
- *         of the parameter and return value types as defined by the JVM spec.
- */ 
+// Returns 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);
 
-/**
- * @return A class in which the method is declared.
- */
+// Returns a class in which the method is declared.
 VMEXPORT Class_Handle method_get_class(Method_Handle mh);
 
-/**
- * @return <code>TRUE</code> if the method is private.
- */
+// Returns TRUE if the method is private.
 VMEXPORT Boolean method_is_private(Method_Handle mh);
 
-/**
- * @return <code>TRUE</code> if the method is static.
- */
+// Returns TRUE if the method is static.
 VMEXPORT Boolean method_is_static(Method_Handle mh);
 
-/**
- * @return <code>TRUE</code> if the method is final.
- */
+// Returns TRUE if the method is final.
 VMEXPORT Boolean method_is_final(Method_Handle mh);
 
-/**
- * @return <code>TRUE</code> if the method is native.
- */
+// Returns TRUE if the method is native.
 VMEXPORT Boolean method_is_native(Method_Handle mh);
 
-/**
- * @return <code>TRUE</code> if the method is synchronized.
- */
+// Returns TRUE if the method is synchronized.
 VMEXPORT Boolean method_is_synchronized(Method_Handle mh);
 
-/**
- * @return <code>TRUE</code> if the method is abstract.
- */
+// Returns TRUE 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.  
- *
- * @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.
- */
+// 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.
 VMEXPORT Boolean method_is_strict(Method_Handle m);
 
-/**
- * @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>).
- */
+// 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).
 VMEXPORT Boolean method_is_overridden(Method_Handle m);
 
-/**
- * @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.
- */
+// 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.
 VMEXPORT Boolean method_is_no_inlining(Method_Handle mh);
 
-/**
- * Always <code>FALSE</code> for Java.
- */
+// Always FALSE 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 <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.
- */
+// 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.
 VMEXPORT Method_Handle method_find_overridden_method(Class_Handle ch, Method_Handle mh);
 
-////
+
+/////////////////////////////////////////////////////////////////
 // begin method iterator related functions.
-///
 
-/**
- * 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.
- */
+// 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.
 VMEXPORT Boolean method_iterator_initialize(ChaMethodIterator*, Method_Handle method, Class_Handle root_class);
 
-/**
- * @return The current method of the iterator. <code>NULL</code> is returned if
- *         therea are no more methods.
- */
+// Returns the current method of the iterator.  NULL 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.
-////
 
-/**
- * @return The method descriptor for a given method signature.
- *         See <code>method_get_descriptor()</code>.
- */
+// Returns the method descriptor for a given method signature.
+// See method_get_descriptor().
 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 <code>NULL</code>.
- */
+// 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.
 VMEXPORT Method_Signature_Handle method_standalone_signature(Class_Handle ch,
                                                               unsigned idx);
 
-////
 // end method signature-related functions.
-////
+///////////////////////////////////////////////////////
 
-////
+
+///////////////////////////////////////////////////////
 // begin local variables-related functions.
-///
 
-/**
- * @return the number of local variables defined for the method.
- */ 
+// Returns 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 <code>NULL</code> 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 NULL for Java methods.
 VMEXPORT Type_Info_Handle method_vars_get_type_info(Method_Handle mh,
                                                      unsigned idx);
-/**
- * @return <code>TRUE</code> if the local variable is a managed pointer.
- */
+
+// Returns TRUE if the local variable is a managed pointer.
 VMEXPORT Boolean method_vars_is_managed_pointer(Method_Handle mh, unsigned idx);
 
-/** 
- * @return <code>TRUE</code> if the local variable is pinned.
- */
+// Returns TRUE 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.
- */
 
-/**
- * @return the number of arguments defined for the method.
- * This number automatically includes the this pointer (if present).
- */
+///////////////////////////////////////////////////////
+// begin argument-related functions.
+
+// Returns 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 <code>TRUE</code> even for primitive types like int or float.
- */
+// Return the class handle of the argument number idx.
+// That's true even for primitive types like int or float.
 VMEXPORT Type_Info_Handle method_args_get_type_info(Method_Signature_Handle msh,
                                                      unsigned idx);
-/**
- * @return <code>TRUE</code> if the argument is a managed pointer.
- */
+
+// Returns TRUE 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);
 
-/**
- * @return <code>TRUE</code> if the return value is a managed pointer.
- */
+// Returns TRUE 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, <code>type_info_get_class</code> 
- * will return the class of the reference.
- */
+// 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.
 VMEXPORT Boolean type_info_is_reference(Type_Info_Handle tih);
 
-/**
- * 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>.
- */ 
+// 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.
 VMEXPORT Boolean type_info_is_unboxed(Type_Info_Handle tih);
 
-/**
- * @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>).
- */
+// 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).
 VMEXPORT Boolean type_info_is_primitive(Type_Info_Handle tih);
 
-/**
- * If <code>TRUE</code>, then <code>type_info_get_type_info</code>
- * returns the type info that the pointer points to.
- */
+// If TRUE, then
+// type_info_get_type_info 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 <code>type_info_is_void</code> is <code>TRUE</code> then
- * <code>type_info_is_unmanaged_pointer</code> is <code>TRUE</code> too.
- */ 
+// 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.
 VMEXPORT Boolean type_info_is_void(Type_Info_Handle tih);
 
-/**
- * If <code>TRUE</code>, use <code>type_info_get_method_sig</code> to 
- * retrieve the method signature.
- */
+// If TRUE, use type_info_get_method_sig 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.
- *
- * @return <code>FALSE</code> for vectors. Always <code>FALSE</code> for Java.
- */ 
+// Is it a general array, i.e., either multidimensional or non zero-based.
+// Returns FALSE for vectors.  Always FALSE for Java.
 VMEXPORT Boolean type_info_is_general_array(Type_Info_Handle tih);
 
-/**
- * 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).
- */
+// 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).
 VMEXPORT Class_Handle type_info_get_class(Type_Info_Handle tih);
 
-/**
- * Get the method signature if <code>type_info_is_method_pointer</code> 
- * returned <code>TRUE</code>.
- */
+// Get the method signature if type_info_is_method_pointer returned TRUE.
 VMEXPORT Method_Signature_Handle type_info_get_method_sig(Type_Info_Handle tih);
 
-/**
- * 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>.
- */
+// Get recursively type info if type_info_is_unmanaged_pointer,
+// type_info_is_vector or type_info_is_general_array returned TRUE.
 VMEXPORT Type_Info_Handle type_info_get_type_info(Type_Info_Handle tih);
 
-/**
- * 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.
- */
+// 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.
 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 
- * <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.
- */
+// 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.
 
-/**
- * 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 <code>vector_length_offset</code> instead.
- */
-VMEXPORT int array_length_offset();
+// Deprecated.  Please use vector_length_offset 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 <code>vector_first_element_offset</code> instead.
- */ 
-VMEXPORT int array_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);
 
-
-/**
- * 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 <code>vector_first_element_offset_class_handle</code> instead.
- */
-VMEXPORT int array_first_element_offset_class_handle(Class_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);
 
-/**
- * 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 <code>vector_first_element_offset_unboxed</code> instead.
- */
-VMEXPORT int array_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);
 
-/**
- * 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.
-////
 
-/**
- * @return <code>TRUE</code> if references within objects and vector elements are
- *          to be treated as offsets rather than raw pointers.
- */
+
+// Returns TRUE if references within objects and vector elements are
+// to be treated as offsets rather than raw pointers.
 VMEXPORT Boolean vm_references_are_compressed();
 
-/**
- * @return The starting address of the GC heap.
- */
+// Returns the starting address of the GC heap.
 VMEXPORT void *vm_heap_base_address();
 
-/**
- * @return The ending address of the GC heap.
- */
+// Returns the ending address of the GC heap.
 VMEXPORT void *vm_heap_ceiling_address();
 
-/**
- * @return <code>TRUE</code> if vtable pointers within objects are to be treated
- *         as offsets rather than raw pointers.
- */
+// Returns TRUE if vtable pointers within objects are to be treated
+// as offsets rather than raw pointers.
 VMEXPORT Boolean vm_vtable_pointers_are_compressed();
 
-/**
- * @return The offset to the vtable pointer in an object.
- */ 
+// Returns the offset to the vtable pointer in an object.
 VMEXPORT int object_get_vtable_offset();
 
-/**
- * @return The base address of the vtable memory area. This value will
- *         never change and can be cached at startup.
- */
+// Returns 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();
 
-/**
- * @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.
- */
+// 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.
 VMEXPORT unsigned vm_get_vtable_ptr_size();
 
-/**
- * @return A printable signature. The character buffer is owned by the
- *         caller. Call <code>free_string_buffer</code> to reclaim the memory.
- */
+// Returns a printable signature.  The character buffer is owned by the
+// caller.  Call free_string_buffer to reclaim the memory.
 VMEXPORT char *method_sig_get_string(Method_Signature_Handle msh);
 
-/**
- * Free a string buffer returned by <code>method_sig_get_string</code>.
- */
+// Free a string buffer returned by method_sig_get_string.
 VMEXPORT void free_string_buffer(char *buffer);
 
 
@@ -979,69 +690,42 @@
     JAVA_PROPERTIES = 1
 } PropertyTable;
 
-/**
- * Sets the property for <code>table_number</code> property table. <code>NULL</code> value is supported.
- */
+//Sets the property for table_number property table. NULL value is supported.
 VMEXPORT void set_property(const char* key, const char* value, PropertyTable table_number);
 
-/**
- * @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>.
- */
+//Returns the value of the property from table_number property table if it
+//has been set by set_property function. Otherwise returns NULL.
 VMEXPORT char* get_property(const char* key, PropertyTable table_number);
 
-/**
- * Safety frees memory of value returned by <code>get_property</code> function.
- */ 
+//Safety frees memory of value returned by get_property function.
 VMEXPORT void destroy_property_value(char* value);
 
-/**
- * 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.
- */
+//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.
 VMEXPORT int is_property_set(const char* key, PropertyTable table_number);
 
-/**
- * Unsets the property in <code>table_number</code> property table.
- */
+//Unsets the property in table_number property table.
 VMEXPORT void unset_property(const char* key, PropertyTable table_number);
 
-/**
- * @return An array of keys from <code>table_number</code> properties table.
- */ 
+//Returns an array of keys from table_number properties table.
 VMEXPORT char** get_properties_keys(PropertyTable table_number);
 
-/**
- * @return An array of keys which start with specified prefix from 
- *         <code>table_number</code> properties table.
- */ 
+//Returns an array of keys which start with specified prefix from table_number properties table.
 VMEXPORT char** get_properties_keys_staring_with(const char* prefix, PropertyTable table_number);
 
-/**
- * Safety frees array of keys memory which returned by <code>get_properties_keys</code>
- * or <code>get_properties_keys_staring_with</code> functions.
- */
+//Safety frees array of keys memory which returned by get_properties_keys
+//or get_properties_keys_staring_with functions.
 VMEXPORT void destroy_properties_keys(char** keys);
 
-/**
- * Tries to interpret property value as <code>Boolean</code> and returns it. 
- * In case of failure returns <code>default_value</code>.
- */
+//Tries to interpret property value as Boolean and returns it. In case of failure returns default_value.
 VMEXPORT Boolean get_boolean_property(const char* property, Boolean default_value, PropertyTable table_number);
 
-/**
- * Tries to interpret property value as <code>int</code> and returns it. In case of failure 
- * returns <code>default_value</code>.
- */
+//Tries to interpret property value as int and returns it. In case of failure returns default_value.
 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=496237&r1=496236&r2=496237
==============================================================================
--- harmony/enhanced/drlvm/trunk/vm/include/open/vm_gc.h (original)
+++ harmony/enhanced/drlvm/trunk/vm/include/open/vm_gc.h Sun Jan 14 22:22:34 2007
@@ -14,7 +14,10 @@
  *  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
@@ -35,22 +38,24 @@
 
 
 /**
- * @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.
@@ -62,7 +67,7 @@
 
 
 /**
- * Release the system-wide lock acquired by <code>vm_gc_lock_enum()</code>.
+ * Release the system-wide lock acquired by vm_gc_lock_enum().
  * The thread is marked as unsafe for root set enumeration.
  */
 VMEXPORT void vm_gc_unlock_enum();
@@ -89,8 +94,7 @@
  * 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.
- * 
- * @sa gc interface functions: gc_get_next_live_object(void *iterator)
+ * See also gc interface functions: gc_get_next_live_object(void *iterator)
  */
 VMEXPORT void vm_classloader_iterate_objects(void *iterator);
 
@@ -99,20 +103,12 @@
  * one object. The GC aborts heap iteration if this function
  * returns false.
  *
- * @return <code>TRUE</code> to continue heap iteration, <code>FALSE</code> to abort
- * 
- * @sa gc.h#gc_iterate_heap()
+ * @return true to continue heap iteration, false to abort
+ * @see 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. 
@@ -131,29 +127,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 <code>TRUE</code> if no apparent trash was found in the object.
+ * @return TRUE if no apparent trash was found in the object.
  * 
  * Used for debugging.
  */
@@ -180,12 +176,16 @@
  */
 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,42 +203,39 @@
 
 /*
  * 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 <code>java.lang.ref.Reference</code> object.
+ * in the java.lang.ref.Reference 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     ///< @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>
+#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
 
 
 /**

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=496237&r1=496236&r2=496237
==============================================================================
--- harmony/enhanced/drlvm/trunk/vm/include/open/vm_util.h (original)
+++ harmony/enhanced/drlvm/trunk/vm/include/open/vm_util.h Sun Jan 14 22:22:34 2007
@@ -14,6 +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.2.4.3 $
+ */  
+
 
 #ifndef _VM_UTILS_H_
 #define _VM_UTILS_H_
@@ -54,17 +59,16 @@
 
 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 <code>class_is_subtype</code>, but <code>sub</code> must not be an 
- * interface class.
- */
+// Like class_is_subtype, but sub must not be an interface class.
 Boolean class_is_subtype_fast(VTable *sub, Class *super);
 
 
@@ -151,18 +155,17 @@
 /**
  * @brief Generates an VM's helper to invoke the provided function.
  *
- * 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 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 function must follow stdcall convention, which takes <code>void*</code> and
- * returns <code>void*</code>, so does the helper.
+ * The function must follow stdcall convention, which takes 'void*' and
+ * returns 'void*', 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=496237&r1=496236&r2=496237
==============================================================================
--- harmony/enhanced/drlvm/trunk/vm/vmcore/include/exceptions.h (original)
+++ harmony/enhanced/drlvm/trunk/vm/vmcore/include/exceptions.h Sun Jan 14 22:22:34 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,7 +14,10 @@
  *  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_
 
@@ -24,22 +27,27 @@
 #include "open/types.h"
 
 /**
- * @file 
- * ref exceptions
- */
+@file
+\ref exceptions
+*/
 
 /**
-  \ 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.
- */
+@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.
+
+*/
+
 /**
- * @return The thread-local exception object, or <code>NULL</code> if no 
- * exception occured.
+ * Returns the thread-local exception object
+ * or NULL if no exception occured.
  */
 VMEXPORT jthrowable exn_get();
 
@@ -48,23 +56,21 @@
 
 
 /**
- * @return <code>TRUE</code> if the thread-local exception object is set.
+ * Returns true if the thread-local exception object is set.
  */
 VMEXPORT bool exn_raised();
 
 /**
  * Clears the thread-local exception object.
  *
- * @note Rename of <code>clear_current_thread_exception()</code>. 
- *       It may be eliminated if exn_catch() will be 
- *       used and will clean thread exception.
+ * @note rename of clear_current_thread_exception(). 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);
@@ -95,22 +101,21 @@
 VMEXPORT jthrowable exn_create(const char* exc_name, const char* message, jthrowable cause);
 
 /**
- * @return <code>TRUE</code> if frame is unwindable and false if isn't. 
+ * Returns true 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.
- *
- * @return Previous value of unwindable property.
+ * Returns 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);
 
@@ -118,7 +123,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);
@@ -153,15 +158,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);
@@ -172,28 +177,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);
@@ -203,27 +208,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
  *
- * @retur The current thread exception object, or <code>NULL</code> 
- *        if no exception occured.
+ * returns the current thread exception object
+ * or NULL if no exception occured.
  *
- * @note Experimental.
+ * @note experimental
  */
 jthrowable exn_function_catch();
 
 /**
- * Wrapper for <code>exn_function_try</code>.
+ * Wrapper for exn_function_try.
  */
 #define exn_try (if (exn_function_try()))
 
 /**
- * Wrapper for <code>exn_function_catch</code>.
+ * Wrapper for exn_function_catch.
  */
 #define exn_catch (th) (if ( th = exn_function_catch()))
 
@@ -251,21 +256,16 @@
 
 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=496237&r1=496236&r2=496237
==============================================================================
--- harmony/enhanced/drlvm/trunk/vm/vmcore/include/jit_export.h (original)
+++ harmony/enhanced/drlvm/trunk/vm/vmcore/include/jit_export.h Sun Jan 14 22:22:34 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,11 +14,16 @@
  *  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
@@ -47,11 +52,10 @@
 // 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 {
 
@@ -72,85 +76,71 @@
 * 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;
 
     /**
@@ -170,20 +160,18 @@
     */
     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 <code>get_address_of_this</code> method. Used for JVMTI debug support.
+    * means of get_address_of_this 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 <code>unwind_frame</code> method so that method could be called again
+    * of the unwind_frame method so that method could be called again
     * with the same arguments. Used for JVMTI debug support.
     */
     Boolean  exe_restore_context_after_unwind : 1;
@@ -209,16 +197,14 @@
                    JIT_Flags          flags
                    );
 
-   /** 
+/** 
     * Performs compilation of given method.
     *
     * @param method_handle      - handle of the method to be compiled
-    * @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.
+    * @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
     */
 JITEXPORT JIT_Result JIT_compile_method_with_params(
     JIT_Handle jit,
@@ -228,10 +214,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);
 

Modified: harmony/enhanced/drlvm/trunk/vm/vmcore/include/jit_export_jpda.h
URL: http://svn.apache.org/viewvc/harmony/enhanced/drlvm/trunk/vm/vmcore/include/jit_export_jpda.h?view=diff&rev=496237&r1=496236&r2=496237
==============================================================================
--- harmony/enhanced/drlvm/trunk/vm/vmcore/include/jit_export_jpda.h (original)
+++ harmony/enhanced/drlvm/trunk/vm/vmcore/include/jit_export_jpda.h Sun Jan 14 22:22:34 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,6 +14,10 @@
  *  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 $
+ */  
 
 #ifndef _JIT_EXPORT_JPDA_H
 #define _JIT_EXPORT_JPDA_H
@@ -24,9 +28,9 @@
 extern "C" {
 #endif // __cplusplus
 
-   /**
+/**
     * Elements of this enum denote various error conditions which can
-    * arise when working with the <code>OpenExeJPDA</code> interface.
+    * arise when working with the OpenExeJPDA interface.
     */
 typedef enum OpenExeJpdaError {
     EXE_ERROR_NONE,
@@ -38,21 +42,19 @@
 } OpenExeJpdaError;
 
 
-   /** 
+/** 
     * Gets corresponding native code location for given bytecode location.
-	*
-    * @param method          - method whose bytecode contains the location
-    * @param bc_pc           - location within the bytecode
-    * @param[out] native_pc  - upon successfull return points to corresponding native
-    *                          code location 
+    * @param method    method whose bytecode contains the location
+    * @param bc_pc     location within the bytecode
+    * @param native_pc (out) upon successfull return points to corresponding native
+    *     code location 
     * @return
-    *     EXE_ERROR_NONE              on success.<br>
-    *     EXE_ERROR_INVALID_METHODID if the given method handle is invalid.<br>
+    *     EXE_ERROR_NONE on success
+    *     EXE_ERROR_INVALID_METHODID if the given method handle is invalid
     *     EXE_ERROR_INVALID_LOCATION if either the execution engine is unable to map
-    *                                the bytecode location or if the location is invalid 
-	*                                (does not correspond to a valid offset of a bytecode 
-	*                                instruction).<br>
-    *     EXE_ERROR_UNSUPPORTED      if the execution engine does not support this functionality.
+    *         the bytecode location or if the location is invalid (does not correspond to
+    *         a valid offset of a bytecode instruction)
+    *     EXE_ERROR_UNSUPPORTED if the execution engine does not support this functionality
     */ 
 JITEXPORT OpenExeJpdaError get_native_location_for_bc(
         JIT_Handle jit,
@@ -61,23 +63,18 @@
         NativeCodePtr  *native_pc
         );
 
-   /**
-    * Gets corresponding bytecode location for given native location (absolute 
-	* code address).
-	*
-    * @param method      - method whose (compiled native) code contains the location
-    * @param native_pc   - location within the native code
-    * @param[out] bc_pc  - upon successfull return points to corresponding bytecode 
-	*                      location 
+/**
+    * Gets corresponding bytecode location for given native location (absolute code address).
+    * @param method    method whose (compiled native) code contains the location
+    * @param native_pc location within the native code
+    * @param bc_pc     (out) upon successfull return points to corresponding bytecode location 
     * @return
-    *     EXE_ERROR_NONE             on success.<br>
-    *     EXE_ERROR_INVALID_METHODID if the given method handle is invalid.<br>
+    *     EXE_ERROR_NONE on success
+    *     EXE_ERROR_INVALID_METHODID if the given method handle is invalid
     *     EXE_ERROR_INVALID_LOCATION if either the execution engine is unable to map
-    *                                the native location or if the location is 
-	*                                invalid (does not correspond to a valid offset 
-	*                                of a processor instruction within the compiled code).<br>
-    *     EXE_ERROR_UNSUPPORTED      if the execution engine does not support this 
-	*                                functionality.
+    *         the native location or if the location is invalid (does not correspond to
+    *         a valid offset of a processor instruction within the compiled code)
+    *     EXE_ERROR_UNSUPPORTED if the execution engine does not support this functionality
     */ 
 JITEXPORT OpenExeJpdaError get_bc_location_for_native(
         JIT_Handle jit,
@@ -87,28 +84,23 @@
         );
 
 
-   /** 
+/** 
     * Gets the value of the bytecode local variable in given method stack frame.
-	*
-    * @param method     - method in whose frame the variable is to be read
-    * @param context    - stack frame of the method describing its current execution state
-    *                     (at the point of thread suspension)
-    * @param var_num    - the variable's slot number
-    * @param var_type   - the variable's type
-    * @param value_ptr  - address of the buffer to write variable value into. 
-	*                     Caller is responsible for providing enough 
-	*                     <code>(OPEN_VM::get_vm_type_size(var_type)</code> bytes) 
-	*                     memory in the buffer
-	*
+    * @param method    method in whose frame the variable is to be read
+    * @param context   stack frame of the method describing its current execution state
+    *     (at the point of thread suspension)
+    * @param var_num    the variable's slot number
+    * @param var_type  the variable's type
+    * @param value_ptr address of the buffer to write variable value into. Caller is responsible for
+    *     providing enough (OPEN_VM::get_vm_type_size(var_type) bytes) memory in the buffer.
     * @return
-    *     EXE_ERROR_NONE             on success.<br>
-    *     EXE_ERROR_INVALID_METHODID if the given method handle is invalid.<br>
-    *     EXE_ERROR_INVALID_LOCATION if the execution engine does not support local 
-	*                                variable access at current execution point 
-	*                                in the method, specified by the context.<br>
-    *     EXE_ERROR_TYPE_MISMATCH    if the variable with given slot is of different type.<br>
-    *     EXE_ERROR_INVALID_SLOT     if the stack frame does not have variable with given slot number.<br>
-    *     EXE_ERROR_UNSUPPORTED      if the execution engine does not support this functionality.
+    *     EXE_ERROR_NONE on success
+    *     EXE_ERROR_INVALID_METHODID if the given method handle is invalid
+    *     EXE_ERROR_INVALID_LOCATION if the execution engine does not support local variable access
+    *         at current execution point in the method, specified by the context
+    *     EXE_ERROR_TYPE_MISMATCH if the variable with given slot is of different type,
+    *     EXE_ERROR_INVALID_SLOT if the stack frame does not have variable with given slot number,
+    *     EXE_ERROR_UNSUPPORTED if the execution engine does not support this functionality
     */ 
 JITEXPORT OpenExeJpdaError get_local_var(
         JIT_Handle jit,
@@ -120,25 +112,22 @@
         );
 
 
-   /** 
+/** 
     * Sets the value of the bytecode local variable in given method stack frame.
-	*
-    * @param method     method in whose frame the variable is to be changed
-    * @param context    stack frame of the method describing its current execution state
-    *                   (at the point of thread suspension)
+    * @param method    method in whose frame the variable is to be changed
+    * @param context   stack frame of the method describing its current execution state
+    *     (at the point of thread suspension)
     * @param var_num    the variable's slot number
-    * @param var_type   the variable's type
-    * @param value_ptr  address of the new value for the variable
-	*
+    * @param var_type  the variable's type
+    * @param value_ptr address of the new value for the variable
     * @return
-    *     EXE_ERROR_NONE             on success.<br>
-    *     EXE_ERROR_INVALID_METHODID if the given method handle is invalid.<br>
+    *     EXE_ERROR_NONE on success
+    *     EXE_ERROR_INVALID_METHODID if the given method handle is invalid
     *     EXE_ERROR_INVALID_LOCATION if the execution engine does not support local variable access
-    *                                at current execution point in the method, 
-	*                                specified by the context.<br>
-    *     EXE_ERROR_TYPE_MISMATCH    if the variable with given slot is of different type.<br>
-    *     EXE_ERROR_INVALID_SLOT     if the stack frame does not have variable with given slot number.<br>
-    *     EXE_ERROR_UNSUPPORTED      if the execution engine does not support this functionality.
+    *         at current execution point in the method, specified by the context
+    *     EXE_ERROR_TYPE_MISMATCH if the variable with given slot is of different type,
+    *     EXE_ERROR_INVALID_SLOT if the stack frame does not have variable with given slot number,
+    *     EXE_ERROR_UNSUPPORTED if the execution engine does not support this functionality
     */ 
 JITEXPORT OpenExeJpdaError set_local_var(
         JIT_Handle jit,



Mime
View raw message