classmethod.h

来自「基于LWVCL开发的库」· C头文件 代码 · 共 820 行 · 第 1/2 页

/*
 * classMethod.h
 * Class, method and field tables.
 *
 * Copyright (c) 1996, 1997, 2004
 *	Transvirtual Technologies, Inc.  All rights reserved.
 *
 * See the file "license.terms" for information on usage and redistribution
 * of this file.
 */

#ifndef __classmethod_h
#define __classmethod_h

#include <assert.h>

#include "config.h"
#include "gtypes.h"
#include "machine.h"
#include "access.h"
#include "object.h"
#include "md.h"	 /* XXX: need this here so KAFFE_PROFILER is accurately def'd */
#include "constants.h"
#include "errors.h"
#include "jthread.h"
#include "locks.h"

#define	MAXMETHOD		64

/* Class state */
typedef enum {
	CSTATE_FAILED = -1,
	CSTATE_UNLOADED,
	CSTATE_LOADED,
	CSTATE_LOADED_SUPER,
	CSTATE_PRELOADED,
	CSTATE_VERIFIED,
	CSTATE_DOING_PREPARE,
	CSTATE_PREPARED,
	CSTATE_DOING_LINK,
	CSTATE_LINKED,
	CSTATE_CONSTINIT,
	CSTATE_DOING_SUPER,
	CSTATE_USABLE,
	CSTATE_DOING_INIT,
	CSTATE_COMPLETE
} class_state_t;

struct _classEntry;
struct _innerClass;
struct Hjava_lang_String;

#include <java_lang_ClassLoader.h>
#include "reference.h"

/**
 * Builtin stab type IDs.
 */
typedef enum {
	STYPE_INT = 1,
	STYPE_INT_POINTER,
	STYPE_BYTE,
	STYPE_BYTE_POINTER,
	STYPE_SHORT,
	STYPE_SHORT_POINTER,
	STYPE_CHAR,
	STYPE_CHAR_POINTER,
	STYPE_LONG,
	STYPE_LONG_POINTER,
	STYPE_FLOAT,
	STYPE_FLOAT_POINTER,
	STYPE_DOUBLE,
	STYPE_DOUBLE_POINTER,
	STYPE_BOOLEAN,
	STYPE_BOOLEAN_POINTER,
	STYPE_VOID,
	STYPE_VOID_POINTER,
	STYPE_DISPATCH_TABLE,
	STYPE_ILOCK,
	STYPE_PROMOTED_BYTE,
	STYPE_PROMOTED_SHORT,
	STYPE_PROMOTED_CHAR,
	STYPE_PROMOTED_BOOLEAN,
	STYPE_MAX
} stype_t;

struct Hjava_lang_Class {
	Hjava_lang_Object	head;		/* A class is an object too */

	/* these fields are also accessed from java and therefore MUST NOT BE CHANGED */

	HArrayOfObject*			signers;
	struct Hjava_security_ProtectionDomain*	protectionDomain;
	struct Hjava_lang_Object*	vmData; /* unused for kaffe */
	struct Hjava_lang_Object*	constructor;

	/* end of fields being accessed from java */

	struct _iLock*		lock;		/* Lock for internal use */

	/* Link to class entry */
	struct _classEntry*	centry;

	Utf8Const*		name;
        Utf8Const*              extSignature;
        constIndex              enclosingClassIndex;
        constIndex              enclosingMethodIndex;
	unsigned int		packageLength;
	char*			sourcefile;	/* source file name if known */
	accessFlags		accflags;
        kaffeClassFlags         kFlags;        

	/* If non-NULL, a pointer to the superclass.
	 * However, if state < CSTATE_DOING_PREPARE, then
	 * (int) superclass is a constant pool index. */
	void*                   superclass;

	struct _constants	constants;

	/* For regular classes, an array of the methods defined in this class.
	   For array types, used for CLASS_ELEMENT_TYPE.
	   For primitive types, used by CLASS_ARRAY_CACHE. */
        union {
	  Method*		       methods;
	  struct Hjava_lang_Class*     element_type;
	  struct Hjava_lang_Class*     array_cache;
	} cache;
	short			method_count;

	/* Number of methods in the dtable. */
	/* If CLASS_IS_PRIMITIVE, then the CLASS_PRIM_SIG. */
	unsigned short			msize;

	/* Pointer to array of Fields, on for each field.
	   Static fields come first. */
	Field*			fields;

	/* The size of the non-static fields, in bytes.
	   For a primitive type, the length in bytes.
	   Also used temporarily while reading fields.  */
	int			size_in_bytes;

	/* Number of fields, including static fields. */
	short			field_count;
	/* Number of static fields. */
	short			nsfields;

	struct _dispatchTable*	vtable;

	/* all interfaces supported by this class */
        struct Hjava_lang_Class** interfaces;
	short*			if2itable;	/* redundant now */
	void**			itable2dtable;
	short			interface_len;
	unsigned short		total_interface_len;
	/* pointers to all itable2dtable entries of classes implementing this interface */
	void***			implementors;	/* interfaces only */
        unsigned int		impl_index;    /* index of the class in the implementors array. */

	Hjava_lang_ClassLoader*	loader;

	/* A bitmap describing the layout of instances of that class.
	   It contains CLASS_FSIZE/ALIGNMENTVOIDP bits.
	   The MSB corresponds to the dtable field.
	 */
	int*			gc_layout;
	class_state_t		state;
	void*			processingThread;
	/* This pointer contains the method which should be called
	 * at object finalization.
	 */
	Method*			finalizer;
	int			alloc_type;	/* allocation type */

	/* array containing static data */
	void*			static_data;

	/* InnerClasses attribute */
	short			this_index;
	short			this_inner_index;
	short			nr_inner_classes;
	struct _innerClass*	inner_classes;

	/* misc other stuff */
	void*			gcjPeer;	/* only needed if GCJ_SUPPORT */
#ifdef KAFFE_VMDEBUG
	int			live_count;
#endif
#if defined(KAFFE_XPROFILER) || defined(KAFFE_XDEBUGGING)
	/** Stab type ID. */
	int stab_id;
#endif
};

#ifndef __DEFINED_CLASS
#define __DEFINED_CLASS
typedef struct Hjava_lang_Class Hjava_lang_Class;
#endif

/*
 * Functions for locking and waiting on *internal* class
 * bits.  This is not for static+synchronized methods.
 * Use the centry lock, as it is convenient and available.
 */
#define lockClass(C) lockMutex(((C)))
#define unlockClass(C) unlockMutex(((C)))
#define waitOnClass(C) waitCond(((C)), 0)
#define signalOnClass(C) signalCond(((C)))
#define broadcastOnClass(C) broadcastCond(((C)))

#define METHOD_TRANSLATED(M)		((M)->kFlags & KFLAG_TRANSLATED)
#define METHOD_JITTED(M)		((M)->kFlags & KFLAG_JITTED)

#define	METHOD_NATIVECODE(M)		(((M)->idx == -1) ? \
		((M)->ncode) : \
		((M)->class->vtable->method[(M)->idx]))

/* Like METHOD_NATIVECODE, except we take the address ---
 * gcc doesn't compile &( ? : ) expressions for some reason
 */
#define	PMETHOD_NATIVECODE(M)		(((M)->idx == -1) ? \
		(void*)&((M)->ncode) : \
		&((M)->class->vtable->method[(M)->idx]))

/**
 * Get start of native code of a method
 *
 * @param method a method
 * @return pointer to start of code
 */
jitCodeHeader* getMethodCodeStart(Method * method);

/**
 * Set start of native code of a method
 *
 * @param method a method
 * @param start pointer to start of code
 */
void setMethodCodeStart(Method * method, jitCodeHeader* start);

#define	_SET_METHOD_NATIVECODE(M, C)	do {\
	if ((M)->idx == -1) {\
		(M)->ncode = (C);\
	} else { \
		(M)->class->vtable->method[(M)->idx] = (C);\
	} \
} while (0)
#define	SET_METHOD_NATIVECODE(M, C)	_SET_METHOD_NATIVECODE(M, C); \
					(M)->kFlags |= KFLAG_TRANSLATED
#define	SET_METHOD_JITCODE(M, C)	_SET_METHOD_NATIVECODE(M, C); \
					(M)->kFlags |= KFLAG_TRANSLATED|KFLAG_JITTED;

/*
 * Stats for the nameMapping object.
 *
 * searching - The system is searching for this particular class.
 * loading - The system is loading this particular class and/or its parents.
 *   If a circularity exists in the hierarchy it will be detected in this
 *   state.
 * loaded - The class and its parents have been loaded.
 * done - The class have been loaded and verified.
 */
typedef enum {
	NMS_EMPTY,
	NMS_SEARCHING,
	NMS_LOADING,
	NMS_LOADED,
	NMS_DONE
} name_mapping_state_t;

/*
 * Class hash entry.
 */
typedef struct _classEntry {
	struct _classEntry*	next;
	Utf8Const*		name;
    
        iStaticLock          slock;
	name_mapping_state_t state;
	Hjava_lang_ClassLoader*	loader;
	union {
		jthread_t thread;
		struct Hjava_lang_Class *cl;
	} data;
} classEntry;

/*
 * The nameDependency structure is used to detect cycles between classes.
 * Basically, its used as a simple deadlock detection system.
 *
 * next - The next object in the list.
 * thread - The thread that is blocked on "mapping".
 * mapping - The mapping that "thread" is waiting for.
 */
typedef struct _nameDependency {
	struct _nameDependency *next;
	jthread_t thread;
	classEntry *mapping;
} nameDependency;

typedef struct _innerClass {
	u2			outer_class;
	u2			inner_class;
	u2			inner_class_accflags;
} innerClass;

typedef struct _parsed_signature {
	Utf8Const*		signature;
	u2			nargs;
	u2			real_nargs;
	u2			ret_and_args[1]; /* index into signature */
	/* ret_and_args[0]: return value
	   ret_and_args[1]: first argument
	   etc */
} parsed_signature_t;

typedef struct _jmethodID {
	Utf8Const*		name;
	parsed_signature_t*	parsed_sig;
        Utf8Const*              extSignature;
	accessFlags		accflags;
        kaffeClassFlags         kFlags;
	long			idx;	/* Index into class->vtable */
	u2			stacksz;
	u2			localsz;
	/* Only used for static/final/constructor methods */
	nativecode*		ncode;
	union {
	  struct {
		jitCodeHeader*	ncode_start;
		nativecode*	ncode_end;
	  } ncode;
	  struct {
		unsigned char*	code;
		unsigned int	codelen;
	  } bcode;
	} c;
	Hjava_lang_Class*	class;
	struct _lineNumbers*	lines;
	struct _localVariables* lvars;
	struct _jexception*	exception_table;
	int			ndeclared_exceptions;
	union {
		constIndex*		local_exceptions;
		struct _jmethodID*	remote_exceptions;
	} declared_exceptions_u;
#define declared_exceptions declared_exceptions_u.local_exceptions
	int			framesize;	/* JIT only: size of frame */

#if defined(KAFFE_PROFILER)
	profiler_click_t	jitClicks;
	profiler_click_t	totalClicks;
	profiler_click_t	totalChildrenClicks;
	int			callsCount;
#endif
} methods;

#define METHOD_NAME(M)          ((M)->name)
#define METHOD_NAMED(M)         (METHOD_NAME(M)->data)

#define PSIG_UTF8(sig)		((sig)->signature)
#define PSIG_DATA(sig)		(PSIG_UTF8((sig))->data)
#define PSIG_RET(sig)		((sig)->ret_and_args[0])
#define PSIG_NARGS(sig)		((sig)->nargs)
#define PSIG_ARG(sig,n)		((sig)->ret_and_args[1+n])
#define PSIG_RNARGS(sig)	((sig)->real_nargs)

#define METHOD_PSIG(M)		((M)->parsed_sig)
#define METHOD_SIG(M)		(PSIG_UTF8(METHOD_PSIG((M))))
#define METHOD_SIGD(M)		(PSIG_DATA(METHOD_PSIG((M))))
#define METHOD_RET_TYPE(M)	(METHOD_SIGD((M))+PSIG_RET(METHOD_PSIG((M))))
#define METHOD_NARGS(M)		(PSIG_NARGS(METHOD_PSIG((M))))
#define METHOD_ARG_TYPE(M,N)    (METHOD_SIGD((M))+PSIG_ARG(METHOD_PSIG((M)),(N)))

#define	METHOD_BYTECODE_LEN(M)	((M)->c.bcode.codelen)
#define	METHOD_BYTECODE_CODE(M)	((M)->c.bcode.code)

typedef struct _dispatchTable {
	Hjava_lang_Class*	class;
	void*			__dummy0; /* For GCJ/C++ compatibility. */
	void*			method[1];
} dispatchTable;

#define	DTABLE_CLASS		0
#define	DTABLE_METHODOFFSET	(sizeof(void*)*2)
#define	DTABLE_METHODSIZE	(sizeof(void*))

typedef struct _jfieldID {
	Hjava_lang_Class*	clazz;
	Utf8Const*		name;
	Utf8Const*		signature;
        Utf8Const*              extSignature;
	Hjava_lang_Class*	type;
	accessFlags		accflags;
	u2			bsize;		/* in bytes */
	union {
		int		boffset;	/* offset in bytes (object) */
		void*		addr;		/* address (static) */
		u2		idx;		/* constant value index */
	} info;
} fields;

#define FIELD_UNRESOLVED_FLAG   0x8000
#define FIELD_CONSTANT_VALUE    0x4000

#define FIELD_RESOLVED(FLD)	((FLD)->type != 0 && !((FLD)->accflags & FIELD_UNRESOLVED_FLAG))

/* Type of field FLD.  Only valid if FIELD_RESOLVED(FLD). */
#define FIELD_TYPE(FLD)		((FLD)->type)
/* Size of field FLD, in bytes. */