Google Git
Sign in
apache / harmony / java6 / . / drlvm / vm / vmcore / include / Class.h
blob: fac28b46662f95adb826d190ad37e1928249e5db [file] [log] [blame]
/**
* 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
*
* 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 Pavel Pervov
*/
#ifndef _CLASS_H_
#define _CLASS_H_
/**
* @file
* Interfaces to class functionality.
*/
#include <assert.h>
#include "open/gc.h"
#include "open/rt_types.h"
#include "port_malloc.h"
#include "String_Pool.h"
#include "jit_intf.h"
#include <vector>
//
// magic number, and major/minor version numbers of class file
//
#define CLASSFILE_MAGIC 0xCAFEBABE
#define CLASSFILE_MAJOR_MIN 45
// Supported class files up to this version
#define CLASSFILE_MAJOR_MAX 50
#define CLASSFILE_MINOR_MAX 0
// forward declarations
struct Class;
// external declarations
class Class_Member;
struct Field;
struct Method;
struct Class_Extended_Notification_Record;
class CodeChunkInfo;
class Lock_Manager;
class ByteReader;
struct ClassLoader;
class JIT;
struct Global_Env;
class Package;
struct VM_thread;
struct AnnotationTable;
struct VTable;
struct Intfc_Table;
/** The constant pool entry descriptor.
* For each constant pool entry, the descriptor content varies depending
* on the constant pool tag that corresponds to this constant pool entry.
* Content of each entry is described in
* <a href="http://java.sun.com/docs/books/vmspec/2nd-edition/ClassFileFormat-Java5.pdf">
* The Java Virtual Machine Specification, Chapter 4</a>, <i>The Constant
* Pool</i> section, with the following exceptions:<ol>
* <li>A zero entry of the constant pool contains an array of tags
* corresponding to entries in the constant pool entries array.</li>
* <li>As required by
* <a href=http://java.sun.com/docs/books/vmspec/2nd-edition/ConstantPool.pdf>
* The Java Virtual Machine Specification, Chapter 5</a>
* <i>Linking/Resolution</i> section, errors are cached for entries that have
* not been resolved earlier for some reason.</li></ol>
*/
union ConstPoolEntry {
/** Zero entry of constant pool only: array of tags for constant pool.*/
unsigned char* tags;
/** CONSTANT_Class.*/
struct {
union {
/** Resolved class*/
Class* klass;
/** Resolution error, if any.*/
struct {
/** Next resolution error in this constant pool.*/
ConstPoolEntry* next;
/** Exception object describing an error.*/
ManagedObject* cause;
} error;
};
/** Index to class name in this constant pool.*/
uint16 name_index;
} CONSTANT_Class;
/** CONSTANT_String.*/
struct {
/** Resolved class.*/
String* string;
/** Index of CONSTANT_Utf8 for this string.*/
uint16 string_index;
} CONSTANT_String;
/** CONSTANT_{Field|Method|InterfaceMethod}ref.*/
struct {
union {
/** Generic class member for CONSTANT_*ref.
* Only valid for resolved refs.*/
Class_Member* member;
/** Resolved entry for CONSTANT_Fieldref.*/
Field* field;
/** resolved entry for CONSTANT_[Interface]Methodref.*/
Method* method;
/** Resolution error, if any.*/
struct {
/** Next resolution error in this constant pool.*/
ConstPoolEntry* next;
/** Exception object describing error.*/
ManagedObject* cause;
} error;
};
/** Index of CONSTANT_Class for this CONSTANT_*ref.*/
uint16 class_index;
/** Index of CONSTANT_NameAndType for CONSTANT_*ref.*/
uint16 name_and_type_index;
} CONSTANT_ref;
/** Shortcut to resolution error in CONSTANT_Class and CONSTANT_ref.*/
struct {
/** Next resolution error in this constant pool.*/
ConstPoolEntry* next;
/** Exception object describing error.*/
ManagedObject* cause;
} error;
/** CONSTANT_Integer.*/
U_32 int_value;
/** CONSTANT_Float.*/
float float_value;
/** CONSTANT_Long and CONSTANT_Double.
* @note In this case we pack all 8 bytes of long/double in one
* ConstPoolEntry and leave the second ConstPoolEntry of the long/double
* unused.*/
struct {
U_32 low_bytes;
U_32 high_bytes;
} CONSTANT_8byte;
/** CONSTANT_NameAndType.*/
struct {
/** Resolved name.*/
String* name;
/** Resolved descriptor.*/
String* descriptor;
/** Name index in this constant pool.*/
uint16 name_index;
/** Descriptor index in this constant pool.*/
uint16 descriptor_index;
} CONSTANT_NameAndType;
/** CONSTANT_Utf8.*/
struct {
/** Content of CONSTANT_Utf8 entry.*/
String* string;
} CONSTANT_Utf8;
};
/** Types of constant pool entries. These entry types are defined by a seperate
* byte array that the first constant pool entry points at.*/
enum ConstPoolTags {
/** pointer to the tags array.*/
CONSTANT_Tags = 0,
/** The next 11 tag values are taken from
* <a href="http://java.sun.com/docs/books/vmspec/2nd-edition/ClassFileFormat-Java5.pdf">
* The Java Virtual Machine Specification, Chapter 4</a>, <i>The Constant
* Pool</i> section.*/
CONSTANT_Utf8 = 1,
CONSTANT_Integer = 3,
CONSTANT_Float = 4,
CONSTANT_Long = 5,
CONSTANT_Double = 6,
CONSTANT_Class = 7,
CONSTANT_String = 8,
CONSTANT_Fieldref = 9,
CONSTANT_Methodref = 10,
CONSTANT_InterfaceMethodref = 11,
CONSTANT_NameAndType = 12,
CONSTANT_Last = CONSTANT_NameAndType,
/** used to mark second entry of Long and Double*/
CONSTANT_UnusedEntry = CONSTANT_Last + 1,
};
/** The constant pool of a class and related operations.
* The structure covers all operations that may be required to run
* on the constant pool, such as parsing and processing queries.*/
struct ConstantPool {
private:
// tag mask; 4 bits are sufficient for tag
static const unsigned char TAG_MASK = 0x0F;
// this entry contains resolution error information
static const unsigned char ERROR_MASK = 0x40;
// "entry is resolved" flag; msb
static const unsigned char RESOLVED_MASK = 0x80;
// constant pool size
uint16 m_size;
// constant pool entries; 0-th entry contains array of constant pool tags
// for all entries
ConstPoolEntry* m_entries;
// List of constant pool entries, which resolution had failed
// Required for fast enumeration of error objects
ConstPoolEntry* m_failedResolution;
public:
/** Initializes the constant pool to its initial values.*/
ConstantPool() {
init();
}
/** Clears constant pool content (if there are any).*/
~ConstantPool() {
clear();
}
/** Checks whether the constant pool is not empty.
* @return <code>true</code> if the constant pool contains
* certain entries; otherwise <code>false</code>.*/
bool available() const { return m_size != 0; }
/** Gets the size of the given constant pool.
* @return The number of entries in the constant pool.*/
uint16 get_size() const { return m_size; }
/** Checks whether the index is a valid one in the constant pool.
* @param[in] index - an index in the constant pool
* @return <code>true</code> if the index is a valid one in the constant
* pool; otherwise <code>false</code>.*/
bool is_valid_index(uint16 index) const {
// index is valid if it's greater than zero and less than m_size
// See specification 4.2 about constant_pool_count
return index != 0 && index < m_size;
}
/** Checks whether the constant-pool entry is resolved.
* @param[in] index - an index in the constant pool
* @return <code>true</code> if the entry is resolved;
* otherwise <code>false</code>.*/
bool is_entry_resolved(uint16 index) const {
assert(is_valid_index(index));
return (m_entries[0].tags[index] & RESOLVED_MASK) != 0;
}
/** Checks whether the resolution of the constant-pool entry has failed.
* @param[in] index - an index in the constant pool
* @return <code>true</code> if the resolution error is recorded
* for the entry.*/
bool is_entry_in_error(uint16 index) const {
assert(is_valid_index(index));
return (m_entries[0].tags[index] & ERROR_MASK) != 0;
}
/** Checks whether the constant-pool entry represents the string of
* the #CONSTANT_Utf8 type.
* @param[in] index - an index in the constant pool
* @return <code>true</code> if the given entry is the <code>utf8</code>
* string; otherwise <code>false</code>.*/
bool is_utf8(uint16 index) const {
return get_tag(index) == CONSTANT_Utf8;
}
/** Checks whether the constant-pool entry refers to a #CONSTANT_Class.
* @param[in] index - an index in the constant pool
* @return <code>true</code> if the given entry is a class;
* otherwise <code>false</code>.*/
bool is_class(uint16 index) const {
return get_tag(index) == CONSTANT_Class;
}
/** Checks whether the constant-pool entry contains a constant.
* @param[in] index - an index in the constant pool
* @return <code>true</code> if the given entry contains a constant;
* otherwise <code>false</code>.*/
bool is_constant(uint16 index) const {
return get_tag(index) == CONSTANT_Integer
|| get_tag(index) == CONSTANT_Float
|| get_tag(index) == CONSTANT_Long
|| get_tag(index) == CONSTANT_Double
|| get_tag(index) == CONSTANT_String
|| get_tag(index) == CONSTANT_Class;
}
/** Checks whether the constant-pool entry is a literal constant.
* @param[in] index - an index in the constant pool
* @return <code>true</code> if the given entry contains a string;
* otherwise <code>false</code>.*/
bool is_string(uint16 index) const {
return get_tag(index) == CONSTANT_String;
}
/** Checks whether the constant-pool entry is #CONSTANT_NameAndType.
* @param[in] index - an index in the constant pool
* @return <code>true</code> if the given entry contains name-and-type;
* otherwise <code>false</code>.*/
bool is_name_and_type(uint16 index) const {
return get_tag(index) == CONSTANT_NameAndType;
}
/** Checks whether the constant-pool entry contains a field reference,
* #CONSTANT_Fieldref.
* @param[in] index - an index in the constant pool
* @return <code>true</code> if the given entry contains a field reference;
* otherwise <code>false</code>.*/
bool is_fieldref(uint16 index) const {
return get_tag(index) == CONSTANT_Fieldref;
}
/** Checks whether the constant-pool entry contains a method reference,
* #CONSTANT_Methodref.
* @param[in] index - an index in the constant pool
* @return <code>true</code> if the given entry contains a method reference;
* otherwise <code>false</code>.*/
bool is_methodref(uint16 index) const {
return get_tag(index) == CONSTANT_Methodref;
}
/** Checks whether the constant-pool entry constains an interface-method
* reference, #CONSTANT_InterfaceMethodref.
* @param[in] index - an index in the constant pool
* @return <code>true</code> if the given entry contains an interface-method
* reference; otherwise <code>false</code>.*/
bool is_interfacemethodref(uint16 index) const {
return get_tag(index) == CONSTANT_InterfaceMethodref;
}
/** Gets a tag of the referenced constant-pool entry.
* @param[in] index - an index in the constant pool
* @return A constant-pool entry tag for a given index.*/
unsigned char get_tag(uint16 index) const {
assert(is_valid_index(index));
return m_entries[0].tags[index] & TAG_MASK;
}
/** Gets characters from the <code>utf8</code> string stored in the
* constant pool.
* @param[in] index - an index in the constant pool
* @return Characters from the <code>utf8</code> string stored in
* the constant pool.*/
const char* get_utf8_chars(uint16 index) const {
return get_utf8_string(index)->bytes;
}
/** Gets the <code>utf8</code> string stored in the constant pool.
* @param[in] index - an index in the constant pool
* @return The <code>utf8</code> string.*/
String* get_utf8_string(uint16 index) const {
assert(is_utf8(index));
return m_entries[index].CONSTANT_Utf8.string;
}
/** Gets characters stored in the <code>utf8</code> string for
* the #CONSTANT_String entry.
* @param[in] index - an index in the constant pool
* @return The <code>utf8</code> string characters for the given
* constant-pool entry.*/
const char* get_string_chars(uint16 index) const {
return get_string(index)->bytes;
}
/** Gets the <code>utf8</code> string stored for the #CONSTANT_String
* entry.
* @param[in] index - an index in the constant pool
* @return The <code>utf8</code> string stored in the constant-pool entry.*/
String* get_string(uint16 index) const {
assert(is_string(index));
return m_entries[index].CONSTANT_String.string;
}
/** Gets the <code>utf8</code> string representing the name part of the
* name-and-type constant-pool entry.
* @param[in] index - an index in the constant pool
* @return The <code>utf8</code> string with the name part.*/
String* get_name_and_type_name(uint16 index) const {
assert(is_name_and_type(index));
assert(is_entry_resolved(index));
return m_entries[index].CONSTANT_NameAndType.name;
}
/** Gets the <code>utf8</code> string representing the descriptor part of
* the name-and-type constant-pool entry.
* @param[in] index - an index in the constant pool
* @return The <code>utf8</code> string with the descriptor part.*/
String* get_name_and_type_descriptor(uint16 index) const {
assert(is_name_and_type(index));
assert(is_entry_resolved(index));
return m_entries[index].CONSTANT_NameAndType.descriptor;
}
/** Gets the generic class member for the <code>CONSTANT_*ref</code>
* constant-pool entry.
* @param[in] index - an index in the constant pool
* @return The generic-class member for the given constant-pool entry.*/
Class_Member* get_ref_class_member(uint16 index) const {
assert(is_fieldref(index)
|| is_methodref(index)
|| is_interfacemethodref(index));
return m_entries[index].CONSTANT_ref.member;
}
/** Gets the method from the #CONSTANT_Methodref or
* the #CONSTANT_InterfaceMethodref constant-pool entry
* @param[in] index - an index in the constant pool
* @return The method from the given constant-pool entry.*/
Method* get_ref_method(uint16 index) const {
assert(is_methodref(index)
|| is_interfacemethodref(index));
assert(is_entry_resolved(index));
return m_entries[index].CONSTANT_ref.method;
}
/** Gets the field from the #CONSTANT_Fieldref
* constant-pool entry.
* @param[in] index - an index in the constant pool
* @return The field from the given constant-pool entry.*/
Field* get_ref_field(uint16 index) const {
assert(is_fieldref(index));
assert(is_entry_resolved(index));
return m_entries[index].CONSTANT_ref.field;
}
/** Gets the class for the #CONSTANT_Class
* constant-pool entry.
* @param[in] index - an index in the constant pool
* @return The class for the given constant-pool entry.*/
Class* get_class_class(uint16 index) const {
assert(is_class(index));
assert(is_entry_resolved(index));
return m_entries[index].CONSTANT_Class.klass;
}
/** Gets a 32-bit value (either interger or float) for a constant stored
* in the constant pool.
* @param[in] index - an index in the constant pool
* @return The value of a 32-bit constant stored in the constant pool.*/
U_32 get_4byte(uint16 index) const {
assert(get_tag(index) == CONSTANT_Integer
|| get_tag(index) == CONSTANT_Float);
return m_entries[index].int_value;
}
/** Gets an integer value for a constant stored in the constant pool.
* @param[in] index - an index in the constant pool
* @return The value of integer constant stored in the constant pool.*/
U_32 get_int(uint16 index) const {
assert(get_tag(index) == CONSTANT_Integer);
return m_entries[index].int_value;
}
/** Gets a float value for a constant stored in the constant pool.
* @param[in] index - an index in the constant pool
* @return A value of a float constant stored in the constant pool.*/
float get_float(uint16 index) const {
assert(get_tag(index) == CONSTANT_Float);
return m_entries[index].float_value;
}
/** Gets a low word of the 64-bit constant (either long or double)
* stored in the constant pool.
* @param[in] index - an index in the constant pool
* @return A value of low 32-bits of 64-bit constant.*/
U_32 get_8byte_low_word(uint16 index) const {
assert(get_tag(index) == CONSTANT_Long
|| get_tag(index) == CONSTANT_Double);
return m_entries[index].CONSTANT_8byte.low_bytes;
}
/** Gets a high word of the 64-bit constant (either long or double)
* stored in the constant pool.
* @param[in] index - an index in the constant pool
* @return A value of high 32-bits of 64-bit constant.*/
U_32 get_8byte_high_word(uint16 index) const {
assert(get_tag(index) == CONSTANT_Long
|| get_tag(index) == CONSTANT_Double);
return m_entries[index].CONSTANT_8byte.high_bytes;
}
/** Gets an address of a constant stored in the constant pool.
* @param[in] index - an index in the constant pool
* @return An address of a constant.*/
void* get_address_of_constant(uint16 index) const {
assert(is_constant(index));
assert(!is_string(index));
return (void*)(m_entries + index);
}
/** Gets an exception, which has caused failure of the referred
* constant-pool entry.
* @param[in] index - an index in the constant pool
* @return An exception object, which is the cause of the
* resolution failure.*/
jthrowable get_error_cause(uint16 index) const {
assert(is_entry_in_error(index));
return (jthrowable)(&(m_entries[index].error.cause));
}
/** Gets a head of a single-linked list containing resolution errors
* in the given constant pool.
* @return A head of a signle-linked list of constant-pool entries,
* which resolution had failed.*/
ConstPoolEntry* get_error_chain() const {
return m_failedResolution;
}
/** Gets an an index in the constant pool where the <code>utf8</code>
* representation for #CONSTANT_String is stored.
* @param[in] index - an index in the constant pool for the
* #CONSTANT_String entry
* @return An an index in the constant pool with the <code>utf8</code>
* representation of the given string.*/
uint16 get_string_index(uint16 index) const {
assert(is_string(index));
return m_entries[index].CONSTANT_String.string_index;
}
/** Gets an index of the constant-pool entry containing the
* <code>utf8</code> string with the name part.
* @param[in] index - an index in the constant pool
* @return An an index in the constant pool with the <code>utf8</code>
* name string.*/
uint16 get_name_and_type_name_index(uint16 index) const {
assert(is_name_and_type(index));
return m_entries[index].CONSTANT_NameAndType.name_index;
}
/** Gets an index of the constant-pool entry containing the
* <code>utf8</code> string with the descriptor part.
* @param[in] index - an index in the constant pool
* @return An an index in the constant pool with the <code>utf8</code>
* string for the descriptor.*/
uint16 get_name_and_type_descriptor_index(uint16 index) const {
assert(is_name_and_type(index));
return m_entries[index].CONSTANT_NameAndType.descriptor_index;
}
/** Gets an index of the constant-pool entry containing a class for
* the given <code>CONSTANT_*ref</code> entry.
* @param[in] index - an index in the constant pool
* @return An index of a class entry for the given constant-pool entry.*/
uint16 get_ref_class_index(uint16 index) const {
assert(is_fieldref(index)
|| is_methodref(index)
|| is_interfacemethodref(index));
return m_entries[index].CONSTANT_ref.class_index;
}
/** Gets an index of <code>CONSTANT_NameAndType</code> for the given
* constant-pool entry.
* @param[in] index - an index in the constant pool
* @return An index of #CONSTANT_NameAndType for the given
* constant-pool entry.*/
uint16 get_ref_name_and_type_index(uint16 index) const {
assert(is_fieldref(index)
|| is_methodref(index)
|| is_interfacemethodref(index));
return m_entries[index].CONSTANT_ref.name_and_type_index;
}
/** Gets a class-name an index in the constant pool for the
* #CONSTANT_Class entry.
* @param[in] index - an index in the constant pool
* @return An index of the <code>utf8</code> name of the given class.*/
uint16 get_class_name_index(uint16 index) const {
assert(is_class(index));
return m_entries[index].CONSTANT_Class.name_index;
}
/** Resolves an entry to the class.
* @param[in] index - an index in the constant pool
* @param[in] clss - a class to resolve the given entry to*/
void resolve_entry(uint16 index, Class* clss) {
// we do not want to resolve entry of a different type
assert(is_class(index));
set_entry_resolved(index);
m_entries[index].CONSTANT_Class.klass = clss;
}
/** Resolves an entry to the field.
* @param[in] index - an index in the constant pool
* @param[in] field - a field to resolve the given entry to*/
void resolve_entry(uint16 index, Field* field) {
// we do not want to resolve entry of different type
assert(is_fieldref(index));
set_entry_resolved(index);
m_entries[index].CONSTANT_ref.field = field;
}
/** Resolves an entry to the method.
* @param[in] index - an index in the constant pool
* @param[in] method - a method to resolve the given entry to*/
void resolve_entry(uint16 index, Method* method) {
// we do not want to resolve entry of a different type
assert(is_methodref(index) || is_interfacemethodref(index));
set_entry_resolved(index);
m_entries[index].CONSTANT_ref.method = method;
}
/** Records a resolution error into a constant-pool entry.
* @param[in] index - an index in the constant pool
* @param[in] exn - a cause of resolution failure
* @note Disable suspension during this operation.*/
void resolve_as_error(uint16 index, jthrowable exn) {
assert(is_class(index)
|| is_fieldref(index)
|| is_methodref(index)
|| is_interfacemethodref(index));
set_entry_error_state(index);
m_entries[index].error.cause = *((ManagedObject**)exn);
m_entries[index].error.next = m_failedResolution;
assert(&(m_entries[index]) != m_failedResolution);
m_failedResolution = &(m_entries[index]);
}
/** Parses in a constant pool for a class.
* @param[in] clss - a class containing the given constant pool
* @param[in] string_pool - a reference to the string pool to intern strings in
* @param[in] cfs - a byte stream to parse the constant pool from
* @return <code>true</code> if the constant pool was parsed successfully;
* <code>false</code> if some error was discovered during the parsing.*/
bool parse(Class* clss, String_Pool& string_pool, ByteReader& cfs);
/** Checks constant pool consistency. <ul>
* <li>Makes sure that all indices to other constant pool entries are in range
* and that contents of the entries are of the right type.
* <li>Sets #CONSTANT_Class entries to point directly
* to <code>String</code> representing the internal form of a fully qualified
* form of a fully qualified name of <code>%Class</code>.
* <li>Sets #CONSTANT_String entries to point directly to the
* <code>String</code> representation.
* <li>Preresolves #CONSTANT_NameAndType entries to signatures. </ul>
* @param[in] env - VM environment
* @param[in] clss - the class that the given constant pool belongs to
* @param[in] is_trusted_cl - defines whether class was loaded by
* trusted classloader. User defined classloaders are not trusted.
* @return <code>true</code> if the constant pool of clss is valid;
* otherwise <code>false</code>.*/
bool check(Global_Env * env, Class* clss, bool is_trusted_cl);
/** Clears the constant-pool content: tags and entries arrays.*/
void clear() {
if(m_size != 0) {
delete[] m_entries[0].tags;
delete[] m_entries;
}
init();
}
/** Initializes the constant pool to initial values.*/
void init() {
m_size = 0;
m_entries = NULL;
m_failedResolution = NULL;
}
private:
/** Sets a resolved flag in the constant-pool entry.
* @param[in] index - an index in the constant pool*/
void set_entry_resolved(uint16 index) {
assert(is_valid_index(index));
//// we do not want to resolve one entry twice
// ppervov: FIXME: there is possible positive/negative race condition
// in class resolution
//assert(!is_entry_resolved(index));
// we should not resolve failed entries
// see comment above
//assert(!is_entry_in_error(index));
m_entries[0].tags[index] |= RESOLVED_MASK;
}
/** Sets an error flag in the constant-pool entry to mark it as failed.
* @param[in] index - an index in the constant pool*/
void set_entry_error_state(uint16 index) {
assert(is_valid_index(index));
//// we do not want to reset the resolved error
// ppervov: FIXME: there is possible positive/negative race condition
// in class resolution
//assert(!is_entry_resolved(index));
// we do not want to reset the reason of the failure
// see comment above
//assert(!is_entry_in_error(index));
m_entries[0].tags[index] |= ERROR_MASK;
}
/** Resolves the #CONSTANT_NameAndType constant-pool entry
* to actual string values.
* @param[in] index - an index in the constant pool
* @param[in] name - name-and-type name
* @param[in] descriptor - name-and-type type (descriptor)*/
void resolve_entry(uint16 index, String* name, String* descriptor) {
// we do not want to resolve entry of different type
assert(is_name_and_type(index));
set_entry_resolved(index);
m_entries[index].CONSTANT_NameAndType.name = name;
m_entries[index].CONSTANT_NameAndType.descriptor = descriptor;
}
/** Resolves the <code>CONSTANT_String</code> constant-pool entry to
* actual string values.
* @param[in] index - an index in the constant pool
* @param[in] str - an actual string*/
void resolve_entry(uint16 index, String* str) {
assert(is_string(index));
set_entry_resolved(index);
m_entries[index].CONSTANT_String.string = str;
}
};
/** Converts a class name from an internal (VM) form to the Java form.
* @param[in] class_name - the class name in an internal form
* @return The class name in the Java form.*/
VMEXPORT String* class_name_get_java_name(const String* class_name);
// A Java class
extern "C" {
/** The state of the Java class*/
enum Class_State {
ST_Start, /// the initial state
ST_LoadingAncestors, /// the loading super class and super interfaces
ST_Loaded, /// successfully loaded
ST_BytecodesVerified, /// bytecodes for methods verified for the class
ST_InstanceSizeComputed, /// preparing the class; instance size known
ST_Prepared, /// successfully prepared
ST_ConstraintsVerified, /// constraints verified for the class
ST_Initializing, /// initializing the class
ST_Initialized, /// the class initialized
ST_Error /// bad class or the class initializer failed
};
/** Access and properties flags for Class, Field and Method.*/
enum AccessAndPropertiesFlags {
/** Public access modifier. Valid for Class, Field, Method. */
ACC_PUBLIC = 0x0001,
/** Private access modifier. Valid for Field, Method.*/
ACC_PRIVATE = 0x0002,
/** Protected access modifier. Valid for Field, Method.*/
ACC_PROTECTED = 0x0004,
/** Static modifier. Valid for Field, Method.*/
ACC_STATIC = 0x0008,
/** Final modifier. Valid for Class, Field, Method.*/
ACC_FINAL = 0x0010,
/** Super modifier. Valid for Class.*/
ACC_SUPER = 0x0020,
/** Synchronized modifier. Valid for Method.*/
ACC_SYNCHRONIZED = 0x0020,
/** Bridge modifier. Valid for Method (since J2SE 5.0).*/
ACC_BRIDGE = 0x0040,
/** Volatile modifier. Valid for Field.*/
ACC_VOLATILE = 0x0040,
/** Varargs modifier. Valid for Method (since J2SE 5.0).*/
ACC_VARARGS = 0x0080,
/** Transient modifier. Valid for Field.*/
ACC_TRANSIENT = 0x0080,
/** Native modifier. Valid for Method.*/
ACC_NATIVE = 0x0100,
/** Interface modifier. Valid for Class.*/
ACC_INTERFACE = 0x0200,
/** Abstract modifier. Valid for Class, Method.*/
ACC_ABSTRACT = 0x0400,
/** Strict modifier. Valid for Method.*/
ACC_STRICT = 0x0800,
/** Synthetic modifier. Valid for Class, Field, Method (since J2SE 5.0).*/
ACC_SYNTHETIC = 0x1000,
/** Annotation modifier. Valid for Class (since J2SE 5.0).*/
ACC_ANNOTATION = 0x2000,
/** Enum modifier. Valid for Class, Field (since J2SE 5.0).*/
ACC_ENUM = 0x4000
};
/** VM representation of Java class.
* This class contains methods for parsing classes, querying class properties,
* setting external properties of a class (source file name, class file name),
* calling the verifier, preparing, resolving and initializing the class.*/
struct Class {
private:
typedef struct {
union {
const String* name;
Class* clss;
};
unsigned cp_index;
} Class_Super;
//
// super class of this class; initially, it is the string name of super
// class; after super class is loaded, it becomes a pointer to class
// structure of the super class.
//
Class_Super m_super_class;
// class name in internal (VM, class-file) format
const String* m_name;
// class canonical (Java) name
String* m_java_name;
// generic type information (since Java 1.5.0)
String* m_signature;
// simple name of the class as given in the source code; empty string if anonymous
String* m_simple_name;
// package to which this class belongs
Package* m_package;
// Distance in the hierarchy from java/lang/Object
U_32 m_depth;
// The field m_is_suitable_for_fast_instanceof should be 0
// if depth==0 or depth>=vm_max_fast_instanceof_depth()
// or is_array or access_flags&ACC_INTERFACE
// It should be 1 otherwise
int m_is_suitable_for_fast_instanceof;
// string name of file from which this class has been loaded
const char* m_class_file_name;
// string name of source java file from which this class has been compiled
const String* m_src_file_name;
// unique class id
// FIXME: current implementation of id is not thread safe
// so, class id may not be unique
unsigned m_id;
// The class loader used to load this class.
ClassLoader* m_class_loader;
// This points to the location where java.lang.Class associated
// with the current class resides. Similarly, java.lang.Class has a field
// that points to the corresponding Class data structure.
ManagedObject** m_class_handle;
// class file major version
uint16 m_version;
// Access and properties flags of a class
uint16 m_access_flags;
// state of this class
Class_State m_state;
// Is this class marked as deprecated
bool m_deprecated;
// Does this class represent a primitive type?
unsigned m_is_primitive : 1;
// Does this class represent an array?
unsigned m_is_array : 1;
// Does base class of this array is primitive
unsigned m_is_array_of_primitives : 1;
// Does the class have a finalizer that is not inherited from
// java.lang.Object?
unsigned m_has_finalizer : 1;
// Should access from this class be checked
// (needed for certain special classes)
unsigned m_can_access_all : 1;
// Can instances of this class be allocated using a fast inline sequence
// containing no calls to other routines
unsigned char m_is_fast_allocation_possible;
// Offset from the top by CLASS_ALLOCATED_SIZE_OFFSET
// The number of bytes allocated for this object. It is the same as
// instance_data_size with the constraint bit cleared. This includes
// the OBJECT_HEADER_SIZE as well as the OBJECT_VTABLE_POINTER_SIZE
unsigned int m_allocated_size;
// This is the size of an instance without any alignment padding.
// It can be used while calculating the field offsets of subclasses.
// It does not include the OBJECT_HEADER_SIZE but does include the
// OBJECT_VTABLE_POINTER_SIZE.
// The m_allocated_size field will be this field properly aligned.
unsigned m_unpadded_instance_data_size;
// How should objects of this class be aligned by GC.
int m_alignment;
// Try to keep instance_data_size near vtable since they are used at the same time
// by the allocation routines and sharing a cache line seem to help.
// The next to high bit is set if allocation needs to consider class_properties.
// (mumble->instance_data_size & NEXT_TO_HIGH_BIT_CLEAR_MASK) will always return the
// actual size of and instance of class mumble.
// Use get_instance_data_size() to get the actual size of an instance.
// Use set_instance_data_size_constraint_bit() to set this bit.
// For most classes the size of a class instance's data block.
// This is what is passed to the GC. See above for details.
unsigned m_instance_data_size;
// ppervov: FIXME: the next two can be joined into a union;
// vtable compression should be dropped in that case
// virtual method table; <code>NULL</code> for interfaces
VTable* m_vtable;
// "Compressed VTable" - offset from the base of VTable allocation area
Allocation_Handle m_allocation_handle;
// number of virtual methods in vtable
unsigned m_num_virtual_method_entries;
// number of interface methods in vtable
unsigned m_num_intfc_method_entries;
// An array of pointers to Method descriptors, one descriptor
// for each corresponding entry in m_vtable.methods[].
Method** m_vtable_descriptors;
// number of dimensions in array; current VM limitation is 255
// Note, that you can derive the base component type of the array
// by looking at m_name->bytes[m_num_dimensions].
unsigned char m_num_dimensions;
// for non-primitive arrays only, array_base_class is the base class
// of an array
Class* m_array_base_class;
// class of the element of an array
Class* m_array_element_class;
// size of element of array; equals zero, if this class is not an array
unsigned int m_array_element_size;
// shift corresponding to size of element of array, undefined for non-arrays
unsigned int m_array_element_shift;
// Number of superinterfaces
uint16 m_num_superinterfaces;
// array of interfaces this class implements; size is m_num_superinterfaces
// initially, it is an array of string names of interfaces and then,
// after superinterfaces are loaded, this becomes an array pointers
// to superinterface class structures
Class_Super* m_superinterfaces;
// constant pool of class
ConstantPool m_const_pool;
// number of fields in this class
uint16 m_num_fields;
// number of static fields in this class
uint16 m_num_static_fields;
// number of instance fields that are references
unsigned m_num_instance_refs;
// array of fields; size is m_num_fields
Field* m_fields;
// size of this class' static data block
unsigned m_static_data_size;
// block containing array of static data fields
void* m_static_data_block;
// number of methods in this class
uint16 m_num_methods;
// array of methods; size is m_num_methods
Method* m_methods;
// pointer to finalize method, NULL if none exists
Method* m_finalize_method;
// pointer to <clinit> method, NULL if none exists
Method* m_static_initializer;
// pointer to init()V method, cached for performance
Method* m_default_constructor;
// index of declaring class in constant pool of this class
uint16 m_declaring_class_index;
// index of CONSTANT_Class of outer class
uint16 m_enclosing_class_index;
// index of CONSTANT_MethodRef of outer method
uint16 m_enclosing_method_index;
// number of inner classes
uint16 m_num_innerclasses;
struct InnerClass {
uint16 index;
uint16 access_flags;
};
// indexes of inner classes descriptors in constant pool
InnerClass* m_innerclasses;
// annotations for this class
AnnotationTable* m_annotations;
//invisible annotations for this class
AnnotationTable* m_invisible_annotations;
// thread, which currently executes <clinit>
VM_thread* m_initializing_thread;
// These fields store information for
// Class Hierarchy Analysis JIT optimizations
// first class extending this class
Class* m_cha_first_child;
// next class which extends the same superclass
Class* m_cha_next_sibling;
// SourceDebugExtension class attribute support
String* m_sourceDebugExtension;
// verifier private data pointer
void* m_verify_data;
// class operations lock
Lock_Manager* m_lock;
// Per-class statistics
// Number of times an instance of the class has been created
// using new, newarray, etc
uint64 m_num_allocations;
// Number of bytes allocated for instances of the class
uint64 m_num_bytes_allocated;
// Number of instanceof/checkcast calls both from the user code
// and the VM that were not subsumed by the fast version of instanceof
uint64 m_num_instanceof_slow;
// For subclasses of java.lang.Throwable only
uint64 m_num_throws;
// Number of times class is checked for initialization
uint64 m_num_class_init_checks;
// Number of "padding" bytes added per class instance to its fields to
// make each field at least 32 bits
U_32 m_num_field_padding_bytes;
public:
/** Initializes class-member variables to their initial values.
* @param[in] env - VM environment
* @param[in] name - a class name to assign to the given class
* @param[in] cl - a class loader for the given class*/
void init_internals(const Global_Env* env, const String* name, ClassLoader* cl);
/** Clears member variables within a class.*/
void clear_internals();
void notify_unloading();
/** Determines whether the given class has a super class.
* @return <code>true</code> if the current class has a super class;
* otherwise <code>false</code>.*/
bool has_super_class() const {
return m_super_class.clss != NULL;
}
/** Gets the name of the super class.
*
* @return The super class name or <code>NULL</code>, if the given class
* is <code>java/lang/Object</code>.
* @note It is valid until the super class is loaded; after that, use
* <code>get_super_class()->get_name()</code> to retrieve the
* super class name.*/
const String* get_super_class_name() const {
return m_super_class.name;
}
/** Gets the super class of the given class.
* @return The super class of the given class or <code>NULL</code>,
* if the given class is <code>java/lang/Object</code>.*/
Class* get_super_class() const {
return m_super_class.clss;
}
/** Gets the class loader of the given class.
* @return the class loader of the given class.*/
ClassLoader* get_class_loader() const {
return m_class_loader;
}
/** Gets the class handle of <code>java.lang.Class</code> for the given class.
* @return The <code>java.lang.Class</code> handle for the given class.*/
ManagedObject** get_class_handle() const { return m_class_handle; }
/** Gets the natively interned class name for the given class.
* @return The class name in the VM format.*/
const String* get_name() const { return m_name; }
/** Gets a natively interned class name for the given class.
* @return A class name in the Java format.*/
String* get_java_name() {
if(!m_java_name) {
m_java_name = class_name_get_java_name(m_name);
}
return m_java_name;
}
/** Gets a class signature.
* @return A class signature.*/
String* get_signature() const { return m_signature; }
/** Gets a simple name of the class.
* @return A simple name of the class.*/
String* get_simple_name();
/** Gets a package containing the given class.
* @return A package to which the given class belongs.*/
Package* get_package() const { return m_package; }
/** Gets depth in the hierarchy of the given class.
* @return A number of classes in the super-class hierarchy.*/
U_32 get_depth() const { return m_depth; }
bool get_fast_instanceof_flag() const { return m_is_suitable_for_fast_instanceof; }
/** Gets the vtable for the given class.
* @return The vtable for the given class or <code>NULL</code>, if the given
* class is an interface.*/
VTable* get_vtable() const { return m_vtable; }
/** Gets an allocation handle for the given class.*/
Allocation_Handle get_allocation_handle() const { return m_allocation_handle; }
/** Gets the length of the source-file name.
* @return The length in bytes of the source-file name.*/
size_t get_source_file_name_length() {
assert(has_source_information());
return m_src_file_name->len;
}
/** Gets a source-file name.
* @return A source-file name for the given class.*/
const char* get_source_file_name() {
assert(has_source_information());
return m_src_file_name->bytes;
}
/** Gets a method localed at <code>method_idx</code> in
* the <code>m_vtable_descriptors</code> table.
* @param method_idx - index of method in vtable descriptors table
* @return A method from the vtable descriptors table.*/
Method* get_method_from_vtable(unsigned method_idx) const {
return m_vtable_descriptors[method_idx];
}
/// Returns the number of virtual methods in vtable
unsigned get_number_of_virtual_method_entries() const {
return m_num_virtual_method_entries;
}
/** Gets the first subclass for Class Hierarchy Analysis.
* @return The first subclass.*/
Class* get_first_child() const { return m_cha_first_child; }
/** Return the next sibling for Class Hierarchy Analysis.
* @return The next sibling.*/
Class* get_next_sibling() const { return m_cha_next_sibling; }
/** Gets offset of m_depth field in struct Class.
* @note Instanceof helpers use returned offset.*/
static size_t get_offset_of_depth() {
Class* dummy=NULL;
return (size_t)((char*)(&dummy->m_depth));
}
/** Gets offset of m_is_suitable_for_fast_instanceof field in struct Class.
* @note Instanceof helper uses returned offset.*/
static size_t get_offset_of_fast_instanceof_flag() {
Class* dummy=NULL;
return (size_t)((char*)(&dummy->m_is_suitable_for_fast_instanceof));
}
/** Gets an offset of <code>m_is_fast_allocation_possible</code> in
* the class.
* @note Allocation helpers use returned offset.*/
size_t get_offset_of_fast_allocation_flag() {
// else one byte ld in helpers will fail
assert(sizeof(m_is_fast_allocation_possible) == 1);
Class* dummy=NULL;
return (size_t)((char*)(&dummy->m_is_fast_allocation_possible));
}
/** Gets an offset of <code>m_allocation_handle</code> in the class.
* @note Allocation helpers use returned offset.*/
size_t get_offset_of_allocation_handle() {
assert(sizeof(m_allocation_handle) == sizeof(void*));
Class* dummy=NULL;
return (size_t)((char*)(&dummy->m_allocation_handle));
}
/** Gets an offset of <code>m_instance_data_size</code> in the class.
* @note Allocation helpers use returned offset.*/
size_t get_offset_of_instance_data_size() {
assert(sizeof(m_instance_data_size) == 4);
Class* dummy=NULL;
return (size_t)((char*)(&dummy->m_instance_data_size));
}
/** Gets an offset of <code>m_num_class_init_checks</code> in the class.
* @note Class initialization helper on IPF uses returned offset.*/
static size_t get_offset_of_class_init_checks() {
Class* dummy = NULL;
return (size_t)((char*)(&dummy->m_num_class_init_checks) - (char*)dummy);
}
/** Gets an offset of <code>m_array_element_class</code> in the class.
* @note Class initialization helper on IPF uses returned offset.*/
static size_t get_offset_of_array_element_class() {
Class* dummy = NULL;
assert(sizeof(dummy->m_array_element_class) == sizeof(void*));
return (size_t)((char*)(&dummy->m_array_element_class) - (char*)dummy);
}
/** Gets an offset of <code>m_class_handle</code> in the class.
* @note It used by VMHelper class*/
static size_t get_offset_of_jlc_handle () {
Class* dummy=NULL;
return (size_t)((char*)(&dummy->m_class_handle) - (char*)dummy);
}
/** Gets the number of array dimensions.
* @return Number of dimentions in an array represented by this class.*/
unsigned char get_number_of_dimensions() const {
assert(is_array());
return m_num_dimensions;
}
/**
* Gets the base class of the array (for non-primitive arrays only).
* @return Class describing the base type of an array
* represented by this class.*/
Class* get_array_base_class() const {
assert(is_array());
return m_array_base_class;
}
/** Gets the class of the array element.
* @return Class describing the element of an array
* represented by this class.*/
Class* get_array_element_class() const {
assert(is_array());
return m_array_element_class;
}
/** Gets the class state.
* @return The class state.*/
Class_State get_state() const { return m_state; }
/** Gets a number of superinterfaces.
* @return A number of superinterfaces of the given class.*/
uint16 get_number_of_superinterfaces() const { return m_num_superinterfaces; }
/** Gets a super-interface name from the array of super-interfaces that
* the given class implements.
* @param[in] index - an index of super-interface to return the name for
* @return The requested super-interface name.*/
const String* get_superinterface_name(uint16 index) const {
assert(index < m_num_superinterfaces);
return m_superinterfaces[index].name;
}
/** Gets a superinterface from the array of superinterfaces the given class
* implements.
* @param[in] index - an index of a superinterface to return
* @return A requested superinterface.*/
Class* get_superinterface(uint16 index) const {
assert(index < m_num_superinterfaces);
return m_superinterfaces[index].clss;
}
/** Gets a constant pool of the given class.
* @return A constant pool of the given class.*/
ConstantPool& get_constant_pool() { return m_const_pool; }
/** Gets a number of fields in the given class.
* @return A number of fields in the given class.*/
uint16 get_number_of_fields() const { return m_num_fields; }
/** Gets a number of static fields in the given class.
* @return A number of static fields in the given class.*/
uint16 get_number_of_static_fields() const { return m_num_static_fields; }
/** Gets a field from the given class by its position in the class-fields
* array.
* @param[in] index - an index in the class-fields array of a field to
* retrieve
* @return The requested field.*/
Field* get_field(uint16 index) const;
/** Gets an address of the memory block containing static data of
* the given class.
* @return An address of a static data block.*/
void* get_static_data_address() const { return m_static_data_block; }
/** Gets a number of methods in the given class.
* @return A number of methods in the given class.*/
uint16 get_number_of_methods() const { return m_num_methods; }
/** Gets a method from the given class by its position in the
* class-method array.
* @param[in] index - an index in the class-method array of a
* method to retrieve
* @return A requested method.*/
Method* get_method(uint16 index) const;
/** Gets a constant-pool index of the declaring class.
* @return An index in the constant pool describing the requested
* declaring class.*/
uint16 get_declaring_class_index() const { return m_declaring_class_index; }
/** Gets a constant-pool index of the enclosing class.
* @return An index in the constant pool describing the requested
* enclosing class.*/
uint16 get_enclosing_class_index() const { return m_enclosing_class_index; }
/** Gets a constant-pool index of the enclosing method.
* @return An index in the constant pool describing the requested enclosing
* method.*/
uint16 get_enclosing_method_index() const { return m_enclosing_method_index; }
/** Gets a number of inner classes.
* @return A number of inner classes.*/
uint16 get_number_of_inner_classes() const { return m_num_innerclasses; }
/** Gets an index in the constant pool of the given class, which
* describes the inner class.
* @param[in] index - an index of the inner class in the array of
* inner classes in the given class
* @return An index in the constant pool describing the requested inner
* class.*/
uint16 get_inner_class_index(uint16 index) const {
assert(index < m_num_innerclasses);
return m_innerclasses[index].index;
}
/** Gets access flags for the inner class.
* @param[in] index - an index of the inner class in the array of inner
* classes in the given class
* @return Access flags of the requested inner class.*/
uint16 get_inner_class_access_flags(uint16 index) const {
assert(index < m_num_innerclasses);
return m_innerclasses[index].access_flags;
}
/** Gets a collection of annotations.
* @return A collection of annotations.*/
AnnotationTable* get_annotations() const { return m_annotations; }
/** Gets a collection of invisible annotations.
* @return A collection of invisible annotations.*/
AnnotationTable* get_invisible_annotations() const {
return m_invisible_annotations;
}
/** Gets a class instance size.
* @return A size of the allocated instance in bytes.*/
unsigned int get_allocated_size() const { return m_allocated_size; }
unsigned int get_instance_data_size() const {
return m_instance_data_size & NEXT_TO_HIGH_BIT_CLEAR_MASK;
}
/** Gets the array-alement size.
* @return A size of the array element.
* @note The given function assumes that the class is an array class.*/
unsigned int get_array_element_size() const {
assert(m_is_array == 1);
return m_array_element_size;
}
/** Gets the class ID.*/
unsigned get_id() const { return m_id; }
/** Gets major version of class file.
* @return Major version of class file.*/
uint16 get_version() const { return m_version; }
/** Gets access and properties flags of the given class.
* @return The 16-bit integer representing access and properties flags
* the given class.*/
uint16 get_access_flags() const { return m_access_flags; }
/** Checks whether the given class represents the primitive type.
* @return <code>true</code> if the class is primitive; otherwise
* <code>false</code>.*/
bool is_primitive() const { return m_is_primitive == 1; }
/** Checks whether the given class represents an array.
* @return <code>true</code> if the given class is an array, otherwise
* <code>false</code>.*/
bool is_array() const { return m_is_array == 1; }
/** Checks whether the base class of the given array is primitive.
* @return <code>true</code> if the base class is primitive, otherwise
* <code>false</code>.*/
bool is_array_of_primitives() const { return m_is_array_of_primitives == 1; }
/** Checks whether the class has the <code>ACC_PUBLIC</code> flag set.
* @return <code>true</code> if the class has the <code>ACC_PUBLIC</code>
* access flag set.*/
bool is_public() const { return (m_access_flags & ACC_PUBLIC) != 0; }
/** Checks whether the class has the <code>ACC_PUBLIC</code> flag set.
* @return <code>true</code> if the class has the <code>ACC_PUBLIC</code>
* access flag set.*/
bool is_private() const { return (m_access_flags & ACC_PRIVATE) != 0; }
/** Checks whether the class has the <code>ACC_PUBLIC</code> flag set.
* @return <code>true</code> if the class has the <code>ACC_PUBLIC</code>
* access flag set.*/
bool is_protected() const { return (m_access_flags & ACC_PROTECTED) != 0; }
/** Checks whether the class has the <code>ACC_FINAL</code> flag set.
* @return <code>true</code> if the class has the <code>ACC_FINAL</code>
* access flag set.*/
bool is_final() const { return (m_access_flags & ACC_FINAL) != 0; }
/** Checks whether the class has the <code>ACC_SUPER</code> flag set.
* @return <code>true</code> if the class has the <code>ACC_SUPER</code>
* access flag set.*/
bool is_super() const { return (m_access_flags & ACC_SUPER) != 0; }
/** Checks whether the class has the <code>ACC_INTERFACE</code> flag set.
* @return <code>true</code> if the class has the <code>ACC_INTERFACE</code>
* access flag set.*/
bool is_interface() const { return (m_access_flags & ACC_INTERFACE) != 0; }
/** Checks whether the class has the <code>ACC_ABSTRACT</code> flag set.
* @return <code>true</code> if the class has the <code>ACC_ABSTRACT</code>
* access flag set.*/
bool is_abstract() const { return (m_access_flags & ACC_ABSTRACT) != 0; }
/** Checks whether the class is enum, that is the <code>ACC_ENUM</code>
* flag is set.
* @return <code>true</code> if the class is enum.*/
bool is_enum() const { return (m_access_flags & ACC_ENUM) != 0; }
/** Checks whether the class has the <code>ACC_SYNTHETIC</code> flag set.
* @return <code>true</code> if the class has the <code>ACC_SYNTHETIC</code>
* access flag set.*/
bool is_synthetic() const { return (m_access_flags & ACC_SYNTHETIC) != 0; }
/** Checks whether the class is an annotation.
* @return <code>true</code> if the class is an annotation.*/
bool is_annotation() const { return (m_access_flags & ACC_ANNOTATION) != 0; }
/** Checks whether the given class has a finalizer.
* @return <code>true</code> if the given class (or its super class) has
* a finalize method; otherwise <code>false</code>.*/
bool has_finalizer() const { return m_has_finalizer == 1; }
/** Checks whether the given class is an inner class of some other class.
* @return <code>true</code> if the given class is an inner class of some
* other class, otherwise <code>false</code>.*/
bool is_inner_class() const { return m_declaring_class_index != 0; }
/** Checks whether the given class can access <code>inner_class</code>.
* @param[in] env - VM environment
* @param[in] inner_class - an inner class to check access to
* @return <code>true</code> if the given class has access to the inner
* class; otherwise <code>false</code>.*/
bool can_access_inner_class(Global_Env* env, Class* inner_class);
/** Checks whether the given class can access a member class.
* @param[in] member - a class member to check access to
* @return <code>true</code> if the given class can access a member class;
* otherwise <code>false</code>.*/
bool can_access_member(Class_Member* member);
/** Checks whether the given class has a source-file name available.
* @return <code>true</code> if source file name is available for the given class;
* otherwise <code>false</code>.*/
bool has_source_information() const { return m_src_file_name != NULL; }
/** Checks whether the given class is in the process of initialization.
* @return <code>true</code> if the class initialization method is executed;
* otherwise <code>false</code>.*/
bool is_initializing() const { return m_state == ST_Initializing; }
/** Checks whether the class is initialized.
* @return <code>true</code> if the class is initialized;
* otherwise <code>false</code>.*/
bool is_initialized() const { return m_state == ST_Initialized; }
/** Checks whether the class is in the error state.
* @return <code>true</code> if the class is in the error state;
* otherwise <code>false</code>.*/
bool in_error() const { return m_state == ST_Error; }
/** Checks whether the given class has a passed preparation stage.
* @return <code>true</code> if the class has a passed preparation stage;
* otherwise <code>false</code>.*/
bool is_at_least_prepared() const {
return m_state == ST_Prepared
|| m_state == ST_ConstraintsVerified
|| m_state == ST_Initializing
|| m_state == ST_Initialized;
}
/** Checks whether the given class represents a class that is a subtype of
* <code>clss</code>, according to the Java instance of rules.
* @param[in] clss - a class to check for being super relative
* @return <code>true</code> if the given class represents a class that is
* a subtype of <code>clss</code>, otherwise <code>false</code>.*/
bool is_instanceof(Class* clss);
/** FIXME: all setter functions must be rethought to become private
* or to be removed altogether, if possible.
* Sets the name of a file from which the given class has been loaded.
* @param[in] cf_name - a class-file name*/
void set_class_file_name(const char* cf_name) {
assert(cf_name);
m_class_file_name = cf_name;
}
/** Sets instance data size constraint bit to let the allocation know
* there are constraints on the way instance should be allocated.
* @note Constaints are recorded in the <code>class_properties</code>
* field of the class <code>VTable</code>.*/
void set_instance_data_size_constraint_bit() {
m_instance_data_size |= NEXT_TO_HIGH_BIT_SET_MASK;
}
/** Sets a class handle of <code>java.lang.Class</code> for the given class.
* @param[in] oh - a class handle of <code>java.lang.Class</code>*/
void set_class_handle(ManagedObject** oh) { m_class_handle = oh; }
/** Constructs internal representation of a class from the byte array
* (defines class).
* @param[in] env - VM environment
* @param[in] cfs - a class-file stream; byte array contaning class data*/
bool parse(Global_Env* env, ByteReader& cfs);
/** Loads a super class and super interfaces of the given class.
* The given class's class loader is used for it.
* @param[in] env - VM environment*/
bool load_ancestors(Global_Env* env);
/** Verifies bytecodes of the class.
* @param[in] env - VM environment
* @return <code>true</code> if bytecodes of a class were successfully verified;
* otherwise <code>false</code>.*/
bool verify(const Global_Env* env);
/** Verifies constraints for the given class collected during the bytecodes
* verification.
* @param[in] env - VM environment
* @return <code>true</code> if constraints successfully pass verification;
* otherwise <code>false</code>.*/
bool verify_constraints(const Global_Env* env);
/** Setups the given class as representing a primitive type.
* @param[in] cl - a class loader the given class belongs to
* @note FIXME: <code>cl</code> is always a bootstrap class loader
* for primitive types. Retrieve the bootstrap class loader
* from VM environment here, not one level up the calling stack.*/
void setup_as_primitive(ClassLoader* cl) {
m_is_primitive = 1;
m_class_loader = cl;
m_access_flags = ACC_ABSTRACT | ACC_FINAL | ACC_PUBLIC;
m_state = ST_Initialized;
}
/** Sets up the given class as representing an array.
* @param[in] env - VM environment
* @param[in] num_dimentions - a number of dimentions this array has
* @param[in] isArrayOfPrimitives - does this array is an array of primitives
* @param[in] baseClass - base class of this array; for example,
* for <code>[[[Ljava/lang/String;</code>
* base class is <code>java/lang/String</code>
* @param[in] elementClass - class representing element of this array;
* for example, for <code>[[I</code>, element
* the class is <code>[I</code>
* @note For single-dimentional arrays <code>baseClass<code> and
* <code>elementClass</code> are the same.*/
void setup_as_array(Global_Env* env, unsigned char num_dimensions,
bool isArrayOfPrimitives, Class* baseClass, Class* elementClass);
/** Prepares a class: <ol>
* <li> assigns offsets:
* - the offset of instance data fields
* - virtual methods in a vtable
* - static data fields in a static data block</li>
* <li> creates a class vtable</li>
* <li> creates a static field block</li>
* <li> creates a static method block </ol>
* @param[in] env - vm environment
* @return <code>true</code> if the class was successfully prepared;
* otherwise <code>false</code>.*/
bool prepare(Global_Env* env);
/** Resolves a constant-pool entry to a class. Loads a class if neccessary.
* @param[in] env - VM environment
* @param[in] cp_index - a constant-pool index of <code>CONSTANT_Class</code>
* to resolve
* @return A resolved class, if a resolution attempt succeeds;
* otherwise <code>NULL</code>.
* @note Should become private as soon as wrappers become members of the
* struct #Class.*/
Class* _resolve_class(Global_Env* env, unsigned cp_index);
/** Resolves a declaring class.
* @return A declaring class, if the given class is inner class of some
* other class and if the resolution was successful;
* otherwise <code>NULL</code>.*/
Class* resolve_declaring_class(Global_Env* env);
/** Resolves a field in the constant pool of the given class.
* @param[in] env - VM environment
* @param[in] cp_index - an index of an entry in the constant pool,
* which describes field to be resolved
* @return A resolved field, if a resolution attempt succeeds;
* otherwise <code>NULL</code>.
* @note Should become private as soon as wrappers
* become members of the struct #Class.*/
Field* _resolve_field(Global_Env* env, unsigned cp_index);
/** Resolves a method in the constant pool of the given class.
* @param[in] env - VM environment
* @param[in] cp_index - an index of an entry in the constant pool,
* which describes method to be resolved
* @return A resolved method, if a resolution attempt succeeds;
* otherwise <code>NULL</code>.
* @note Should become private as soon as wrappers become members of
* the struct #Class.*/
Method* _resolve_method(Global_Env* env, unsigned cp_index);
/** Initializes the class.
* @param[in] throw_exception - defines whether the exception should
* be thrown or raised
* @note The given method may raise exception, if an error occurs during
* the initialization of the class.*/
void initialize();
/** Looks up the field with specified name and descriptor in the given class only.
* @param[in] name - the field name to look up for
* @param[in] desc - the field descriptor to look up for
* @return The looked up field if found in the given class,
* otherwise <code>NULL</code>.*/
Field* lookup_field(const String* name, const String* descriptor);
/** Looks up the field with specified name and descriptor in the given class
* and also in the super class and super-interfaces recursively.
* @param[in] name - field name to look up for
* @param[in] desc - field descriptor to look up for
* @return The looked up field if found, <code>NULL</code> otherwise*/
Field* lookup_field_recursive(const String* name, const String* descriptor);
/** Looks up a method with a specified name and descriptor in the given
* class only.
* @param[in] name - a method name to look up for
* @param[in] desc - a method descriptor to look up for
* @return The looked-up method, if found in the given class;
* otherwise <code>NULL</code>.*/
Method* lookup_method(const String* name, const String* desc);
/** Allocates an instance of the given class and returns a pointer to it.
* @return A managed pointer to the allocated class instance;
* <code>NULL</code>, if no memory is available and
* <code>OutOfMemoryError</code> exception is raised on a
* caller thread.*/
ManagedObject* allocate_instance();
/**
* Calculates a size of the block allocated for the array, which is represented by
* the given class.
* @param[in] length the length of the array
* @return The size of the array of specified length in bytes, or 0 if the size is too big.
*/
unsigned calculate_array_size(int length) const {
if (length < 0) {
return 0;
}
assert(m_array_element_size);
assert(length >= 0);
assert(is_array());
unsigned first_elem_offset;
if(m_array_element_shift < 3) {
first_elem_offset = VM_VECTOR_FIRST_ELEM_OFFSET_1_2_4;
} else {
first_elem_offset = VM_VECTOR_FIRST_ELEM_OFFSET_8;
}
// check overflow, we need:
// first_elem_offset + (length << m_array_element_shift)
// + GC_OBJECT_ALIGNMENT < NEXT_TO_HIGH_BIT_SET_MASK
//
if (((NEXT_TO_HIGH_BIT_SET_MASK - GC_OBJECT_ALIGNMENT - first_elem_offset)
>> m_array_element_shift) <= (unsigned)length) {
// zero means overflow
return 0;
}
unsigned size = first_elem_offset + (length << m_array_element_shift);
size = (((size + (GC_OBJECT_ALIGNMENT - 1)) & (~(GC_OBJECT_ALIGNMENT - 1))));
assert((size % GC_OBJECT_ALIGNMENT) == 0);
assert((size & NEXT_TO_HIGH_BIT_SET_MASK) == 0);
return size;
}
/** Estimates the amount of memory allocated for C++ part of the given class.
* @return The size of memory allocated for the given class.*/
unsigned calculate_size();
/** Gets the interface vtable for interface <code>iid</code> within
* object <code>obj</code>.
* @param[in] obj - an object to retrieve an interface table entry from
* @param[in] iid - an interface class to retrieve vtable for
* @return An interface vtable from object; <code>NULL</code>, if no
* such interface exists for the object.*/
static void* helper_get_interface_vtable(ManagedObject* obj, Class* iid);
// SourceDebugExtension class attribute support
/** Checks whether the given class has the
* <code>SourceDebugExtension</code> attribute.
* @return <code>true</code> if the <code>SourceDebugExtension</code>
* attribute is available for the given class;
* otherwise <code>false</code>.*/
bool has_source_debug_extension() const {
return m_sourceDebugExtension != NULL;
}
/** Gets length of the <code>SourceDebugExtension</code> attribute.
* @return The <code>SourceDebugExtension</code> attribute length.*/
unsigned get_source_debug_extension_length() const {
return m_sourceDebugExtension->len;
}
/** Gets data from the <code>SourceDebugExtension</code> attribute.
* @return <code>SourceDebugExtension</code> attribute bytes.*/
const char* get_source_debug_extension() const {
return m_sourceDebugExtension->bytes;
}
/** Stores a verifier specific pointer into the given class.
* @param[in] data - a verifier specific data pointer*/
void set_verification_data(void* data) {
assert(m_verify_data == NULL);
m_verify_data = data;
}
/** Gets a pointer to verifier specific data, previously stored with
* the call to <code>set_verification_data</code>.
* @return A pointer to verifier specific data or <code>NULL</code>, if
* none was set.*/
void* get_verification_data() {
return m_verify_data;
}
/** Locks access to the given class.*/
void lock();
/** Unlocks access to the given class.*/
void unlock();
// Statistics update
/** Updates allocation statistics.
* @param[in] size - a size of an allocated instance*/
void instance_allocated(unsigned size) {
m_num_allocations++;
m_num_bytes_allocated += size;
}
/** Updates an instance of slow path statistics.*/
void instanceof_slow_path_taken() { m_num_instanceof_slow++; }
/** Updates throwing statistics for <code>java/lang/Throwable</code> decendants.*/
void class_thrown() { m_num_throws++; }
/** Allocates memory for code from pool of defining classloader for the class.*/
void* code_alloc(size_t size, size_t alignment, Code_Allocation_Action action);
/** Updates initialization check statistics.*/
void initialization_checked() { m_num_class_init_checks++; }
/** Gets the number of times instance of the given class was allocated.
* @return The number of allocations of the given class.*/
uint64 get_times_allocated() const { return m_num_allocations; }
/** Gets the total number of bytes allocated for instances of the given class.
* @return The number of bytes allocated for all instances of the given class.*/
uint64 get_total_bytes_allocated() const { return m_num_bytes_allocated; }
/** Gets the number of times the slow path of the check instance was taken.
* @return The number of times the slow path was taken.*/
uint64 get_times_instanceof_slow_path_taken() const { return m_num_instanceof_slow; }
/** Gets the number of times the given class was thrown.
* @return The number of times the given class was thrown.*/
uint64 get_times_thrown() const { return m_num_throws; }
/** Gets the number of times the initialization of the given class
* was checked by run-time helpers.
* @return The number of times initialization of the given class was checked.*/
uint64 get_times_init_checked() const { return m_num_class_init_checks; }
/** Gets the number of excessive bytes used for aligning class fields.
* @return A number of excessive bytes used for aligning class fields.*/
uint64 get_total_padding_bytes() const { return m_num_field_padding_bytes; }
private:
/** Parses super-interfaces information from a class-file stream.
* @param[in] cfs - a class-file stream to parse superinterfaces information from
* @return <code>true</code> if information was succesfully parsed;
* otherwise <code>false</code>.*/
bool parse_interfaces(ByteReader &cfs);
/** Parses class fields from a class-file stream.
* @param[in] env - VM enviroment
* @param[in] cfs - a class-file stream
* @param[in] is_trusted_cl - defines whether class was loaded by
* trusted classloader. User defined classloaders are not trusted.
* @return <code>true</code> if successfully parses fields; <code>false</code>
* if any parse error occurs.*/
bool parse_fields(Global_Env* env, ByteReader &cfs, bool is_trusted_cl);
/** Parses class methods from a class-file stream.
* @param[in] env - VM enviroment
* @param[in] cfs - a class file stream
* @param[in] is_trusted_cl - defines whether class was loaded by
* trusted classloader. User defined classloaders are not trusted.
* @return <code>true</code> if successfully parses methods; <code>false</code>
* if any parse error occurs.*/
bool parse_methods(Global_Env* env, ByteReader &cfs, bool is_trusted_cl);
/** Calculates and assigns offsets to class fields during preparation.*/
void assign_offsets_to_fields();
/** Assign offsets to class-instance fields.
* @param[in] field_ptrs - an array of class fields to assign
* offsets to
* @param[in] do_field_compaction - defines whether the class fields should
* be compacted*/
void assign_offsets_to_instance_fields(Field** field_ptrs, bool do_field_compaction);
/** Assigns an offset to an instance field.
* @param[in] field - a field to calculate offset for
* @param[in] do_field_compaction - defines whether the class fields should
* be compacted*/
void assign_offset_to_instance_field(Field* field, bool do_field_compaction);
/** Assigns offsets to static fields of a class.
* @param[in] field_ptrs - an array of fields
* @param[in] do_field_compaction - defines whether the class fields should
* be compacted*/
void assign_offsets_to_static_fields(Field** field_ptrs, bool do_field_compaction);
/** Initializes an interface class.
* @return <code>true</code> if the interface was successfully initialized;
* otherwise <code>false</code>.*/
bool initialize_static_fields_for_interface();
/** Assigns offsets (from the base of the vtable) and the <code>VTable</code> index to
* class methods.
* @param[in] env - VM environment*/
void assign_offsets_to_methods(Global_Env* env);
/** Creates the vtable for the given class.
* @param[in] n_vtable_entries - a number of entries for the vtable*/
void create_vtable(unsigned n_vtable_entries);
/** Populates the vtable descriptors table with methods overriding as necessary.
* @param[in] intfc_table_entries - must contain all interfaces of the given class
*/
void populate_vtable_descriptors_table_and_override_methods(const std::vector<Class*>& intfc_table_entries);
/** Creates and populates an interface table for a class.
* @param[in] intfc_table_entries - must contain all interfaces of the given class
* @return The created interface table.*/
Intfc_Table* create_and_populate_interface_table(const std::vector<Class*>& intfc_table_entries);
/** Sets vtable entries to methods addresses.*/
void point_vtable_entries_to_stubs();
/** Adds any required "fake" methods to a class. These are interface methods
* inherited by an abstract class that are not implemented by that class
* or any superclass. Such methods will never be called, but they are added
* so they have the correct offset in the virtual method part of the vtable
* (that is the offset of the "real" method in the vtable for a concrete class).*/
void add_any_fake_methods();
}; // struct Class
} // extern "C"
/** Gets instance of java/lang/Class associated with this class.
* @param[in] clss - class to retrieve java/lang/Class instance for.
* @return Instance of java/lang/Class associated with class.*/
ManagedObject* struct_Class_to_java_lang_Class(Class* clss);
/** Gets handle of java/lang/Class instance associated with this class.
* @param[in] clss - class to retrieve handle with java/lang/Class instance for.
* @return Handle with instance of java/lang/Class associated with class.
* @note This function allocates local handle and stores reference to
* java/lang/Class into it.*/
jclass struct_Class_to_jclass(Class* clss);
/** Gets native class from the java/lang/Class handle.
* @param[in] jc - handle to retrieve struct Class from.
* @return Class for the given handle.*/
Class* jclass_to_struct_Class(jclass jc);
/** Gets native class for any given object handle.
* @param[in] jobj - object to retrieve class for.
* @return Class for the given object handle.*/
Class* jobject_to_struct_Class(jobject jobj);
/** Gets pointer to instance of java/lang/Class associated with the class.
* @param[in] clss - class to retrieve pointer to instance of java/lang/Class for.
* @return Pointer to instance of java/lang/Class associated with the class.
* @note This is NOT real handle, so, when using this function, make sure the
* returned value will never be passed to ANY user code including JVMTI
* agent callbacks.*/
jobject struct_Class_to_java_lang_Class_Handle(Class* clss);
/** Gets native class from instance of java/lang/Class.
* @param[in] jlc - instance of java/lang/Class to retrieve class from.
* @return Native class from instance of java/lang/Class.*/
Class* java_lang_Class_to_struct_Class(ManagedObject* jlc);
/** Looks up field in class and its superclasses.
* @param[in] clss - class to lookup field in.
* @param[in] name - name of the field.
* @param[in] desc - descriptor of the field.
* @return Requested field, if the field exists, <code>NULL</code> otherwise.*/
Field* class_lookup_field_recursive(Class* clss, const char* name, const char* desc);
/** Looks up method in class and its superclasses.
* @param[in] clss - class to lookup method in.
* @param[in] name - name of the method as VM String.
* @param[in] desc - descriptor of the method as VM String.
* @return Requested method, if the method exists,
* <code>NULL</code> otherwise.
* @note VMEXPORT specifier is solely for interpreter.*/
VMEXPORT
Method* class_lookup_method_recursive(Class* clss, const String* name, const String* desc);
/** Looks up method in class and its superclasses.
* @param[in] clss - class to lookup method in.
* @param[in] name - name of the method.
* @param[in] desc - descriptor of the method.
* @return Requested method, if the method exists,
* <code>NULL</code> otherwise.*/
Method* class_lookup_method_recursive(Class* clss, const char* name, const char* desc);
/** Looks up method in the given class only.
* @param[in] clss - class to lookup method in.
* @param[in] name - name of the method.
* @param[in] desc - descriptor of the method.
* @return Requested method, if the method exists,
* <code>NULL</code> otherwise.*/
Method* class_lookup_method(Class* clss, const char* name, const char* desc);
/** Gets method given its offset in the vtable.
* @param[in] vt - vtable containing method.
* @param[in] offset - offset of the method in the vtable.
* @return Method at the specified offset.*/
Method* class_get_method_from_vt_offset(VTable* vt, unsigned offset);
/** Loads a class and performs the first two parts of the link process:
* verify and prepare.
* @param[in] env - VM environment.
* @param[in] classname - name of a class to load.
* @param[in] cl - class loader to load class with.
* @return Loaded class, if loading and linking succeeded,
* <code>NULL</code> otherwise.*/
Class* class_load_verify_prepare_by_loader_jni(Global_Env* env,
const String* classname,
ClassLoader* cl);
/** Loads a class with bootstrap class loader and performs the first two parts
* of the link process: verify and prepare.
* @param[in] env - VM environment.
* @param[in] classname - name of a class to load.
* @param[in] cl - class loader to load class with.
* @return Loaded class, if loading and linking succeeded,
* <code>NULL</code> otherwise.
* @note The class is loaded .*/
Class* class_load_verify_prepare_from_jni(Global_Env* env,
const String* classname);
/** Executes static initializer of class.
* @param[in] clss - class to initialize.*/
void class_initialize_from_jni(Class *clss);
/** Registers a number of native methods to a given class.
* @param[in] klass - a specified class
* @param[in] methods - an array of methods
* @param[in] num_methods - a number of methods
* @return <code>false</code>, if methods resistration is successful;
* otherwise <code>true</code>.
* @note Function raises <code>NoSuchMethodError</code> with the method name in
* exception message, if one of the methods in the <code>JNINativeMethod*</code>
* array is not present in a specified class.*/
bool
class_register_methods(Class_Handle klass, const JNINativeMethod* methods, int num_methods);
/** Unregisters a native methods off a given class.
* @param[in] klass - specified class
* @return <code>false</code>, if methods unresistration is successful;
* otherwise <code>true</code>.*/
bool
class_unregister_methods(Class_Handle klass);
//method is defined in Resolve.cpp
Class* resolve_class_new_env(Global_Env* env, Class* clss, unsigned cp_index, bool raise_exn);
Method* resolve_special_method_env(Global_Env *env, Class_Handle curr_clss, unsigned index, bool raise_exn);
Method* resolve_static_method_env(Global_Env *env, Class *clss, unsigned cp_index, bool raise_exn);
Method* resolve_virtual_method_env(Global_Env *env, Class *clss, unsigned cp_index, bool raise_exn);
Method* resolve_interface_method_env(Global_Env *env, Class *clss, unsigned cp_index, bool raise_exn);
Field* resolve_static_field_env(Global_Env *env, Class *clss, unsigned cp_index, bool putfield, bool is_runtume);
Field* resolve_nonstatic_field_env(Global_Env* env, Class* clss, unsigned cp_index, unsigned putfield, bool raise_exn);
#endif // _CLASS_H_