harmony-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From smish...@apache.org
Subject svn commit: r496237 [2/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/common.h
URL: http://svn.apache.org/viewvc/harmony/enhanced/drlvm/trunk/vm/include/open/common.h?view=diff&rev=496237&r1=496236&r2=496237
==============================================================================
--- harmony/enhanced/drlvm/trunk/vm/include/open/common.h (original)
+++ harmony/enhanced/drlvm/trunk/vm/include/open/common.h Sun Jan 14 22:22:34 2007
@@ -14,14 +14,18 @@
  *  See the License for the specific language governing permissions and
  *  limitations under the License.
  */
+/** 
+ * @author Aleksey Ignatenko 
+ * @version $Revision: 1.1.2.1.4.3 $
+ */  
 
 // excluding remarks: 
 #if defined (__INTEL_COMPILER)
-#pragma warning (disable:1684) // conversion from pointer to same-sized integral type (potential portability problem)
-#pragma warning (disable:279)  // controlling expression is constant
-#pragma warning (disable:444)  // destructor for base class is not virtual
-#pragma warning (disable:981)  // operands are evaluated in unspecified order
-#pragma warning (disable:181)  // argument is incompatible with corresponding format string conversion (in printf)
+#pragma warning (disable:1684)    // conversion from pointer to same-sized integral type (potential portability problem)
+#pragma warning (disable:279)    // controlling expression is constant
+#pragma warning (disable:444)   // destructor for base class is not virtual
+#pragma warning (disable:981) // operands are evaluated in unspecified order
+#pragma warning (disable:181) // argument is incompatible with corresponding format string conversion (in printf)
 #pragma warning (disable:1599) // declaration hides variable "dclazz" (declared at line NN)
 #endif // _MSC_VER
 
@@ -29,9 +33,7 @@
 #pragma warning (disable:4800)    // forcing value to bool 'true' or 'false' (performance warning)
 #endif
 
-/** 
- * Warning appears when local variable is defined and not used.
- */
+//Warning appears when local variable is defined and not used
 #if defined (__INTEL_COMPILER) && defined(__GNUC__)
 #pragma warning (disable:177)
 #define UNUSED
@@ -46,10 +48,7 @@
 #define UNUSED
 #endif // !__GNUC__
 
-/** 
- * Warning appears when function parameter is not used in 
- * function body.
- */
+//Warning appears when function parameter is not used in function body
 #if defined (__INTEL_COMPILER) && defined(__GNUC__)
 #pragma warning (disable:869)
 #define UNREF

Modified: harmony/enhanced/drlvm/trunk/vm/include/open/ee_em_intf.h
URL: http://svn.apache.org/viewvc/harmony/enhanced/drlvm/trunk/vm/include/open/ee_em_intf.h?view=diff&rev=496237&r1=496236&r2=496237
==============================================================================
--- harmony/enhanced/drlvm/trunk/vm/include/open/ee_em_intf.h (original)
+++ harmony/enhanced/drlvm/trunk/vm/include/open/ee_em_intf.h Sun Jan 14 22:22:34 2007
@@ -1,20 +1,23 @@
 /*
- * Licensed to the Apache Software Foundation (ASF) under one or more
- * 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
+ *  Licensed to the Apache Software Foundation (ASF) under one or more
+ *  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
  *
- *    http://www.apache.org/licenses/LICENSE-2.0
+ *     http://www.apache.org/licenses/LICENSE-2.0
  *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
+ *  Unless required by applicable law or agreed to in writing, software
+ *  distributed under the License is distributed on an "AS IS" BASIS,
+ *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing permissions and
+ *  limitations under the License.
  */
-  
+/** 
+ * @author Mikhail Y. Fursov
+ * @version $Revision: 1.1.2.1.4.4 $
+ */  
 #ifndef _EE_EM_H_
 #define _EE_EM_H_
 
@@ -41,9 +44,9 @@
    * The given method is called only once per JIT instance.
    * 
    * @param[in] jit   - the run-time JIT handle used at run-time to refer to 
-   *                    the given JIT instance
+   *                the given JIT instance
    * @param[in] name  - the persistent JIT name that the compiler uses to separate 
-   *                    its configuration settings from the ones of other JITs 
+   *                its configuration settings from the ones of other JITs 
    */
 JITEXPORT void JIT_init(JIT_Handle jit, const char* name);
 
@@ -83,18 +86,19 @@
    * by the <code>role</code> parameter.
    * The profile type and the profile collector are defined by the profile 
    * collector handle.
+
    *
    * @param[in] jit  - the JIT instance 
    * @param[in] pc   - the handle of the profile collector instance
    * @param[in] role - the role of JIT in profiling defining whether to collect 
-   *                   or to use the profile
+   *               or to use the profile
    *
    * @return  <code>TRUE</code> if JIT does profiling of the <code>pc</code> type 
-   *          according to the <code>role</code> parameter; <code>FALSE</code> if 
-   *          profiling is not supported.
+   *          according the <code>role</code> parameter, <code>FALSE</code> if profiling is not 
+   *          supported.
    *
    * @note The given method is optional. A JIT compiler without profiling
-   *       support does not need this method. 
+   *        support does not need this method. 
    */
 JITEXPORT bool JIT_enable_profiling(JIT_Handle jit, PC_Handle pc, EM_JIT_PC_Role role);
 
@@ -104,5 +108,4 @@
 
 
 #endif
-
 

Modified: harmony/enhanced/drlvm/trunk/vm/include/open/em_profile_access.h
URL: http://svn.apache.org/viewvc/harmony/enhanced/drlvm/trunk/vm/include/open/em_profile_access.h?view=diff&rev=496237&r1=496236&r2=496237
==============================================================================
--- harmony/enhanced/drlvm/trunk/vm/include/open/em_profile_access.h (original)
+++ harmony/enhanced/drlvm/trunk/vm/include/open/em_profile_access.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 Mikhail Y. Fursov
+ * @version $Revision: 1.1.2.2.4.4 $
+ */
 #ifndef _EM_PROFILE_ACCESS_H_
 #define _EM_PROFILE_ACCESS_H_
 
@@ -26,78 +29,62 @@
 #endif
 
 /**
- * Known profiler types. Each of the profilers
- * is represented with separate interface to 
- * create and to access to profiles.
- */
+  * Known profiler types. Each of the profilers
+  * is represented with separate interface to 
+  * create and to access to profiles.
+  */
 enum EM_PCTYPE {
-  
-/** 
- * Entry-backedge profiler.
- * Collects number execution counts for
- * methods entries and backedges if present.
- */
+    /**  Entry-backedge profiler
+      *  Collects number execution counts for
+      *  methods entries and backedges if present.
+      */
     EM_PCTYPE_ENTRY_BACKEDGE=1,
-/** 
- * Edge profiler.
- * Collects profile for method entry and 
- * all edges in <code>IR Control Flow Graph</code>.
- */
+    /**  Edge profiler.
+      *  Collects profile for method entry and 
+      *  all edges in IR Control Flow Graph
+      */
     EM_PCTYPE_EDGE=2,
-
-/** 
- * Value profiler.
- * Collects profile for each given instruction.
- */
+    /** Value profiler
+      * Collects profile for each given instruction
+      */
     EM_PCTYPE_VALUE=3
     
 };
 
-/** 
- * A EM interface used to access to profile collectors.
- */
+/** A EM interface used to access to profile collectors*/
 typedef struct EM_ProfileAccessInterface {
 
-/** 
- * Request profile collector type for specified profile collector handle.
- *
- *  @param  _this  - EM instance profile collector belongs to
- *  @param  pc     - profile collector handle we interested in
- *
- *  @return The type of profile collector.
- */
+    /** Request profile collector typ for specified profile collector handle 
+      *  @param  _this - EM instance profile collector belongs to
+      *  @param  pc    - profile collector handle we interested in
+      *  @return       - the type of profile collector
+      */
     EM_PCTYPE               (*get_pc_type) (
                                 EM_Handle _this,
                                 PC_Handle pc
                             );
 
-/** 
- * Request method profile from profile collector.
- *
- * @param _this     - EM instance profile collector belongs to
- * @param pc        - profile collector used to collect profile
- * @param mh        - method we asking profile for
- *
- * @return Method profile handle, that can be used to access
- *         to custom method profile properties with specialized 
- *         profile collector interface.
- */
+    /** Request method profile from profile collector
+      * @param _this     - EM instance profile collector belongs to
+      * @param pc        - profile collector used to collect profile
+      * @param mh        - method we asking profile for
+      * @return          - method profile handle, that can be used to access
+      *                    to custom method profile properties with 
+      *                    specialized profile collector interface
+      */
     Method_Profile_Handle   (*get_method_profile)(
                                 EM_Handle _this,
                                 PC_Handle pc,
                                 Method_Handle mh
                             );
 
- /** 
-  * Request profile collector of specified type and role for a JIT.
-  *
-  * @param _this          - EM instance profile collector belongs to
-  * @param profile_type   - the type of profile collector
-  * @param jh             - handle to JIT, profile collector created for
-  * @param jit_role       - the role of JIT: the user or supplier of profile
-  *
-  * @return  The handle to profile collector instance. 
-  */
+    /** Request profile collector of specified type and role for a JIT
+      * @param _this          - EM instance profile collector belongs to
+      * @param profile_type   - the type of profile collector
+      * @param jh             - handle to JIT, profile collector created for.
+      * @param jit_role       - the role of JIT: the user or supplier of profile
+      * @return               - the handle to profile collector instance 
+      */
 
     PC_Handle               (*get_pc)(
                                 EM_Handle _this,
@@ -112,138 +99,108 @@
     // All methods below could be moved into separate EB and Edge 
     // profiler collectors specific files.
 
-/** 
- * Create new entry-backedge profile for a method.
- * Only one profile per method can be created for a single 
- * profile collector instance. 
- */
+    /** Create new entry-backedge profile for a method
+      * Only one profile per method can be created for a single 
+      * profile collector instance 
+      */
     Method_Profile_Handle (*eb_profiler_create_profile) (PC_Handle ph, Method_Handle mh);
 
-/** 
- * Request the address of entry counter.
- * JIT configured to generate entry-backedge profile must 
- * emit the code to increment this counter every time a method called.
- */
+    /** Request the address of entry counter
+      * JIT configured to generate entry-backedge profile must 
+      * emit the code to increment this counter every time a method called
+      */
     void* (*eb_profiler_get_entry_counter_addr)(Method_Profile_Handle mph);
 
-/** 
- * Request the address of backedge counter.
- * JIT configured to generate entry-backedge profile must 
- * emit the code to increment this counter every time any backedge in
- * a method is called.
- */
+    /** Request the address of backedge counter
+      * JIT configured to generate entry-backedge profile must 
+      * emit the code to increment this counter every time any backedge in
+      * a method is called
+      */
     void* (*eb_profiler_get_backedge_counter_addr)(Method_Profile_Handle mph);
 
-/** 
- * Check if entry-backedge profiler is configured to work in synchronous mode
- * In synchronous mode JIT is responsible to emit checks that counter's limit
- * is reached for both entry and backedge counters. If limit is reached 
- * <code>eb_profiler_sync_mode_callback</code> must be called directly from 
- * managed code.
- * In asynchronous mode counters checks are done by profile collector in a 
- * separate thread.
- *
- * @sa eb_profiler_sync_mode_callback()
- */
+    /** Check if entry-backedge profiler is configured to work in synchronous mode
+      * In synchronous mode JIT is responsible to emit checks that counter's limit
+      * is reached for both entry and backedge counters. If limit is reached 
+      * eb_profiler_sync_mode_callback must be called directly from managed code
+      * In asynchronous mode counters checks are done by profile collector in a 
+      * separate thread.
+      * @see eb_profiler_sync_mode_callback()
+      */
     char (*eb_profiler_is_in_sync_mode)(PC_Handle pch);
 
-/** 
- * If profile collector is in <code>sync</code> mode 
- * JIT must call this method every time the counter limit is reached.
- *
- * @sa eb_profiler_is_in_sync_mode()
- */
+    /** If profile collector is in 'sync' mode (@see eb_profiler_is_in_sync_mode())
+      * JIT must call this method every time the counter limit is reached
+      */
     void (*eb_profiler_sync_mode_callback)(Method_Profile_Handle mph);
 
-/** 
- * @return The counter's limit for entry threshold for a given
- *         profile collector.
- */
+    /** Return the counter's limit for entry threshold for a given
+      * profile collector
+      */
     uint32 (*eb_profiler_get_entry_threshold)(PC_Handle pch);
 
-/** 
- * @return The counter's limit for backedge threshold for a given
- *         profile collector.
- */
+    /** Return the counter's limit for backedge threshold for a given
+      * profile collector
+      */
     uint32 (*eb_profiler_get_backedge_threshold)(PC_Handle pch);
 
 
 
     //EDGE profiler interface
 
-    /** 
-	 * Create an edge profile for a method. 
-     * Only one profile per method can be created for a single 
-     * profile collector instance.
-	 *
-     * @param ph               - edge profile collector handle
-     * @param mh               - method handle to create profile for
-     * @param numEdgeCounters  - number of edge counters in a method
-     * @param counterKeys      - the keys, or numbers, will be associated with 
-     *                           each counter. The key must be used to access to
-     *                           counter value
-     * @param checksum         - profile checksum
-	 *
-     * @return A handle to access method profile data.
-     */
+    /** Create an edge profile for a method. 
+      * Only one profile per method can be created for a single 
+      * profile collector instance 
+      * @param ph               - edge profile collector handle
+      * @param mh               - method handle to create profile for
+      * @param numEdgeCounters  - number of edge counters in a method
+      * @param counterKeys      - the keys, or numbers, will be associated with 
+      *                           each counter. The key must be used to access to
+      *                           counter value
+      * @param checksum         - profile checksum
+      * @return                 - a handle to access method profile data
+      */
     Method_Profile_Handle (*edge_profiler_create_profile) (PC_Handle ph, Method_Handle mh, uint32 numEdgeCounters, uint32* counterKeys, uint32 checkSum);
 
 
-    /** 
-	 * Return number of edge counters in profile.
-	 */
+    /** Return number of edge counters in profile */
     uint32 (*edge_profiler_get_num_counters)(Method_Profile_Handle mph);
 
-    /** 
-	 * Return profile checksum.
-	 */
+    /** Return profile checksum*/
     uint32 (*edge_profiler_get_checksum)(Method_Profile_Handle mph);
 
-    /** 
-	 * Return the address of counter associated with key.
-	 */
+    /** Return the address of counter associated with key*/
     void* (*edge_profiler_get_counter_addr)(Method_Profile_Handle mph, uint32 key);
 
-    /** 
-	 * Return the address of entry counter.
-	 */
+    /** Return the address of entry counter*/
     void* (*edge_profiler_get_entry_counter_addr)(Method_Profile_Handle mph);
 
-    /** 
-	 * Return the entry threshold for profile collector.
-     */
+    /** Return the entry threshold for profile collector
+      */
     uint32 (*edge_profiler_get_entry_threshold)(PC_Handle pch);
     
-    /** 
-	 * Return the edge threshold for profile collector.
-     */
-
+    /** Return the edge threshold for profile collector
+      */
     uint32 (*edge_profiler_get_backedge_threshold)(PC_Handle pch);
-    
-	// Value profiler interface
+    // Value profiler interface
 
-    /** 
-	 * Create an value profile for a method. 
-     * Only one profile per method can be created for a single 
-     * profile collector instance.
-	 *
-     * @param pch              - value profile collector handle
-     * @param mh               - method handle to create profile for
-     * @param numKeys          - number of instructions to be profiled
-     * @param keys             - the keys, or numbers, will be associated with 
-     *                           each instruction. The key must be used to access to
-     *                           instruction value
-     */
+    /** Create an value profile for a method. 
+    * Only one profile per method can be created for a single 
+    * profile collector instance 
+    * @param pch              - value profile collector handle
+    * @param mh               - method handle to create profile for
+    * @param numKeys          - number of instructions to be profiled
+    * @param keys             - the keys, or numbers, will be associated with 
+    *                           each instruction. The key must be used to access to
+    *                           instruction value
+    */
     Method_Profile_Handle (*value_profiler_create_profile) (PC_Handle pch, Method_Handle mh, uint32 numKeys, uint32* keys);
     
-    /** 
-	 * Update frequency or insert the new value of given instruction.
-     */
+    /** Update frequency or insert the new value of given instruction.
+      */
     void (*value_profiler_add_value)(Method_Profile_Handle mph, uint32 instructionKey, POINTER_SIZE_INT valueToAdd);
     
-    /** 
-	 * @return The maximum value(by frequency) of give instruction.
-     */
+    /** Return the maximum value(by frequency) of give instruction.
+      */
     POINTER_SIZE_INT (*value_profiler_get_top_value) (Method_Profile_Handle mph, uint32 instructionKey);
 
 
@@ -257,5 +214,4 @@
 
 
 #endif
-
 

Modified: harmony/enhanced/drlvm/trunk/vm/include/open/gc.h
URL: http://svn.apache.org/viewvc/harmony/enhanced/drlvm/trunk/vm/include/open/gc.h?view=diff&rev=496237&r1=496236&r2=496237
==============================================================================
--- harmony/enhanced/drlvm/trunk/vm/include/open/gc.h (original)
+++ harmony/enhanced/drlvm/trunk/vm/include/open/gc.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, Salikh Zakirov
+ * @version $Revision: 1.1.2.1.4.3 $
+ */  
 
 #ifndef _OPEN_GC_H
 #define _OPEN_GC_H
@@ -27,9 +31,9 @@
  *
  * This is a global include file which provides to the VM an interface to the
  * GC. This interface is the only supported interface that the VM should call
- * to talk to the GC. All routines in this C interface will begin with <code>gc_</code>.
+ * to talk to the GC. All routines in this C interface will begin with "gc_"
  *
- * The GC expects that there is a <code>vm_gc.h</code> file holding the only  
+ * The GC expects that there is a vm_gc.h file holding the only  
  * interface that the GC will use to talk to the VM.
  *
  * In order to eliminate dependency on certain types such as (VTable *) we 
@@ -49,7 +53,7 @@
 
 
 /**
- * <code>GCExport</code> is used to declare functions exported by GC.
+ * GCExport is used to declare functions exported by GC.
  */
 #ifndef PLATFORM_POSIX
 #ifdef BUILDING_VM
@@ -75,10 +79,13 @@
 
 #if defined(USE_GC_STATIC) || defined(BUILDING_GC)
 
-/** 
- * @name Routines to support the initialization and termination of GC
+/*
+ * *****
+ * *
+ * *  Routines to support the initialization and termination of GC.
+ * * 
+ * *****
  */
-//@{
 
 /**
  * Is called by VM to start GC initialization sequence.
@@ -90,8 +97,10 @@
  */
 GCExport void gc_init();
 
+
+
 /**
- * May be called at various points the VM decides are GC-safe.
+ * may be called at various points the VM decides are GC-safe.
  * The GC may ignore this, or it may force a root set enumeration, or it may
  * execute a full GC.
  *
@@ -105,13 +114,16 @@
 /**
  * If the GC supports a "bump-the-pointer" style allocation, where the GC's
  * thread-local information contains a "current" pointer and a "limit" pointer,
- * then it should return <code>TRUE</code>, and it should set <code>*offset_of_current</code>
- * to be the offset into the GC thread block of the "current" pointer, and similar for
- * <code>*offset_of_limit</code> and the "limit" pointer. If not, then it should return
- * <code>FALSE</code>.
+ * then it should return TRUE, and it should set *offset_of_current to be the
+ * offset into the GC thread block of the "current" pointer, and similar for
+ * *offset_of_limit and the "limit" pointer.  If not, then it should return
+ * FALSE.
  */
 GCExport Boolean gc_supports_frontier_allocation(unsigned *offset_of_current, unsigned *offset_of_limit);
 
+
+
+
 /**
  * This API is used by the VM to notify the GC that the
  * VM has completed bootstrapping and initialization, and 
@@ -119,19 +131,21 @@
  * live references.
  *
  * Prior to this function being called the GC might see some
- * strange sights such as <code>NULL</code> or incomplete vtables. The GC will
+ * strange sights such as NULL or incomplete vtables. The GC will
  * need to consider these as normal and work with the VM to ensure 
  * that bootstrapping works. This means that the GC will make few
  * demands on the VM prior to this routine being called.
  *
  * However, once called the GC will feel free to do 
  * stop-the-world collections and will assume that the entire
- * <code>gc_import.h</code> interface is available and fully functioning.
+ * gc_import.h interface is available and fully functioning.
  *
  * If this routine is called twice the result is undefined.
  */
 GCExport void gc_vm_initialized();
 
+
+
 /**
  * This is called once the VM has no use for the heap or the 
  * garbage collector data structures. The assumption is that the 
@@ -140,19 +154,21 @@
  * After this routine has been called the VM can not relie on any
  * data structures created by the GC.
  *
- * Errors: If <code>gc_enumerate_finalizable_objects</code> has been called and
- *         <code>gc_wrapup</code> gc discovers an object that has not had it
+ * Errors: If gc_enumerate_finalizable_objects has been called and
+ *         gc_wrapup gc discovers an object that has not had it
  *         finalizer run then it will attempt to report an error.
  */
 GCExport void gc_wrapup();
 
+
+
 /**
  * Is called by the VM to enumerate the root reference.
  */
 GCExport void gc_add_root_set_entry(Managed_Object_Handle *ref, Boolean is_pinned);
 
 /**
- * Resembles <code>gc_add_root_set_entry()</code> but is passed the address of a slot
+ * Resembles gc_add_root_set_entry() but is passed the address of a slot
  * containing a compressed reference.
  */
 GCExport void gc_add_compressed_root_set_entry(uint32 *ref, Boolean is_pinned);
@@ -160,20 +176,20 @@
 /**
  * Is called by the VM to enumerate weak root reference.
  *
- * @param slot          - a pointer to the slot, containing the weak root
- * @param is_pinned     - <code>TRUE</code> denotes that object pointed-to from this slot
- *                        should not be moved during garbage collection
- * @param is_short_weak - <code>TRUE</code> means that the weak root must be cleared
- *                        before object becomes eligible for finalization
+ * @param slot An pointer to the slot, containing the weak root
+ * @param is_pinned TRUE denotes that object pointed-to from this slot
+ *        should not be moved during garbage collection.
+ * @param is_short_weak TRUE means that the weak root must be cleared
+ *        before object becomes eligible for finalization.
  */
 GCExport void gc_add_weak_root_set_entry(Managed_Object_Handle *slot, 
     Boolean is_pinned, Boolean is_short_weak);
 
-/**
+/*
  * Enumerate a managed pointer.  
- * The pointer can be declared as pinned. The pointer can
+ * The pointer can be declared as pinned.  The pointer can
  * point to the managed heap or any other area where data can be stored: stack
- * or static fields. It is the responsibility of the GC to ignore pointers
+ * or static fields.  It is the responsibility of the GC to ignore pointers
  * that are not in the managed heap.
  *
  * @note Is this function needed for Java? -salikh
@@ -181,20 +197,22 @@
 GCExport void gc_add_root_set_entry_managed_pointer(void **slot,
                                                     Boolean is_pinned);
 
+
+
 /**
- * Call from the VM to the gc to enumerate an interior pointer. <code>**ref</code> is a
+ * Call from the VM to the gc to enumerate an interior pointer. **ref is a
  * slot holding a pointer into the interior of an object. The base of the
- * object is located at <code>*ref</code> - offset. The strategy employed is to place the
- * slot, the object base and the offset into a <code>slot_base_offset</code> table. We then
- * call <code>gc_add_root_set_entry</code> with the slot in the table holding the base of
+ * object is located at *ref - offset. The strategy employed is to place the
+ * slot, the object base and the offset into a slot_base_offset table. We then
+ * call gc_add_root_set_entry with the slot in the table holding the base of
  * the object. Upon completion of the garbage collection the routine
- * <code>fixup_interior_pointers</code> is called and the <code>slot_base_offset</code> table is
+ * fixup_interior_pointers is called and the slot_base_offset table is
  * traversed and the new interior pointer is calculated by adding the base of
- * the object and the offset. This new interior pointer value is then placed
+ * the object and the offset.  This new interior pointer value is then placed
  * into the slot.
  *
  * This routine can be called multiple times with the same interiour pointer
- * without any problems. The offset is checked to make sure it is positive but
+ * without any problems.  The offset is checked to make sure it is positive but
  * the logic is not dependent on this fact.
  *
  * @note Optional function, never called by Java virtual machine.
@@ -252,20 +270,20 @@
  * pointer to the object. If it is not able to allocate the object 
  * without invoking a GC then it returns NULL.
  *
- * @param size            - the size of the object to allocate. If the high bit
- *                          set then various constraints as described above are
- *                          placed on the allocation of this object.
- * @param type            - a pointer to the vtable of the class being 
- *                          allocated. This routine will place this value 
- *                          in the appropriate slot of the new object.
- * @param thread_pointer  - a pointer to the GC's thread-local space
- *
- * This is like <code>gc_malloc_or_null</code>, except that it passes a pointer to
- * the thread's GC-specific space as a third argument. This prevents
- * the GC from having to immediately call <code>vm_get_thread_curr_alloc_block()</code>
+ * @param size - the size of the object to allocate. If the high bit
+ *               set then various constraints as described above are
+ *               placed on the allocation of this object.
+ * @param type - a pointer to the vtable of the class being 
+ *                   allocated. This routine will place this value 
+ *                   in the appropriate slot of the new object.
+ * @param thread_pointer - a pointer to the GC's thread-local space.
+ *
+ * This is like gc_malloc_or_null, except that it passes a pointer to
+ * the thread's GC-specific space as a third argument.  This prevents
+ * the GC from having to immediately call vm_get_thread_curr_alloc_block()
  * as its first task.
  *
- * @note Rename of <code>gc_malloc_with_thread_pointer()</code>.
+ * @note rename of gc_malloc_with_thread_pointer()
  */
 GCExport Managed_Object_Handle gc_alloc_fast(unsigned size, 
                                              Allocation_Handle type,
@@ -275,15 +293,15 @@
  * This routine is used to allocate an object. See the above 
  * discussion on the overloading of size. {link allocation}
  *
- * @param size           - the size of the object to allocate. If the high bit
- *                         set then various constraints as described above are
- *                         placed on the allocation of this object.
- * @param type           - a pointer to the vtable of the class being allocated.
- *                         This routine will place this value in the 
- *                         appropriate slot of the new object.
- * @param thread_pointer - a pointer to the GC's thread-local space
+ * @param size - the size of the object to allocate. If the high bit
+ *               set then various constraints as described above are
+ *               placed on the allocation of this object.
+ * @param type - a pointer to the vtable of the class being allocated.
+ *                   This routine will place this value in the 
+ *                   appropriate slot of the new object.
+ * @param thread_pointer - a pointer to the GC's thread-local space.
  * 
- * @note Rename of <code>gc_malloc_or_null_with_thread_pointer()</code>.
+ * @note rename of gc_malloc_or_null_with_thread_pointer()
  */
 GCExport Managed_Object_Handle gc_alloc(unsigned size, 
                                         Allocation_Handle type,
@@ -293,19 +311,18 @@
 /**
  * For bootstrapping situations, when we still don't have
  * a class for the object. This routine is only available prior to 
- * a call to the call <code>gc_vm_initialized<code>. If it is called after
- * the call to <code>gc_vm_initialized</code> then the results are undefined. 
- * The GC places <code>NULL</code> in the vtable slot of the newly allocated
+ * a call to the call gc_vm_initialized. If it is called after
+ * the call to gc_vm_initialized then the results are undefined. 
+ * The GC places NULL in the vtable slot of the newly allocated
  * object.
  * 
  * The object allocated will be pinned, not finalizable and not an array.
  *
  * @param size - the size of the object to allocate. The high bit
  *               will never be set on this argument.
+ * @return The newly allocated object
  *
- * @return The newly allocated object.
- *
- * @note Will be renamed to <code>gc_alloc_pinned_noclass()</code> to comply with 
+ * @note Will be renamed to gc_alloc_pinned_noclass() to comply with 
  *       accepted naming conventions.
  */
 GCExport Managed_Object_Handle gc_pinned_malloc_noclass(unsigned size);
@@ -318,34 +335,45 @@
 GCExport Managed_Object_Handle gc_alloc_pinned(unsigned size, Allocation_Handle type, void *thread_pointer);
 
 
-//@}
-/** @name Routines to support write barriers
- */
-//@{
 
 
+/*
+ * *****
+ * *
+ * *  Routines to support write barriers.
+ * * 
+ * *****
+ */
+
 /**
- * @return <code>TRUE</code> if the GC requires write barriers before every store to
- *         a field of a reference type.
+ * Returns TRUE if the GC requires write barriers before every store to
+ * a field of a reference tpe.
  */
 GCExport Boolean gc_requires_barriers();
 
-//@}
-/** @name Routines to support threads
- */
-//@{
 
 
+/*
+ * *****
+ * *
+ * *  Routines to support threads.
+ * * 
+ * *****
+ */
+
 /**
  * This routine is called during thread startup to set
  * an initial nursery for the thread.
  *
- * @note <code>gc_thread_init</code> and <code>gc_thread_kill</code> assume that
- *       the current thread is the one we are interested in. If we passed in the 
- *       thread then these things could be cross inited and cross killed.
+ * @note gc_thread_init and gc_thread_kill assume that
+ *           the current thread is the one we are interested in
+ *           If we passed in the thread then these things could be
+ *           cross inited and cross killed.
  */
 GCExport void gc_thread_init(void *gc_information);
 
+
+
 /**
  * This is called just before the thread is reclaimed.
  */
@@ -361,7 +389,7 @@
  * This function signals VM to obtain thread lock and start thread iteration.
  *
  * \li vm obtains thread lock
- * \li vm repeatedly calls <code>gc_iterate_thread(thread)</code>
+ * \li vm repeatedly calls gc_iterate_thread(thread)
  * \li vm releases thread lock
  *
  * @note Not implemented.
@@ -370,15 +398,15 @@
  
 /**
  * VM calls this method repeatedly to iterate over the list of java threads,
- * initiated earlier by calling <code>vm_iterate_threads()</code>.
+ * initiated earlier by calling vm_iterate_threads()
  *
  * Thread creation and termination is locked during this iteration.
  *
  * gc may do one of the following:
  * 1. store thread handle for later use 
  * 2. enumerate thread right now, while
- *    holding thread lock (using <code>vm_suspend_thread(thread)</code> and
- *    <code>vm_enumerate_thread_root_set(thread)</code>).
+ * holding thread lock (using vm_suspend_thread(thread) and
+ * vm_enumerate_thread_root_set(thread)).
  *
  * @note Not implemented.
  */
@@ -397,13 +425,13 @@
  *
  * GC calls this VM function when it wants a thread
  * to be suspended for stack enumeration or 
- * read/write barrier change.
+ * read/write barrier change
  * 
- * blocks until synchronously call <code>gc_thread_suspended(thread)</code> 
+ * blocks until synchronously call gc_thread_suspended(thread) 
  * or asynchronously delegate enumeration to thread
  * (self-enumeration)
  *
- * @note We need a way to signal that process of thread suspension
+ * @note we need a way to signal that process of thread suspension
  *       is complete.
  *
  * @note Not implemented.
@@ -414,19 +442,19 @@
  * VM calls this GC callback when it's accomplished the requested
  * operation of suspending a thread in gc-safe point
  *
- * May be called synchronously from the same context
- * as <code>vm_suspend_thread()</code> in case of cross-enumeration, or
+ * may be called synchronously from the same context
+ * as vm_suspend_thread() in case of cross-enumeration, or
  * may be called asynchronously from the specified
- * thread context in case of self-enumeration.
+ * thread context in case of self-enumeration
  *
- * After this function completes, 
- * the thread is resumed automatically.
+ * after this function completes, 
+ * the thread is resumed automatically
  *
  * GC is expected to call a limited subset 
  * of GC-VM interface functions from this callback:
- * \li <code>vm_enumerate_thread_root_set(thread)</code>
- * \li <code>vm_install_write_barrier(...)</code>  
- *     (hypothetical, not designed yet)
+ * \li vm_enumerate_thread_root_set(thread)
+ * \li vm_install_write_barrier(...)  
+ *   (hypothetical, not designed yet)
  * \li make a thread stack snapshot for later analysis
  *
  * @note Not implemented.
@@ -435,9 +463,9 @@
 
 /**
  * GC calls this function to command VM to enumerate a thread,
- * which was earlier suspenden using <code>vm_suspend_thread()</code>.
+ * which was earlier suspenden using vm_suspend_thread().
  *
- * In response to this call, VM repeatedly calls <code>gc_add_root_set_entry()</code> to
+ * In response to this call, VM repeatedly calls gc_add_root_set_entry() to
  * enumerate thread stacks and local handles
  *
  * @note Not implemented.
@@ -447,7 +475,7 @@
 /**
  * GC calls this function to command VM to enumerate global slots.
  *
- * During enumeration of global root set, either all threads need 
+ * during enumeration of global root set, either all threads need 
  * to be suspended, or write barrier installed.
  *
  * Apparently some operations should be blocked in VM, like class loading,
@@ -456,20 +484,25 @@
  * this function or introduce new system-wide lock on operations that
  * change the number of global reference slots.
  *
- * This function calls <code>gc_add_root_set_entry()</code> for all global reference
+ * this function calls gc_add_root_set_entry() for all global reference
  * slots.
  *
  * @note Not implemented.
  */
 VMEXPORT void vm_enumerate_global_root_set();
-//@}
-/** @name Routines to support the functionality required by the Java language specification
+
+
+/*
+ * *****
+ * *
+ * *  Routines to support the functionality required by the Java language specification.
+ * * 
+ * *****
  */
-//@{
 
 /**
  * API for the VM to force a GC, typically in response to a call to 
- * <code>java.lang.Runtime.gc</code>.
+ * java.lang.Runtime.gc
  */
 GCExport void gc_force_gc();
 
@@ -477,27 +510,26 @@
 
 /**
  * API for the VM to determine the current GC heap size, typically in response to a
- * call to <code>java.lang.Runtime.totalMemory</code>.
+ * call to java.lang.Runtime.totalMemory
  */
 GCExport int64 gc_total_memory();
 
 /**
  * API for the VM to determine the maximum GC heap size, typically in response to a
- * call to <code>java.lang.Runtime.maxMemory</code>.
+ * call to java.lang.Runtime.maxMemory
  */
 GCExport int64 gc_max_memory();
 
 
 /**
  * API for the VM to get an approximate view of the free space, 
- * typically in response to a call to <code>java.lang.Runtime.freeMemory</code>.
+ * typically in response to a call to java.lang.Runtime.freeMemory
  */
 GCExport int64 gc_free_memory();
 
 
 /**
- * @return <code>TRUE</code> if the object is pinned.
- *
+ * returns TRUE if the object is pinned.
  * Routine to support the functionality required by JNI to see if an object is pinned.
  */
 GCExport Boolean gc_is_object_pinned (Managed_Object_Handle obj);
@@ -523,8 +555,8 @@
 
 #else /* #if defined(USE_GC_STATIC) || defined(BUILDING_GC) */
 
-/**
- * The below variables are used in the runtime dynamic linking of
+/*
+ * the below variables are used in the runtime dynamic linking of
  * garbage collector with virtual machine executable.
  */
 
@@ -572,11 +604,11 @@
 
 
 /**
- * Granularity of object alignment.
+ * granularity of object alignment.
  *
  * Objects are aligned on 4 or 8 bytes. If they are aligned on 8 bytes then
  * Arrays will be required to start on the indicated alignement. This means that
- * for 8 byte alignment on the IA32 the header will look like this:
+ * for 8 byte alignment on the IA32 the header will look like this
  *
  * uint32 gc_header_lock_hash
  * VTable *vt
@@ -595,7 +627,7 @@
 #if !defined(USE_GC_STATIC) && !defined(BUILDING_GC)
 
 /*
- * The below variables are used in the runtime dynamic linking of
+ * the below variables are used in the runtime dynamic linking of
  * garbage collector with virtual machine executable.
  */
 
@@ -618,7 +650,7 @@
 
 /* 
  * The variables below are exported by the VM so other DLLs modules
- * may use them. <code>dll_gc.cpp</code> initializes them to the addresses exported
+ * may use them. dll_gc.cpp initializes them to the addresses exported
  * by GC DLL.
  */
 
@@ -629,20 +661,25 @@
 
 #else // USE_GC_STATIC
 
-//@}
-/** @name Routines to support various write barriers
+
+/*
+ * *****
+ * *
+ * *  Routines to support various write barriers.
+ * * 
+ * *****
  */
-//@{
+
 
 /**
- * @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.
  */
 GCExport Boolean gc_supports_compressed_references();
 
 /**
  * These interfaces are marked for replacement for the IPF by the following
- * <code>gc_heap_write_mumble</code> interface.
+ * gc_heap_write_mumble interface.
  *
  * @deprecated Will be removed soon.
  */
@@ -658,7 +695,7 @@
 
 
 /**
- * By calling this function VM notifies GC that a heap reference was written to
+ * by calling this function VM notifies GC that a heap reference was written to
  * global slot.
  *
  * There are some global slots that are shared by different threads. Write
@@ -716,8 +753,8 @@
 GCExport int32 gc_get_hashcode (Managed_Object_Handle object);
 
 /**
- * Get object hashcode.
- */
+ *  * Get object hashcode
+ *   */
 GCExport int32 gc_get_hashcode (Managed_Object_Handle p_object);
 
 /**
@@ -728,12 +765,12 @@
 
 /**
  * Iterates all objects in the heap.
- * This function calls <code>vm_iterate_object()</code> for each
+ * This function calls vm_iterate_object() for each
  * iterated object.
  * Used for JVMTI Heap Iteration.
  * Should be called only in stop-the-world setting
  *
- * @see <code>vm_gc.h#vm_iterate_object()</code>
+ * @see vm_gc.h#vm_iterate_object()
  */
 GCExport void gc_iterate_heap();
 
@@ -743,28 +780,30 @@
 GCExport void gc_finalize_on_exit();
 
 
-//@}
-/** @name Routines to support soft, weak, and phantom reference objects
+/*
+ * *****
+ * *
+ * *  Routines to support soft, weak, and phantom reference objects.
+ * * 
+ * *****
  */
-//@{
-
 
 // XXX move this elsewhere -salikh
 #ifdef JNIEXPORT
 /**
  * reference   - the reference object to register.
  * referent    - the referent of the reference object that is to be
- *               retrieved with the get method.
+ *                      retrieved with the get method.
  *
  * The weak reference code written in Java and the support code provide by the
- * VM must agree on what the layout of a <code>Java.lang.ref.Reference</code> object looks
+ * VM must agree on what the layout of a Java.lang.ref.Reference object looks
  * like and agree that any subclassing will only append fields to the agreed
- * upon layout. This seems reasonable.
+ * upon layout.  This seems reasonable.
  *
  * In addition the support code will have exclusive knowledge and control of a
- * single field (called <code>the_referent</code>) which holds the reference to the target
- * object. The java code will assume that this field is a read only integer
- * and should not be traced by the gc. The <code>Java.lang.ref.ReferenceQueue</code> layout
+ * single field (called the_referent) which holds the reference to the target
+ * object.  The java code will assume that this field is a read only integer
+ * and should not be traced by the gc. The Java.lang.ref.ReferenceQueue layout
  * needs to also be known by the supporting code so that it can move reference
  * objects onto the queues at the appropriate times. The Java code uses normal
  * mechanisms to load the Reference classes and to create a reference.
@@ -772,10 +811,9 @@
  * The constructor code however needs to call the appropriate register function
  * listed below based upon whether we have a soft, weak, or phantom reference.
  * The VM support code will fill in the referent field. The routine
- * <code>gc_get_referent</code> will return the value in this field.
- *
- * @note The phantom reference method get will not use the <code>gc_get_referent</code> 
- *       but instead just return <code>NULL</code> as required by the spec.
+ * gc_get_referent will return the value in this field.  Note that the phantom
+ * reference method get will not use the gc_get_referent but instead just
+ * return NULL as required by the spec.
  * 
  * @note XXX Why are they in gc_export.h? -salikh
  */
@@ -811,14 +849,14 @@
 GCExport unsigned int gc_time_since_last_gc();
 
 /**
- * @return The base address of the heap.
+ * @return the base address of the heap.
  *
- * API for VM to determine the starting and ending adddresses of the heap.
+ * API for VM to determine the starting and ending adddresses of the heap
  */
 GCExport void *gc_heap_base_address();
 
 /**
- * @return The top address of the heap.
+ * @return the top address of the heap.
  */
 GCExport void *gc_heap_ceiling_address();
 
@@ -832,6 +870,9 @@
 /**
  * \page gc_finalization_and_weak_refs Finalization and weak references design in GC
  *
+ * @author Salikh Zakirov
+ * @version written on 2005-05-31
+ *
  * \section gc_finalization Finalization
  *
  * According to the JVM specification, VM must call non-trivial finalization methods
@@ -843,12 +884,11 @@
  * phantom reference strengh, however, without requiring any particular interaction
  * from them. (In the code we sometimes refer to weak references as <i>short weak
  * references<i>, and call JNI weak global references <i>long weak references</i>.
- *
- * @sa <code>gc_add_weak_root_set_entry()</code> for more details
+ * See gc_add_weak_root_set_entry() for more details).
  *
  * The requirements described above can be met using following algorithm.
  * \li All weak reference classes can be identified on the stage of class preparation,
- *     when VM calls <code>gc_class_prepared()</code> callback.
+ *     when VM calls gc_class_prepared() callback.
  * \li We start marking with regular (strong) roots, and traverse only strong references.
  *     During the process of marking all objects of the reference classes are collected
  *     to the reference lists. As we traverse only strong references, only strongly reachable
@@ -880,7 +920,7 @@
  * \li Long weak roots are handled in exactly the same way as short weak roots.
  * \li Note, that as the references are cleared, they are also added to the list
  *     of references to be enqueued. This list is later transferred to the VM
- *     using <code>vm_enqueue_reference()</code> function.
+ *     using vm_enqueue_reference() function.
  * \li Weak reference objects require special handling of their referent field,
  *     because it needs to be reported as an updatable slot before compaction.
  *     This is performed as a last step, when we have a guarantee that all
@@ -891,37 +931,40 @@
  * Current implementation of weak references places the following requirements
  * \li All reference objects must have exactly one non-regulur object reference,
  *     and this reference must be at the same offset for references of all types.
- *     GC calls <code>class_is_reference()</code> to find out whether the class represents
+ *     GC calls class_is_reference() to find out whether the class represents
  *     weak reference and finds out the referent offset by calling VM function 
- *     <code>class_get_referent_offset()</code>. Note, that referent offset being constant
+ *     class_get_referent_offset(). Note, that referent offset being constant
  *     for all kinds of references is not enforced by this interface.
- * \li VM must not enqueue references during call of <code>vm_enqueue_reference()</code>
+ * \li VM must not enqueue references during call of vm_enqueue_reference()
  *     because this may lead to deadlocks on reference queue monitors due
- *     to the fact that <code>vm_enqueue_reference()</code> is called during stop-the-world
+ *     to the fact that vm_enqueue_reference() is called during stop-the-world
  *     phase of garbage collection.
  */
 
 
 /**
- * \page gc_vm_interface GC-VM interface
- *
- * The interface between garbage collector and virtual machine is
- * bidirectional:
- * <UL>
- * <LI>gc.h contains functions, which GC exports for use in VM.
- * <LI><code>vm_gc.h</code> contains VM functions which are available to GC during its
- * operation.
- * </UL>
- *  
- * A number of conventions exist, which are not easily expressed as C++ header
- * files. These include:
- * <UL>
- * <LI>Thread local nurseries, see gc_supports_frontier_allocation().
- * <LI>Read and Write barrier interface, gc_heap_write_ref() and others.
- * </UL>
- *
- * The conceptual overview of the interface is given in @link guide GC Writers'
- * guide @endlink
- */
+\page gc_vm_interface GC-VM interface
+
+@author Salikh Zakirov
+@version 2005-05-31
+
+The interface between garbage collector and virtual machine is
+bidirectional:
+<UL>
+<LI>gc.h contains functions, which GC exports for use in VM.
+<LI>vm_gc.h contains VM functions which are available to GC during its
+operation.
+</UL>
+
+A number of conventions exist, which are not easily expressed as C++ header
+files. These include:
+<UL>
+<LI>Thread local nurseries, see gc_supports_frontier_allocation().
+<LI>Read and Write barrier interface, gc_heap_write_ref() and others.
+</UL>
+
+The conceptual overview of the interface is given in @link guide GC Writers'
+guide @endlink
+*/
 
 #endif // _OPEN_GC_H

Modified: harmony/enhanced/drlvm/trunk/vm/include/open/hycomp.h
URL: http://svn.apache.org/viewvc/harmony/enhanced/drlvm/trunk/vm/include/open/hycomp.h?view=diff&rev=496237&r1=496236&r2=496237
==============================================================================
--- harmony/enhanced/drlvm/trunk/vm/include/open/hycomp.h (original)
+++ harmony/enhanced/drlvm/trunk/vm/include/open/hycomp.h Sun Jan 14 22:22:34 2007
@@ -18,54 +18,36 @@
 #if !defined(hycomp_h)
 #define hycomp_h
 
-/**
- * USE_PROTOTYPES:         Use full ANSI prototypes.
- *
- * CLOCK_PRIMS:            We want the timer/clock prims to be used
- *
- * LITTLE_ENDIAN:          This is for the intel machines or other
- *                         little endian processors. Defaults to big endian.
- *
- * NO_LVALUE_CASTING:      This is for compilers that don't like the left side
- *                         of assigns to be cast.  It hacks around to do the
- *                         right thing.
- *
- * ATOMIC_FLOAT_ACCESS:    So that float operations will work.
- *
- * LINKED_USER_PRIMITIVES: Indicates that user primitives are statically linked
- *                         with the VM executeable.
- *
- * OLD_SPACE_SIZE_DIFF:    The 68k uses a different amount of old space.
- *                         This "legitimizes" the change.
- *
- * SIMPLE_SIGNAL:          For machines that don't use real signals in C.
- *                         (eg: PC, 68k)
- *
- * OS_NAME_LOOKUP:         Use nlist to lookup user primitive addresses.
- *
- * VMCALL:                 Tag for all functions called by the VM.
- *
- * VMAPICALL:              Tag for all functions called via the PlatformFunction
- *                         callWith: mechanism.
- *      
- * SYS_FLOAT:              For some math functions where extended types (80 or 96 bits) are returned
- *                         Most platforms return as a double
- *
- * FLOAT_EXTENDED:         If defined, the type name for extended precision floats.
- *
- * PLATFORM_IS_ASCII:      Must be defined if the platform is ASCII
- *
- * EXE_EXTENSION_CHAR:     the executable has a delimiter that we want to stop at as part of argv[0].
- *
- * By default order doubles in the native (that is big/little endian) ordering. 
- */
-
+/*
+USE_PROTOTYPES:       Use full ANSI prototypes.
+CLOCK_PRIMS:          We want the timer/clock prims to be used
+LITTLE_ENDIAN:        This is for the intel machines or other
+                      little endian processors. Defaults to big endian.
+NO_LVALUE_CASTING:    This is for compilers that don't like the left side
+                      of assigns to be cast.  It hacks around to do the
+                      right thing.
+ATOMIC_FLOAT_ACCESS:  So that float operations will work.
+LINKED_USER_PRIMITIVES: Indicates that user primitives are statically linked
+                        with the VM executeable.
+OLD_SPACE_SIZE_DIFF:  The 68k uses a different amount of old space.
+                      This "legitimizes" the change.
+SIMPLE_SIGNAL:        For machines that don't use real signals in C.
+                      (eg: PC, 68k)
+OS_NAME_LOOKUP:       Use nlist to lookup user primitive addresses.
+VMCALL:               Tag for all functions called by the VM.
+VMAPICALL:            Tag for all functions called via the PlatformFunction
+                      callWith: mechanism.
+      
+SYS_FLOAT:  For some math functions where extended types (80 or 96 bits) are returned
+            Most platforms return as a double
+FLOAT_EXTENDED: If defined, the type name for extended precision floats.
+PLATFORM_IS_ASCII: Must be defined if the platform is ASCII
+EXE_EXTENSION_CHAR: the executable has a delimiter that we want to stop at as part of argv[0].
+*/
+/* By default order doubles in the native (i.e. big/little endian) ordering. */
 #define HY_PLATFORM_DOUBLE_ORDER
 #if defined(LINUX)
-
-/**
- * @note Linux supports different processors - do not assume 386. 
- */
+/* NOTE: Linux supports different processors -- do not assume 386 */
 #if defined(LINUXPPC64) || defined(POINTER64)
 #define DATA_TYPES_DEFINED
 typedef unsigned long int UDATA;        /* 64bits */
@@ -96,9 +78,7 @@
 #define DIR_SEPARATOR '/'
 #define DIR_SEPARATOR_STR "/"
 
-/**
- * No priorities on Linux 
- */
+/* no priorities on Linux */
 #define HY_PRIORITY_MAP {0,0,0,0,0,0,0,0,0,0,0,0}
 
 #if (defined(LINUXPPC) && !defined(LINUXPPC64))
@@ -109,9 +89,7 @@
 #define GLOBAL_DATA(symbol) ((void*)&(symbol))
 #define GLOBAL_TABLE(symbol) GLOBAL_DATA(symbol)
 
-/**
- * Win32 - Windows 3.1 & NT using Win32 
- */
+/* Win32 - Windows 3.1 & NT using Win32 */
 #if defined(WIN32)
 
 typedef __int64 I_64;
@@ -126,17 +104,9 @@
 #define DIR_SEPARATOR '\\'
 #define DIR_SEPARATOR_STR "\\"
 
-/** 
- * Modifications for the Alpha running WIN-NT 
- */
-
+/* Modifications for the Alpha running WIN-NT */
 #if defined(_ALPHA_)
-#undef small 
-
-/**
- * Defined as char in rpcndr.h 
- */
-
+#undef small                    /* defined as char in rpcndr.h */
 typedef double FLOAT_EXTENDED;
 #endif
 
@@ -160,39 +130,26 @@
 #define VMAPICALL
 #endif
 #define PVMCALL VMCALL *
-
-/**
- * Provide some reasonable defaults for the VM types:
- * <ul>
- * <li><code>UDATA</code>        - unsigned data, can be used as an integer or 
- *                                 pointer storage</li>
- * <li><code>IDATA</code>        - signed data, can be used as an integer or 
- *                                 pointer storage</li>
- * <li><code>U_64 / I_64</code>  - unsigned/signed 64 bits</li>
- * <li><code>U_32 / I_32</code>  - unsigned/signed 32 bits</li>
- * <li><code>U_16 / I_16</code>  - unsigned/signed 16 bits</li>
- * <li><code>U_8 / I_8</code>    - unsigned/signed 8 bits (bytes -- not to be 
- *                                 confused with char)</li>
- * <li><code>BOOLEAN</code>      - something that can be zero or non-zero</li>
- * </ul>
- */
+/* Provide some reasonable defaults for the VM "types":
+  UDATA     unsigned data, can be used as an integer or pointer storage.
+  IDATA     signed data, can be used as an integer or pointer storage.
+  U_64 / I_64 unsigned/signed 64 bits.
+  U_32 / I_32 unsigned/signed 32 bits.
+  U_16 / I_16 unsigned/signed 16 bits.
+  U_8 / I_8   unsigned/signed 8 bits (bytes -- not to be confused with char)
+  BOOLEAN something that can be zero or non-zero.
+*/
 #if !defined(DATA_TYPES_DEFINED)
 typedef unsigned int UDATA;
 typedef unsigned int U_32;
 typedef unsigned short U_16;
 typedef unsigned char U_8;
-/** 
- * No generic U_64 or I_64. 
- */
+/* no generic U_64 or I_64 */
 typedef int IDATA;
 typedef int I_32;
 typedef short I_16;
 typedef char I_8;
-
-/**
- * Don't typedef <code>BOOLEAN</code> since it's already def'ed on Win32. 
- */
-
+/* don't typedef BOOLEAN since it's already def'ed on Win32 */
 #endif
 #ifdef LINUX
 #define BOOLEAN UDATA
@@ -203,22 +160,12 @@
 #endif
 
 #if !defined(HY_DEFAULT_SCHED)
-
-/**
- * By default, pthreads platforms use the <code>SCHED_OTHER</code> thread 
- * scheduling policy. 
- */
-
+/* by default, pthreads platforms use the SCHED_OTHER thread scheduling policy */
 #define HY_DEFAULT_SCHED SCHED_OTHER
 #endif
 
 #if !defined(HY_PRIORITY_MAP)
-
-/** 
- * If no priority map if provided, priorities will be determined 
- * algorithmically. 
- */
-
+/* if no priority map if provided, priorities will be determined algorithmically */
 #endif
 
 #if !defined(FALSE)
@@ -243,29 +190,17 @@
 #define PROTOTYPE(x)  ()
 #define VARARGS
 #endif
-
-/** 
- * Assign the default line delimiter, if it was not set. 
- */
-
+/* Assign the default line delimiter if it was not set */
 #if !defined(PLATFORM_LINE_DELIMITER)
 #define PLATFORM_LINE_DELIMITER "\015\012"
 #endif
-
-/**
- * Set the max path length, if it was not set. 
- */
-
+/* Set the max path length if it was not set */
 #if !defined(MAX_IMAGE_PATH_LENGTH)
 #define MAX_IMAGE_PATH_LENGTH (2048)
 #endif
 typedef double ESDOUBLE;
 typedef float ESSINGLE;
-
-/** 
- * Helpers for U_64s. 
- */
-
+/* helpers for U_64s */
 #define CLEAR_U64(u64)  (u64 = (U_64)0)
 #define LOW_LONG(l) (*((U_32 *) &(l)))
 #define HIGH_LONG(l)  (*(((U_32 *) &(l)) + 1))
@@ -285,11 +220,7 @@
 #define CLASSP(x)   ((Class *) (x))
 #define CLASSPP(x)  ((Class **) (x))
 #define BYTEP(x)    ((BYTE *) (x))
-
-/**
- * Test - was conflicting with OS2.h 
- */
-
+/* Test - was conflicting with OS2.h */
 #define ESCHAR(x)   ((CHARACTER) (x))
 #define FLT(x)      ((FLOAT) x)
 #define FLTP(x)     ((FLOAT *) (x))
@@ -331,11 +262,7 @@
 #define LFLT(x)     FLT((x))
 #define LFLTP(x)    FLTP((x))
 #endif
-
-/**
- * Macros for converting between words and longs and accessing bits. 
- */
-
+/* Macros for converting between words and longs and accessing bits */
 #define HIGH_WORD(x)  U16(U32((x)) >> 16)
 #define LOW_WORD(x)   U16(U32((x)) & 0xFFFF)
 #define LOW_BIT(o)    (U32((o)) & 1)
@@ -351,39 +278,24 @@
 #define HY_CFUNC
 #define HY_CDATA
 #endif
-
-/**
- * Macros for tagging functions which read/write the vm thread. 
- */
-
+/* Macros for tagging functions which read/write the vm thread */
 #define READSVMTHREAD
 #define WRITESVMTHREAD
 #define REQUIRESSTACKFRAME
-
-/**
- * Macro for tagging functions, which never return. 
- */
-
+/* macro for tagging functions which never return */
 #if defined(__GNUC__)
-
-/** 
- * On GCC, we can actually pass this information on to the compiler. 
- */
-
+/* on GCC, we can actually pass this information on to the compiler */
 #define NORETURN __attribute__((noreturn))
 #else
 #define NORETURN
 #endif
-
-/**
- * On some systems <code>va_list</code> is an array type. This is probably in
- * violation of the ANSI C spec, but it's not entirely clear. Because of this, 
- * we end up with an undesired extra level of indirection if we take the address 
- * of a <code>va_list</code> argument. 
+/* on some systems va_list is an array type.  This is probably in
+ * violation of the ANSI C spec, but it's not entirely clear.  Because of this, we end
+ * up with an undesired extra level of indirection if we take the address of a
+ * va_list argument. 
  *
- * To get it right, always use the <code>VA_PTR</code> macro.
+ * To get it right ,always use the VA_PTR macro
  */
-
 #if !defined(VA_PTR)
 #define VA_PTR(valist) (&valist)
 #endif
@@ -394,11 +306,7 @@
 #if !defined(TOC_STORE_TOC)
 #define TOC_STORE_TOC(dest,wrappedPointer)
 #endif
-
-/**
- * Macros for accessing I_64 values. 
- */
-
+/* Macros for accessing I_64 values */
 #if defined(ATOMIC_LONG_ACCESS)
 #define PTR_LONG_STORE(dstPtr, aLongPtr) ((*U32P(dstPtr) = *U32P(aLongPtr)), (*(U32P(dstPtr)+1) = *(U32P(aLongPtr)+1)))
 #define PTR_LONG_VALUE(dstPtr, aLongPtr) ((*U32P(aLongPtr) = *U32P(dstPtr)), (*(U32P(aLongPtr)+1) = *(U32P(dstPtr)+1)))
@@ -406,19 +314,11 @@
 #define PTR_LONG_STORE(dstPtr, aLongPtr) (*(dstPtr) = *(aLongPtr))
 #define PTR_LONG_VALUE(dstPtr, aLongPtr) (*(aLongPtr) = *(dstPtr))
 #endif
-
-/** 
- * Macro used when declaring tables which require relocations.
- */
-
+/* Macro used when declaring tables which require relocations.*/
 #if !defined(HYCONST_TABLE)
 #define HYCONST_TABLE const
 #endif
-
-/**
- * ANSI qsort is not always available. 
- */
-
+/* ANSI qsort is not always available */
 #if !defined(HY_SORT)
 #define HY_SORT(base, nmemb, size, compare) qsort((base), (nmemb), (size), (compare))
 #endif

Modified: harmony/enhanced/drlvm/trunk/vm/include/open/hythread_ext.h
URL: http://svn.apache.org/viewvc/harmony/enhanced/drlvm/trunk/vm/include/open/hythread_ext.h?view=diff&rev=496237&r1=496236&r2=496237
==============================================================================
--- harmony/enhanced/drlvm/trunk/vm/include/open/hythread_ext.h (original)
+++ harmony/enhanced/drlvm/trunk/vm/include/open/hythread_ext.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
  * 
@@ -296,12 +296,11 @@
 int VMCALL hythread_is_daemon(hythread_t thread) ;
 
 
- //@}
- /**
-  * TM Thread states constants. They are compatible with JVMTI.
-  */
-//@{
-
+/**
+ * //@}
+ * TM Thread states constants. They are compatible with JVMTI.
+ * //@{
+ */
 #define TM_THREAD_STATE_ALIVE JVMTI_THREAD_STATE_ALIVE  // 0x0001 Thread is alive. Zero if thread is new (not started) or terminated.  
 #define TM_THREAD_STATE_TERMINATED JVMTI_THREAD_STATE_TERMINATED // 0x0002Thread has completed execution.  
 #define TM_THREAD_STATE_RUNNABLE JVMTI_THREAD_STATE_RUNNABLE // 0x0004 Thread is runnable.  

Modified: harmony/enhanced/drlvm/trunk/vm/include/open/jthread.h
URL: http://svn.apache.org/viewvc/harmony/enhanced/drlvm/trunk/vm/include/open/jthread.h?view=diff&rev=496237&r1=496236&r2=496237
==============================================================================
--- harmony/enhanced/drlvm/trunk/vm/include/open/jthread.h (original)
+++ harmony/enhanced/drlvm/trunk/vm/include/open/jthread.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,26 +14,26 @@
  *  See the License for the specific language governing permissions and
  *  limitations under the License.
  */
-
+/**
+ * @author Andrey Chernyshev
+ * @version $Revision$
+ */
 
 #ifndef _OPEN_THREAD_GENERIC_H
 #define _OPEN_THREAD_GENERIC_H
 
 /**
- * @file 
- * Java threading interface
- *
+ * @file jthread_.h
+ * @brief Java threading interface
  * @details
  * Java threading interface - contains functions to work with Java threads. 
  * The generic part od Java thrading interface is mostly targeted to address 
- * the needs of <code>java.lang.Object</code> and <code>java.lang.Thread</code> 
- * classes implementations.
- * All functions in this interface start with <code><>jthread_*</code> prefix.
- * The implemnentation of this layer provides the mapping of Java thrads onto 
- * native/OS threads.
+ * the needs of java.lang.Object and java.lang.Thread classes implementations.
+ * All functions in this interface start with jthread_* prefix.
+ * The implemnentation of this layer provides the mapping of Java thrads onto native/OS threads.
+ * 
+ * For more detailes see thread manager component documentation located at vm/thread/doc/ThreadManager.htm
  * 
- * For more detailes, see thread manager component documentation located at 
- * <code>vm/thread/doc/ThreadManager.htm</code>
  */
 
 #include "open/types.h"
@@ -46,8 +46,7 @@
 #endif /* __cplusplus */
 
 
-/** 
- * @name Basic manipulation
+/** @name Basic manipulation
  */
 //@{
 
@@ -133,17 +132,15 @@
  *
  * @param[in] thread those attribute is set
  * @param[in] name thread name
- *
- * @sa <code>java.lang.Thread.setName()</code>
+ * @sa java.lang.Thread.setName()
  */
 IDATA jthread_set_name(jthread thread, jstring name);
 
 /**
  * Returns the name for the <code>thread</code>.
  *
- * @param[in] - thread those attribute is read
- *
- * @sa <code>java.lang.Thread.getName()</code>
+ * @param[in] thread those attribute is read
+ * @sa java.lang.Thread.getName()
  */
 jstring jthread_get_name(jthread thread);
 

Modified: harmony/enhanced/drlvm/trunk/vm/include/open/thread_externals.h
URL: http://svn.apache.org/viewvc/harmony/enhanced/drlvm/trunk/vm/include/open/thread_externals.h?view=diff&rev=496237&r1=496236&r2=496237
==============================================================================
--- harmony/enhanced/drlvm/trunk/vm/include/open/thread_externals.h (original)
+++ harmony/enhanced/drlvm/trunk/vm/include/open/thread_externals.h Sun Jan 14 22:22:34 2007
@@ -1,9 +1,9 @@
 /* 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 @@
  * limitations under the License.
  */
 
+/* 
+ * @author Artem Aliev
+ * @version $Revision$
+ */
 
 #ifndef OPEN_THREAD_EXTERNALS_H
 #define OPEN_THREAD_EXTERNALS_H
@@ -28,50 +32,50 @@
 
 
 /**
- * @param[in] obj - jobject those address needs to be given
+ * Returns the address of the memory chunk in the object which can be used by the 
+ * Thread Manager for synchronization purposes.
  *
- * @return The address of the memory chunk in the object which can be used by the 
- *         Thread Manager for synchronization purposes.
+ * @param[in] obj jobject those address needs to be given
+ * @return 
  */
 VMEXPORT void *vm_object_get_lockword_addr(jobject obj);
 
 /**
- * @return The size of the memory chunk in the object that can be used by
- *         Thread Manager for synchronization purposes. 
+ * Returns the size of the memory chunk in the object that can be used by
+ * Thread Manager for synchronization purposes. 
  *
  * The returned size must be equal for all Java objets and is constant over time. 
- * It should be possible to call this method during initialization time. 
+ * It should be possible to call this method during initialization time.
+ *
+ * @return the size 
  */
  VMEXPORT size_t vm_object_get_lockword_size();
 
 
 /**
- * Stores a pointer to TM-specific data in the <code>java.lang.Thread</code> object.
+ * Stores a pointer to TM-specific data in the java.lang.Thread object.
  *
  * A typical implementation may store a pointer within a private
  * non-static field of Thread.
  *
- * @param[in] thread    - a <code>java.lang.Thread</code> object those private field 
- *                        is going to be used for data storage
- * @param[in] data_ptr  - a pointer to data to be stored
+ * @param[in] thread a java.lang.Thread object those private field is going to be used for data storage
+ * @param[in] data_ptr a pointer to data to be stored
  */
 VMEXPORT void vm_jthread_set_tm_data(jthread thread, void *data_ptr);
 
 /**
- * Retrieves TM-specific data from the <code>java.lang.Thread</code> object.
+ * Retrieves TM-specific data from the java.lang.Thread object
  *
- * @param[in] thread - a thread
- *
- * @return TM-specific data previously stored, or <code>NULL</code>,
- *         if there are none.
+ * @param[in] thread a thread 
+ * @return TM-specific data previously stored, or NULL if there are none.
  */
 VMEXPORT void *vm_jthread_get_tm_data(jthread thread);
 
 /** 
- * Registrates current thread in VM, so it could execute Java.
+ * Registrates current thread in VM, so it could execute Java
  *
- * @param[in] java_vm    - current thread will be attached to the specified VM
- * @param[out] p_jni_env - will point to JNI environment assocciated with the thread
+ * @param[in] java_vm current thread will be attached to the specified VM
+ * @param[out] p_jni_env will point to JNI environment assocciated with the thread
  */
 VMEXPORT jint vm_attach(JavaVM * java_vm, JNIEnv ** p_jni_env);
 
@@ -81,19 +85,17 @@
 VMEXPORT jint vm_detach(jthread java_thread);
 
 /**
- * Creates exception object using given class name and message and throws it
- * using <code>jthread_throw_exception</code> method.
- *
- * @param[in] name     - char* name
- * @param[in] message  - char* message
- *
- * @return <code>int</code>
+ * creates exception object using given class name and message and throws it
+ * using jthread_throw_exception method;
+ * @param[in] name char* -name
+ * @param[in] message char* -message
+ * @return int.
  */
 VMEXPORT IDATA jthread_throw_exception(char* name, char* message);
 
 /**
- * Throws given exception object. Desides whether current thread is unwindable
- * and throws it, raises exception otherwise.
+ * Throws given exception object; Desides whether current thread is unwindable
+ * and throws it, raises exception otherwise;
  */
 VMEXPORT IDATA jthread_throw_exception_object(jobject object);
 
@@ -104,18 +106,16 @@
 VMEXPORT void jvmti_send_wait_monitor_event(jobject obj, jlong timeout);
 
 /**
- * <code>vm_objects_are_equal<br>
- * obj1 jobject<br>
- * obj2 jobject</code>
- * 
- * @return <code>int</code>
+ * vm_objects_are_equal
+ * obj1 jobject
+ * obj2 jobject
+ * @return int
  */
 VMEXPORT int vm_objects_are_equal(jobject obj1, jobject obj2);
 
 /**
- * <code>ti</code> is enabled
- *
- * @return <code>int</code>
+ * ti is enabled
+ * @return int
  */
 VMEXPORT int ti_is_enabled();
 
@@ -124,5 +124,4 @@
 #endif
 
 #endif  /* OPEN_THREAD_EXTERNALS_H */
-
 

Modified: harmony/enhanced/drlvm/trunk/vm/include/open/thread_helpers.h
URL: http://svn.apache.org/viewvc/harmony/enhanced/drlvm/trunk/vm/include/open/thread_helpers.h?view=diff&rev=496237&r1=496236&r2=496237
==============================================================================
--- harmony/enhanced/drlvm/trunk/vm/include/open/thread_helpers.h (original)
+++ harmony/enhanced/drlvm/trunk/vm/include/open/thread_helpers.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,7 +14,10 @@
  *  See the License for the specific language governing permissions and
  *  limitations under the License.
  */
-
+/**
+ * @author Artem Aliev
+ * @version $Revision$
+ */
 
 #ifndef OPEN_THREAD_HELPERS_H
 #define OPEN_THREAD_HELPERS_H
@@ -23,7 +26,7 @@
  * @file 
  * @brief Provides optimized assambly code generators for common monitor functions.
  *
- * @sa Thread manager component documentation located at vm/thread/doc/ThreadManager.htm
+ * For more detailes see thread manager component documentation located at vm/thread/doc/ThreadManager.htm
  */
 
 #include "open/types.h"

Modified: harmony/enhanced/drlvm/trunk/vm/include/open/ti_thread.h
URL: http://svn.apache.org/viewvc/harmony/enhanced/drlvm/trunk/vm/include/open/ti_thread.h?view=diff&rev=496237&r1=496236&r2=496237
==============================================================================
--- harmony/enhanced/drlvm/trunk/vm/include/open/ti_thread.h (original)
+++ harmony/enhanced/drlvm/trunk/vm/include/open/ti_thread.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 Andrey Chernyshev
+ * @version $Revision$
+ */
 
 #ifndef OPEN_THREAD_TI_H
 #define OPEN_THREAD_TI_H
@@ -24,9 +27,8 @@
  * @brief JVMTI support 
  * @details
  * TI part of the Java threading interface.
- * The TI part is mostly targeted to address the needs of JVMTI and 
- * <code>java.lang.management</code> classes needs.
- * All functions start with <code>jthread_*</code> prefix.
+ * The TI part is mostly targeted to address the needs of JVMTI and java.lang.management classes needs.
+ * All functions start with jthread_* prefix.
  */
 
 #include "jvmti_types.h"
@@ -38,7 +40,7 @@
 #endif /* __cplusplus */
 
 /**
- * JVM TI local storage structure.
+ * JVM TI local storage structure
  *
  * @param[in] thread 
  */

Modified: harmony/enhanced/drlvm/trunk/vm/include/open/types.h
URL: http://svn.apache.org/viewvc/harmony/enhanced/drlvm/trunk/vm/include/open/types.h?view=diff&rev=496237&r1=496236&r2=496237
==============================================================================
--- harmony/enhanced/drlvm/trunk/vm/include/open/types.h (original)
+++ harmony/enhanced/drlvm/trunk/vm/include/open/types.h Sun Jan 14 22:22:34 2007
@@ -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.3 $
+ */  
 
 #ifndef _VM_TYPES_H_
 #define _VM_TYPES_H_
@@ -21,9 +25,10 @@
 #include "common.h"
 
 #define MAX_UINT32 0xffffffff
-/**
- * DLL stuff
- */
+
+//////////////////////////////////////////////////////////////////////////
+// DLL stuff
+
 #if defined(PLATFORM_POSIX) || (defined(USE_STATIC_GC) && defined(BUILDING_GC))
 
 #define VMEXPORT
@@ -47,9 +52,8 @@
 
 #endif // !PLATFORM_POSIX
 
-/**
- * Various Numeric Types
- */
+//////////////////////////////////////////////////////////////////////////
+// Various Numeric Types
 
 // Boolean, uint8, int8, uint16, int16, uint32, int32, uint64, int64,
 // POINTER_SIZED_INT
@@ -119,12 +123,10 @@
 
 #endif //!PLATFORM_POSIX
 
-/**
- * The integer datatype on the platform that can hold a pointer.
- * ? 02/7/25: addded <code>POINTER_SIZE_SINT</code>, since in some cases
- * a pointer-size integer has to be signed (for example, when specifying LIL offsets)
- */
- #ifdef POINTER64
+// The integer datatype on the platform that can hold a pointer.
+// ? 02/7/25: addded POINTER_SIZE_SINT, since in some cases
+// a pointer-size integer has to be signed (for example, when specifying LIL offsets)
+#ifdef POINTER64
 #define POINTER_SIZE_INT uint64
 #define POINTER_SIZE_SINT int64
 #ifdef PLATFORM_NT
@@ -138,9 +140,8 @@
 #define PI_FMT ""
 #endif // POINTER64
 
-/**
- * <code>VM_Data_Type</code>
- */
+//////////////////////////////////////////////////////////////////////////
+// VM_Data_Type
 
 typedef
 enum VM_Data_Type {
@@ -171,10 +172,8 @@
     VM_DATA_TYPE_END     = ')'         // For the iterator
 } VM_Data_Type; //VM_Data_Type
 
-/**
- * (? 20030317) These defines are deprecated.
- * Use <code>VM_Data_Type</code> in all new code.
- */
+// (? 20030317) These defines are deprecated.
+// Use VM_Data_Type in all new code.
 #define Java_Type           VM_Data_Type
 #define JAVA_TYPE_BYTE      VM_DATA_TYPE_INT8
 #define JAVA_TYPE_CHAR      VM_DATA_TYPE_CHAR
@@ -191,12 +190,12 @@
 #define JAVA_TYPE_INVALID   VM_DATA_TYPE_INVALID
 #define JAVA_TYPE_END       VM_DATA_TYPE_END
 
-/**
- * Handles for Various VM Structures.
- *
- * This header file is also used in pure C sources,
- * thus we use struct instead of classes.
- */
+//////////////////////////////////////////////////////////////////////////
+// Handles for Various VM Structures
+
+// This header file is also used in pure C sources,
+// thus we use struct instead of classes
+
 typedef struct Class *Class_Handle;
 typedef struct VTable *VTable_Handle;
 typedef struct Field *Field_Handle;
@@ -204,37 +203,31 @@
 typedef struct Method_Signature *Method_Signature_Handle;
 typedef struct TypeDesc *Type_Info_Handle;
 typedef POINTER_SIZE_INT Allocation_Handle;
-typedef POINTER_SIZE_INT Runtime_Type_Handle;
 typedef void* NativeCodePtr;
 typedef struct ClassLoader* ClassLoaderHandle;
 typedef struct ManagedObject* ManagedPointer;
 
-/**
- * Fields of these types are not directly accessible from the core VM.
- */
- typedef struct ManagedObject Java_java_lang_Class;
-typedef ManagedObject Java_java_lang_System;
+// Fields of these types are not directly accessible from the core VM.
+// typedef struct ManagedObject Java_java_lang_Class;
+// typedef ManagedObject Java_java_lang_System;
 typedef struct ManagedObject Java_java_lang_Throwable;
 typedef struct ManagedObject Java_java_lang_Thread;
 typedef struct ManagedObject Java_java_io_FileInputStream;
 typedef struct ManagedObject Java_java_lang_String;
 
 
-/**
- * Used for opaques accesses to managed arrays. This handle points
- * to an array in the managed heap, so handling must be careful to account
- * for the possiblity of a moving GC.
- */
- typedef void *Vector_Handle;
+// Used for opaques accesses to managed arrays.  This handle points
+// to an array in the managed heap, so handling must be careful to account
+// for the possiblity of a moving GC.
+typedef void *Vector_Handle;
 
 typedef void *Managed_Object_Handle;
 
 typedef void *GC_Enumeration_Handle;
 
-/**
- * For disable warnings in release version.
- * warning type: warning: unused variable <type_of variable> <variable>
- */
+//For disable warnings in release version.
+//warning type: warning: unused variable <type_of variable> <variable>
 
 
+//////////////////////////////////////////////////////////////////////////
 #endif //!_VM_TYPES_H_



Mime
View raw message