verify-type.c

linux下建立JAVA虚拟机的源码KAFFE

/*
 * verify-type.c
 *
 * Copyright 2004
 *   Kaffe.org contributors. See ChangeLog for details. All rights reserved.
 *
 * See the file "license.terms" for information on usage and redistribution
 * of this file.
 *
 * Code for handing of types in the verifier.
 */

#include "debug.h"
#include "itypes.h"
#include "soft.h"
#include "gc.h"
#include "exception.h"
#include "errors.h"
#include "utf8const.h"
#include <string.h>
#include "verify.h"
#include "verify-debug.h"
#include "verify-type.h"
#include "verify-uninit.h"

/*
 * types for type checking (pass 3b)
 */
static Type  verify_UNSTABLE;
static Type* TUNSTABLE = &verify_UNSTABLE;

Type* getTUNSTABLE(void)
{
  return TUNSTABLE;
}

static Type  verify_INT;
static Type* TINT = &verify_INT;

Type* getTINT(void)
{
  return TINT;
}

static Type  verify_FLOAT;
static Type* TFLOAT = &verify_FLOAT;

Type* getTFLOAT(void)
{
  return TFLOAT;
}
       
static Type  verify_LONG;
static Type* TLONG = &verify_LONG;

Type* getTLONG(void)
{
  return TLONG;
}

static Type  verify_DOUBLE;
static Type* TDOUBLE = &verify_DOUBLE;

Type* getTDOUBLE(void)
{
  return TDOUBLE;
}

/* used for the second space of LONGs and DOUBLEs
 * in local variables or on the operand stack
 */
static Type  _WIDE;
static Type* TWIDE = &_WIDE;

Type* getTWIDE(void)
{
  return TWIDE;
}

bool
isWide(const Type * t)
{
	return (t->data.class == TWIDE->data.class);
}

static Type  verify_NULL;
static Type* TNULL = &verify_NULL;

Type* getTNULL(void)
{
  return TNULL;
}

bool
isNull(const Type * t)
{
	return (t->data.class == TNULL->data.class);
}

static const char* OBJECT_SIG  = "Ljava/lang/Object;";
static Type  verify_OBJ;
static Type* TOBJ = &verify_OBJ;

Type* getTOBJ(void)
{
  return TOBJ;
}

static const char* OBJARR_SIG = "[Ljava/lang/Object;";
static Type  verify_OBJARR;
static Type* TOBJARR = &verify_OBJARR;

Type* getTOBJARR(void)
{
  return TOBJARR;
}

static const char* STRING_SIG = "Ljava/lang/String;";
static Type  verify_STRING;
static Type* TSTRING = &verify_STRING;

Type* getTSTRING(void)
{
  return TSTRING;
}

static const char* CHARARR_SIG = "[C";
static Type  verify_CHARARR;
static Type* TCHARARR = &verify_CHARARR;

Type* getTCHARARR(void)
{
  return TCHARARR;
}

static const char* BYTEARR_SIG = "[B";
static Type  verify_BYTEARR;
static Type* TBYTEARR = &verify_BYTEARR;

Type* getTBYTEARR(void)
{
  return TBYTEARR;
}

static const char* BOOLARR_SIG = "[Z";
static Type  verify_BOOLARR;
static Type* TBOOLARR = &verify_BOOLARR;

Type* getTBOOLARR(void)
{
  return TBOOLARR;
}

static const char* SHORTARR_SIG = "[S";
static Type  verify_SHORTARR;
static Type* TSHORTARR = &verify_SHORTARR;

Type* getTSHORTARR(void)
{
  return TSHORTARR;
}

static const char* INTARR_SIG = "[I";
static Type  verify_INTARR;
static Type* TINTARR = &verify_INTARR;

Type* getTINTARR(void)
{
  return TINTARR;
}

static const char* LONGARR_SIG = "[J";
static Type  verify_LONGARR;
static Type* TLONGARR = &verify_LONGARR;

Type* getTLONGARR(void)
{
  return TLONGARR;
}

static const char* FLOATARR_SIG = "[F";
static Type  verify_FLOATARR;
static Type* TFLOATARR = &verify_FLOATARR;

Type* getTFLOATARR(void)
{
  return TFLOATARR;
}

static const char* DOUBLEARR_SIG = "[D";
static Type  verify_DOUBLEARR;
static Type* TDOUBLEARR = &verify_DOUBLEARR;

Type* getTDOUBLEARR(void)
{
  return TDOUBLEARR;
}

/*
 * Initialize Type structures needed for verification
 */
void
initVerifierPrimTypes(void)
{
	TUNSTABLE->tinfo = TINFO_SYSTEM;
	TUNSTABLE->data.class = (Hjava_lang_Class*)TUNSTABLE;
	
	TWIDE->tinfo = TINFO_SYSTEM;
	TWIDE->data.class = (Hjava_lang_Class*)TWIDE;
	
	
	TINT->tinfo = TINFO_PRIMITIVE;
	TINT->data.class = intClass;
	
	TLONG->tinfo = TINFO_PRIMITIVE;
	TLONG->data.class = longClass;
	
	TFLOAT->tinfo = TINFO_PRIMITIVE;
	TFLOAT->data.class = floatClass;
	
	TDOUBLE->tinfo = TINFO_PRIMITIVE;
	TDOUBLE->data.class = doubleClass;
	
	
	TNULL->tinfo = TINFO_CLASS;
	TNULL->data.class = (Hjava_lang_Class*)TNULL;
	
	TOBJ->tinfo = TINFO_SIG;
	TOBJ->data.sig = OBJECT_SIG;
	
	TOBJARR->tinfo = TINFO_SIG;	
	TOBJARR->data.sig = OBJARR_SIG;
	
	
	TSTRING->data.sig = STRING_SIG;
	TSTRING->tinfo = TINFO_SIG;
	
	
	TCHARARR->tinfo = TINFO_SIG;
	TCHARARR->data.sig = CHARARR_SIG;
	
	TBYTEARR->tinfo = TINFO_SIG;
	TBYTEARR->data.sig = BYTEARR_SIG;
	
	TBOOLARR->tinfo = TINFO_SIG;
	TBOOLARR->data.sig = BOOLARR_SIG;
	
	TSHORTARR->tinfo = TINFO_SIG;
	TSHORTARR->data.sig = SHORTARR_SIG;
	
	TINTARR->tinfo = TINFO_SIG;
	TINTARR->data.sig = INTARR_SIG;
	
	TLONGARR->tinfo = TINFO_SIG;
	TLONGARR->data.sig = LONGARR_SIG;
	
	TFLOATARR->tinfo = TINFO_SIG;
	TFLOATARR->data.sig = FLOATARR_SIG;
	
	TDOUBLEARR->tinfo = TINFO_SIG;	
	TDOUBLEARR->data.sig = DOUBLEARR_SIG;
}


/**
 *  If the given type is a simply a signature or class name, we
 *  resolve it to be a pointer to an actual Class object in memory.
 */
void
resolveType(Verifier* v, Type *t)
{
	if (t->tinfo & TINFO_SIG ||
	    *t->data.name == '[') {
		
		t->tinfo = TINFO_CLASS;
		t->data.class = getClassFromSignature(t->data.sig, v->class->loader, v->einfo);	    
	}
	else if (t->tinfo & TINFO_NAME) {
		char* tmp = NULL;
		const char* sig = t->data.name;
		
		tmp = checkPtr(gc_malloc((strlen(sig) + 3) * sizeof(char), KGC_ALLOC_VERIFIER));
		sprintf(tmp, "L%s;", sig);
		sig = tmp;
		
		DBG(VERIFY3, dprintf("%s    converted name to sig \"%s\" and about to load...\n", indent, sig); );
		t->tinfo = TINFO_CLASS;
		t->data.class = getClassFromSignature(sig, v->class->loader, v->einfo);
		
		if (tmp) {
			gc_free(tmp);
		}
	}
}


/**
 * Takes two classes, two lists of interfaces, merges them all into a newly
 * allocated SupertypeSet, and puts the result into the head of the Verifier's
 * list of allocated supertype sets.
 */
void
createSupertypeSet(Verifier* v,
		   Hjava_lang_Class* class_a,
		   uint32 num_interfaces_a,
		   Hjava_lang_Class** interfaces_a,
		   Hjava_lang_Class* class_b,
		   uint32 num_interfaces_b,
		   Hjava_lang_Class** interfaces_b)
{
	uint32 i, j;
	SupertypeSet* set = checkPtr(gc_malloc(sizeof(SupertypeSet), KGC_ALLOC_VERIFIER));
	
	(num_interfaces_a > num_interfaces_b) ?
		(i = num_interfaces_a + 1) :
		(i = num_interfaces_b + 1) ;
	set->list = checkPtr(gc_malloc(i * sizeof(Hjava_lang_Class*), KGC_ALLOC_VERIFIER));
	
	set->list[0] = getCommonSuperclass(class_a, class_b);
	set->count = 1;
	
	for (i = 0; i < num_interfaces_a; i++) {
		for (j = 0; j < num_interfaces_b; j++) {
			if (interfaces_a[i] == interfaces_b[j]) {
				set->list[set->count++] = interfaces_a[i];
			}
		}
	}
	
	set->next = v->supertypes;
	v->supertypes = set;
}

/**
 * t1 is a TINFO_CLASS
 * t2 is a TINFO_CLASS
 */
static inline
void
mergeClassesIntoSuperset(Verifier* v,
			 Type* t1,
			 Type* t2)
{
	createSupertypeSet(v,
			   t1->data.class, (uint32)t1->data.class->total_interface_len, t1->data.class->interfaces,
			   t2->data.class, (uint32)t2->data.class->total_interface_len, t2->data.class->interfaces);
}

/**
 * tc is a TINFO_CLASS
 * ts is a TINFO_SUPERTYPES
 */
static inline
void
mergeClassAndSuperset(Verifier* v, Type* tc, Type* ts)
{
	createSupertypeSet(v,
			   tc->data.class, (uint32)tc->data.class->total_interface_len, tc->data.class->interfaces,
			   ts->data.supertypes->list[0], ts->data.supertypes->count - 1, ts->data.supertypes->list + 1);
}

/**
 * t1 is a TINFO_SUPERTYPES
 * t2 is a TINFO_SUPERTYPES
 */
static inline
void
mergeSupersets(Verifier* v, Type* t1, Type* t2)
{
	createSupertypeSet(v,
			   t1->data.supertypes->list[0], t1->data.supertypes->count - 1, t1->data.supertypes->list + 1,
			   t2->data.supertypes->list[0], t2->data.supertypes->count - 1, t2->data.supertypes->list + 1);
	
}

/**
 * Frees all the memory allocated during the creation of the
 * given SupertypeSet.
 *
 * @param supertypes The supertype list to be deallocated.
 * @deffunc void freeSupertypes (SupertypeSet* supertypes)
 */
void
freeSupertypes(SupertypeSet* supertypes)