harmony-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From gshiman...@apache.org
Subject svn commit: r565820 - in /harmony/enhanced/drlvm/trunk/vm/include/open: vm_class_loading.h vm_class_manipulation.h vm_class_support.h vm_field_access.h vm_method_access.h vm_type_access.h
Date Tue, 14 Aug 2007 16:10:53 GMT
Author: gshimansky
Date: Tue Aug 14 09:10:52 2007
New Revision: 565820

URL: http://svn.apache.org/viewvc?view=rev&rev=565820
Log:
Applied patch from HARMONY-3123
[drlvm][classloader][open] Class Support OPEN headers split, cleaned, and documented


Added:
    harmony/enhanced/drlvm/trunk/vm/include/open/vm_class_loading.h   (with props)
    harmony/enhanced/drlvm/trunk/vm/include/open/vm_class_manipulation.h   (with props)
    harmony/enhanced/drlvm/trunk/vm/include/open/vm_class_support.h   (with props)
    harmony/enhanced/drlvm/trunk/vm/include/open/vm_field_access.h   (with props)
    harmony/enhanced/drlvm/trunk/vm/include/open/vm_method_access.h   (with props)
    harmony/enhanced/drlvm/trunk/vm/include/open/vm_type_access.h   (with props)

Added: harmony/enhanced/drlvm/trunk/vm/include/open/vm_class_loading.h
URL: http://svn.apache.org/viewvc/harmony/enhanced/drlvm/trunk/vm/include/open/vm_class_loading.h?view=auto&rev=565820
==============================================================================
--- harmony/enhanced/drlvm/trunk/vm/include/open/vm_class_loading.h (added)
+++ harmony/enhanced/drlvm/trunk/vm/include/open/vm_class_loading.h Tue Aug 14 09:10:52 2007
@@ -0,0 +1,151 @@
+/*
+ *  Copyright 2006 The Apache Software Foundation or its licensors, as applicabl
+e.
+ *
+ *  Licensed 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
+ *
+ *  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 Intel, Pavel Pervov
+ * @version $Revision: 1.6 $
+ */  
+#ifndef _VM_CLASS_LOADING_H
+#define _VM_CLASS_LOADING_H
+
+/**
+ * @file
+ * Class loading functionality of the class support interface. 
+ * These functions are responsible for loading classes
+ * from the virtual machine and interested components.
+ */
+
+
+/** 
+ * @defgroup Extended VM Class Loading Extended Interface
+ * The extended functionality is implemented on the basis of basic interfaces
+ * and enables greater efficiency on the corresponding component side. 
+ */
+
+/**
+ * Looks up the class only among the classes loaded by the given class loader. 
+ * 
+ * This class loader does not delegate the lookup operation to 
+ * the parent loader or try to load any class.
+ *
+ * @param classloader    - the handle of the C++ class loader
+ * @param name           - the name of the class to look up
+ *
+ * @return The handle for C++ class representation, if found. Otherwise, <code>NULL</code>.
+ *
+ * @note Replaces cl_get_class.
+ */
+Class_Handle
+class_loader_lookup_class(Open_Class_Loader_Handle classloader, const char* name);
+
+
+/**
+ * Tries to load the class given its name and using the specified class loader.
+ *
+ * @param classloader    - the handle of the C++ class loader representation
+ * @param name           - the name of the class to load
+ *
+ * @return The handle for the C++ class representation, if loaded successfully; otherwise, <code>NULL</code>.
+ *
+ * @note Replaces cl_load_class. 
+ */
+Class_Handle
+class_loader_load_class(Open_Class_Loader_Handle classloader, const char* name);
+
+/** @ingroup Extended 
+ *
+ * Tries to load the class given its name and using the bootstrap class loader.
+ *
+ * @param name  - the name of the class to load
+ * @param exc   - the exception code for a class loading failure
+ *
+ * @result The handle for the C++ class representation, if loaded successfully; otherwise, <code>NULL</code>.
+ *
+ * @note Replaces class_load_class_by_name_using_system_class_loader. 
+ */
+Class_Handle
+vm_load_class_with_bootstrap(const char* name);
+
+/**
+ * Returns the C++ class structure representing the system 
+ * <code>java.lang.Object</code> class. 
+ *
+ * This function is the fast equivalent of the <code>vm_load_class_with_bootstrap("java/lang/Object")</code> function.
+ *
+ * @return the handle for the <code>java.lang.Object</code> C++ class representation. 
+ *
+ * @note Replaces get_system_object_class.
+ */
+Class_Handle
+vm_get_java_lang_object_class();
+
+/**
+ * Returns the C++ class structure representing the system class
+ * <code>java.lang.string</code>. 
+ * 
+ * This function is the fast equivalent of the <code>vm_load_class_with_bootstrap("java/lang/String")</code> function.
+ *
+ * @return The handle of <code>java.lang.String</code> C++ class representation
+ *
+ * @note Replaces get_system_string_class.
+ */
+Class_Handle
+vm_get_java_lang_string_class();
+
+/**
+ * Stores the pointer to verifier-specific data into the class loader C++ structure. 
+ *
+ * @param classloader      - the handle to the class loader to set the verifier data in
+ * @param data             - the pointer to the verifier data
+ *
+ * @note Replaces cl_set_verify_data_ptr.
+ */
+void
+class_loader_set_verifier_data_ptr(Open_Class_Loader_Handle classloader, const void* data);
+
+/**
+ * Returns the pointer to verifier-specific data associated with the given class loader.
+ *
+ * @param classloader - the handle to class loader to retrieve verifier pointer from
+ * 
+ * @return The pointer to the verifier data
+ *
+ * @note Replaces cl_get_verify_data_ptr.
+ */
+void*
+class_loader_get_verifier_data_ptr(Open_Class_Loader_Handle classloader);
+
+/**
+ * Acquires the lock on a given class loader. 
+ *
+ * @param classloader - the handle to the C++ class loader structure to acquire lock on.
+ * 
+ * @note Replaces cl_acquire_lock.
+ */
+void
+class_loader_lock(Open_Ă‘lass_Loader_Handle classloader);
+
+/**
+ * Releases the lock on a given class loader. 
+ *
+ * @param classloader - the handle to the C++ class loader structure to release lock on. 
+ * 
+ * @note Replaces cl_acquire_lock.
+ */
+void
+class_loader_unlock(Open_Class_Loader_Handle classloader);
+
+#endif // _VM_CLASS_LOADING_H

Propchange: harmony/enhanced/drlvm/trunk/vm/include/open/vm_class_loading.h
------------------------------------------------------------------------------
    svn:eol-style = native

Added: harmony/enhanced/drlvm/trunk/vm/include/open/vm_class_manipulation.h
URL: http://svn.apache.org/viewvc/harmony/enhanced/drlvm/trunk/vm/include/open/vm_class_manipulation.h?view=auto&rev=565820
==============================================================================
--- harmony/enhanced/drlvm/trunk/vm/include/open/vm_class_manipulation.h (added)
+++ harmony/enhanced/drlvm/trunk/vm/include/open/vm_class_manipulation.h Tue Aug 14 09:10:52 2007
@@ -0,0 +1,813 @@
+/*
+ *  Copyright 2006 The Apache Software Foundation or its licensors, as applicabl
+e.
+ *
+ *  Licensed 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
+ *
+ *  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 Intel, Pavel Pervov
+ * @version $Revision: 1.10 $
+ */
+#ifndef _VM_CLASS_MANIPULATION_H
+#define _VM_CLASS_MANIPULATION_H
+
+/**
+ * @file
+ * Part of Class Support interface related to retrieving and changing
+ * different class properties.
+ *
+ * The list of properties includes, but is not limited to, class name
+ * class super class, fields, methods and so on.
+ */
+
+/** 
+ * Returns the class name.
+ *
+ * @param klass - the class handle
+ *
+ * @return Class name bytes.
+ *
+ * @note An assertion is raised if <i>klass</i> equals to <code>NULL</code>.
+ */
+const char*
+class_get_name(Open_Class_Handle klass);
+
+/** 
+ * Returns the class name.
+ *
+ * @param klass - the class handle
+ *
+ * @return Class name bytes.
+ *
+ * @ingroup Extended
+ */
+const char*
+class_get_java_name(Open_Class_Handle klass);
+
+
+/** 
+ * Returns the super class of the current class.
+ *
+ * @param klass - the class handle
+ *
+ * @return The class handle of the super class.
+ *
+ * @note An assertion is raised if <i>klass</i> equals to <code>NULL</code>.
+ */
+Open_Class_Handle
+class_get_super_class(Open_Class_Handle klass);
+
+/**
+ * Returns the class loader of the current class.
+ *
+ * @param klass - the class handle
+ *
+ * @return The class loader.
+ *
+ * @note An assertion is raised if <i>klass</i> equals to <code>NULL</code>.
+ */
+Open_Class_Loader_Handle
+class_get_class_loader(Open_Class_Handle klass);
+
+/**
+ * Checks whether the current class is a primitive type.
+ *
+ * @param klass - the class handle
+ *
+ * @return <code>TRUE</code> for a primitive class; otherwise, <code>FALSE</code>.
+ *
+ * @note An assertion is raised if <i>klass</i> equals to <code>NULL</code>.
+ */
+Boolean
+class_is_primitive(Open_Class_Handle klass);
+
+/**
+ * Checks whether the current class is an array.
+ *
+ * @param klass - the class handle
+ *
+ * @return <code>TRUE</code> for an array; otherwise, <code>FALSE</code>.
+ *
+ * @note An assertion is raised if <i>klass</i> equals to <code>NULL</code>.
+ */
+Boolean
+class_is_array(Open_Class_Handle klass);
+
+/**
+ * Checks whether the current class is an instance of another class.
+ *
+ * @param klass - the class handle
+ * @param super_klass - super class handle
+ *
+ * @return <code>TRUE</code> if <i>klass</i> is an instance of a <i>super_class</i>; otherwise, <code>FALSE</code>.
+ *
+ * @note An assertion is raised if <i>klass</i> or <i>super_klass</i> equals to <code>NULL</code>.
+ */
+Boolean
+class_is_instanceof(Open_Class_Handle klass, Open_Class_Handle super_klass);
+
+/**
+ * Checks whether the current class is abstract.
+ *
+ * @param klass - the class handle
+ *
+ * @return <code>TRUE</code> for an abstract class; otherwise, <code>FALSE</code>.
+ *
+ * @note An assertion is raised if <i>klass</i> equals to <code>NULL</code>.
+ * @note Replaces the class_property_is_abstract function.
+ */
+Boolean
+class_is_abstract(Open_Class_Handle klass);
+
+/**
+ * Checks whether the current class is an interface class.
+ *
+ * @param klass - the class handle
+ *
+ * @return <code>TRUE</code> for an interface class; otherwise, <code>FALSE</code>.
+ *
+ * @note An assertion is raised if <i>klass</i> equals to <code>NULL</code>.
+ * @note Replaces functions class_is_interface_ and class_property_is_interface2.
+ */
+Boolean
+class_is_interface(Open_Class_Handle klass);
+
+/**
+ * Checks whether the current class is final.
+ *
+ * @param klass - the class handle
+ *
+ * @return <code>TRUE</code> for a final class; otherwise, <code>FALSE</code>.
+ *
+ * @note An assertion is raised if <i>klass</i> equals to <code>NULL</code>.
+ * @note Replaces functions class_is_final_ and class_property_is_final.
+ */
+Boolean
+class_is_final(Open_Class_Handle klass);
+
+/**
+ * Checks whether the given classes are the same.
+ *
+ * @param klass1  - the first class handle
+ * @param klass2 - the second class handle
+ *
+ * @return <code>TRUE</code> for the same classes; otherwise, <code>FALSE</code>.
+ *
+ * @note An assertion is raised if <i>klass1</i> or <i>klass2</i> equal to <code>NULL</code>.
+ */
+Boolean
+class_is_same_class(Open_Class_Handle klass1, Open_Class_Handle klass2);
+
+/**
+ * Returns the offset of the referent field 
+ * in the <code>java.lang.ref.Reference</code> object.
+ *
+ * It is assumed that the class represents the reference object,
+ * that is, running the class_is_reference function returns a non-zero value.
+ *
+ * @note The returned value is most probably a constant
+ *             and does not depend on the class.
+ *
+ * @note This interface allows only one weak, soft or phantom reference per object.
+ *             It seems to be sufficient for the JVM spec.
+ */
+int
+class_get_referent_offset(Open_Class_Handle clss);
+
+/**
+ * Returns the VM_Data_Type value for the given class.
+ *
+ * @param klass - the class handle
+ *
+ * @return The VM_Data_Type value.
+ */
+VM_Data_Type
+class_get_primitive_type_of_class(Open_Class_Handle klass);
+
+/**
+ * Returns the class corresponding to the primitive type.
+ *
+ * @param type - the primitive type
+ *
+ * @return The class corresponding to a primitive type.
+ *
+ * @note For all primitive types <i>type</i> is:
+ *            <code>type == class_get_primitive_type_of_class(class_get_class_of_primitive_type(type))</code>
+ */
+Open_Class_Handle
+class_get_class_of_primitive_type(VM_Data_Type type);
+
+/**
+ * Returns the size of an instance in the heap, in bytes.
+ * 
+ * @param klass - the class handle
+ *
+ * @return The size of an instance in the heap.
+ *
+ * @note Replaces class_get_boxed_data_size function.
+ */
+unsigned
+class_get_instance_size(Open_Class_Handle klass);
+
+/**
+ * For given a class handle <i>klass</i> constructs a class of
+ * the type representing on-dimentional array of <i>klass</i>.
+ * For example, given the class of Ljava/lang/String; this function
+ * will return array class [Ljava/lang/String;.
+ *
+ * @param klass - the class handle
+ *
+ * @return The class handle of the type representing the array of <i>klass</i>.
+ */
+Open_Class_Handle
+class_get_array_of_class(Open_Class_Handle klass);
+
+/**
+ * Returns the class of the array element of the given class.
+ *
+ * @param klass - the class handle
+ *
+ * @return The class of the array element of the given class.
+ *
+ * @note The behavior is undefined if the parameter does not represent
+ * an array class.
+ */
+Open_Class_Handle
+class_get_array_element_class(Open_Class_Handle klass);
+
+/**
+ * Returns the type info for the elements of the array for array classes.
+ *
+ * @param klass - the class handle
+ *
+ * @return Type information for the elements of the array.
+ */
+Open_Type_Info_Handle
+class_get_element_type_info(Open_Class_Handle klass);
+
+/**
+ * Gets the handle for the field. 
+ *
+ * @param klass - the class handle
+ * @param index - this value is the sequence number of field in the set of fields
+ *                both inherited and defined in this class.
+ *
+ * @return The handle for the field. If <i>index</i> is greater than or equal to
+ * <code>class_num_instance_fields_recursive</code>, function returns NULL.
+ */
+Open_Field_Handle
+class_get_instance_field_recursive(Open_Class_Handle klass, unsigned index);
+
+/**
+ * Returns the size of the element of the array for class handles that represent an array.
+ * 
+ * This function is a combination of functions class_get_instance_size and
+ * class_get_array_element_class. 
+ *
+ * @param klass - the class handle
+ *
+ * @return The size of the element of the array.
+ *
+ * @ingroup Extended
+ */
+unsigned
+class_element_size(Open_Class_Handle klass);
+
+/**
+ * Returns the vtable handle for the given class.
+ *
+ * @param klass - the class handle
+ *
+ * @return The vtable handle for the given class.
+ */
+Open_VTable_Handle
+class_get_vtable(Open_Class_Handle klass);
+
+/**
+ * Verifies that the class is fully initialized.
+ *
+ * @param klass - the class handle
+ *
+ * @return <code>TRUE</code> if the class is already fully
+ *                initialized; otherwise, <code>FALSE</code>. 
+ *
+ * @note The function class_needs_initialization is merged with this function. 
+ */
+Boolean
+class_is_initialized(Open_Class_Handle klass);
+
+/**
+ * Gets the alignment of the class.
+ *
+ * @param klass - the class handle
+ *
+ * @return The alignment of the class.
+ */
+unsigned
+class_get_alignment(Open_Class_Handle klass);
+
+/**
+ * Checks whether the class has a non-trivial finalizer.
+ *
+ * @param klass - the class handle
+ *
+ * @return <code>TRUE</code> if the class has a non-trivial finalizer. 
+ *                : otherwise, <code>FALSE</code>.
+ */
+Boolean
+class_is_finalizable(Open_Class_Handle klass);
+
+/**
+ * Checks whether the class is an array of primitives.
+ *
+ * @param klass - the class handle
+ *
+ * @return <code>TRUE</code> if this is an array of primitives.
+ *               : otherwise, <code>FALSE</code>.
+ */
+Boolean
+class_is_non_ref_array(Open_Class_Handle klass);
+
+/**
+ * Checks whether all instances of the given class are pinned.
+ *
+ * @param klass - the class handle
+ *
+ * @return <code>TRUE</code> if all instances of this class are pinned; otherwise, <code>FALSE</code>.
+ */
+Boolean
+class_is_pinned(Open_Class_Handle klass);
+
+/**
+ * Checks whether the class represented by Class_Handle
+ * is a descendant of <code>java.lang.ref.Reference</code>. 
+ * 
+ * The type of reference (weak, soft or phantom) is encoded in the return 
+ * value of WeakReferenceType.
+ *
+ * @param klass - the class handle
+ *
+ * @return One of WEAK_REFERENCE, SOFT_REFERENCE, or PHANTOM_REFERENCE if
+ * the given class is corresponding descendant of <code>java.lang.ref.Reference</code>.
+ * NOT_REFERENCE (0) is returned otherwise.
+ */
+WeakReferenceType
+class_get_reference_type(Open_Class_Handle klass);
+
+/**
+ * Checks whether the class is likely to be used as an exception object. 
+ *
+ * This is a hint only. Even if this function returns <code>FALSE</code>,
+ * the class might still be used for exceptions.
+ *
+ * @param klass - the class handle
+ *
+ * @return <code>TRUE</code> if the class is likely to be used
+ *                as an exception object; otherwise, <code>FALSE</code>. 
+ */
+Boolean
+class_hint_is_exceptiontype(Open_Class_Handle klass);
+
+/**
+ * Checks whether the class represents an enumerator.
+ *
+ * @param klass - the class handle
+ *
+ * @return <code>TRUE</code> if the class represents an enum.
+ *               : otherwise, <code>FALSE</code>.
+ */
+Boolean
+class_is_enum(Open_Class_Handle klass);
+
+/**
+ * Returns the number of instance fields defined in the given class.
+ * This number includes inherited fields.
+ *
+ * @param klass - the class handle
+ *
+ * @return The number of instance fields defined in a class.
+ *
+ * @note Replaces the class_num_instance_fields_recursive function.
+ */
+unsigned
+class_get_all_instance_fields_number(Open_Class_Handle klass);
+
+/**
+ * Returns the name of the package containing the class.
+ *
+ * @param klass - the class handle
+ *
+ * @return The name of the package containing the class.
+ *
+ * @note Not used
+ */
+const char*
+class_get_package_name(Open_Class_Handle klass);
+
+/**
+ * Returns the pointer to the location of the constant.
+ *
+ * @param klass  - the class handle
+ * @param index - interpreted as a constant pool index
+ *
+ * @return The pointer to the location of the constant in the
+ * constant pool of the class.
+ *
+ * @note This function must not be called for constant strings.  
+ *             Instead, one of the following can be done:
+ *            <ol>
+ *               <li>JIT-compiled code gets the string object at run time by calling
+ *                   VM_RT_LDC_STRING
+ *               <li>The class_get_const_string_intern_addr() function is used.
+ *            </ol>
+ */
+const void*
+class_get_const_addr(Open_Class_Handle klass, unsigned short index);
+
+/**
+ * Returns the type of the compile-time constant.
+ *
+ * @param klass  - the class handle
+ * @param index - interpreted as a constant pool index
+ *
+ * @return The type of a compile-time constant.
+ */
+VM_Data_Type
+class_get_const_type(Open_Class_Handle klass, unsigned short index);
+
+/**
+ * Returns the address of the interned version of the string. 
+ * 
+ * Calling this function has
+ * a side-effect of interning the string, so that the JIT compiler can
+ * load a reference to the interned string without checking whether 
+ * it is <code>NULL</code>.
+ *
+ * @param klass  - the class handle
+ * @param index - interpreted as a constant pool index
+ *
+ * @return The address of the interned version of the string.
+ *
+ * @note Not used
+ */
+void*
+class_get_const_string_intern_addr(Open_Class_Handle klass, unsigned short index);
+
+/**
+ * Returns the descriptor for the field or method/interface in the constant pool entry.
+ *
+ * @param klass         - the class handle
+ * @param cp_index - interpreted as a constant pool index
+ *
+ * @return The descriptor for field or method/interface in constant pool entry.
+ */
+const char*
+class_get_cp_entry_descriptor(Open_Class_Handle klass, unsigned short cp_index);
+
+/**
+ * Returns the data type for the field in the constant pool entry.
+ *
+ * @param klass         - the class handle
+ * @param cp_index - interpreted as a constant pool index
+ *
+ * @return The data type for the field in the constant pool entry.
+ */
+VM_Data_Type
+class_get_cp_field_type(Open_Class_Handle klass, unsigned short cp_index);
+
+/**
+ * Initializes the <i>iterator</i> to iterate over all classes that
+ * descend from <i>klass</i>, including <i>klass</i> itself.
+ *
+ * @param klass      - the class handle
+ * @param iterator - the class iterator
+ *
+ * @return <code>TRUE</code> if iteration is supported over <i>klass</i> and
+ *               <code>FALSE</code> if it is not.
+ *
+ * @note Reference to the internal type ChaClassIterator.
+ */
+Boolean
+class_iterator_initialize(ChaClassIterator* iterator, Open_Class_Handle klass);
+
+/**
+ * Returns the current class of the iterator.
+ *
+ * @param iterator - the class iterator
+ *
+ * @return The current class of the iterator. If there are no more classes, 
+ *                returns <code>NULL</code>. 
+ *
+ * @note Reference to the internal type ChaClassIterator.
+ */
+Open_Class_Handle
+class_iterator_get_current(ChaClassIterator* iterator);
+
+/**
+ * Advances the iterator.
+ *
+ * @param iterator  - the class iterator
+ *
+ * @note Reference to the internal type ChaClassIterator.
+ */
+void class_iterator_advance(ChaClassIterator* iterator);
+
+/**
+ * Returns the descriptor for the given method.
+ *
+ * @param klass  - the class handle
+ * @param index - interpreted as a constant pool index
+ *
+ * @return The descriptor for the method.
+ *
+ * @note Replaces the const_pool_get_method_descriptor function.
+ */
+const char*
+class_get_cp_method_descriptor(Open_Class_Handle klass, unsigned short index);
+
+/**
+ * Returns the descriptor for the field.
+ *
+ * @param klass - the class handle
+ * @param index - interpreted as a constant pool index
+ *
+ * @return  The descriptor for the field.
+ *
+ * @note Replaces the const_pool_get_field_descriptor function.
+ */
+const char*
+class_get_cp_field_descriptor(Open_Class_Handle klass, unsigned short index);
+
+/** 
+ * Returns the class constant pool size.
+ *
+ * @param klass - the class handle
+ *
+ * @return Constant pool size.
+ *
+ * @note An assertion is raised if <i>klass</i> equals to <code>NULL</code>.
+ */
+unsigned short
+class_get_cp_size(Open_Class_Handle klass);
+
+/** 
+ * Returns the constant pool entry tag.
+ *
+ * @param klass  - the class handle
+ * @param index - the constant pool entry index
+ *
+ * @return The constant pool entry tag.
+ *
+ * @note An assertion is raised if <i>klass</i> equals to 
+ *            <code>NULL</code> or if <i>index</i> is out of range.
+ */
+unsigned char
+class_get_cp_tag(Open_Class_Handle klass, unsigned short index);
+
+/** 
+ * Returns the class name entry index in the constant pool.
+ * This function is only legal for constant pool entries with CONSTANT_Class tags.
+ *
+ * @param klass  - the class handle
+ * @param index - the constant pool entry index
+ *
+ * @return The class name entry index.
+ *
+ * @note An assertion is raised if <i>klass</i> equals to 
+ *            <code>NULL</code> or if <i>index</i> is out of range.
+ */
+unsigned short
+class_get_cp_class_name_index(Open_Class_Handle klass, unsigned short index);
+
+/** 
+ * Returns the class name entry index in the constant pool.
+ * 
+ * The function is legal for constant pool entries with  CONSTANT_Fieldref, 
+ * CONSTANT_Methodref and CONSTANT_InterfaceMethodref tags.
+ *
+ * @param klass  - the class handle
+ * @param index - the constant pool entry index
+ *
+ * @return The class name entry index.
+ *
+ * @note An assertion is raised if <i>klass</i> equals to 
+ *            <code>NULL</code> or if <i>index</i> is out of range.
+ */
+unsigned short
+class_get_cp_ref_class_index(Open_Class_Handle klass, unsigned short index);
+
+/** 
+ * Returns the name and type entry index in the constant pool.
+ *
+ * This function is legal for constant pool entries with CONSTANT_Fieldref, 
+ * CONSTANT_Methodref and CONSTANT_InterfaceMethodref tags. 
+ *
+ * @param klass  - the class handle
+ * @param index - the constant pool entry index
+ *
+ * @return The name_and_type entry index.
+ *
+ * @note An assertion is raised if <i>klass</i> equals to 
+ *            <code>NULL</code> or if <i>index</i> is out of range.
+ */
+unsigned short
+class_get_cp_ref_name_and_type_index(Open_Class_Handle klass, unsigned short index);
+
+/** 
+ * Returns the string entry index in the constant pool.
+ *
+ * This function is legal for constant pool entries with CONSTANT_String tags. 
+ *
+ * @param klass  - the class handle
+ * @param index - the constant pool entry index
+ *
+ * @return The string entry index.
+ *
+ * @note An assertion is raised if <i>klass</i> equals to 
+ *            <code>NULL</code> or if <i>index</i> is out of range.
+ */
+unsigned short
+class_get_cp_string_index(Open_Class_Handle klass, unsigned short index);
+
+/** 
+ * Returns the name entry index in the constant pool.
+ *
+ * @note Function is legal for constant pool entry with CONSTANT_NameAndType tags.
+ *
+ * @param klass - the class handle
+ * @param index - the constant pool entry index
+ *
+ * @return  The name entry index.
+ *
+ * @note An assertion is raised if <i>klass</i> equals to 
+ *       <code>NULL</code> or if <i>index</i> is out of range.
+ */
+unsigned short
+class_get_cp_name_index(Open_Class_Handle klass, unsigned short index);
+
+/** 
+ * Returns the descriptor entry index in the constant pool.
+ * This function is legal for constant pool entries with CONSTANT_NameAndType tags.
+ *
+ * @param klass   - the class handle
+ * @param index - the constant pool entry index
+ *
+ * @return The descriptor entry index.
+ *
+ * @note An assertion is raised if <i>klass</i> equals to 
+ *            <code>NULL</code> or if <i>index</i> is out of range.
+ */
+unsigned short
+class_get_cp_descriptor_index(Open_Class_Handle klass, unsigned short index);
+
+/** 
+ * Returns bytes for the UTF8 constant pool entry.
+ * This function is legal for constant pool entries with CONSTANT_UTF8 tags.
+ *
+ * @param klass  - the class handle
+ * @param index - the constant pool entry index
+ *
+ * @return Bytes for the UTF8 constant pool entry. 
+ *
+ * @note An assertion is raised if <i>klass</i> equals to 
+ *            <code>NULL</code> or if <i>index</i> is out of range.
+ */
+const char*
+class_get_cp_utf8_bytes(Open_Class_Handle klass, unsigned short index);
+
+/**
+ * Resolves the class for the constant pool entry.
+ *
+ * @param klass   - the class handle
+ * @param index  - the constant pool entry index
+ * @param exc     - the pointer to exception
+ *
+ * @return The class resolved for the constant pool entry.
+ *
+ * @note Replaces the vm_resolve_class and resolve_class functions.
+ */
+Open_Class_Handle
+class_resolve_class(Open_Class_Handle klass, unsigned short index);
+
+/**
+ * Resolves the class for the constant pool entry 
+ * and checks whether an instance can be created.
+ *
+ * @param klass   - the class handle
+ * @param index  - the constant pool entry index
+ * @param exc     - the pointer to the exception
+ *
+ * @return The class resolved for the constant pool entry. If no instances
+ *                 of the class can be created, returns <code>NULL</code> and raises and exception.
+ *
+ * @note Replaces the vm_resolve_class_new and resolve_class_new functions.
+ *
+ */
+Open_Class_Handle
+class_resolve_class_new(Open_Class_Handle klass, unsigned short index);
+
+/**
+ * Resolves the class interface method for the constant pool entry.
+ *
+ * @param klass   - the class handle
+ * @param index  - the constant pool entry index
+ * @param exc     - the pointer to exception
+ *
+ * @return  interface method resolved for the constant pool entry.
+ *
+ * @note Replace the resolve_interface_method function.
+ */
+Open_Method_Handle
+class_resolve_interface_method(Open_Class_Handle klass, unsigned short index);
+
+/**
+ * Resolves class static method for the constant pool entry.
+ *
+ * @param klass   - the class handle
+ * @param index  - the constant pool entry index
+ * @param exc     - the pointer to exception
+ *
+ * @return The static method resolved for the constant pool entry.
+ *
+ * @note Replaces the resolve_static_method function.
+ */
+Open_Method_Handle
+class_resolve_static_method(Open_Class_Handle klass, unsigned short index);
+
+/**
+ * Resolves the class virtual method for the constant pool entry.
+ *
+ * @param klass   - the class handle
+ * @param index  - the constant pool entry index
+ * @param exc     - the pointer to exception
+ *
+ * @return The virtual method resolved for the constant pool entry.
+ *
+ * @note Replaces the resolve_virtual_method function.
+ */
+Open_Method_Handle
+class_resolve_virtual_method(Open_Class_Handle klass, unsigned short index);
+
+/**
+ * Resolves the class special method for the constant pool entry.
+ *
+ * @param klass   - the class handle
+ * @param index  - the constant pool entry index
+ * @param exc     - pointer to exception
+ *
+ * @return The special method resolved for the constant pool entry.
+ *
+ * @note Replaces the resolve_special_method function.
+ */
+Open_Method_Handle
+class_resolve_special_method(Open_Class_Handle klass, unsigned short index);
+
+/**
+ * Resolves the class static field for the constant pool entry.
+ *
+ * @param klass - the class handle
+ * @param index - the constant pool entry index
+ * @param exc   - pointer to exception
+ *
+ * @return The static field resolved for the constant pool entry.
+ *
+ * @note Replaces the resolve_static_field function.
+ */
+Open_Field_Handle
+class_resolve_static_field(Open_Class_Handle klass, unsigned short index);
+
+/**
+ * Resolves the class non-static field for the constant pool entry.
+ *
+ * @param klass   - the class handle
+ * @param index  - the constant pool entry index
+ * @param exc     - pointer to exception
+ *
+ * @return The non-static field resolved for the constant pool entry.
+ *
+ * @note Replaces the resolve_nonstatic_field function.
+ */
+Open_Field_Handle
+class_resolve_nonstatic_field(Open_Class_Handle klass, unsigned short index);
+
+/**
+ * Provides the initialization phase for the given class.
+ *
+ * @param klass  - class handle
+ *
+ * @note For interpreter use only.
+ */
+void
+class_initialize(Class_Handle klass);
+
+#endif // _VM_CLASS_MANIPULATION_H

Propchange: harmony/enhanced/drlvm/trunk/vm/include/open/vm_class_manipulation.h
------------------------------------------------------------------------------
    svn:eol-style = native

Added: harmony/enhanced/drlvm/trunk/vm/include/open/vm_class_support.h
URL: http://svn.apache.org/viewvc/harmony/enhanced/drlvm/trunk/vm/include/open/vm_class_support.h?view=auto&rev=565820
==============================================================================
--- harmony/enhanced/drlvm/trunk/vm/include/open/vm_class_support.h (added)
+++ harmony/enhanced/drlvm/trunk/vm/include/open/vm_class_support.h Tue Aug 14 09:10:52 2007
@@ -0,0 +1,374 @@
+/*
+ *  Copyright 2006 The Apache Software Foundation or its licensors, as applicable.
+ *
+ *  Licensed 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
+ *
+ *  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 Intel, Pavel Pervov
+ * @version $Revision: 1.6 $
+ */  
+
+#ifndef _VM_CLASS_SUPPORT_H
+#define _VM_CLASS_SUPPORT_H
+
+/**
+ * @file
+ * Class Support interface exposed by VM.
+ *
+ * This file combines separate groups of interfaces commonly reffered to as
+ * Class Support.
+ *
+ * If you do not know which part of Class Support interfaces you need,
+ * include this file.
+ */
+
+#include "vm_class_loading.h"
+#include "vm_class_manipulation.h"
+#include "vm_method_access.h"
+#include "vm_field_access.h"
+#include "vm_type_access.h"
+
+
+/* Inclusion of all these functions into class support interface is yet to decide. */
+
+/* "through VM" method */
+/* NOTE: reference to internal type Byte */
+
+/**
+ * Called by a EE to have the VM replace a section of executable code in a thread-safe fashion. 
+ */
+void vm_patch_code_block(Byte* code_block, Byte* new_code, size_t size);
+
+/**
+ * Called by a EE in order to be notified whenever the vtable entries for the given method 
+ * are changed. This could happen, e.g., when a method is first compiled, or when it is 
+ * recompiled.  The callback_data pointer will be passed back to the JIT during the callback.  
+ * The callback method is JIT_recompiled_method_callback.
+ */
+void vm_register_jit_recompiled_method_callback(JIT_Handle jit, Method_Handle method, void* callback_data);
+
+/**
+ * Called by a JIT in order to be notified whenever the given method is overridden by a newly 
+ * loaded class. The callback_data pointer will be passed back to the JIT during the callback.  
+ * The callback function is JIT_overridden_method_callback.
+ */
+void vm_register_jit_overridden_method_callback(JIT_Handle jit, Method_Handle method, void* callback_data);
+
+/**
+ * Called by a JIT in order to be notified whenever the given class is extended.
+ * The callback_data pointer will be passed back to the JIT during the callback. 
+ * The callback function is JIT_extended_class_callback.
+ */
+void vm_register_jit_extended_class_callback(JIT_Handle jit, Class_Handle clss, void* callback_data);
+
+/**
+ * A set of functions is used by the code generated by the JIT.
+ * The address of a function is obtained from the VM by invoking the
+ * function vm_get_rt_support_addr (see below).
+ */
+void* vm_get_rt_support_addr(VM_RT_SUPPORT f);
+
+/**
+ * Temporary interface addition
+ * same as vm_get_rt_support_addr, but tries to optimize the stubs it creates,
+ * by specializing them.
+ */
+void* vm_get_rt_support_addr_optimized(VM_RT_SUPPORT f, Class_Handle c);
+
+/**
+ * Set the information about an exception handler in the code generated by
+ * the JIT.
+ */
+void method_set_target_handler_info(Method_Handle method, JIT_Handle j, unsigned eh_number, void* start_ip, void* end_ip, void* handler_ip, Class_Handle catch_cl, Boolean exc_obj_is_dead);
+
+/**
+ * Get the size of the memory block allocated earlier by
+ * method_allocate_info_block().
+ */
+unsigned method_get_info_block_size_jit(Method_Handle method, JIT_Handle j);
+
+/**
+ * Get the size of the memory block allocated earlier by
+ * method_allocate_code_block().
+ * A triple <method, jit, id> uniquely identifies a code block.
+ */
+VMEXPORT unsigned method_get_code_block_size_jit(Method_Handle method, JIT_Handle j, int id);
+
+/**
+ * Retrieve the memory block allocated earlier by
+ * method_allocate_code_block().
+ * A triple <method, jit, id> uniquely identifies a code block.
+ */
+Byte* method_get_code_block_addr_jit(Method_Handle method, JIT_Handle j, int id);
+
+/**
+ * Allocated a "read-only" data block.
+ *
+ * This function is deprecated.  In all new code, use
+ * method_allocate_data_block() only.  At some point, we will revisit
+ * this interface to have more control over the layout of various
+ * memory blocks allocated by the VM.
+ */
+Byte* method_allocate_jit_data_block(Method_Handle method, JIT_Handle j, size_t size, size_t alignment);
+
+/**
+ * Called by a JIT to have the VM recompile a method using the specified JIT. After 
+ * recompilation, the corresponding vtable entries will be updated, and the necessary 
+ * callbacks to JIT_recompiled_method_callback will be made. It is a requirement that 
+ * the method has not already been compiled by the given JIT; this means that multiple 
+ * instances of a JIT may need to be active at the same time. (See vm_clone_jit.)
+ */
+void vm_recompile_method(JIT_Handle jit, Method_Handle method);
+
+/// FIXME - This isn't method interface function!
+// Replaces method_get_JIT_id
+JIT_Handle
+compilation_get_JIT_id(Compile_Handle compile_handle);
+
+/**
+ * Enables allocation of multiple chunks of code with different heat values. 
+ * 
+ * The JIT compiler is responsible for specifying  unique IDs of code chunks within one method.
+ * The first instruction of the chunk with id=0 is the entry point of the method.
+ *
+ * @param method    - the method handle
+ * @param jit       - the JIT handle
+ * @param size      - the size of the allocated code block
+ * @param alignment - the memory block aligment
+ * @param heat      - ?
+ * @param id        - code chunk id
+ * @param action    - the resulting return action
+ *
+ * @return The pointer to the allocated code block with the following specifics: 
+ *                 <ul>
+ *                     <li>If the CAA_Allocate argument is specified, memory is allocated and the function returns the pointer
+ *                          to this memory.
+ *                     <li>If the CAA_Simulate argument is specified, no memory is allocated and the function returns the address 
+ *                         that would have been allocated if CAA_Allocate was specified and all the other arguments were the same. 
+ *                 </ul>
+ *                 The function may also return <code>NULL</code> when CAA_Simulate is specified. For example, this may happen
+ *                 when multiple heat values are mapped to the same code pool or when the specified size require a new code pool.
+ *
+ * @note FIXME This has to go to the compilation infrastructure interface. 
+ */
+Open_Native_Code_Ptr
+method_allocate_code_block(Open_Method_Handle method,
+                           JIT_Handle jit,
+                           size_t size,
+                           size_t alignment,
+                           unsigned heat,
+                           int id,
+                           Code_Allocation_Action action);
+
+/**
+ * Allocates the "read-write" data block for the given method.
+ *
+ * This block is intended for data that may be required during program execution, 
+ * for example, tables for switch statements. This block cannot be retrieved later. 
+ *
+ * Separation of data allocated by <i>method_allocate_data_block</i> and
+ * <i>method_allocate_info_block</i> may help improve locality of references
+ * to data accessed during execution of compiled code and data accessed during
+ * stack unwinding.
+ *
+ * @param method    - the method handle
+ * @param jit       - the JIT handle
+ * @param size      - the size of the allocated code block
+ * @param alignment - the memory block aligment
+ *
+ * @return The pointer to the allocated data block.
+ *
+ * @note Reference to type <i>Byte</i>.
+ * @note FIXME This has to go to the compilation infrastructure interface.
+ *
+ * @see method_allocate_info_block
+ */
+Byte*
+method_allocate_data_block(Open_Method_Handle method,
+                           JIT_Handle jit,
+                           size_t size,
+                           size_t alignment);
+
+/**
+ * Returns the class handle corresponding to a given allocation handle.
+ */
+Class_Handle allocation_handle_get_class(Allocation_Handle ah);
+
+/**
+ * Returns the offset to the vtable pointer in an object.
+ */
+int object_get_vtable_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.
+ */
+int vtable_get_super_array_offset();
+
+/**
+ * Returns TRUE if vtable pointers within objects are to be treated
+ * as offsets rather than raw pointers.
+ */
+Boolean vm_vtable_pointers_are_compressed();
+
+/**
+ * @return the number of bytes allocated by VM in VTable
+ *         for use by GC.
+ */
+size_t vm_number_of_gc_bytes_in_vtable();
+
+/**
+ * Returns the base address of the vtable memory area.  This value will
+ * never change and can be cached at startup.
+ */
+POINTER_SIZE_INT vm_get_vtable_base();
+
+/**
+ * Returns the width in bytes (e.g. 4 or 8) of the vtable type
+ * information in each object's header.  This is typically used
+ * by the JIT for generating type-checking code, e.g. for inlined
+ * type checks or for inlining of virtual methods.
+ */
+unsigned vm_get_runtime_type_handle_width();
+
+/**
+ * Returns the number of superclass hierarchy elements that are
+ * stored within the vtable.  This is for use with fast type checking.
+ */
+int vm_max_fast_instanceof_depth();
+
+/* array object access */
+
+/**
+ * allocate new vector.
+ *
+ * @param array_class Class structure of array to be allocated.
+ * @param length length of array to be allocated.
+ * @return pointer to the allocated array,
+ *         NULL if exception occured, and context is not unwindable,
+ *         no-return if exception occured in unwindable context.
+ *           
+ * @throws OutOfMemoryError
+ * @note in case that this method is called from jitted code,
+ *       unwinding is performed, and this method never returns.
+ *       In all other cases, current thread exception is set,
+ *       and control is returned.
+ * @note implemented in vm_arrays.cpp
+ *           
+ * NOTE: reference to internal type Class
+ */
+Vector_Handle vm_new_vector(Class* array_class, int length);
+
+/** 
+ * allocate new primitive vector.
+ *
+ * @copydoc vm_new_vector() 
+ *
+ * @note attempt to pass non-primitive array class to this function
+ *       will cause undefined results.
+ *
+ * NOTE: reference to internal type Class
+ */
+Vector_Handle vm_new_vector_primitive(Class* vector_class, int length);
+
+/**
+ * Return the offset to the length field of the array.  That field has
+ * the same offset for vectors of all types.
+ */
+int vector_length_offset();
+
+/**
+ * Return the offset to the first element of the vector of the given type.
+ * Assume that the elements are boxed. Byte offset.
+ */
+int vector_first_element_offset_class_handle(Class_Handle element_type);
+
+/**
+ * Return the offset to the first element of the vector of the given type.
+ * Assume that the elements are boxed. Byte offset.
+ */
+int vector_first_element_offset_vtable_handle(VTable_Handle element_type);
+
+/**
+ * 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.
+ */
+int vector_first_element_offset(VM_Data_Type 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.
+ */
+int vector_first_element_offset_unboxed(Class_Handle element_type);
+
+/* object allocation */
+
+
+/**
+ * allocate new object using its Class structure.
+ *
+ * @param clss Class structure of the object.
+ * @note XXX exception and out of memory semantics are not specified -salikh
+ * NOTE: reference to internal types Java_java_lang_Object, Class
+ */
+Java_java_lang_Object* class_alloc_new_object(Class* clss);
+
+/**
+ * allocates new object using its VTable structure.
+ *
+ * @param vtable VTable structure of the object.
+ * @note XXX exception and out of memory semantics are not specified -salikh
+ * NOTE: reference to internal types Java_java_lang_Object, VTable
+ */
+Java_java_lang_Object* class_alloc_new_object_using_vtable(VTable *vtable);
+
+/* Kernel */
+
+/**
+ * Find Class With Class Loader.
+ *
+ * NOTE: reference to internal type ClassLoader
+ */
+jclass FindClassWithClassLoader(const char* name, ClassLoader* loader);
+
+/**
+ * Find Class With Class Loader.
+ *
+ * NOTE: reference to internal type ClassLoader
+ */
+jclass SignatureToClass (JNIEnv* env_ext, const char* sig, ClassLoader* class_loader);
+
+/**
+ * Find field.
+ *
+ * NOTE: reference to internal types Field, Class
+ */
+Field* LookupField(Class* clss, const char* name);
+
+/**
+ * Find method.
+ *
+ * NOTE: reference to internal types Method, Class
+ */
+Method* LookupMethod (Class* clss, const char* mname, const char* msig);
+/* NOTE: reference to internal type ClassLoader */
+
+/**
+ * Get Method Parameter Types.
+ */
+jclass* GetMethodParameterTypes (JNIEnv* env, const char* sig, unsigned short* nparams, ClassLoader* class_loader);
+
+#endif /* _VM_CLASS_SUPPORT_H */

Propchange: harmony/enhanced/drlvm/trunk/vm/include/open/vm_class_support.h
------------------------------------------------------------------------------
    svn:eol-style = native

Added: harmony/enhanced/drlvm/trunk/vm/include/open/vm_field_access.h
URL: http://svn.apache.org/viewvc/harmony/enhanced/drlvm/trunk/vm/include/open/vm_field_access.h?view=auto&rev=565820
==============================================================================
--- harmony/enhanced/drlvm/trunk/vm/include/open/vm_field_access.h (added)
+++ harmony/enhanced/drlvm/trunk/vm/include/open/vm_field_access.h Tue Aug 14 09:10:52 2007
@@ -0,0 +1,187 @@
+/*
+ *  Copyright 2006 The Apache Software Foundation or its licensors, as applicabl
+e.
+ *
+ *  Licensed 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
+ *
+ *  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 Intel, Pavel Pervov
+ * @version $Revision: 1.4 $
+ */
+#ifndef _VM_FIELD_ACCESS_H
+#define _VM_FIELD_ACCESS_H
+
+/**
+ * @file
+ * Part of Class Support interface related to retrieving different
+ * properties of fields contained in class
+ */
+
+/**
+ * Returns the name of the field.
+ *
+ * @param field - the field handle
+ *
+ * @return The name of the field.
+ */
+const char*
+field_get_name(Open_Field_Handle field);
+
+/**
+ * Returns the field <i>descriptor</i>.
+ * 
+ * The descriptor is a string representation of the field types as
+ * defined by the JVM specification.
+ *
+ * @param field - the field handle
+ *
+ * @return The field descriptor.
+ */
+const char*
+field_get_descriptor(Open_Field_Handle field);
+
+/**
+ * Returns the class that defined the given field.
+ *
+ * @param field - the field handle
+ *
+ * @return The class that defined the field.
+ */
+Open_Class_Handle
+field_get_class(Open_Field_Handle field);
+
+/**
+ * Returns the address of the given static field.
+ *
+ * @param field - the field handle
+ *
+ * @return The address of the static field.
+ */
+void*
+field_get_address(Open_Field_Handle field);
+
+/**
+ * Returns the offset to the given instance field.
+ *
+ * @param field - the field handle
+ *
+ * @return The offset to the instance field.
+ */
+unsigned
+field_get_offset(Open_Field_Handle field);
+
+/**
+ * Returns the type info that represents the type of the field.
+ *
+ * @param field - the field handle
+ *
+ * @return Type information.
+ *
+ * @note Replaces field_get_type_info_of_field_value. 
+ */
+Open_Type_Info_Handle
+field_get_type_info_of_field_type(Open_Field_Handle field);
+
+/**
+ * Returns the class that represents the type of the field.
+ *
+ * @param field - the field handle
+ *
+ * @return the class that represents the type of the field.
+ *
+ * @note Replaces field_get_class_of_field_value.
+ */
+Open_Class_Handle
+field_get_class_of_field_type(Open_Field_Handle field);
+
+/**
+ *  Checks whether the field is final.
+ *
+ * @param field - the field handle
+ *
+ * @return <code>TRUE</code> if the field is final.
+ *
+ * #note Extended
+ */
+Boolean
+field_is_final(Open_Field_Handle field);
+
+/**
+ *  Checks whether the field is static.
+ *
+ * @param field - the field handle
+ *
+ * @return <code>TRUE</code> if the field is static; otherwise, <code>FALSE</code>. 
+ *
+ * @ingroup Extended 
+ */
+Boolean
+field_is_static(Open_Field_Handle field);
+
+/**
+ *  Checks whether the field is private.
+ *
+ * @param field - the field handle
+ *
+ * @return <code>TRUE</code> if the field is private; otherwise, <code>FALSE</code>. 
+ *
+ * @ingroup Extended 
+ */
+Boolean
+field_is_private(Open_Field_Handle field);
+
+/**
+ *  Checks whether the field is public.
+ *
+ * @param field - the field handle
+ *
+ * @return <code>TRUE</code> if the field is public; otherwise, <code>FALSE</code>. 
+ *
+ * @ingroup Extended 
+ */
+Boolean
+field_is_public(Open_Field_Handle field);
+
+/**
+ *  Checks whether the field is volatile.
+ *
+ * @param field - the field handle
+ *
+ * @return <code>TRUE</code> if the field is volatile; otherwise, <code>FALSE</code>. 
+ *
+ * @ingroup Extended 
+ */
+Boolean
+field_is_volatile(Open_Field_Handle field);
+
+/**
+ *  Checks whether the field is literal.
+ *
+ * @param field - the field handle
+ *
+ * @return <code>TRUE</code> if the field is literal.
+ */
+Boolean
+field_is_literal(Open_Field_Handle field);
+
+/**
+ *  Checks whether the field is injected.
+ *
+ * @param field - the field handle
+ *
+ * @return <code>TRUE</code> if the field is injected; otherwise, <code>FALSE</code>. 
+ */
+Boolean
+field_is_injected(Open_Field_Handle field);
+
+#endif // _VM_FIELD_ACCESS_H

Propchange: harmony/enhanced/drlvm/trunk/vm/include/open/vm_field_access.h
------------------------------------------------------------------------------
    svn:eol-style = native

Added: harmony/enhanced/drlvm/trunk/vm/include/open/vm_method_access.h
URL: http://svn.apache.org/viewvc/harmony/enhanced/drlvm/trunk/vm/include/open/vm_method_access.h?view=auto&rev=565820
==============================================================================
--- harmony/enhanced/drlvm/trunk/vm/include/open/vm_method_access.h (added)
+++ harmony/enhanced/drlvm/trunk/vm/include/open/vm_method_access.h Tue Aug 14 09:10:52 2007
@@ -0,0 +1,618 @@
+/*
+ *  Copyright 2006 The Apache Software Foundation or its licensors, as applicabl
+e.
+ *
+ *  Licensed 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
+ *
+ *  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 Intel, Pavel Pervov
+ * @version $Revision: 1.7 $
+ */
+#ifndef _VM_METHOD_ACCESS_H
+#define _VM_METHOD_ACCESS_H
+
+/**
+ * @file
+ * Part of Class Support interface related to retrieving different
+ * properties of methods contained in class.
+ */
+
+/**
+ * Returns the method name.
+ *
+ * @param method - the method handle
+ *
+ * @return Method name bytes.
+ *
+ * @note An assertion is raised if <i>method</i> equals to <code>NULL</code>. 
+ */
+const char*
+method_get_name(Open_Method_Handle method);
+
+/**
+ * Returns the method descriptor.
+ *
+ * @param method - the method handle
+ *
+ * @return Method descriptor bytes.
+ *
+ * @note An assertion is raised if <i>method</i> equals to <code>NULL</code>. 
+ */
+const char*
+method_get_descriptor(Open_Method_Handle method);
+
+/**
+ * Returns the signature that can be used to iterate over the agruments of the given method
+ * and to query the type of the method result.
+ *
+ * @param method - the method handle
+ *
+ * @return The method signature.
+ *
+ * @note An assertion is raised if <i>method</i> equals to <code>NULL</code>. 
+ */
+Method_Signature_Handle
+method_get_signature(Method_Handle method);
+
+/**
+ * Returns the class where the given method is declared.
+ *
+ * @param method - the method handle
+ *
+ * @return The name of the class where the method is declared.
+ *
+ * @note An assertion is raised if <i>method</i> equals to <code>NULL</code>. 
+ */
+Open_Class_Handle
+method_get_class(Open_Method_Handle method);
+
+/**
+ * Returns access flags for the given method.
+ *
+ * @param method - the method handle
+ *
+ * @return Access flags.
+ *
+ * @note An assertion is raised if <i>method</i> equals to <code>NULL</code>. 
+ */
+unsigned short
+method_get_flags(Open_Method_Handle method);
+
+/**
+ * Checks whether the given method is protected.
+ *
+ * @param method - the method handle
+ *
+ * @return <code>TRUE</code> if the given method is protected; otherwise, <code>FALSE</code>.
+ *
+ * @note An assertion is raised if <i>method</i> equals to <code>NULL</code>. 
+ **/
+unsigned
+method_is_protected(Open_Method_Handle method);
+
+/**
+ *  Checks whether the given method is private.
+ *
+ * @param method - the method handle
+ *
+ * @return <code>TRUE</code> if the given method is private; otherwise, <code>FALSE</code>.
+ *
+ * @note An assertion is raised if <i>method</i> equals to <code>NULL</code>. 
+ * @ingroup Extended 
+ */
+Boolean
+method_is_private(Open_Method_Handle method);
+
+/**
+ *  Checks whether the given method is public.
+ *
+ * @param method - the method handle
+ *
+ * @return <code>TRUE</code> if the given method is public; otherwise, <code>FALSE</code>.
+ *
+ * @note An assertion is raised if <i>method</i> equals to <code>NULL</code>. 
+ * @ingroup Extended
+ */
+Boolean
+method_is_public(Open_Method_Handle method);
+
+/**
+ *  Checks whether the given method is static.
+ *
+ * @param method - the method handle
+ *
+ * @return <code>TRUE</code> if the given method is static; otherwise, <code>FALSE</code>.
+ *
+ * @note An assertion is raised if <i>method</i> equals to <code>NULL</code>. 
+ * @ingroup Extended 
+ */
+Boolean
+method_is_static(Open_Method_Handle method);
+
+/**
+ *  Checks whether the given method is native.
+ *
+ * @param method - the method handle
+ *
+ * @return <code>TRUE</code> if the given method is native; otherwise, <code>FALSE</code>.
+ *
+ * @note An assertion is raised if <i>method</i> equals to <code>NULL</code>. 
+* @ingroup Extended 
+ */
+Boolean
+method_is_native(Open_Method_Handle method);
+
+/**
+ *  Checks whether the given method is synchronized.
+ *
+ * @param method - the method handle
+ *
+ * @return <code>TRUE</code> if the given method is synchronized; otherwise, <code>FALSE</code>.
+ *
+ * @note An assertion is raised if <i>method</i> equals to <code>NULL</code>. 
+* @ingroup Extended 
+ */
+Boolean
+method_is_synchronized(Open_Method_Handle method);
+
+/**
+ *  Checks whether the given method is final.
+ *
+ * @param method - the method handle
+ *
+ * @return <code>TRUE</code> if the given method is final; otherwise, <code>FALSE</code>.
+ *
+ * @note An assertion is raised if <i>method</i> equals to <code>NULL</code>. 
+* @ingroup Extended 
+ */
+Boolean
+method_is_final(Open_Method_Handle method);
+
+/**
+ *  Checks whether the given method is abstract.
+ *
+ * @param method - the method handle
+ *
+ * @return <code>TRUE</code> if the given method is abstract; otherwise, <code>FALSE</code>.
+ *
+ * @note An assertion is raised if <i>method</i> equals to <code>NULL</code>. 
+* @ingroup Extended 
+ */
+Boolean
+method_is_abstract(Open_Method_Handle method);
+
+/**
+ *  Checks whether the given method is strict.
+ *
+ * Java* methods can have a flag set to indicate that floating point operations
+ * must be performed in the strict mode.
+ *
+ * @param method - the method handle
+ *
+ * @return <code>TRUE</code> if the <code>ACC_STRICT</code> flag is set for 
+ *                the Java* method and <code>FALSE</code> if otherwise.
+ *
+ * @note An assertion is raised if <i>method</i> equals to <code>NULL</code>. 
+* @ingroup Extended 
+ */
+Boolean
+method_is_strict(Open_Method_Handle method);
+
+/**
+ *  Checks whether the given method has been overridden in a subclass.
+ *
+ * @param method - the method handle
+ *
+ * @return <code>TRUE</code> if the method has been overriden and <code>FALSE</code> otherwise.
+ *
+ * @note An assertion is raised if <i>method</i> equals to <code>NULL</code>. 
+ *
+ * @note If this function returns <code>FALSE</code>, loading the subclass later 
+ *             in the execution of the program may invalidate this condition.
+*              If a JIT compiler uses this function to perform  unconditional inlining, 
+                the compiler must be prepared to patch the code later. 
+*
+ * @see vm_register_jit_overridden_method_callback
+ */
+Boolean
+method_is_overridden(Open_Method_Handle method);
+
+/**
+ * Checks whether the method is the <init> method for the class. 
+ *
+ * @param method - the method handle
+ *
+ * @return <code>TRUE</code> if the method is the <init> method; otherwise, <code>FALSE</code>.
+ */
+Boolean
+method_is_init(Open_Method_Handle method);
+
+/**
+ * Checks whether the method is the <clinit> method for the class. 
+ *
+ * @param method - the method handle
+ *
+ * @return <code>TRUE</code> if the method is the <clinit> method for the class; otherwise, <code>FALSE</code>.
+ */
+Boolean
+method_is_clinit(Open_Method_Handle method);
+
+/**
+ * Checks whether the JIT compiler is allowed to in-line the method.
+ * 
+ * The compiler can be set not to in-line a method for various reasons, for example, 
+ * the JIT must not in-line native methods and Java* methods
+ * loaded by a different class loader than the caller.
+ *
+ * @param method - the method handle
+ *
+ * @return <code>TRUE</code> if the JIT must not in-line the method; otherwise, <code>FALSE</code>.
+ *
+ * @note An assertion is raised if <i>method</i> equals to <code>NULL</code>. 
+ * @note Always <code>FALSE</code> for Java*.
+ */
+Boolean
+method_is_no_inlining(Open_Method_Handle method);
+
+/**
+ * Retrieves potential side effects of the given method. 
+ *
+ * @param m - handle for the method, for which side effects are retrieved
+ *
+ * @return Enumeration value which corresponds to side effects method may have.
+ * One of:
+ *      MSE_Unknown         - it is not known whether this method has side effects
+ *      MSE_True            - method has side effects
+ *      MSE_False           - method does not have side effects
+ *      MSE_True_Null_Param - 
+ */
+VMEXPORT Method_Side_Effects method_get_side_effects(Open_Method_Handle m);
+
+/**
+ * Sets potential side effects of the given method. 
+ *
+ * @param m - method handle for which side effects are set
+ * @param mse - side effect of this method (see method_get_side_effects for details)
+ */
+VMEXPORT void method_set_side_effects(Open_Method_Handle m, Method_Side_Effects mse);
+
+/**
+ * Sets the number of exception handlers in the code generated by the JIT compiler 
+ * <i>jit</i> for the given method. 
+ *
+ * @param method        - the method handle
+ * @param jit           - the JIT handle
+ * @param num_handlers  - the number of exception handlers
+ *
+ * @note The JIT compiler must then call the <i>method_set_target_handler_info</i> function
+ *             for each of the <i>num_handlers</i> exception handlers.
+ */
+void
+method_set_num_target_handlers(Open_Method_Handle method,
+                               Open_JIT_Handle jit,
+                               unsigned short num_handlers);
+
+/**
+ *  Checks whether the local variable is pinned.
+ *
+ * @param method    - method handle
+ * @param index     - the local variable index
+ *
+ * @return <i>TRUE</i> if the local variable is pinned; otherwise, <code>FALSE</code>.
+ *
+ * @note Replaces the method_vars_is_pinned function.
+* @ingroup Extended 
+* @note Not used.
+ */
+Boolean
+method_local_is_pinned(Open_Method_Handle method, unsigned short index);
+
+/**
+ * Returns the handle for an accessible method overriding <i>method</i> in <i>klass</i> 
+ * or in its closest superclass that overrides <i>method</i>.
+ *
+ * @param klass     - the class handle
+ * @param method    - the method handle
+ *
+ * @return The method handle for an accessible method overriding <i>method</i>; otherwise, <code>FALSE</code>.
+ */
+Open_Method_Handle
+method_find_overridden_method(Open_Class_Handle klass,
+                              Open_Method_Handle method);
+
+/**
+ * Returns type information of the local variable.
+ *
+ * @param method    - the method handle
+ * @param index     - the local variable number
+ *
+ * @return The type information of the local variable.
+ *
+ * @note Because local variables are not typed in Java*, this function
+ *             always returns <code>NULL</code> for Java* methods.
+ * @note Replaces the method_vars_get_type_info function. 
+ */
+Open_Type_Info_Handle
+method_local_get_type_info(Open_Method_Handle method, unsigned short index);
+
+/**
+ * Returns the number of arguments defined for the method.
+ * This number automatically includes the pointer to this (if present).
+ *
+ * @param method_signature  - method signature handle
+ *
+ * @return The number of arguments defined for the method.
+ */
+unsigned char
+method_args_get_number(Method_Signature_Handle method_signature);
+
+/**
+ * Initializes the ChaMethodIterator <i>iterator</i> to iterate over all
+ * methods that match the method signature and descend from <i>klass</i>
+ * (including <i>klass</i> itself).
+ *
+ * @param iterator  - the class iterator
+ * @param method    - the method handle
+ * @param klass     - the class handle
+ *
+ * @return <code>TRUE</code> if iteration is supported over <i>klass</i>,
+ *                <code>FALSE</code> if it is not.
+ *
+ * @note Reference to internal type ChaMethodIterator.
+ */
+Boolean
+method_iterator_initialize(ChaMethodIterator* iterator,
+                           Open_Method_Handle method,
+                           Open_Class_Handle klass);
+
+/**
+ * Advances the iterator.
+ *
+ * @param iterator  - class iterator
+ *
+ * @note Reference to internal type ChaMethodIterator.
+ */
+void
+method_iterator_advance(ChaMethodIterator* iterator);
+
+/**
+ * Returns the current method of the iterator.
+ *
+ * @param iterator  - the class iterator
+ *
+ * @return The current method of the iterator or <code>NULL</code> if no more methods are left.
+ *
+ * @note Reference to the internal type <i>ChaMethodIterator</i>.
+ */
+Method_Handle
+method_iterator_get_current(ChaMethodIterator* iterator);
+
+/**
+ * Returns the number of exceptions that the given method can throw.
+ *
+ * @param method    - the method handle
+ *
+ * @return The number of exceptions.
+ *
+ * @note Replaces method_number_throws function.
+ */
+unsigned short
+method_get_num_throws(Open_Method_Handle method);
+
+/**
+ * Returns the exception class a given method can throw.
+ *
+ * @param method    - the method handle
+ * @param index     - the exception number
+ *
+ * @return the exception class a given method can throw.
+ */
+Open_Class_Handle
+method_get_throws(Open_Method_Handle method, unsigned short index);
+
+/**
+ * Returns the number of method exception handlers.
+ *
+ * @param method    - the method handle
+ *
+ * @return The number of method exception handlers.
+ *
+ * @note An assertion is raised if method equals to <code>NULL</code>. 
+ * @note Replaces method_get_num_handlers function.
+ */
+unsigned short
+method_get_exc_handler_number(Open_Method_Handle method);
+
+/**
+ * Obtains the method exception handle information.
+ *
+ * @param method         - the method handle
+ * @param index            - the exception handle index number
+ * @param start_pc       - the resulting pointer to the exception handle start program count
+ * @param end_pc         - the resulting pointer to the exception handle end program count
+ * @param handler_pc  - the resulting pointer to the exception handle program count
+ * @param catch_type  - the resulting pointer to the constant pool entry index
+ *
+ * @note An assertion is raised if <i>method</i> equals to <code>NULL</code> or
+ *             if the exception handle index is out of range or if any pointer equals to <code>NULL</code>. 
+ * @note Replaces the method_get_handler_info function.
+ */
+void
+method_get_exc_handler_info(Open_Method_Handle method,
+                            unsigned short index,
+                            unsigned short* start_pc,
+                            unsigned short* end_pc,
+                            unsigned short* handler_pc,
+                            unsigned short* catch_type);
+
+/**
+ * Returns type information for the return value.
+ *
+ * @param method_signature  - the method signature handle
+ *
+ * @return The type information for the return value.
+ */
+Type_Info_Handle
+method_ret_type_get_type_info(Method_Signature_Handle method_signature);
+
+/**
+ *  Checks whether the given argument is a managed pointer.
+ *
+ * @param method_signature  - the method signature handle
+ * @param index             - the argument index
+ *
+ * @return <code>TRUE</code> if the argument is a managed pointer; otherwise, <code>FALSE</code>.
+ */
+Boolean
+method_args_is_managed_pointer(Method_Signature_Handle method_signature, unsigned index);
+
+/**
+ * Returns type information for the given argument.
+ *
+ * @param method_signature  - the method signature handle
+ * @param index             - the argument index
+ *
+ * @return Type information for the argument.
+ */
+Type_Info_Handle
+method_args_get_type_info(Method_Signature_Handle method_signature, unsigned index);
+
+/**
+ * Returns the method bytecode size.
+ *
+ * @param method - the method handle
+ *
+ * @return The method bytecode size.
+ *
+ * @note Replaces the method_get_code_length function.
+ */
+jint
+method_get_bytecode_size(Open_Method_Handle method);
+
+/**
+ * Returns the method bytecode array.
+ *
+ * @param method - the method handle
+ *
+ * @return The method bytecode array.
+ *
+ * @note An assertion is raised if the method equals to <code>NULL</code>. 
+ * @note Reference to type <i>Byte</i>.
+ * @note Replaces the method_get_bytecode function.
+ */
+const char*
+method_get_bytecode_addr(Open_Method_Handle method);
+
+/**
+ * Returns the maximum number of local variables for the given method.
+ *
+ * @param method - the method handle
+ *
+ * @return The maximum number of local variables for the method.
+ *
+ * @note An assertion is raised if the method equals to <code>NULL</code>. 
+ * @note Replaces functions method_get_max_local and method_vars_get_number.
+ */
+jint
+method_get_max_locals(Open_Method_Handle method);
+
+/**
+ * Returns the maximum stack depth for the given method.
+ *
+ * @param method - the method handle
+ *
+ * @return The maximum stack depth for the method.
+ *
+ * @note An assertion is raised if <i>method</i> equals to <code>NULL</code>. 
+ */
+jint
+method_get_max_stack(Open_Method_Handle method);
+
+/**
+ * Returns the offset from the start of the vtable to the entry for the given method
+ *
+ * @param method - the method handle
+ *
+ * @return The offset from the start of the vtable to the entry for the method, in bytes. 
+ */
+unsigned
+method_get_offset(Open_Method_Handle method);
+
+/**
+ * Gets the address of the code pointer for the given method.
+ * 
+ * A straight-forward JIT compiler that does not support recompilation can only generate
+ * code with indirect branches through the address provided by this function.
+ *
+ * @param method - the method handle
+ *
+ * @return the address where the code pointer for a given method is.
+ *
+ *  @see vm_register_jit_recompiled_method_callback
+ */
+Open_Native_Code_Ptr
+method_get_indirect_address(Open_Method_Handle method);
+
+/**
+ * Allocates an information block for the given method.
+ * 
+ * An <i>info block</i> can be later retrieved by the JIT compiler for various operations. 
+ * For example, the JIT can store GC maps for root set enumeration and stack
+ * unwinding in the onfo block.
+ *
+ * @param method    - the method handle
+ * @param jit       - the JIT handle
+ * @param size      - the size of the allocated code block
+ *
+ * @return The pointer to the allocated info block.
+ *
+ * @note Reference to type <i>Byte</i>.
+ *
+ * @see method_allocate_data_block
+ */
+Byte*
+method_allocate_info_block(Open_Method_Handle method,
+                           JIT_Handle jit,
+                           size_t size);
+
+/**
+ * Retrieves the memory block allocated earlier by the
+ * <i>method_allocate_data_block</i> function.
+* The pair of parameters <method, jit> uniquely identifies the JIT compiler information block.
+ *
+ * @param method    - the method handle
+ * @param jit       - the JIT handle
+ *
+ * @return The pointer to the allocated data block.
+ *
+ * @note Reference to type <i>Byte</i>.
+ */
+Byte*
+method_get_data_block_jit(Method_Handle method, JIT_Handle jit);
+
+/**
+ * Retrieves the memory block allocated earlier by the
+ * <i>method_allocate_info_block</i> function.
+ * The pair of parameters <method, jit> uniquely identifies the JIT compiler information block.
+ *
+ * @param method    - the method handle
+ * @param jit       - the JIT handle
+ *
+ * @return The pointer to the allocated info block.
+ *
+ * @note Reference to type <i>Byte</i>.
+ */
+Byte*
+method_get_info_block_jit(Method_Handle method, JIT_Handle jit);
+
+#endif // _VM_METHOD_ACCESS_H

Propchange: harmony/enhanced/drlvm/trunk/vm/include/open/vm_method_access.h
------------------------------------------------------------------------------
    svn:eol-style = native

Added: harmony/enhanced/drlvm/trunk/vm/include/open/vm_type_access.h
URL: http://svn.apache.org/viewvc/harmony/enhanced/drlvm/trunk/vm/include/open/vm_type_access.h?view=auto&rev=565820
==============================================================================
--- harmony/enhanced/drlvm/trunk/vm/include/open/vm_type_access.h (added)
+++ harmony/enhanced/drlvm/trunk/vm/include/open/vm_type_access.h Tue Aug 14 09:10:52 2007
@@ -0,0 +1,83 @@
+/*
+ *  Copyright 2006 The Apache Software Foundation or its licensors, as applicabl
+e.
+ *
+ *  Licensed 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
+ *
+ *  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 Intel, Pavel Pervov
+ * @version $Revision: 1.4 $
+ */
+#ifndef _VM_TYPE_ACCESS_H
+#define _VM_TYPE_ACCESS_H
+
+/**
+ * @file
+ * Part of Class Support interface related to accessing generalized
+ * types' properties.
+ */
+
+/**
+ * Checks whether type information contains the reference type. 
+ *
+ * @param typeinfo - the type information handle
+ *
+ * @return <code>TRUE</code> if type information contains reference description; otherwise, <code>FALSE</code>.
+ */
+Boolean
+type_info_is_reference(Type_Info_Handle typeinfo);
+
+/**
+ * Checks whether type information contains the void type. 
+ *
+ * @param typeinfo - the type information handle
+ *
+ * @return <code>TRUE</code> if type information contains void type; otherwise, <code>FALSE</code>.
+ */
+Boolean
+type_info_is_void(Type_Info_Handle tih);
+
+/**
+ * Checks whether  type information describes the one-dimensional array. 
+ *
+ * @param typeinfo - the type information handle
+ *
+ * @return <code>TRUE</code> if type information describes the one-dimensional array; otherwise, <code>FALSE</code>.
+ */
+Boolean
+type_info_is_vector(Type_Info_Handle tih);
+
+/**
+ * Returns the C++ class structure for the given type information. 
+ *
+ * @param typeinfo - the type information handle
+ * @param exc         - the variable to return the exception "code"
+ *
+ * @return The handle of the C++ class structure for the specified type information.
+ *
+ * @note Reference to the internal type <i>Loader_Exception</i>.
+ */
+Class_Handle
+type_info_get_class(Type_Info_Handle typeinfo, Loader_Exception* exc);
+
+/**
+ * Returns recursive type information for the given type information. 
+ *
+ * @param typeinfo - type information to query
+ *
+ * @return Recursive type information if available; otherwise, <code>NULL</code>.
+ */
+Type_Info_Handle
+type_info_get_type_info(Type_Info_Handle typeinfo);
+
+#endif // _VM_TYPE_ACCESS_H

Propchange: harmony/enhanced/drlvm/trunk/vm/include/open/vm_type_access.h
------------------------------------------------------------------------------
    svn:eol-style = native



Mime
View raw message