Attachment #98393 for bug #148629

Some Eclipse Foundation services are deprecated, or will be soon. Please ensure you've read this important communication.

View | Details | Raw Unified | Return to bug 148629 | Differences between

and this patch

Collapse All | Expand All

Lines 152-157 typedef void* pbcieng_t; Link Here

(-)src-native/BCI/BCIEng/BCIEngInterface.h (+2 lines)
152	_BCIENGINTERFACE_EXT_REF unsigned Initialize(pbcieng_t i_pbcieng, const char* i_pchOptions, size_t i_cbOptions);	152	_BCIENGINTERFACE_EXT_REF unsigned Initialize(pbcieng_t i_pbcieng, const char* i_pchOptions, size_t i_cbOptions);
153	_BCIENGINTERFACE_EXT_REF unsigned Instrument(pbcieng_t i_pbcieng, void* i_pInClass, size_t i_cbInClass,	153	_BCIENGINTERFACE_EXT_REF unsigned Instrument(pbcieng_t i_pbcieng, void* i_pInClass, size_t i_cbInClass,
154	void** o_ppOutClass, size_t* o_pcbOutClass);	154	void** o_ppOutClass, size_t* o_pcbOutClass);
		155	_BCIENGINTERFACE_EXT_REF unsigned Instrument2(pbcieng_t i_pbcieng, void* i_pInClass, size_t i_cbInClass,
		156	void** o_ppOutClass, size_t* o_pcbOutClass, void ()(void **));
155	_BCIENGINTERFACE_EXT_REF unsigned SetAllocator(pbcieng_t i_pbcieng, pfnMalloc_t i_pfnMalloc);	157	_BCIENGINTERFACE_EXT_REF unsigned SetAllocator(pbcieng_t i_pbcieng, pfnMalloc_t i_pfnMalloc);
156	_BCIENGINTERFACE_EXT_REF unsigned SetCallback(pbcieng_t i_pbcieng, pfnCallback_t i_pfnCallback, unsigned i_uFlags);	158	_BCIENGINTERFACE_EXT_REF unsigned SetCallback(pbcieng_t i_pbcieng, pfnCallback_t i_pfnCallback, unsigned i_uFlags);
157		159

Lines 132-138 public: Link Here

(-)src-native/BCI/BCIEng/Module.h (-1 / +2 lines)
132		132
133	virtual const vector<string>& GetSourceFileNames() = 0;	133	virtual const vector<string>& GetSourceFileNames() = 0;
134		134
135	virtual void Parse()=0;	135	virtual int Parse()=0;
136	virtual void Emit();	136	virtual void Emit();
137		137
138	CMethods* GetMethods(){return m_pMethods;}	138	CMethods* GetMethods(){return m_pMethods;}
Lines 527-532 public: Link Here
527	X_REASON_PARSE_ERROR, // Parsing error	527	X_REASON_PARSE_ERROR, // Parsing error
528	X_REASON_INVALID_CALL, // Invalid method call (e.g. abstract method)	528	X_REASON_INVALID_CALL, // Invalid method call (e.g. abstract method)
529	X_REASON_CODE_OVERRUN, // Code overrun during emission	529	X_REASON_CODE_OVERRUN, // Code overrun during emission
		530	X_REASON_VERIFICATION_FAILED, // Verifier stack map recalculation failed
530	X_REASON_LAST	531	X_REASON_LAST
531	};	532	};
532		533

Lines 34-41 Link Here

(-)src-native/BCI/BCIEng/BCIEngJ/ModuleJ.cpp (-6 / +100 lines)
34	#include <iostream>	34	#include <iostream>
35	#endif	35	#endif
36		36
37	static CInsSetJ InsSet;	37	#include <assert.h>
38		38
		39	static CInsSetJ InsSet;
39	//==============================================================================	40	//==============================================================================
40	// CModuleJ implementation	41	// CModuleJ implementation
41	//------------------------------------------------------------------------------	42	//------------------------------------------------------------------------------
Lines 51-56 CModuleJ::CModuleJ() Link Here
51	m_fDestroyClass = false;	52	m_fDestroyClass = false;
52	m_fAccessFlags = 0;	53	m_fAccessFlags = 0;
53	m_sourceFileNamesPopulated = false;	54	m_sourceFileNamesPopulated = false;
		55	m_verificationContext = NULL;
		56	m_classHandler = NULL;
		57	m_methodContexts = NULL;
		58	m_use_stack_map_recalculation = false;
54	}	59	}
55		60
56	//------------------------------------------------------------------------------	61	//------------------------------------------------------------------------------
Lines 63-68 CModuleJ::~CModuleJ() Link Here
63	{	68	{
64	delete m_pClass;	69	delete m_pClass;
65	}	70	}
		71	if (m_verificationContext != NULL) {
		72	free_verification_context(m_verificationContext);
		73	m_verificationContext = NULL;
		74	}
		75	if (m_classHandler != NULL) {
		76	class_destroy_handler(m_classHandler);
		77	m_classHandler = NULL;
		78	}
		79	if (m_methodContexts != NULL) {
		80	free(m_methodContexts);
		81	m_methodContexts = NULL;
		82	}
66	}	83	}
67		84
68	//------------------------------------------------------------------------------	85	//------------------------------------------------------------------------------
Lines 83-88 CModuleJ::Open(CSTR i_szName) Link Here
83	m_fDestroyClass = true;	100	m_fDestroyClass = true;
84	FileStreamIn.Close();	101	FileStreamIn.Close();
85	Verify();	102	Verify();
		103
86	}	104	}
87		105
88	//------------------------------------------------------------------------------	106	//------------------------------------------------------------------------------
Lines 184-190 CModuleJ::CreateMethod(u2 i_u2AccFlags, Link Here
184	}	202	}
185		203
186	//------------------------------------------------------------------------------	204	//------------------------------------------------------------------------------
187	void	205	int
188	CModuleJ::Parse()	206	CModuleJ::Parse()
189	{	207	{
190	CJMethods* pMethods = m_pClass->GetMethods();	208	CJMethods* pMethods = m_pClass->GetMethods();
Lines 227-238 CModuleJ::Parse() Link Here
227	}	245	}
228	m_pMethods->push_back(pMtd);	246	m_pMethods->push_back(pMtd);
229	}	247	}
		248
		249	vf_Result status;
		250	int ind;
		251	if (GetClassBuilder().GetMajorVersion() >= 50
		252	&& IsStackMapCalculationUsed()) {
		253	m_classHandler = get_class_handler_from_builder(this);
		254	assert(m_classHandler);
		255	m_verificationContext = allocate_verification_context(m_classHandler);
		256	assert(m_verificationContext);
		257	m_methodContexts = (method_handler )malloc(m_pMethods->size() sizeof(method_handler));
		258	assert(m_methodContexts);
		259	memset(m_methodContexts, 0, m_pMethods->size() * sizeof(method_handler));
		260	//fprintf(stderr, "class : %s is java6 compiled\n", m_strName.c_str());
		261	}
230		262
231	CMethods::iterator iterm;	263	CMethods::iterator iterm;
232	for(iterm = m_pMethods->begin(); iterm < m_pMethods->end(); iterm++)	264	for(iterm = m_pMethods->begin(), ind = 0; iterm < m_pMethods->end(); iterm++, ind++)
233	{	265	{
234	(*iterm)->Parse();	266	(*iterm)->Parse();
		267	if (GetClassBuilder().GetMajorVersion() >= 50
		268	&& IsStackMapCalculationUsed()) {
		269	m_methodContexts[ind] = get_method_handler_for_cmethod(*iterm);
		270	assert(m_methodContexts[ind]);
		271	status = init_verification_context_for_method(m_methodContexts[ind], m_verificationContext);
		272
		273	if (status != VF_OK) {
		274	fprintf(stderr, "class was skiped: %s\n", m_strName.c_str());
		275	return (1); /skip/
		276	}
		277	//fprintf(stderr, "class was instrumented: %s\n", m_strName.c_str());
		278	((CMethodJ )(iterm))->SetMethodHandler(m_methodContexts[ind]);
		279
		280	}
235	}	281	}
		282	return (0);
236	}	283	}
237		284
238	//------------------------------------------------------------------------------	285	//------------------------------------------------------------------------------
Lines 385-392 CMethodJ::Emit() Link Here
385	m_pMtdExTable->Emit();	432	m_pMtdExTable->Emit();
386		433
387	//-------	434	//-------
388	// Loop over instructions and patch the local variable info table	435	// Loop over instructions and patch the local variable info table,
		436	// local variable type table (Java 5.0) and stack map table (Java 6.0)
389	//	437	//
		438
		439
390		440
391	// Local variable table LVT	441	// Local variable table LVT
392	CLocalVariableTableAttribute* pLclAttr = m_pCodeAttr->GetLocalVariables();	442	CLocalVariableTableAttribute* pLclAttr = m_pCodeAttr->GetLocalVariables();
Lines 403-408 CMethodJ::Emit() Link Here
403	CLocalVariableTypeTable LclTypeTableSav;	453	CLocalVariableTypeTable LclTypeTableSav;
404	CLocalVariableTypeTable::iterator itrLclType, itrLclTypeSav; // LVTT Iterator	454	CLocalVariableTypeTable::iterator itrLclType, itrLclTypeSav; // LVTT Iterator
405		455
		456	// The smtNull variable is for reference initialization in case the method does not have
		457	// a Stack Map Table attribute
		458	CStackMapTable smtNull;
		459	CStackMapTableAttribute* pSmtAttr = m_pCodeAttr->GetStackMaps();
		460	CStackMapTable& StackMapTable = pSmtAttr?pSmtAttr->GetStackMapTable():smtNull;
		461	CStackMapTable::iterator itrStackMapFrame = StackMapTable.begin();
		462
406	CInsBlocks::iterator iterBlocks;	463	CInsBlocks::iterator iterBlocks;
407	IP_t ip = 0;	464	IP_t ip = 0;
408		465
Lines 458-463 CMethodJ::Emit() Link Here
458	}	515	}
459	}	516	}
460	}	517	}
		518
		519	// Scan for a relevant entry in the Stack Map Table and fix it
		520	while (itrStackMapFrame != StackMapTable.end()
		521	&& (*itrStackMapFrame)->GetByteCodeOffset() < ipOrig)
		522	{
		523	++itrStackMapFrame;
		524	}
		525	if (itrStackMapFrame != StackMapTable.end()
		526	&& (*itrStackMapFrame)->GetByteCodeOffset() == ipOrig)
		527	{
		528	(*itrStackMapFrame)->SetByteCodeOffset(ip);
		529	}
461		530
462	// Advance ip	531	// Advance ip
463	ip += (*iterIns)->GetSize(ip);	532	ip += (*iterIns)->GetSize(ip);
Lines 503-513 CMethodJ::Emit() Link Here
503	}	572	}
504	}	573	}
505	}	574	}
		575	// Replace the method body
		576	m_pCodeAttr->SetCode(m_pBody->GetCodeSize(), m_pBody->GiveAvayCode());
506		577
		578	// Calculate new stack depth
507	CalcStackDepth();	579	CalcStackDepth();
508		580
509	// Replace the method body	581	if (((CModuleJ *)GetModule())->GetClassBuilder().GetMajorVersion() >= 50
510	m_pCodeAttr->SetCode(m_pBody->GetCodeSize(), m_pBody->GiveAvayCode());	582	&& ((CModuleJ *)GetModule())->IsStackMapCalculationUsed()) {
		583
		584	u1 *tbl;
		585	vf_Result status;
		586	status = recompute_stackmaptable((uint8 *)&tbl, m_methodHandler, ((CModuleJ )GetModule())->GetVerificationContext());
		587	if (status != VF_OK) {
		588	throw CModuleException(CModuleException::X_REASON_VERIFICATION_FAILED, "stack map recalcualtion failed");
		589	}
		590	else {
		591	//CStackMapTable smt (tbl);
		592	CStackMapTableAttribute* smta = GetCodeAttribute()->GetOrCreateStackMaps();
		593	if (tbl != NULL) {
		594	smta->RereadFromBuffer(tbl); //skiping name
		595	smta->GetStackMapTable().AdjustOffsetDeltas();
		596	}
		597	}
		598	}
		599	// Final Stack Map Table handling: adjust offset deltas
		600	//StackMapTable.AdjustOffsetDeltas();
		601
		602
		603
511		604
512	}	605	}
513		606
Lines 628-633 CMtdExTableJ::Emit() Link Here
628	}	721	}
629	}	722	}
630	}	723	}
		724
631	CJException jex = CJException(uType, ipStart, ipRealEnd, ipHandler);	725	CJException jex = CJException(uType, ipStart, ipRealEnd, ipHandler);
632	extblj.push_back(jex);	726	extblj.push_back(jex);
633	}	727	}





#include "Module.h"
#include "JClassBuilder.h"
#include "class_inerface_int.h"

class CModuleJ;
class CMethodJ;

	virtual void	Open(CJClassBuilder* io_pClass, bool i_fDestroyClass = false);
	virtual void	AddExtRef(CExtRef& i_ExtRef);
	virtual void	AddStringAttrib(CSTR i_szName, CSTR i_szValue);
	virtual int	Parse();
	virtual void	Emit();

	void	Emit(CJStream& i_jstream);	// Java specific emission
	CJClassFile&	GetClass();
	CJClassBuilder& GetClassBuilder();
	class_handler GetClassHandler() {return m_classHandler;}
	verification_context GetVerificationContext(){return m_verificationContext;}

	virtual const vector<string>& GetSourceFileNames();

	// Module modification methods
	CCPFieldrefInfo*	CreateFieldRef(u2 i_u2AccFlags, CSTR i_szName, CJavaType i_jtype);
	CMethodJ*			CreateMethod(u2 i_u2AccFlags, CSTR i_szName, CSTR i_szSignature);
	bool IsStackMapCalculationUsed() const {return m_use_stack_map_recalculation;}
	void UseStackMapCalculation(bool a_use_stack_map_recalculation) {m_use_stack_map_recalculation = a_use_stack_map_recalculation;}
protected:

private:

	// Storage in support of GetSourceFileNames:
	vector<string>	m_sourceFileNames;
	bool			m_sourceFileNamesPopulated;
	verification_context m_verificationContext; /*verifier context for support java 6.0 and latter*/
	class_handler m_classHandler; /* class descriptor used for verification needs(recalculations) introduced in java 6.0*/
	method_handler *m_methodContexts; /*collections of method handlers*/
	bool m_use_stack_map_recalculation;
};

//==============================================================================

		m_strSignature = i_szSignature;
		m_pCodeAttr = i_pCodeAttr;
		m_u2AccessFlags = i_u2AccessFlags;
		m_methodHandler = NULL;
		

		// Set the "hasThis" attribute, which is accessible to all CMethod users
		SetHasThis(!(m_u2AccessFlags & ACC_STATIC));

	CSTR	GetSignature() const {return m_strSignature.c_str();}
	bool IsAbstract() { return ((m_u2AccessFlags & ACC_ABSTRACT) != 0); };
    u2 GetAccessFlags() const { return m_u2AccessFlags; }
	void SetMethodHandler(method_handler i_methodHandler) {m_methodHandler = i_methodHandler;}
	method_handler GetMethodHandler() {return m_methodHandler;}

	virtual void Parse();
	virtual void Emit();

	CCodeAttribute*		m_pCodeAttr;		// Code attribute from CJClassFile
	u2					m_u2AccessFlags;	// Method access flags
	IP_t				m_origCodeLength;	// Saved code length from Parse to Emit
	method_handler		m_methodHandler;
};






/********************************************************************** 
 * Copyright (c) 2008 IBM Corporation and others. 
 * All rights reserved.   This program and the accompanying materials 
 * are made available under the terms of the Eclipse Public License v1.0 
 * which accompanies this distribution, and is available at 
 * http://www.eclipse.org/legal/epl-v10.html         
 * $Id$ 
 * 
 * Contributors: 
 * Intel - Initial API and implementation 
 **********************************************************************/ 

#ifndef _CLASS_INTERFACE_INT_H_
#define _CLASS_INTERFACE_INT_H_

#include "JClassBuilder.h"

//typedef u1 uint8;
//typedef u2 uint16;
//#include "class_interface.h"
//#include "class_interface_x.h"

#include "x_verifier/x_class_interface.h"
#include "x_verifier/x_verifier.h"

typedef Class_Handle class_handler;
typedef Method_Handle method_handler;
typedef void *(*get_vm_pointer_t)(void **);

class_handler get_class_handler_from_builder(class CModuleJ *);
method_handler get_method_handler_for_cmethod(class CMethod *);

//extern "C" {
//unsigned method_get_bytecode_length( method_handler);
//}

extern int initialize_dynamic(get_vm_pointer_t);
void class_destroy_handler(class_handler);

int initialize_static();

#endif




/********************************************************************** 
 * Copyright (c) 2008 IBM Corporation and others. 
 * All rights reserved.   This program and the accompanying materials 
 * are made available under the terms of the Eclipse Public License v1.0 
 * which accompanies this distribution, and is available at 
 * http://www.eclipse.org/legal/epl-v10.html         
 * $Id$ 
 * 
 * Contributors: 
 * Intel - Initial API and implementation 
 **********************************************************************/ 

#include <stdlib.h>
#include <string.h>

#include <map>

#include <assert.h>
#include "BCIEng.h"
#include "JClassBuilder.h"
#include "ModuleJ.h"

#include "JMemStream.h"
#include "class_inerface_int.h"


#include <jni.h>

typedef unsigned long intptr;

static JNIEnv *(*m_get_vm_pointer)(void **);
static jclass m_j_l_class;
static jclass m_j_l_classloader;
static jmethodID m_j_l_class_getName; /*()Ljava/lang/String;*/
static jmethodID m_j_l_class_isInterface;/* ()Z */
static jmethodID m_j_l_class_getClassLoader; /*()Ljava/lang/ClassLoader;*/
static jmethodID m_j_l_classloader_findLoadedClass; /*(Ljava/lang/String;)Ljava/lang/Class;*/
static jmethodID m_j_l_classloader_getSystemClassLoader; /*()Ljava/lang/ClassLoader;*/
static jobject m_system_classloader;
/**
 * Define class handler
 */
/*[0xdead0001 - simplefied, 0xdead0002 - instrumented, 0xdead0000 - none]*/
#define CLASS_HANDLER_MASK 0xdeadffff
#define CLASS_HANDLER_SIMPLEFIED 0xdead0001
#define CLASS_HANDLER_INSTRUMENTED 0xdead0002
#define CLASS_HANDLER_NONE 0xdead0000
#define IS_CLASS_INSTRUMENTED(x) (((x)->magic & CLASS_HANDLER_MASK) == CLASS_HANDLER_INSTRUMENTED)
struct Class{
	int magic; 
	struct {
		class CModuleJ *instrumented_class;
		void *simplified_class;	
	} X; /*XXX: possible union here will be more applieble */
	int loaded;
	const char *class_name; /*used if loaded = 0*/
	struct Class *super_class;
};

typedef std::map<std::string,class_handler> name2ch_t;
static name2ch_t m_name2ch;

#define MEHTOD_HANDLER_MASK 0xbabeffff
#define METHOD_HANDLER_SELF 0xbabe0001
#define METHOD_HANDLER_EXT 0xbabe0002
#define METHOD_HANDLER_NONE 0xbabe0000
struct Method {
	int magic; 
	struct {
		class CMethodJ *instrumented_method;
		void *simplefied_method;
	} X; /*XXX: possible union here will be more applieble */
	class_handler class_owner;
	const char *method_name; /*used for METHOD_HANDLER_EXT only*/
	const char *method_descriptor; /*used for METHOD_HANDLER_EXT only*/
};

static struct Class *m_j_l_object_ch; 
/**
 * Define field handler
 */
typedef struct Field_ * field_handler;

/**
 * Define method handler
 */
//typedef struct Method_ * method_handler;

/**
 * Define class loader handler
 */
typedef struct ClassLoader_ * classloader_handler;

static int 
create_class_handler(class_handler *pch, int flag, const char *class_name, int loaded, void *dsk)
{
	class_handler ch0 = m_name2ch[class_name]; /*for debug*/
	if (m_name2ch[class_name] != NULL 
		&& m_name2ch[class_name]->magic == flag) {
			*pch = m_name2ch[class_name];
			return (0);
	} 
	class_handler ch = (class_handler)malloc(sizeof(struct Class));
	memset(ch, 0, sizeof(struct Class));
	assert(ch);
	ch->loaded = loaded;
	if (loaded == 0) {
		ch->class_name = class_name;
	}
	ch->magic = flag;
	switch(flag) {
	case (CLASS_HANDLER_SIMPLEFIED):
		ch->X.simplified_class = dsk;
		if (loaded == 0) {
			ch->class_name = class_name;
		}
		ch->loaded = loaded;
		break;
	case (CLASS_HANDLER_INSTRUMENTED):
		ch->X.instrumented_class = (CModuleJ *)dsk;
		break;
	default:
		assert(!"shouldn't be here!!!");
	}
	*pch = ch;
	m_name2ch[class_name] = ch;
	return (0);
}

extern "C" int
create_method_handler(method_handler *pmh, class_handler ch, int flag, void *dsk) 
{
	method_handler mh = (method_handler)malloc(sizeof(struct Method));
	assert(mh);
	memset(mh, 0, sizeof(struct Method));
	switch (flag) {
	case METHOD_HANDLER_SELF:
		mh->X.instrumented_method = (class CMethodJ *)dsk;
		break;
	case METHOD_HANDLER_EXT:
		mh->X.simplefied_method = dsk;
		break;
	default:
		assert(!"shouldn't enter here");
	}
	mh->magic = (IS_CLASS_INSTRUMENTED(ch))?METHOD_HANDLER_SELF:flag;
	mh->class_owner = ch;
	*pmh = mh;
	return (0);
}
/**
 * Class interface
 */

extern "C" unsigned short 
class_get_version( class_handler klass ) {
	if (IS_CLASS_INSTRUMENTED(klass)) {
		return klass->X.instrumented_class->GetClassBuilder().GetMajorVersion();
	} else {
		assert (!"not implemented yet!");
	}
	return (0);
}

extern "C" const char *
class_get_name( class_handler klass ) 
{
	JNIEnv *env;
	jstring class_name;
	if (IS_CLASS_INSTRUMENTED(klass)) {
		return klass->X.instrumented_class->GetName();
	} 
	else {
		if (klass->loaded == 0) {
			return(klass->class_name);
		}
		env = m_get_vm_pointer((void **)&env);
		class_name = (jstring)env->CallObjectMethod((jobject)klass->X.simplified_class, m_j_l_class_getName);
		if (class_name == NULL)
			return (NULL);
		char *class_name_simple = (char *)env->GetStringUTFChars(class_name, NULL);
		char *ch = strchr(class_name_simple, '.');
		while (ch != NULL) {
			*ch = '/';
			ch = strchr(ch, '.');
		}
		return(class_name_simple);
	
	}
	return (NULL);
}

extern "C" classloader_handler
class_get_class_loader( class_handler klass )
{
	if (IS_CLASS_INSTRUMENTED(klass)) {
		return (0);
	} else {
		assert(!"simplefied");
	}
	return (NULL);
}

extern "C" class_handler
class_get_super_class( class_handler klass )
{

	const char *class_name;
	const char *super_class_name = NULL;
	jobject this_class = NULL;
	jobject super_class;
	JNIEnv *env = NULL;
	env = m_get_vm_pointer((void **)&env);
	assert(env);
	int loaded = 1;
	if (klass->loaded == 0 && strcmp(klass->class_name,"java/lang/Object") == 0) return (NULL);
	if (klass->super_class != NULL) return (klass->super_class);
	
	if (IS_CLASS_INSTRUMENTED(klass)) {
		class_name = klass->X.instrumented_class->GetName();
		CConstPool* cpool = klass->X.instrumented_class->GetClass().GetConstPool();
		CCPUtf8Info* utfinfo = cpool->GetClass(klass->X.instrumented_class->GetClass().GetSuperClass());
		super_class_name = (const char *)utfinfo->GetBytes();
		assert(super_class_name);	
		super_class = (jclass)env->FindClass(super_class_name);		
	} 
	else {
		if (klass->loaded == 0) {
			assert(klass->class_name);
			this_class = (jclass)env->FindClass(klass->class_name);
			if (this_class == NULL && env->ExceptionCheck()) {
				//env->ExceptionDescribe();
				env->ExceptionClear();
				//XXX: class wasn't found or loaded
				return (m_j_l_object_ch);
				//return (NULL);
			}
		}
		this_class = this_class?this_class:(jobject)klass->X.simplified_class;
		super_class = (jobject)env->GetSuperclass((jclass)this_class);
	}

	if (super_class == NULL) {
		if (env->ExceptionCheck()) {
			//env->ExceptionDescribe();
			env->ExceptionClear();
			//XXX: class wasn't found or loaded
			loaded = 0;
			//return (NULL);
		}
		else {
			klass->super_class = m_j_l_object_ch;
			return (m_j_l_object_ch);
			//return (NULL); /*it happends when klass is java.lang.Object*/
		}
	}
	else {
		jstring jclass_name = (jstring)env->CallObjectMethod(super_class, m_j_l_class_getName);
		if (jclass_name == NULL) {
			return (m_j_l_object_ch);
		}
		char *class_name_simple = (char *)env->GetStringUTFChars(jclass_name, NULL);
		assert (class_name_simple);
		char *ch = strchr(class_name_simple, '.');
		while (ch != NULL) {
			*ch = '/';
			ch = strchr(ch, '.');
		}
		super_class_name = class_name_simple;
	}
	
	//assert(super_class);
	class_handler ch;
	jobject super_class_ref = env->NewGlobalRef(super_class);
	env->DeleteLocalRef(super_class);
	int status = create_class_handler(&ch, CLASS_HANDLER_SIMPLEFIED, super_class_name, loaded, super_class_ref);
	assert(status == 0);
	return (ch);
}

extern "C" unsigned
class_is_same_class( class_handler klass1, class_handler klass2 )
{
	assert(!"verifier entered!!");
	return 0;
}

static char* 
package_name(const char* kname)
{
	char *tokp;
	char *tok0;
	tokp = tok0 = (char *)&kname[0];
	tok0 = strchr(kname, '/');
	while (tok0 != NULL) {
		tokp = tok0;
		tok0 = strchr(tok0 + 1, '/');
	}
	return (tokp);
}

extern "C" unsigned
class_is_same_package( class_handler klass1, class_handler klass2 ) 
{
	if (klass1 == klass2) {
		return (1);
	}
	else {
		const char *klass1_name = class_get_name(klass1);
		const char *klass2_name = class_get_name(klass2);
		char* package1 = package_name(klass1_name);
		char* package2 = package_name(klass2_name);
		int package1_len = (package1 - klass1_name);
		int package2_len = (package2 - klass2_name);
		if (package1_len != package2_len)
			return (0);
		return(strncmp(klass1_name, klass2_name, package2_len) == 0);
		assert(!"verifier entered!!");
	}
	return (0);
}

extern "C" unsigned
class_is_interface( class_handler klass ) 
{
	JNIEnv *env;
	env = m_get_vm_pointer((void **)&env);
	assert(env);
	if (IS_CLASS_INSTRUMENTED(klass)) {
		return (0);
	} 
	else {
		return (unsigned)(env->CallBooleanMethod((jobject)klass->X.simplified_class, m_j_l_class_isInterface));
	}
	
	return (0);
}

extern "C" unsigned
class_is_array( class_handler klass ) 
{
	assert(!"verifier entered!!");
	return (0);
}

extern "C" unsigned
class_is_final_( class_handler klass ) 
{
	assert(!"verifier entered!!");
	return (0);
}

extern "C" unsigned short
class_get_superinterface_number( class_handler klass )
{
	assert(!"verifier entered!!");
	return (0);
}

extern "C" class_handler
class_get_superinterface( class_handler klass, unsigned short index )
{
	assert(!"verifier entered!!");
	return (NULL);
}

extern "C" class_handler
class_get_array_element_class( class_handler klass )
{
	assert(!"verifier entered!!");
	return (NULL);
}


extern "C" class_handler
class_get_extended_class( class_handler klass, const char *super_name )
{
	return (NULL);
}

extern "C" unsigned short
class_get_method_number( class_handler klass )
{
	assert(!"verifier entered!!");
	return (0);
}

extern "C" method_handler
class_get_method( class_handler klass, unsigned short index )
{
	assert(!"verifier entered!!");
	return (NULL);
}


/**
 * Constant pool inteface
 */

extern "C" unsigned short
class_cp_get_size( class_handler klass )
{
	assert(klass);
	if (IS_CLASS_INSTRUMENTED(klass)) {
		assert(klass->X.instrumented_class);
		assert(klass->X.instrumented_class->GetClassBuilder().GetConstPool());
		return klass->X.instrumented_class->GetClassBuilder().GetConstPool()->GetSize();
	} else {
		assert (!"not implemented yet!");
	}
	assert(!"verifier entered!!");
	return (0);
}


extern "C" unsigned char
class_cp_get_tag( class_handler klass, unsigned short index )
{
	if (IS_CLASS_INSTRUMENTED(klass)) {
		return (*klass->X.instrumented_class->GetClassBuilder().GetConstPool())[index]->GetTag();
	} else {
		assert (!"not implemented yet!");
	}
	return (0);
}

extern "C" unsigned short
class_cp_get_class_name_index( class_handler klass, unsigned short index )
{
	if (IS_CLASS_INSTRUMENTED(klass)) {
		CCPInfo * ccinfo = (*klass->X.instrumented_class->GetClassBuilder().GetConstPool())[index];
		assert(ccinfo->GetTag() == CONSTANT_Class);
		return ((CCPClassInfo *)ccinfo)->GetClassInd();
	} else {
		assert (!"not implemented yet!");
	}
	return (0);
}

extern "C" unsigned short
class_cp_get_ref_class_index( class_handler klass, unsigned short index )
{
	if (IS_CLASS_INSTRUMENTED(klass)) {
		CCPInfo * ccinfo = (*klass->X.instrumented_class->GetClassBuilder().GetConstPool())[index];
		unsigned char tag = ccinfo->GetTag();
		switch(tag) {
		case CONSTANT_Fieldref:
			return ((CCPFieldrefInfo *)ccinfo)->GetClassInd();
		break;
		case CONSTANT_Methodref:
			return ((CCPMethodrefInfo *)ccinfo)->GetClassInd();
		break;
		case CONSTANT_InterfaceMethodref:
			return ((CCPInterfaceMethodrefInfo *)ccinfo)->GetClassInd();
		break;
		default:
			assert(!"unsupported tag");
		}
	} else {
		assert (!"not implemented yet!");
	}
	return (0);
}

extern "C" unsigned short
class_cp_get_ref_name_and_type_index( class_handler klass, unsigned short index )
{
	if (IS_CLASS_INSTRUMENTED(klass)) {
		CCPInfo * ccinfo = (*klass->X.instrumented_class->GetClassBuilder().GetConstPool())[index];
		unsigned char tag = ccinfo->GetTag();
		switch(tag) {
		case CONSTANT_Fieldref:
			return ((CCPFieldrefInfo *)ccinfo)->GetNameAndTypeInd();
		break;
		case CONSTANT_Methodref:
			return ((CCPMethodrefInfo *)ccinfo)->GetNameAndTypeInd();
		break;
		case CONSTANT_InterfaceMethodref:
			return ((CCPInterfaceMethodrefInfo *)ccinfo)->GetNameAndTypeInd();
		break;
		default:
			assert(!"unsupported tag");
		}
	} else {
		assert (!"not implemented yet!");
	}
	return (0);
}

extern "C" unsigned short
class_cp_get_string_index( class_handler klass, unsigned short index )
{
	assert(!"verifier entered!!");
	return (0);
}

extern "C" unsigned short
class_cp_get_name_index( class_handler klass, unsigned short index )
{
	if (IS_CLASS_INSTRUMENTED(klass)) {
		CCPInfo * ccinfo = (*klass->X.instrumented_class->GetClassBuilder().GetConstPool())[index];
		unsigned char tag = ccinfo->GetTag();
		assert(tag == CONSTANT_NameAndType);
		return ((CCPNameAndTypeInfo *)ccinfo)->GetNameInd();
	} else {
		assert (!"not implemented yet!");
	}
	return (0);
}

extern "C" unsigned short
class_cp_get_descriptor_index( class_handler klass, unsigned short index )
{
	if (IS_CLASS_INSTRUMENTED(klass)) {
		CCPInfo * ccinfo = (*klass->X.instrumented_class->GetClassBuilder().GetConstPool())[index];
		unsigned char tag = ccinfo->GetTag();
		assert(tag == CONSTANT_NameAndType);
		return ((CCPNameAndTypeInfo *)ccinfo)->GetDescriptorInd();
	} else {
		assert (!"not implemented yet!");
	}
	return (0);
}

extern "C" const char *
class_cp_get_utf8_bytes( class_handler klass, unsigned short index )
{
	if (IS_CLASS_INSTRUMENTED(klass)) {
		return (const char *)((CCPUtf8Info *)(*klass->X.instrumented_class->GetClassBuilder().GetConstPool())[index])->GetBytes();
	} else {
		assert (!"not implemented yet!");
	}
	return (0);
}

extern "C" void
class_set_verify_data_ptr( class_handler klass, void *data )
{
	assert(!"verifier entered!!");
	return;
}

extern "C" void *
class_get_verify_data_ptr( class_handler klass )
{
	assert(!"verifier entered!!");
	return (NULL);
}

extern "C" method_handler
class_resolve_method( class_handler klass, unsigned short index )
{
	assert(!"verifier entered!!");
	return (NULL);
}

extern "C" field_handler
class_resolve_nonstatic_field( class_handler klass, unsigned short index )
{
	assert(!"verifier entered!!");
	return (NULL);
}

/**
 * Method interface
 */

extern "C" class_handler
method_get_class( method_handler hmethod )
{
	assert(hmethod);
	return hmethod->class_owner;
}

extern "C" const char *
method_get_name( method_handler method )
{
	if (method->magic == METHOD_HANDLER_SELF) {
		return (method->X.instrumented_method->GetName());
	}
	else {
		assert(!"verifier entered!!");
	}
	return (NULL);
}

extern "C" const char *
method_get_descriptor( method_handler method )
{
	if (method->magic == METHOD_HANDLER_SELF) {
		return (method->X.instrumented_method->GetSignature());
	}
	else {
		assert(!"verifier entered!!");
	}
	return (NULL);
}

extern "C" unsigned
method_get_bytecode_length( method_handler method )
{
	/*insert check about instrumentation*/
	if (method->magic == METHOD_HANDLER_SELF) {
		unsigned size = 0;
		CInstructions::const_iterator insIterator;
		if (method->X.instrumented_method->GetCodeAttribute() == NULL) return (0);
		return (method->X.instrumented_method->GetCodeAttribute()->GetCodeLength());
	}
	else {
		assert(!"verifier entered!!");
	}
	return (0);	
}

extern "C" unsigned char *
method_get_bytecode( method_handler method )
{
	if (method->magic == METHOD_HANDLER_SELF) {
		return (method->X.instrumented_method->GetCodeAttribute()->GetCode());
	}
	else {
		assert(!"verifier entered!!");
	}
	return (NULL);	
}

extern "C" unsigned
method_get_max_locals( method_handler method )
{
	if (method->magic == METHOD_HANDLER_SELF) {
		/*XXX: add check for instrumented method*/
		CMethodJ * jmethod = (CMethodJ *)(method->X.instrumented_method);
		return (jmethod->GetCodeAttribute()->GetMaxLocals());
	}
	else {
		assert(!"verifier entered!!");
	}
	return (0);	
	
}

extern "C" unsigned 
method_get_max_stack( method_handler method )
{
	if (method->magic == METHOD_HANDLER_SELF) {
		CMethodJ * jmethod = (CMethodJ *)(method->X.instrumented_method);
		return (jmethod->GetCodeAttribute()->GetMaxStack());
	}
	else {
		assert(!"verifier entered!!");
	}
	return (0);	
}

extern "C" unsigned
method_is_static( method_handler method )
{
	if (method->magic == METHOD_HANDLER_SELF) {
		return (method->X.instrumented_method->GetAccessFlags() & ACC_STATIC);
	}
	else {
		//assert(!"verifier entered!!");
		return (0); /*we're assuming that this function called after class_resolve_method and couldn't return static methods*/
	}
	return (0);	
	
}

extern "C" unsigned
method_is_protected( method_handler method )
{
	assert(!"verifier entered!!");
	return (0);
}

/**
 * Method exception handler
 */

extern "C" unsigned short
method_get_exc_handler_number( method_handler method )
{
	return (method->X.instrumented_method->GetExTable()->size());
}

extern "C" void
method_get_exc_handler_info( method_handler method, unsigned short index,
                             unsigned short *start_pc, unsigned short *end_pc,
                             unsigned short *handler_pc, unsigned short *catch_type )
{
	class CExTable& exc = method->X.instrumented_method->GetCodeAttribute()->GetExTable();
	*start_pc = exc[index].GetStartPC();
	*end_pc = exc[index].GetEndPC();
	*handler_pc = exc[index].GetHandlerPC();
	*catch_type = exc[index].GetCatchtype();

	return;
}

extern "C" unsigned short
method_get_number_exc_method_can_throw( method_handler hmethod )
{
	assert(!"verifier entered!!");
	return (0);
}

extern "C" const char *
method_get_exc_method_can_throw( method_handler hmethod, unsigned short index )
{
	assert(!"verifier entered!!");
	return (NULL);
}


extern "C" unsigned char *
method_get_stackmaptable( method_handler hmethod )
{
	
	CStackMapTableAttribute *attr = hmethod->X.instrumented_method->GetCodeAttribute()->GetStackMaps();
	if (attr == NULL)
		return (NULL);
	u4 length = attr->GetLength();
	u1 *stackmap = (u1 *)malloc(length);
	CJMemStream mem_stream;
	mem_stream.Open(stackmap, length);
	CJStream stream(&mem_stream);
	attr->Write(stream);
	//return (attr->GetInfo());
	return (stackmap);
}

extern "C" void 
method_modify_exc_handler_info(method_handler method, 
                                    unsigned short idx, 
                                    unsigned short start_pc,
                                    unsigned short end_pc, 
                                    unsigned short handler_pc, 
                                    unsigned short handler_cp_index )
{

	class CExTable& exc = method->X.instrumented_method->GetCodeAttribute()->GetExTable();
	exc[idx].SetStartPC(start_pc);
	exc[idx].SetEndPC(end_pc);
	exc[idx].SetHandlerPC(handler_pc);
	return;
}

extern "C" void 
method_remove_exc_handler( method_handler method, unsigned short idx )
{
	assert(!"verifier entered!!");
	return;
}

/**
 * Class loader interface
 */

extern "C" void
class_loader_set_verifier_data_ptr( classloader_handler classloader, void *data )
{
	assert(!"verifier entered!!");
	return;
}

extern "C" void *
class_loader_get_verifier_data_ptr( classloader_handler classloader )
{
	assert(!"verifier entered!!");
	return (NULL);
}

extern "C" void
class_loader_lock( classloader_handler classloader )
{
	assert(!"verifier entered!!");
	return;
}

extern "C" void
class_loader_unlock( classloader_handler classloader )
{
	assert(!"verifier entered!!");
	return;
}

extern "C" class_handler
class_loader_lookup_class( classloader_handler classloader, const char *name )
{
	if (m_name2ch[name] != NULL && IS_CLASS_INSTRUMENTED(m_name2ch[name])) 
		return (m_name2ch[name]);
	else
		return (NULL);
}

extern "C" class_handler
class_loader_load_class( classloader_handler classloader, const char *name )
{
	assert(!"verifier entered!!");
	return (NULL);
}

extern "C" unsigned
field_is_protected( field_handler field )
{
	assert(!"verifier entered!!");
	return (0);
}

class_handler
get_class_handler_from_builder(class CModuleJ *module) 
{
	class_handler ch;

	m_name2ch.clear();
	int status = create_class_handler(&m_j_l_object_ch, CLASS_HANDLER_SIMPLEFIED, "java/lang/Object", 0, NULL);
	assert(!status);
	
	status = create_class_handler(&ch, CLASS_HANDLER_INSTRUMENTED, module->GetName(), 1, module);
	assert(!status);
	return (ch);
}

method_handler 
get_method_handler_for_cmethod(class CMethod *method)
{
	class_handler ch = NULL;
	method_handler mh = NULL;
	int status;
	status = create_class_handler(&ch, CLASS_HANDLER_INSTRUMENTED, (const char *)method->GetModule()->GetName(), 1, method->GetModule());
	assert(!status);
	status = create_method_handler(&mh, ch, METHOD_HANDLER_SELF, method);
	assert(!status);
	return (mh);
}

extern "C" unsigned short
class_cp_get_class_entry(class_handler klass, const char* name)
{

	
	CCPClassInfo *cinfo;
	if (IS_CLASS_INSTRUMENTED(klass)) {
		/*for this class we'll have entry somewhere in some future */
		if (strcmp(klass->X.instrumented_class->GetName(), name) == 0) {
			return (klass->X.instrumented_class->GetClass().GetThisClass());
		}
		assert(name);
		cinfo = (klass->X.instrumented_class->GetClassBuilder().FindClass(name));
		if (cinfo == NULL) {
			/*should be created new class antry */
			cinfo = *klass->X.instrumented_class->GetClassBuilder().CreateClassConstant(name);
			assert(cinfo);
		} 
		return(cinfo->GetCpIndex());
	} else {
		assert (!"not implemented yet!");
	}
	return (0);
}

int
initialize_dynamic(get_vm_pointer_t a_get_vm_pointer)
{
	m_get_vm_pointer = (JNIEnv *(*)(void **))a_get_vm_pointer;
	JNIEnv *env;
	
	env = m_get_vm_pointer((void **)&env);
	assert(env);
	
	if (m_j_l_class) return (0);
	
	m_j_l_class = env->NewGlobalRef(env->FindClass("java/lang/Class"));
		assert(m_j_l_class);
	
	m_j_l_class_getName = env->GetMethodID(m_j_l_class, "getName", "()Ljava/lang/String;");
	assert(m_j_l_class_getName);
	
	m_j_l_class_getClassLoader = env->GetMethodID(m_j_l_class, "getClassLoader", "()Ljava/lang/ClassLoader;");
	assert(m_j_l_class_getClassLoader);
	
	m_j_l_class_isInterface = env->GetMethodID(m_j_l_class, "isInterface", "()Z");
	assert(m_j_l_class_isInterface);
	
	m_j_l_classloader = env->NewGlobalRef(env->FindClass("java/lang/ClassLoader"));
	assert(m_j_l_classloader);

	m_j_l_classloader_findLoadedClass = env->GetMethodID(m_j_l_classloader, "findLoadedClass", "(Ljava/lang/String;)Ljava/lang/Class;"); 
	assert(m_j_l_classloader_findLoadedClass);

	return (0);
}

void 
class_destroy_handler(class_handler ch) 
{
	if (ch == NULL) return;
	if (!IS_CLASS_INSTRUMENTED(ch) && ch->loaded == 1) {
		JNIEnv *env;
		env = m_get_vm_pointer((void **)&env);
		assert(env);
		env->DeleteGlobalRef((jobject)ch->X.simplified_class);
	
	}
	free(ch);
	ch = NULL;
}




/********************************************************************** 
 * Copyright (c) 2008 IBM Corporation and others. 
 * All rights reserved.   This program and the accompanying materials 
 * are made available under the terms of the Eclipse Public License v1.0 
 * which accompanies this distribution, and is available at 
 * http://www.eclipse.org/legal/epl-v10.html         
 * $Id$ 
 * 
 * Contributors: 
 * Intel - Initial API and implementation 
 **********************************************************************/ 

#ifndef _CLASS_INTERFACE_X_H_
#define _CLASS_INTERFACE_X_H_

typedef unsigned long intptr;


#ifdef __cplusplus
//extern "C" {
#endif

#if 0
#include "class_interface.h"
#include "x_verifier.h"
#else
#define __INSURE__
#include "verifier-ext/class_interface.h"
#include "verifier-ext/x_verifier.h"
#endif

// removes given exception handler (handlers with greater indexes shift)
void method_remove_exc_handler( method_handler method, unsigned short idx );

//modifies start_pc, end_pc 
void method_modify_exc_handler_info(method_handler method, 
                                    unsigned short idx, 
                                    unsigned short start_pc,
                                    unsigned short end_pc, 
                                    unsigned short handler_pc, 
                                    unsigned short handler_cp_index );
unsigned short class_get_cp_class_entry(class_handler k_class, const char* name);
#ifdef __cplusplus
//}
#endif
#endif /*!_CLASS_INTERFACE_X_H_*/

Lines 20-25 Link Here

(-)src-native/BCI/BCIEng/BCIEngProbe/BCIEngProbe.cpp (-5 / +21 lines)
20	#pragma convert(819) /* see comment in CommonDef.h about this */	20	#pragma convert(819) /* see comment in CommonDef.h about this */
21	#endif	21	#endif
22		22
		23	#include <assert.h>
		24
23	#ifdef WIN32	25	#ifdef WIN32
24	#pragma warning(disable:4786)	26	#pragma warning(disable:4786)
25	#endif	27	#endif
Lines 32-37 Link Here
32	#include "BCIEngProbe.h" // BCI Engine for Probe Kit	34	#include "BCIEngProbe.h" // BCI Engine for Probe Kit
33	#include "BCIEngInterface.h" // for callback message number defines	35	#include "BCIEngInterface.h" // for callback message number defines
34		36
		37
35	#include <stdio.h> // for sprintf on Linux	38	#include <stdio.h> // for sprintf on Linux
36	#ifdef MVS	39	#ifdef MVS
37	# include <unistd.h> /* for __etoa */	40	# include <unistd.h> /* for __etoa */
Lines 1830-1839 CBCIEngProbe::Instrument(void* i_pInClas Link Here
1830	// Starting with the call to Open, we don't need to delete pClass any more:	1833	// Starting with the call to Open, we don't need to delete pClass any more:
1831	// The module owns it.	1834	// The module owns it.
1832	CModuleJ* pModuleJ = new CModuleJ;	1835	CModuleJ* pModuleJ = new CModuleJ;
		1836	pModuleJ->UseStackMapCalculation(m_use_external_verifier);
1833	pModuleJ->Open(pClass, true);	1837	pModuleJ->Open(pClass, true);
1834	pModuleJ->SetAccessFlags(pClass->GetAccessFlags());	1838	pModuleJ->SetAccessFlags(pClass->GetAccessFlags());
1835	pModuleJ->Parse();	1839	if (pModuleJ->Parse() != 0) {
1836		1840	*o_pcbOutClass = i_cbInClass;
		1841	*o_ppOutClass = i_pInClass;
		1842	delete pClass;
		1843	return false;
		1844	}
		1845
1837	// If we were asked to, then dump the module before and after instrumentation	1846	// If we were asked to, then dump the module before and after instrumentation
1838	const char *dump_output_file;	1847	const char *dump_output_file;
1839	if ((dump_output_file = getenv("PROBEKIT_DUMP_FILE")) != NULL) {	1848	if ((dump_output_file = getenv("PROBEKIT_DUMP_FILE")) != NULL) {
Lines 1845-1850 CBCIEngProbe::Instrument(void* i_pInClas Link Here
1845	output_stream << "=========== DUMP BEFORE INSTRUMENTATION" << endl;	1854	output_stream << "=========== DUMP BEFORE INSTRUMENTATION" << endl;
1846	pModuleJ->Dump(output_stream);	1855	pModuleJ->Dump(output_stream);
1847		1856
		1857
1848	#if defined(MVS) \|\| defined(__OS400__)	1858	#if defined(MVS) \|\| defined(__OS400__)
1849	/* On EBCDIC systems, convert ASCII to EBCDIC */	1859	/* On EBCDIC systems, convert ASCII to EBCDIC */
1850	char* data = output_stream.str();	1860	char* data = output_stream.str();
Lines 1864-1870 CBCIEngProbe::Instrument(void* i_pInClas Link Here
1864	// to this module, but we still ran callsite probes against this	1874	// to this module, but we still ran callsite probes against this
1865	// module and maybe we didn't actually do anything.	1875	// module and maybe we didn't actually do anything.
1866	// In that case we should set out == in and return without calling emit.	1876	// In that case we should set out == in and return without calling emit.
1867
1868	pModuleJ->Emit();	1877	pModuleJ->Emit();
1869		1878
1870	// Tell the client that's driving us that we did something to this module	1879	// Tell the client that's driving us that we did something to this module
Lines 1882-1887 CBCIEngProbe::Instrument(void* i_pInClas Link Here
1882	#else	1891	#else
1883	ofstream output_stream(dump_output_file, ios::app);	1892	ofstream output_stream(dump_output_file, ios::app);
1884	#endif	1893	#endif
		1894
1885	output_stream << "=========== DUMP AFTER INSTRUMENTATION" << endl;	1895	output_stream << "=========== DUMP AFTER INSTRUMENTATION" << endl;
1886	pModuleJ->Dump(output_stream);	1896	pModuleJ->Dump(output_stream);
1887		1897
Lines 1898-1903 CBCIEngProbe::Instrument(void* i_pInClas Link Here
1898	}	1908	}
1899		1909
1900	*o_pcbOutClass = pClass->GetSize();	1910	*o_pcbOutClass = pClass->GetSize();
		1911	if (m_pfnMalloc == NULL) {
		1912	/skipping/
		1913	*o_pcbOutClass = i_cbInClass;
		1914	*o_ppOutClass = i_pInClass;
		1915	delete pClass;
		1916	return false;
		1917	}
1901	o_ppOutClass = m_pfnMalloc(o_pcbOutClass);	1918	o_ppOutClass = m_pfnMalloc(o_pcbOutClass);
1902		1919
1903	CJMemStream OutStream; // Memory stream	1920	CJMemStream OutStream; // Memory stream
Lines 1998-2004 CBCIEngProbe::Instrument(CModule* i_pmod Link Here
1998	{	2015	{
1999	InstrumentMethod(*itrMeth);	2016	InstrumentMethod(*itrMeth);
2000	}	2017	}
2001
2002	// Process any staticInitializer fragments that matched this class,	2018	// Process any staticInitializer fragments that matched this class,
2003	// and default initializers for staticField elements in probes that matched.	2019	// and default initializers for staticField elements in probes that matched.
2004	HandleStaticInitializers(pmodj);	2020	HandleStaticInitializers(pmodj);
Lines 3179-3185 CBCIEngProbe::InstrumentMethod(CMethod* Link Here
3179	{	3195	{
3180	return;	3196	return;
3181	}	3197	}
3182		3198
3183	// Allow the client that's driving us to veto instrumentation of this module	3199	// Allow the client that's driving us to veto instrumentation of this module
3184	if (NULL != m_pfnCallback &&	3200	if (NULL != m_pfnCallback &&
3185	(m_wCBFlags & BCIENGINTERFACE_CALLBACK_METHOD) &&	3201	(m_wCBFlags & BCIENGINTERFACE_CALLBACK_METHOD) &&

Lines 504-509 private: Link Here

(-)src-native/BCI/BCIEng/BCIEngProbe/BCIEngProbe.h (+2 lines)
504	// These fields are reset and reused for each instrumented method	504	// These fields are reset and reused for each instrumented method
505	IP_t m_ipFinally; // Finally wrapper label	505	IP_t m_ipFinally; // Finally wrapper label
506	IP_t m_ipCatchAll; // catch-all wrapper label	506	IP_t m_ipCatchAll; // catch-all wrapper label
		507	friend class CBCIEngProbeInterface;
		508	bool m_use_external_verifier;
507	};	509	};
508		510
509	#endif // defined _BCIENGPROBE_H_	511	#endif // defined _BCIENGPROBE_H_

Lines 20-25 Link Here

(-)src-native/BCI/BCIEng/BCIEngProbe/BCIEngProbeInterface.cpp (+31 lines)
20	#pragma convert(819) /* see comment in CommonDef.h about this */	20	#pragma convert(819) /* see comment in CommonDef.h about this */
21	#endif	21	#endif
22		22
		23	#include <assert.h>
		24
23	#ifdef MVS	25	#ifdef MVS
24	#include <unistd.h> /* for __atoe */	26	#include <unistd.h> /* for __atoe */
25	#endif	27	#endif
Lines 37-42 Link Here
37		39
38	#define TOK_WHITESPACE " \t"	40	#define TOK_WHITESPACE " \t"
39		41
		42	int g_use_verifier;
40	//------------------------------------------------------------------------------	43	//------------------------------------------------------------------------------
41	inline static unsigned ExceptionToError(CBCIEngProbeInterfaceException& ex)	44	inline static unsigned ExceptionToError(CBCIEngProbeInterfaceException& ex)
42	{	45	{
Lines 341-346 CBCIEngProbeInterface::Initialize(const Link Here
341		344
342	}	345	}
343		346
		347	//------------------------------------------------------------------------------
		348	void
		349	CBCIEngProbeInterface::UseStackMapRecalculation(bool a_use_recalculation)
		350	{
		351	m_peng.m_use_external_verifier = a_use_recalculation;
		352	}
344		353
345	//------------------------------------------------------------------------------	354	//------------------------------------------------------------------------------
346	void	355	void
Lines 439-444 unsigned Instrument(pbcieng_t i_pbcieng, Link Here
439	try	448	try
440	{	449	{
441	CBCIEngProbeInterface* peng = (CBCIEngProbeInterface*)i_pbcieng;	450	CBCIEngProbeInterface* peng = (CBCIEngProbeInterface*)i_pbcieng;
		451	peng->UseStackMapRecalculation(false);
		452	peng->Instrument(i_pInClass, i_cbInClass, o_ppOutClass, o_pcbOutClass);
		453	}
		454	catch (CBCIEngProbeInterfaceException& ex)
		455	{
		456	uErr = ExceptionToError(ex);
		457	}
		458	return uErr;
		459	}
		460
		461	//------------------------------------------------------------------------------
		462	unsigned Instrument2(pbcieng_t i_pbcieng, void* i_pInClass, size_t i_cbInClass,
		463	void** o_ppOutClass, size_t* o_pcbOutClass, void (pEnv)(void **))
		464	{
		465	unsigned uErr = 0;
		466	initialize_dynamic(pEnv);
		467	try
		468	{
		469
		470	CBCIEngProbeInterface* peng = (CBCIEngProbeInterface*)i_pbcieng;
		471	peng->UseStackMapRecalculation(true);
442	peng->Instrument(i_pInClass, i_cbInClass, o_ppOutClass, o_pcbOutClass);	472	peng->Instrument(i_pInClass, i_cbInClass, o_ppOutClass, o_pcbOutClass);
443	}	473	}
444	catch (CBCIEngProbeInterfaceException& ex)	474	catch (CBCIEngProbeInterfaceException& ex)
Lines 453-458 unsigned SetAllocator(pbcieng_t i_pbcien Link Here
453	{	483	{
454	unsigned uErr = 0;	484	unsigned uErr = 0;
455	CBCIEngProbeInterface* peng = (CBCIEngProbeInterface*)i_pbcieng;	485	CBCIEngProbeInterface* peng = (CBCIEngProbeInterface*)i_pbcieng;
		486	//assert(i_pfnMalloc);
456	peng->SetAllocator(i_pfnMalloc);	487	peng->SetAllocator(i_pfnMalloc);
457	return uErr;	488	return uErr;
458	}	489	}

Lines 85-90 public: Link Here

(-)src-native/BCI/BCIEng/BCIEngProbe/BCIEngProbeInterface.h (+3 lines)
85		85
86	private:	86	private:
87	CBCIEngProbe m_peng;	87	CBCIEngProbe m_peng;
		88	void UseStackMapRecalculation(bool a_use_recalculation);
		89	friend unsigned Instrument(pbcieng_t, void, size_t , void* , size_t* );
		90	friend unsigned Instrument2(pbcieng_t, void, size_t , void* , size_t, void (f)(void *));
88	};	91	};
89		92
90	//------------------------------------------------------------------------------	93	//------------------------------------------------------------------------------




// For this header to work, you need to define one of these ARCH symbols:
//
//	WIN32 (means x86)
//	IA32_ARCH (means x86)
//  IPF_ARCH (means Itanium Processor Family)
//  EM64T_ARCH (means Intel/AMD 64-bit processors)
//	IA32_ARCH (means x86)
//	SPARC_ARCH
//	HPPA_ARCH
//	ALPHA_ARCH
//	PPC_ARCH
//  LINUX_PPC_ARCH  (LINUX PPC64)
//	OS390_ARCH (means zSeries)
//	AS400_ARCH (means iSeries)
//

    // This brings _WINDOWS_ into scope. Use _WINDOWS_ to wrap Windows code.
#   include <windows.h>           /* for lots o' stuff, but esp. _WINDOWS_ */
#   include <malloc.h>            /* for alloca */
#elif defined(IPF_ARCH) || (EM64T_ARCH)
#   include <stdint.h>         /* for int64_t and uint64_t */
#endif

/* On LinuxPPC64 we need this to get int64_t */
#if defined(PPC_ARCH)
#   include </usr/include/sys/types.h>
#endif
/* Only on OS400, we need this to get malloc/free */
#ifdef OS400
#include <stdlib.h>

	typedef signed long long int int64_t;
	typedef unsigned long long int uint64_t;
#else
#   if defined(_WINDOWS_)
		typedef __int64 int64_t;
		typedef unsigned __int64 uint64_t;
#elif defined(PPC_ARCH)
#       if !defined(IPF_ARCH) && !defined(EM64T_ARCH) && !defined(LINUX_PPC_ARCH) // Already being declared in stdint.h
		typedef long long int64_t;
		typedef unsigned long long uint64_t;
#   else
#       if !defined(IPF_ARCH) && !defined(EM64T_ARCH)
	        typedef long long int64_t;
			typedef unsigned long long uint64_t;
#       endif
#   endif
#endif

//------------------------------------------------------------------------------

///////
#if defined(WIN32) || defined(IA32_ARCH) || defined(IPF_ARCH) || defined(EM64T_ARCH) || defined(ALPHA_ARCH)
#   define BIG_ENDIAN_HW
#elif defined(SPARC_ARCH) || defined(HPPA_ARCH) || defined(PPC_ARCH) || defined(AS400_ARCH) || defined(OS390_ARCH)
#   define LITTLE_ENDIAN_HW
#else
#   error "Platform-specific configuration required"




#define CONSTANT_InterfaceMethodref	11		// Interface method refernce constant 
#define CONSTANT_NameAndType		12		// Name and type constant

#define CONSTANT_Unknown			0
// Array types
#define T_BOOLEAN					4		// bool
#define T_CHAR						5		// char

#define T_INT						10		// int
#define T_LONG						11		// long

// stack map frame types (new in Java 6.0)
#define SAME_LOCALS_1_STACK_ITEM_EXTENDED   247
#define SAME_FRAME_EXTENDED                 251
#define FULL_FRAME                          255

// verification types (new in Java 6.0)
#define ITEM_Top                    0
#define ITEM_Integer                1
#define ITEM_Float                  2
#define ITEM_Double                 3
#define ITEM_Long                   4
#define ITEM_Null                   5
#define ITEM_UninitializedThis      6
#define ITEM_Object                 7
#define ITEM_Uninitialized          8

// ToDo: other Java specific definitions
typedef unsigned char				u1;		// 1 byte




string
CJClassBuilder::GetSuperClassName()
{
	CCPClassInfo* pccpClassInfo = (CCPClassInfo*)((*m_pConstPool)[GetSuperClass()]);
	CCPUtf8Info* pcpUtf8 = (CCPUtf8Info*)((*m_pConstPool)[pccpClassInfo->GetClassInd()]);
	string strSuperClass = (string)*pcpUtf8;
	return strSuperClass;
}

	CConstPool::iterator itr = m_pConstPool->begin();
	while(itr != m_pConstPool->end())
	{
		if (*itr == NULL) return NULL;
		if((*itr)->GetTag() == CONSTANT_Class)
		{
			CCPClassInfo* pcpci = (CCPClassInfo*)*itr;

}

//------------------------------------------------------------------------------
// CreateClassConstant
// In:
//	i_szClassName - class name
// Returns:
//	CCPClassInfo* - pointer to the class infoin the constant pool
//
CCPClassInfo* 
CJClassBuilder::CreateClassConstant(CSTR i_szClassName)
{
	u2 u2ClassName = m_pConstPool->Add(new CCPUtf8Info(i_szClassName));
	u2 u2ClassRef  = m_pConstPool->Add(new CCPClassInfo(u2ClassName));
	CCPClassInfo* pcpClass = (CCPClassInfo*)((*m_pConstPool)[u2ClassRef]);
	return pcpClass;
}

//------------------------------------------------------------------------------
// CreateIntegerConstant
// In:
//	i_int - Integer value to add

Lines 62-68 public: Link Here

(-)src-native/BCI/JClass/JClassBuilder.h (-1 / +2 lines)
62		62
63	// Constant pool manipulation	63	// Constant pool manipulation
64	CCPStringInfo* CreateStringConstant(CSTR i_szString);	64	CCPStringInfo* CreateStringConstant(CSTR i_szString);
65	CCPIntegerInfo* CreateIntegerConstant (JINTEGER i_int);	65	CCPClassInfo* CreateClassConstant(CSTR i_szClassName);
		66	CCPIntegerInfo* CreateIntegerConstant (JINTEGER i_int);
66	CCPLongInfo* CreateLongConstant(JLONG i_long);	67	CCPLongInfo* CreateLongConstant(JLONG i_long);
67	CCPFloatInfo* CreateFloatConstant(JFLOAT i_float);	68	CCPFloatInfo* CreateFloatConstant(JFLOAT i_float);
68	CCPDoubleInfo* CreateDoubleConstant(JDOUBLE i_double);	69	CCPDoubleInfo* CreateDoubleConstant(JDOUBLE i_double);




#  include <iostream>
#endif

#include "JavaDef.h"
#include "CommonDef.h"

#include "JClassFile.h"
#include "JMemStream.h"

USE_NAMESPACE(std);


:CCPInfo(CONSTANT_Utf8)
{
	m_u2Length = i_utf8Info.GetLength();
	m_pu1Bytes = new u1[m_u2Length + 1];
	m_pu1Bytes[m_u2Length] = '\0';
	memcpy(m_pu1Bytes, i_utf8Info.GetBytes(), m_u2Length + 1);
}

//------------------------------------------------------------------------------

void
CCPUtf8Info::Read(CJStream& i_jstream)
{
	i_jstream >> m_u2Length; 
	m_pu1Bytes = new u1[m_u2Length + 1];
	m_pu1Bytes[m_u2Length] = 0; /*Helps standard string functions find end of the string*/
	i_jstream.ReadUtf8((void*)m_pu1Bytes, m_u2Length);
}


		{
			pCurrent = new CLocalVariableTypeTableAttribute(m_pClassFile);
		}
 		else if(*pcpUtf8 == "StackMapTable")
		{
			pCurrent = new CStackMapTableAttribute(m_pClassFile);
		}
		else if(*pcpUtf8 == "Exceptions")
		{
			pCurrent = new CExceptionsAttribute(m_pClassFile);

	return NULL;
}

//------------------------------------------------------------------------------
CStackMapTableAttribute* 
CCodeAttribute::GetStackMaps()
{
	for(CJAttribs::iterator iter = m_Attribs.begin(); iter < m_Attribs.end(); iter++)
	{
		if(*(*iter)->GetName() == "StackMapTable")
			return (CStackMapTableAttribute*)*iter;
	}
	return NULL;
}

//------------------------------------------------------------------------------
CStackMapTableAttribute* 
CCodeAttribute::GetOrCreateStackMaps()
{
    // Return the StackMapTable attribute of this Code attribute, creating a new one
    // if such an attribute does not exist

    CStackMapTableAttribute* result = NULL;
	for(CJAttribs::iterator iter = m_Attribs.begin(); iter < m_Attribs.end(); iter++)
	{
		if(*(*iter)->GetName() == "StackMapTable")
        {
			result = (CStackMapTableAttribute*)*iter;
        }
	}

    if (result == NULL)
    {
        result = new CStackMapTableAttribute(m_pClassFile);
        m_Attribs.push_back(result);
    }
    return result;
}

//==============================================================================
// CExceptionsAttribute implementation

{}

//==============================================================================
// CStackMapTableAttribute implementation
//
CVerificationTypeInfo::CVerificationTypeInfo(u1 i_u1Tag)
: m_u1Tag(i_u1Tag)
{
}

CVerificationTypeInfo::~CVerificationTypeInfo()
{
}

void
CVerificationTypeInfo::Read(CJStream& i_jstream)
{
    // m_u1Tag is read by the CVerificationTypes container.
}

u2
CVerificationTypeInfo::Read(u1 *i_tbl)
{
    // m_u1Tag is read by the CVerificationTypes container.
	return 0;
}

void
CVerificationTypeInfo::Write(CJStream& i_jstream) const
{
    i_jstream << m_u1Tag;
}

u4
CVerificationTypeInfo::GetSize() const
{
    return sizeof(m_u1Tag);
}

//------------------------------------------------------------------------------
CVerificationTypes::~CVerificationTypes()
{
    for (iterator iter = begin(); iter != end(); iter++)
    {
        delete *iter;
    }
}

CVerificationTypes::CVerificationTypes(const CVerificationTypes &i_VerTypes)
{
    *this = i_VerTypes;
}

CVerificationTypes&
CVerificationTypes::operator =(const CVerificationTypes &i_VerTypes)
{
	for(iterator iter = begin(); iter != end(); iter++)
	{
		delete *iter;
	}
	if(!i_VerTypes.empty())
	{
		const_iterator iterIn;
		clear();
		for(iterIn = i_VerTypes.begin(); iterIn != i_VerTypes.end(); iterIn++)
		{
			push_back((*iterIn)->Clone());
		}
	}
	return *this;
}

void
CVerificationTypes::Read(CJStream& i_jstream, u2 i_u2EntriesToRead)
{
    CVerificationTypeInfo* pCurrent;
    
    resize(i_u2EntriesToRead);
    for(u2 u2Ind = 0; u2Ind < i_u2EntriesToRead; u2Ind++)
    {
        u1 u1Tag;
        i_jstream >> u1Tag;
        switch (u1Tag)
        {
        case ITEM_Top:
        case ITEM_Integer:
        case ITEM_Float:
        case ITEM_Double:
        case ITEM_Long:
        case ITEM_Null:
        case ITEM_UninitializedThis:
            pCurrent = new CVerificationTypeInfo(u1Tag);
            break;
        case ITEM_Object:
            pCurrent = new CVerificationTypeObjectInfo(u1Tag);
            break;
        case ITEM_Uninitialized:
            pCurrent = new CVerificationTypeUninitializedVariableInfo(u1Tag);
            break;
        default:
            throw CJClassFileException(CJClassFileException::X_INTERNAL_ERROR);
        }

        pCurrent->Read(i_jstream);
        (*this)[u2Ind] = pCurrent;
    }
}

void 
CVerificationTypes::Write(CJStream& i_jstream) const
{
    for (u2 u2Ind = 0; u2Ind < size(); u2Ind++)
    {
        (*this)[u2Ind]->Write(i_jstream);
    }
}

u4
CVerificationTypes::GetSize() const
{
    u4 u4Size = 0;
	for (const_iterator iter = begin(); iter != end(); iter++)
	{
		u4Size += (*iter)->GetSize();
	}
    return u4Size;
}

//------------------------------------------------------------------------------
CVerificationTypeObjectInfo::CVerificationTypeObjectInfo(u1 i_u1Tag)
: CVerificationTypeInfo(i_u1Tag)
{
}

CVerificationTypeObjectInfo::~CVerificationTypeObjectInfo()
{
}

void
CVerificationTypeObjectInfo::Read(CJStream& i_jstream)
{
    CVerificationTypeInfo::Read(i_jstream);
    i_jstream >> m_u2CpoolIndex;
}

void
CVerificationTypeObjectInfo::Write(CJStream& i_jstream) const
{
    CVerificationTypeInfo::Write(i_jstream);
    i_jstream << m_u2CpoolIndex;
}

u4
CVerificationTypeObjectInfo::GetSize() const
{
    u4 u4Size = CVerificationTypeInfo::GetSize()
        + sizeof(m_u2CpoolIndex);
    return u4Size;
}

//------------------------------------------------------------------------------
CVerificationTypeUninitializedVariableInfo::CVerificationTypeUninitializedVariableInfo(u1 i_u1Tag)
: CVerificationTypeInfo(i_u1Tag)
{
}

CVerificationTypeUninitializedVariableInfo::~CVerificationTypeUninitializedVariableInfo()
{
}

void
CVerificationTypeUninitializedVariableInfo::Read(CJStream& i_jstream)
{
    CVerificationTypeInfo::Read(i_jstream);
    i_jstream >> m_u2Offset;
}

void
CVerificationTypeUninitializedVariableInfo::Write(CJStream& i_jstream) const
{
    CVerificationTypeInfo::Write(i_jstream);
    i_jstream << m_u2Offset;
}

u4
CVerificationTypeUninitializedVariableInfo::GetSize() const
{
    u4 u4Size = CVerificationTypeInfo::GetSize()
        + sizeof(m_u2Offset);
    return u4Size;
}

//------------------------------------------------------------------------------
CStackMapFrameInfo::CStackMapFrameInfo(u1 i_u1FrameType)
: m_u1FrameType(i_u1FrameType)
{
    m_u2ByteCodeOffset = 0;
    m_u2OffsetDelta = 0;
}

CStackMapFrameInfo::~CStackMapFrameInfo()
{
}

void
CStackMapFrameInfo::Read(CJStream& i_jstream)
{
    // m_u1FrameType is read by the CStackMapTable container
}

void
CStackMapFrameInfo::Write(CJStream& i_jstream) const
{
    i_jstream << m_u1FrameType;
}

u4
CStackMapFrameInfo::GetSize() const
{
    return sizeof(m_u1FrameType);
}

void 
CStackMapFrameInfo::SetByteCodeOffset(u2 i_u2Offset) 
{ 
    m_u2ByteCodeOffset = i_u2Offset; 
}

void
CStackMapFrameInfo::AdjustOffsetDelta(int i_s2PrevFrameOffset)
{
    int newOffsetDelta = m_u2ByteCodeOffset - 1 - i_s2PrevFrameOffset;
    if (newOffsetDelta < 0)
    {
        // Frame order was changed. This is not supported
        throw CJClassFileException(CJClassFileException::X_INTERNAL_ERROR);
    }
    m_u2OffsetDelta = (u2)newOffsetDelta; // this is a safe cast since newDelta >= 1
}

CStackMapFrameInfo::CStackMapFrameInfo(const CStackMapFrameInfo &i_Other)
: m_u2ByteCodeOffset(i_Other.m_u2ByteCodeOffset), m_u2OffsetDelta(i_Other.m_u2OffsetDelta),
    m_u1FrameType(i_Other.m_u1FrameType)
{
}

//------------------------------------------------------------------------------
CStackMapSameFrameInfo::CStackMapSameFrameInfo(u1 i_u1FrameType, bool i_IsExtended)
: CStackMapFrameInfo(i_u1FrameType), m_IsExtended(i_IsExtended)
{
}

CStackMapSameFrameInfo::~CStackMapSameFrameInfo()
{
}

void
CStackMapSameFrameInfo::Read(CJStream& i_jstream)
{
    CStackMapFrameInfo::Read(i_jstream);
    if (m_IsExtended)
    {
        // SAME_FRAME_EXTENDED type
        i_jstream >> m_u2OffsetDelta;
    }
    else        
    {
        // SAME frame type. offset_delta is stored in the tag
        m_u2OffsetDelta = GetFrameType();
    }
}

void
CStackMapSameFrameInfo::Write(CJStream& i_jstream) const
{
    CStackMapFrameInfo::Write(i_jstream);
    if (m_IsExtended)
    {
        // SAME_FRAME_EXTENDED type
        i_jstream << m_u2OffsetDelta;
    }
}

u4
CStackMapSameFrameInfo::GetSize() const
{
    u4 u4Size = CStackMapFrameInfo::GetSize();
    if (m_IsExtended)
    {
        u4Size += sizeof(m_u2OffsetDelta);
    }
    return u4Size;
}

void
CStackMapSameFrameInfo::AdjustOffsetDelta(int i_s2PrevFrameOffset)
{
    CStackMapFrameInfo::AdjustOffsetDelta(i_s2PrevFrameOffset);
    if (m_u2OffsetDelta > 63)
    {
        // Frame type is SAME_FRAME_EXTENDED
        m_u1FrameType = SAME_FRAME_EXTENDED;
        m_IsExtended = true;
    }
    else
    {
        // Frame type is SAME_FRAME. offset_delta is stored in the tag
        m_u1FrameType = (u1)m_u2OffsetDelta; // this is safe since m_u2OffsetDelta <= 63
        m_IsExtended = false;
    }
}

CStackMapFrameInfo*
CStackMapSameFrameInfo::Clone() const
{
    return new CStackMapSameFrameInfo(*this);
}

//------------------------------------------------------------------------------
CStackMapChopFrameInfo::CStackMapChopFrameInfo(u1 i_u1FrameType)
: CStackMapFrameInfo(i_u1FrameType)
{
}

CStackMapChopFrameInfo::~CStackMapChopFrameInfo()
{
}

void
CStackMapChopFrameInfo::Read(CJStream& i_jstream)
{
    CStackMapFrameInfo::Read(i_jstream);
    i_jstream >> m_u2OffsetDelta;
}

void
CStackMapChopFrameInfo::Write(CJStream& i_jstream) const
{
    CStackMapFrameInfo::Write(i_jstream);
    i_jstream << m_u2OffsetDelta;
}

u4
CStackMapChopFrameInfo::GetSize() const
{
    u4 u4Size = CStackMapFrameInfo::GetSize()
        + sizeof(m_u2OffsetDelta);
    return u4Size;
}

CStackMapFrameInfo*
CStackMapChopFrameInfo::Clone() const
{
    return new CStackMapChopFrameInfo(*this);
}

//------------------------------------------------------------------------------
CStackMapSameLocals1StackItemFrameInfo::CStackMapSameLocals1StackItemFrameInfo(u1 i_u1FrameType, 
                                                                               bool i_IsExtended)
: CStackMapFrameInfo(i_u1FrameType), m_IsExtended(i_IsExtended)
{
}

CStackMapSameLocals1StackItemFrameInfo::~CStackMapSameLocals1StackItemFrameInfo()
{
}

void
CStackMapSameLocals1StackItemFrameInfo::Read(CJStream& i_jstream)
{
    CStackMapFrameInfo::Read(i_jstream);
    if (m_IsExtended)
    {
        // SAME_LOCALS_1_STACK_ITEM_FRAME_EXTENDED type
        i_jstream >> m_u2OffsetDelta;
    }
    else        
    {
        // SAME_LOCALS_1_STACK_ITEM_FRAME frame type
        m_u2OffsetDelta = GetFrameType() - 64;
    }
    m_Stack.Read(i_jstream, 1); // must hold exactly one stack item
}

void
CStackMapSameLocals1StackItemFrameInfo::Write(CJStream& i_jstream) const
{
    CStackMapFrameInfo::Write(i_jstream);
    if (m_IsExtended)
    {
        // SAME_FRAME_EXTENDED type
        i_jstream << m_u2OffsetDelta;
    }
    m_Stack.Write(i_jstream);
}

u4
CStackMapSameLocals1StackItemFrameInfo::GetSize() const
{
    u4 u4Size = CStackMapFrameInfo::GetSize();
    if (m_IsExtended)
    {
        u4Size += sizeof(m_u2OffsetDelta);
    }
    u4Size += m_Stack.GetSize();
    return u4Size;
}

void
CStackMapSameLocals1StackItemFrameInfo::AdjustOffsetDelta(int i_s2PrevFrameOffset)
{
    CStackMapFrameInfo::AdjustOffsetDelta(i_s2PrevFrameOffset);
    if (m_u2OffsetDelta + 64 > 127)
    {
        // Frame type is SAME_LOCALS_1_STACK_FRAME_EXTENDED
        m_u1FrameType = SAME_LOCALS_1_STACK_ITEM_EXTENDED;
        m_IsExtended = true;
    }
    else
    {
        // Frame type is SAME_LOCALS_1_STACK_FRAME. offset_delta is stored in the tag
        m_u1FrameType = (u1)(m_u2OffsetDelta + 64); // this is safe since m_u2OffsetDelta <= 63
        m_IsExtended = false;
    }
}

CStackMapFrameInfo*
CStackMapSameLocals1StackItemFrameInfo::Clone() const
{
    return new CStackMapSameLocals1StackItemFrameInfo(*this);
}

CStackMapSameLocals1StackItemFrameInfo::CStackMapSameLocals1StackItemFrameInfo(const CStackMapSameLocals1StackItemFrameInfo &i_Other)
: CStackMapFrameInfo(i_Other), m_Stack(i_Other.m_Stack), m_IsExtended(i_Other.m_IsExtended)
{
}

//------------------------------------------------------------------------------
CStackMapAppendFrameInfo::CStackMapAppendFrameInfo(u1 i_u1FrameType)
: CStackMapFrameInfo(i_u1FrameType)
{
}

CStackMapAppendFrameInfo::~CStackMapAppendFrameInfo()
{
}

void
CStackMapAppendFrameInfo::Read(CJStream& i_jstream)
{
    CStackMapFrameInfo::Read(i_jstream);
    i_jstream >> m_u2OffsetDelta;
    m_Locals.Read(i_jstream, GetFrameType() - 251);
}

void
CStackMapAppendFrameInfo::Write(CJStream& i_jstream) const
{
    CStackMapFrameInfo::Write(i_jstream);
    i_jstream << m_u2OffsetDelta;
    m_Locals.Write(i_jstream);
}

u4
CStackMapAppendFrameInfo::GetSize() const
{
    u4 u4Size = CStackMapFrameInfo::GetSize()
        + sizeof(m_u2OffsetDelta)
        + m_Locals.GetSize();
    return u4Size;
}

CStackMapFrameInfo*
CStackMapAppendFrameInfo::Clone() const
{
    return new CStackMapAppendFrameInfo(*this);
}

CStackMapAppendFrameInfo::CStackMapAppendFrameInfo(const CStackMapAppendFrameInfo &i_Other)
: CStackMapFrameInfo(i_Other), m_Locals(i_Other.m_Locals)
{
}

//------------------------------------------------------------------------------
CStackMapFullFrameInfo::CStackMapFullFrameInfo(u1 i_u1FrameType)
: CStackMapFrameInfo(i_u1FrameType), m_u2NumberOfLocals(0), m_u2NumberOfStackItems(0)
{
}

CStackMapFullFrameInfo::~CStackMapFullFrameInfo()
{
}

void
CStackMapFullFrameInfo::Read(CJStream& i_jstream)
{
    CStackMapFrameInfo::Read(i_jstream);
    i_jstream >> m_u2OffsetDelta
              >> m_u2NumberOfLocals;
    m_Locals.Read(i_jstream, m_u2NumberOfLocals);
    i_jstream >> m_u2NumberOfStackItems;
    m_Stack.Read(i_jstream, m_u2NumberOfStackItems);
}

void
CStackMapFullFrameInfo::Write(CJStream& i_jstream) const
{
    CStackMapFrameInfo::Write(i_jstream);
    i_jstream << m_u2OffsetDelta
              << m_u2NumberOfLocals;
    m_Locals.Write(i_jstream);
    i_jstream << m_u2NumberOfStackItems;
    m_Stack.Write(i_jstream);
}

u4
CStackMapFullFrameInfo::GetSize() const
{
    u4 u4Size = CStackMapFrameInfo::GetSize()
        + sizeof(m_u2OffsetDelta)
        + sizeof(m_u2NumberOfLocals)
        + m_Locals.GetSize()
        + sizeof(m_u2NumberOfStackItems)
        + m_Stack.GetSize();
    return u4Size;
}

CStackMapFrameInfo*
CStackMapFullFrameInfo::Clone() const
{
    return new CStackMapFullFrameInfo(*this);
}

CStackMapFullFrameInfo::CStackMapFullFrameInfo(const CStackMapFullFrameInfo &i_Other)
: CStackMapFrameInfo(i_Other), m_Locals(i_Other.m_Locals), m_Stack(i_Other.m_Stack),
    m_u2NumberOfLocals(i_Other.m_u2NumberOfLocals), 
    m_u2NumberOfStackItems(i_Other.m_u2NumberOfStackItems)
{
}

//------------------------------------------------------------------------------
CStackMapTable::~CStackMapTable()
{
    for (iterator iter = begin(); iter != end(); iter++)
    {
        delete *iter;
    }
}

void
CStackMapTable::Read(CJStream& i_jstream)
{
    u2 u2Size;
    CStackMapFrameInfo* pCurrent;
    int s2PrevFrameOffset = -1;

    i_jstream >> u2Size;
    resize(u2Size);
    for(u2 u2Ind = 0; u2Ind < u2Size; u2Ind++)
    {
        u1 u1FrameType;
        i_jstream >> u1FrameType;
        if (u1FrameType >= 0 && u1FrameType <= 63)
        {
            pCurrent = new CStackMapSameFrameInfo(u1FrameType, false);
        }
        else if (u1FrameType >= 64 && u1FrameType <= 127)
        {
            pCurrent = new CStackMapSameLocals1StackItemFrameInfo(u1FrameType, false);
        }
        else if (u1FrameType == SAME_LOCALS_1_STACK_ITEM_EXTENDED)
        {
            pCurrent = new CStackMapSameLocals1StackItemFrameInfo(u1FrameType, true);
        }
        else if (u1FrameType >= 248 && u1FrameType <= 250)
        {
            pCurrent = new CStackMapChopFrameInfo(u1FrameType);
        }
        else if (u1FrameType == SAME_FRAME_EXTENDED)
        {
            pCurrent = new CStackMapSameFrameInfo(u1FrameType, true);
        }
        else if (u1FrameType >= 252 && u1FrameType <= 254)
        {
            pCurrent = new CStackMapAppendFrameInfo(u1FrameType);
        }
        else if (u1FrameType == FULL_FRAME)
        {
            pCurrent = new CStackMapFullFrameInfo(u1FrameType);
        }
        else
        {
            // Unknown frame type
            throw CJClassFileException(CJClassFileException::X_INTERNAL_ERROR);
        }
        
        pCurrent->Read(i_jstream);
        pCurrent->SetByteCodeOffset(s2PrevFrameOffset + 1 + pCurrent->m_u2OffsetDelta);
        (*this)[u2Ind] = pCurrent;
        s2PrevFrameOffset = pCurrent->GetByteCodeOffset();
    }
}

void
CStackMapTable::AdjustOffsetDeltas()
{
    // Recalculate offset deltas for all frames. This function must be called before
    // writing the Stack Map Table to the class file or calculating its size
    CStackMapFrameInfo* pCurrent;
    int s2PrevFrameOffset = -1;

    for (u2 u2Ind = 0; u2Ind < size(); u2Ind++)
    {
        pCurrent = (*this)[u2Ind];
        pCurrent->AdjustOffsetDelta(s2PrevFrameOffset);
        s2PrevFrameOffset = pCurrent->GetByteCodeOffset();
    }
}

CStackMapFrameInfo*
CStackMapTable::GetFrameAtOffset(u2 i_u2Offset)
{
    bool found = false;
    iterator it = begin();
    for (; it != end(); ++it)
    {
        if ((*it)->GetByteCodeOffset() == i_u2Offset)
        {
            found = true;
            break;
        }
    }

    if (found)
    {
        return (*it);
    }
    else
    {
        return NULL;
    }
}

void
CStackMapTable::Write(CJStream& i_jstream) const
{
    i_jstream << (u2)size(); // the number_of_entries field

    CStackMapFrameInfo* pCurrent;
    int s2PrevFrameOffset = -1;

    for (u2 u2Ind = 0; u2Ind < size(); u2Ind++)
    {
        pCurrent = (*this)[u2Ind];
        pCurrent->Write(i_jstream);
        s2PrevFrameOffset = pCurrent->GetByteCodeOffset();
    }
}

u4
CStackMapTable::GetSize() const
{
    u4 u4Size = sizeof(u2); // the number_of_entries field
    for (const_iterator iter = begin(); iter != end(); iter++)
    {
        u4Size += (*iter)->GetSize();
    }
    return u4Size;
}

CStackMapTable& 
CStackMapTable::operator = (const CStackMapTable& i_StackMaps)
{
	for(iterator iter = begin(); iter != end(); iter++)
	{
		delete *iter;
	}
	if(!i_StackMaps.empty())
	{
		const_iterator iterIn;
		clear();
		for(iterIn = i_StackMaps.begin(); iterIn != i_StackMaps.end(); iterIn++)
		{
			push_back((*iterIn)->Clone());
		}
	}
	return *this;
}

//------------------------------------------------------------------------------
CStackMapTableAttribute::CStackMapTableAttribute(CJClassFile* i_pClassFile)
: CAttributeInfo(i_pClassFile)
{
    u2 u2NameInd = i_pClassFile->GetConstPool()->Add(new CCPUtf8Info("StackMapTable"));
    m_u2NameInd = u2NameInd;
    m_StackMapTable.clear();
}

CStackMapTableAttribute::~CStackMapTableAttribute()
{
}

void
CStackMapTableAttribute::Read(CJStream& i_jstream)
{
	CAttributeInfo::Read(i_jstream);
    m_StackMapTable.Read(i_jstream);
}

void
CStackMapTableAttribute::Write(CJStream& i_jstream) const
{
	const u4 u4Length = GetLength() - CAttributeInfo::SizeOf();
	i_jstream	<<	m_u2NameInd
				<<	u4Length;
    m_StackMapTable.Write(i_jstream);
}

u4
CStackMapTableAttribute::GetSize() const
{
    return GetLength();
}

u4
CStackMapTableAttribute::GetLength() const
{
    u4 u4Length = CAttributeInfo::SizeOf()
        + m_StackMapTable.GetSize();
    return u4Length;
}

void
CStackMapTableAttribute::RereadFromBuffer(u1 *i_u1Tbl) 
{
	u2 u2skip = 0;
	u4 u4attributeLenght = 0;
	
	if (i_u1Tbl == NULL) return;

	u2skip = i_u1Tbl[0];
	u2skip <<= 8;
	u2skip |= i_u1Tbl[1];

	u4attributeLenght = i_u1Tbl[2];
	u4attributeLenght <<= 8;
	u4attributeLenght |= i_u1Tbl[3];
	u4attributeLenght <<= 8;
	u4attributeLenght |= i_u1Tbl[4];
	u4attributeLenght <<= 8;
	u4attributeLenght |= i_u1Tbl[5];
	m_u4Length = u4attributeLenght;
	CJMemStream memstream;
	memstream.Open(&i_u1Tbl[2], u4attributeLenght 
		+ sizeof(u2) /*part of attribute header (its length)*/
		+ 2 /*workaround for end buffer checking*/);
	CJStream mem_jstream(&memstream);
	//GetStackMapTable().RereadFromBuffer(&i_u1Tbl[6]);
	this->Read(mem_jstream);
}
//==============================================================================
// CJClassFile implementation
//


	{
		throw CJClassFileException(CJClassFileException::X_BAD_MAGIC);
	}
	i_jstream	>>	m_u2MajorVersion;
	if(CJClassFile::MajorVersion < m_u2MajorVersion)
	{
		throw CJClassFileException(CJClassFileException::X_BAD_VERSION);
	}
	i_jstream	>>	m_u2MinorVersion;
	i_jstream	>>	m_u2MajorVersion;
	m_pConstPool->Read(i_jstream);
	i_jstream	>>	m_u2AccessFlags
				>>	m_u2ThisClass

CJClassFile::Write(CJStream& i_jstream) const
{
	i_jstream	<<	m_u4Magic
				<<	m_u2MinorVersion
				<<	m_u2MajorVersion;
	m_pConstPool->Write(i_jstream);
	i_jstream	<<	m_u2AccessFlags
				<<	m_u2ThisClass

Lines 82-87 class CExceptionsAttribute; Link Here

(-)src-native/BCI/JClass/JClassFile.h (-2 / +291 lines)
82	class CLineNumberTableAttribute;	82	class CLineNumberTableAttribute;
83	class CLocalVariableTableAttribute;	83	class CLocalVariableTableAttribute;
84	class CLocalVariableTypeTableAttribute;	84	class CLocalVariableTypeTableAttribute;
		85	class CStackMapTableAttribute;
85		86
86	//------------------------------------------------------------------------------	87	//------------------------------------------------------------------------------
87	// Container classes	88	// Container classes
Lines 182-189 public: Link Here
182	const CCPUtf8Info& operator = (const CCPUtf8Info& i_utf8)	183	const CCPUtf8Info& operator = (const CCPUtf8Info& i_utf8)
183	{	184	{
184	m_u2Length = i_utf8.GetLength();	185	m_u2Length = i_utf8.GetLength();
185	m_pu1Bytes = new u1[m_u2Length];	186	m_pu1Bytes = new u1[m_u2Length + 1];
186	memcpy(m_pu1Bytes, i_utf8.GetBytes(), m_u2Length);	187	memcpy(m_pu1Bytes, i_utf8.GetBytes(), m_u2Length);
		188	m_pu1Bytes[m_u2Length] = '\0';
187	return *this;	189	return *this;
188	}	190	}
189	operator string ()	191	operator string ()
Lines 672-677 public: Link Here
672	CLineNumberTableAttribute* GetLineNumbers();	674	CLineNumberTableAttribute* GetLineNumbers();
673	CLocalVariableTableAttribute* GetLocalVariables();	675	CLocalVariableTableAttribute* GetLocalVariables();
674	CLocalVariableTypeTableAttribute* GetLocalVariableTypes();	676	CLocalVariableTypeTableAttribute* GetLocalVariableTypes();
		677	CStackMapTableAttribute* GetStackMaps();
		678	CStackMapTableAttribute* GetOrCreateStackMaps();
		679
675		680
676	protected:	681	protected:
677	u2 m_u2MaxStack;	682	u2 m_u2MaxStack;
Lines 899-904 private: Link Here
899	};	904	};
900		905
901	//------------------------------------------------------------------------------	906	//------------------------------------------------------------------------------
		907	// Verification Type Information (new in Java 6)
		908	//
		909	// Represents the following verification types: Top, Integer, Float, Double, Long, Null,
		910	// UninitializedThis
		911	//
		912	class CVerificationTypeInfo
		913	{
		914	public:
		915	CVerificationTypeInfo(u1 i_u1Tag);
		916	~CVerificationTypeInfo();
		917	virtual void Read(CJStream& i_jstream);
		918	virtual u2 Read(u1* i_tbl);
		919	virtual void Write(CJStream& i_jstream) const;
		920	virtual u4 GetSize() const;
		921	virtual CVerificationTypeInfo* Clone() const
		922	{
		923	return new CVerificationTypeInfo(*this);
		924	}
		925
		926	u1 GetTag() { return m_u1Tag; }
		927
		928	private:
		929	u1 m_u1Tag;
		930	};
		931
		932	//------------------------------------------------------------------------------
		933	// Verification Type Information Vector
		934	//
		935	class CVerificationTypes : public vector<CVerificationTypeInfo*>
		936	{
		937	public:
		938	CVerificationTypes() { clear(); }
		939	CVerificationTypes(const CVerificationTypes &i_VerTypes);
		940	~CVerificationTypes();
		941
		942	CVerificationTypes& operator = (const CVerificationTypes &i_VerTypes);
		943
		944	virtual void Read(CJStream& i_jstream, u2 i_u2EntriesToRead);
		945	virtual void Write(CJStream& i_jstream) const;
		946	virtual u4 GetSize() const;
		947
		948	private:
		949	};
		950
		951	//------------------------------------------------------------------------------
		952	// Verification Type Information: Object (new in Java 6)
		953	//
		954	class CVerificationTypeObjectInfo : public CVerificationTypeInfo
		955	{
		956	public:
		957	CVerificationTypeObjectInfo(u1 i_u1Tag);
		958	~CVerificationTypeObjectInfo();
		959	virtual void Read(CJStream& i_jstream);
		960	virtual void Write(CJStream& i_jstream) const;
		961	virtual u4 GetSize() const;
		962	virtual CVerificationTypeInfo* Clone() const
		963	{
		964	return new CVerificationTypeObjectInfo(*this);
		965	}
		966
		967	u2 GetCpoolIndex() { return m_u2CpoolIndex; }
		968	void SetCpoolIndex(u2 i_u2CpoolIndex) { m_u2CpoolIndex = i_u2CpoolIndex; }
		969
		970	private:
971	u2 m_u2CpoolIndex;
972	};
973
974	//------------------------------------------------------------------------------
975	// Verification Type Information: Uninitialized Variable (new in Java 6)
976	//
977	class CVerificationTypeUninitializedVariableInfo : public CVerificationTypeInfo
978	{
979	public:
980	CVerificationTypeUninitializedVariableInfo(u1 i_u1Tag);
981	~CVerificationTypeUninitializedVariableInfo();
982	virtual void Read(CJStream& i_jstream);
983	virtual void Write(CJStream& i_jstream) const;
984	virtual u4 GetSize() const;
985	virtual CVerificationTypeInfo* Clone() const
986	{
987	return new CVerificationTypeUninitializedVariableInfo(*this);
988	}
989
990	u2 GetOffset() { return m_u2Offset; }
991	void SetOffset(u2 i_u2Offset) { m_u2Offset = i_u2Offset; }
992
993	private:
994	u2 m_u2Offset;
995	};
996
997
998	//------------------------------------------------------------------------------
999	// Stack Map Frame Information (new in Java 6)
1000	//
1001	class CStackMapFrameInfo
1002	{
1003	friend class CStackMapTable;
1004	public:
1005	CStackMapFrameInfo(u1 i_u1FrameType);
1006	CStackMapFrameInfo(const CStackMapFrameInfo &i_Other);
1007	~CStackMapFrameInfo();
1008
1009	virtual void Read(CJStream& i_jstream);
1010	virtual void Write(CJStream& i_jstream) const;
1011	virtual u4 GetSize() const;
1012	virtual CStackMapFrameInfo* Clone() const = 0;
1013
1014	u1 GetFrameType() const { return m_u1FrameType; }
1015	u2 GetByteCodeOffset() { return m_u2ByteCodeOffset; }
1016	void SetByteCodeOffset(u2 i_u2Offset);
1017
1018	protected:
1019	virtual void AdjustOffsetDelta(int i_s2PrevFrameOffset);
1020
1021	u2 m_u2ByteCodeOffset;
1022	u2 m_u2OffsetDelta;
1023	u1 m_u1FrameType;
1024	};
1025
1026	//------------------------------------------------------------------------------
1027	// Stack Map Frame Information: same_frame and same_frame_extended (new in Java 6)
1028	//
1029	class CStackMapSameFrameInfo : public CStackMapFrameInfo
1030	{
1031	friend class CStackMapTable;
1032	public:
1033	CStackMapSameFrameInfo(u1 i_u1FrameType, bool i_IsExtended);
1034	~CStackMapSameFrameInfo();
1035
1036	virtual void Read(CJStream& i_jstream);
1037	virtual void Write(CJStream& i_jstream) const;
1038	virtual u4 GetSize() const;
1039	virtual CStackMapFrameInfo* Clone() const;
1040
1041	protected:
1042	virtual void AdjustOffsetDelta(int i_s2PrevFrameOffset);
1043
1044	private:
1045	bool m_IsExtended;
1046	};
1047
1048	//------------------------------------------------------------------------------
1049	// Stack Map Frame Information: chop_frame (new in Java 6)
1050	//
1051	class CStackMapChopFrameInfo : public CStackMapFrameInfo
1052	{
1053	public:
1054	CStackMapChopFrameInfo(u1 i_u1FrameType);
1055	~CStackMapChopFrameInfo();
1056
1057	virtual void Read(CJStream& i_jstream);
1058	virtual void Write(CJStream& i_jstream) const;
1059	virtual u4 GetSize() const;
1060	virtual CStackMapFrameInfo* Clone() const;
1061
1062	private:
1063	};
1064
1065	//------------------------------------------------------------------------------
1066	// Stack Map Frame Information: same_locals_1_stack_item_frame and
1067	// same_locals_1_stack_item_frame_extended (new in Java 6)
1068	//
1069	class CStackMapSameLocals1StackItemFrameInfo : public CStackMapFrameInfo
1070	{
1071	friend class CStackMapTable;
1072	public:
1073	CStackMapSameLocals1StackItemFrameInfo(u1 i_u1FrameType, bool i_IsExtended);
1074	CStackMapSameLocals1StackItemFrameInfo(const CStackMapSameLocals1StackItemFrameInfo &i_Other);
1075	~CStackMapSameLocals1StackItemFrameInfo();
1076
1077	virtual void Read(CJStream& i_jstream);
1078	virtual void Write(CJStream& i_jstream) const;
1079	virtual u4 GetSize() const;
1080	virtual CStackMapFrameInfo* Clone() const;
1081
1082	CVerificationTypes& GetStack() { return m_Stack; }
1083
1084	protected:
1085	virtual void AdjustOffsetDelta(int i_s2PrevFrameOffset);
1086
1087	private:
1088	CStackMapSameLocals1StackItemFrameInfo& operator = (CStackMapSameLocals1StackItemFrameInfo &i_Other);
1089
1090	CVerificationTypes m_Stack; // A vector with 1 entry
1091	bool m_IsExtended;
1092	};
1093
1094	//------------------------------------------------------------------------------
1095	// Stack Map Frame Information: append_frame (new in Java 6)
1096	//
1097	class CStackMapAppendFrameInfo : public CStackMapFrameInfo
1098	{
1099	public:
1100	CStackMapAppendFrameInfo(u1 i_u1FrameType);
1101	CStackMapAppendFrameInfo(const CStackMapAppendFrameInfo &i_Other);
1102	~CStackMapAppendFrameInfo();
1103
1104	virtual void Read(CJStream& i_jstream);
1105	virtual void Write(CJStream& i_jstream) const;
1106	virtual u4 GetSize() const;
1107	virtual CStackMapFrameInfo* Clone() const;
1108
1109	CVerificationTypes& GetLocals() { return m_Locals; }
1110
1111	private:
1112	CStackMapAppendFrameInfo& operator = (const CStackMapAppendFrameInfo &i_Other);
1113
1114	CVerificationTypes m_Locals;
1115	};
1116
1117	//------------------------------------------------------------------------------
1118	// Stack Map Frame Information: full_frame (new in Java 6)
1119	//
1120	class CStackMapFullFrameInfo : public CStackMapFrameInfo
1121	{
1122	public:
1123	CStackMapFullFrameInfo(u1 i_u1FrameType);
1124	CStackMapFullFrameInfo(const CStackMapFullFrameInfo &i_Other);
1125	~CStackMapFullFrameInfo();
1126
1127	virtual void Read(CJStream& i_jstream);
1128	virtual void Write(CJStream& i_jstream) const;
1129	virtual u4 GetSize() const;
1130	virtual CStackMapFrameInfo* Clone() const;
1131
1132	CVerificationTypes& GetLocals() { return m_Locals; }
1133	CVerificationTypes& GetStack() { return m_Stack; }
1134
1135	private:
1136	CStackMapFullFrameInfo& operator = (const CStackMapFullFrameInfo &i_Other);
1137
1138	u2 m_u2NumberOfLocals;
1139	CVerificationTypes m_Locals;
1140	u2 m_u2NumberOfStackItems;
1141	CVerificationTypes m_Stack;
1142	};
1143
1144
1145	//------------------------------------------------------------------------------
1146	// Stack Map Table (new in Java 6)
1147	//
1148	class CStackMapTable : public vector<CStackMapFrameInfo*>
1149	{
1150	public:
1151	CStackMapTable() { clear(); }
1152	~CStackMapTable();
1153	virtual void Read(CJStream& i_jstream);
1154	virtual void Write(CJStream& i_jstream) const;
1155	virtual u4 GetSize() const;
1156
1157	void AdjustOffsetDeltas();
1158	CStackMapFrameInfo* GetFrameAtOffset(u2 i_u2Offset);
1159
1160	CStackMapTable& operator = (const CStackMapTable& i_StackMaps);
1161	};
1162
1163	//------------------------------------------------------------------------------
1164	// Stack Map Table Attribute (new in Java 6 - [4.8.4])
1165	//
1166	class CStackMapTableAttribute : public CAttributeInfo
1167	{
1168	friend class CStackMapTable;
1169	public:
1170	CStackMapTableAttribute(CJClassFile* i_pClassFile);
1171	~CStackMapTableAttribute();
1172	virtual void Read(CJStream& i_jstream);
1173	virtual void Write(CJStream& i_jstream) const;
1174	virtual u4 GetSize() const;
1175	virtual u4 GetLength() const;
1176
1177	CStackMapTable& GetStackMapTable() { return m_StackMapTable; }
1178	void SetStackMapTable(const CStackMapTable& i_stackmap) {m_StackMapTable = i_stackmap;}
1179	void RereadFromBuffer(u1 *i_u1Tbl);
1180
1181	private:
1182	CStackMapTable m_StackMapTable;
1183
1184	// Disable assignment operator.
1185	// To enable, implement these functions as public
1186	CStackMapTableAttribute& operator = (const CStackMapTableAttribute& i_other) {}
1187	};
1188
1189	//------------------------------------------------------------------------------
902	// Interface information	1190	// Interface information
903	//	1191	//
904	class CInterfaceInfo	1192	class CInterfaceInfo
Lines 999-1004 public: Link Here
999	virtual u4 GetSize() const;	1287	virtual u4 GetSize() const;
1000		1288
1001	u2 GetAccessFlags() {return m_u2AccessFlags;}	1289	u2 GetAccessFlags() {return m_u2AccessFlags;}
		1290	void SetAccessFlags(u2 i_u2AccessFlags) {m_u2AccessFlags = i_u2AccessFlags;}
1002	u2 GetNameInd() const {return m_u2NameInd;}	1291	u2 GetNameInd() const {return m_u2NameInd;}
1003	u2 GetDescriptorInd() const {return m_u2DescriptorInd;}	1292	u2 GetDescriptorInd() const {return m_u2DescriptorInd;}
1004	CJAttribs& GetAttribs() {return m_Attribs;}	1293	CJAttribs& GetAttribs() {return m_Attribs;}
Lines 1070-1076 public: Link Here
1070	class CJClassFile	1359	class CJClassFile
1071	{	1360	{
1072	public:	1361	public:
1073	enum {MajorVersion = 3, MinorVersion = 46}; // TODO: comment on version	1362	enum {MajorVersion = 46, MinorVersion = 3}; // J2SE 1.2
1074	CJClassFile();	1363	CJClassFile();
1075	virtual ~CJClassFile();	1364	virtual ~CJClassFile();
1076		1365

Return to bug 148629

Lines 30-35 Link Here

(-)src-native/BCI/BCIEng/BCIEngJ/ModuleJ.h (-2 / +15 lines)
30		30
31	#include "Module.h"	31	#include "Module.h"
32	#include "JClassBuilder.h"	32	#include "JClassBuilder.h"
		33	#include "class_inerface_int.h"
33		34
34	class CModuleJ;	35	class CModuleJ;
35	class CMethodJ;	36	class CMethodJ;
Lines 57-75 public: Link Here
57	virtual void Open(CJClassBuilder* io_pClass, bool i_fDestroyClass = false);	58	virtual void Open(CJClassBuilder* io_pClass, bool i_fDestroyClass = false);
58	virtual void AddExtRef(CExtRef& i_ExtRef);	59	virtual void AddExtRef(CExtRef& i_ExtRef);
59	virtual void AddStringAttrib(CSTR i_szName, CSTR i_szValue);	60	virtual void AddStringAttrib(CSTR i_szName, CSTR i_szValue);
60	virtual void Parse();	61	virtual int Parse();
61	virtual void Emit();	62	virtual void Emit();
62		63
63	void Emit(CJStream& i_jstream); // Java specific emission	64	void Emit(CJStream& i_jstream); // Java specific emission
64	CJClassFile& GetClass();	65	CJClassFile& GetClass();
65	CJClassBuilder& GetClassBuilder();	66	CJClassBuilder& GetClassBuilder();
		67	class_handler GetClassHandler() {return m_classHandler;}
		68	verification_context GetVerificationContext(){return m_verificationContext;}
66		69
67	virtual const vector<string>& GetSourceFileNames();	70	virtual const vector<string>& GetSourceFileNames();
68		71
69	// Module modification methods	72	// Module modification methods
70	CCPFieldrefInfo* CreateFieldRef(u2 i_u2AccFlags, CSTR i_szName, CJavaType i_jtype);	73	CCPFieldrefInfo* CreateFieldRef(u2 i_u2AccFlags, CSTR i_szName, CJavaType i_jtype);
71	CMethodJ* CreateMethod(u2 i_u2AccFlags, CSTR i_szName, CSTR i_szSignature);	74	CMethodJ* CreateMethod(u2 i_u2AccFlags, CSTR i_szName, CSTR i_szSignature);
72		75	bool IsStackMapCalculationUsed() const {return m_use_stack_map_recalculation;}
		76	void UseStackMapCalculation(bool a_use_stack_map_recalculation) {m_use_stack_map_recalculation = a_use_stack_map_recalculation;}
73	protected:	77	protected:
74		78
75	private:	79	private:
Lines 85-90 private: Link Here
85	// Storage in support of GetSourceFileNames:	89	// Storage in support of GetSourceFileNames:
86	vector<string> m_sourceFileNames;	90	vector<string> m_sourceFileNames;
87	bool m_sourceFileNamesPopulated;	91	bool m_sourceFileNamesPopulated;
		92	verification_context m_verificationContext; /verifier context for support java 6.0 and latter/
		93	class_handler m_classHandler; /* class descriptor used for verification needs(recalculations) introduced in java 6.0*/
		94	method_handler m_methodContexts; /collections of method handlers*/
		95	bool m_use_stack_map_recalculation;
88	};	96	};
89		97
90	//==============================================================================	98	//==============================================================================
Lines 100-105 public: Link Here
100	m_strSignature = i_szSignature;	108	m_strSignature = i_szSignature;
101	m_pCodeAttr = i_pCodeAttr;	109	m_pCodeAttr = i_pCodeAttr;
102	m_u2AccessFlags = i_u2AccessFlags;	110	m_u2AccessFlags = i_u2AccessFlags;
		111	m_methodHandler = NULL;
		112
103		113
104	// Set the "hasThis" attribute, which is accessible to all CMethod users	114	// Set the "hasThis" attribute, which is accessible to all CMethod users
105	SetHasThis(!(m_u2AccessFlags & ACC_STATIC));	115	SetHasThis(!(m_u2AccessFlags & ACC_STATIC));
Lines 110-115 public: Link Here
110	CSTR GetSignature() const {return m_strSignature.c_str();}	120	CSTR GetSignature() const {return m_strSignature.c_str();}
111	bool IsAbstract() { return ((m_u2AccessFlags & ACC_ABSTRACT) != 0); };	121	bool IsAbstract() { return ((m_u2AccessFlags & ACC_ABSTRACT) != 0); };
112	u2 GetAccessFlags() const { return m_u2AccessFlags; }	122	u2 GetAccessFlags() const { return m_u2AccessFlags; }
		123	void SetMethodHandler(method_handler i_methodHandler) {m_methodHandler = i_methodHandler;}
		124	method_handler GetMethodHandler() {return m_methodHandler;}
113		125
114	virtual void Parse();	126	virtual void Parse();
115	virtual void Emit();	127	virtual void Emit();
Lines 121-126 private: Link Here
121	CCodeAttribute* m_pCodeAttr; // Code attribute from CJClassFile	133	CCodeAttribute* m_pCodeAttr; // Code attribute from CJClassFile
122	u2 m_u2AccessFlags; // Method access flags	134	u2 m_u2AccessFlags; // Method access flags
123	IP_t m_origCodeLength; // Saved code length from Parse to Emit	135	IP_t m_origCodeLength; // Saved code length from Parse to Emit
		136	method_handler m_methodHandler;
124	};	137	};
125		138
126		139

Added Link Here

(-)src-native/BCI/BCIEng/BCIEngJ/class_inerface_int.h (+42 lines)
1	/**********************************************************************
2	* Copyright (c) 2008 IBM Corporation and others.
3	* All rights reserved. This program and the accompanying materials
4	* are made available under the terms of the Eclipse Public License v1.0
5	* which accompanies this distribution, and is available at
6	* http://www.eclipse.org/legal/epl-v10.html
7	* $Id$
8	*
9	* Contributors:
10	* Intel - Initial API and implementation
11	**********************************************************************/
12
13	#ifndef _CLASS_INTERFACE_INT_H_
14	#define _CLASS_INTERFACE_INT_H_
15
16	#include "JClassBuilder.h"
17
18	//typedef u1 uint8;
19	//typedef u2 uint16;
20	//#include "class_interface.h"
21	//#include "class_interface_x.h"
22
23	#include "x_verifier/x_class_interface.h"
24	#include "x_verifier/x_verifier.h"
25
26	typedef Class_Handle class_handler;
27	typedef Method_Handle method_handler;
28	typedef void (get_vm_pointer_t)(void **);
29
30	class_handler get_class_handler_from_builder(class CModuleJ *);
31	method_handler get_method_handler_for_cmethod(class CMethod *);
32
33	//extern "C" {
34	//unsigned method_get_bytecode_length( method_handler);
35	//}
36
37	extern int initialize_dynamic(get_vm_pointer_t);
38	void class_destroy_handler(class_handler);
39
40	int initialize_static();
41
42	#endif

Lines 22-35 Link Here

(-)src-native/BCI/Common/CommonDef.h (-9 / +14 lines)
22	// For this header to work, you need to define one of these ARCH symbols:	22	// For this header to work, you need to define one of these ARCH symbols:
23	//	23	//
24	// WIN32 (means x86)	24	// WIN32 (means x86)
		25	// IA32_ARCH (means x86)
25	// IPF_ARCH (means Itanium Processor Family)	26	// IPF_ARCH (means Itanium Processor Family)
26	// EM64T_ARCH (means Intel/AMD 64-bit processors)	27	// EM64T_ARCH (means Intel/AMD 64-bit processors)
27	// IA32_ARCH (means x86)
28	// SPARC_ARCH	28	// SPARC_ARCH
29	// HPPA_ARCH	29	// HPPA_ARCH
30	// ALPHA_ARCH	30	// ALPHA_ARCH
31	// PPC_ARCH	31	// PPC_ARCH
32	// LINUX_PPC_ARCH (LINUX PPC64)
33	// OS390_ARCH (means zSeries)	32	// OS390_ARCH (means zSeries)
34	// AS400_ARCH (means iSeries)	33	// AS400_ARCH (means iSeries)
35	//	34	//
Lines 72-81 Link Here
72	// This brings _WINDOWS_ into scope. Use _WINDOWS_ to wrap Windows code.	71	// This brings _WINDOWS_ into scope. Use _WINDOWS_ to wrap Windows code.
73	# include <windows.h> /* for lots o' stuff, but esp. _WINDOWS_ */	72	# include <windows.h> /* for lots o' stuff, but esp. _WINDOWS_ */
74	# include <malloc.h> /* for alloca */	73	# include <malloc.h> /* for alloca */
75	#elif defined(IPF_ARCH) \|\| (EM64T_ARCH) \|\| (LINUX_PPC_ARCH)	74	#elif defined(IPF_ARCH) \|\| (EM64T_ARCH)
76	# include <stdint.h> /* for int64_t and uint64_t */	75	# include <stdint.h> /* for int64_t and uint64_t */
77	#endif	76	#endif
78		77
		78	/* On LinuxPPC64 we need this to get int64_t */
		79	#if defined(PPC_ARCH)
		80	# include </usr/include/sys/types.h>
		81	#endif
79	/* Only on OS400, we need this to get malloc/free */	82	/* Only on OS400, we need this to get malloc/free */
80	#ifdef OS400	83	#ifdef OS400
81	#include <stdlib.h>	84	#include <stdlib.h>
Lines 113-127 typedef unsigned short WORD, *PWORD; Link Here
113	typedef signed long long int int64_t;	116	typedef signed long long int int64_t;
114	typedef unsigned long long int uint64_t;	117	typedef unsigned long long int uint64_t;
115	#else	118	#else
116	#if defined(_WINDOWS_)	119	# if defined(_WINDOWS_)
117	typedef __int64 int64_t;	120	typedef __int64 int64_t;
118	typedef unsigned __int64 uint64_t;	121	typedef unsigned __int64 uint64_t;
119	#else	122	#elif defined(PPC_ARCH)
120	# if !defined(IPF_ARCH) && !defined(EM64T_ARCH) && !defined(LINUX_PPC_ARCH) // Already being declared in stdint.h
121	typedef long long int64_t;
122	typedef unsigned long long uint64_t;	123	typedef unsigned long long uint64_t;
		124	# else
		125	# if !defined(IPF_ARCH) && !defined(EM64T_ARCH)
		126	typedef long long int64_t;
		127	typedef unsigned long long uint64_t;
123	# endif	128	# endif
124	#endif	129	# endif
125	#endif	130	#endif
126		131
127	//------------------------------------------------------------------------------	132	//------------------------------------------------------------------------------
Lines 197-203 typedef unsigned short WORD, *PWORD; Link Here
197	///////	202	///////
198	#if defined(WIN32) \|\| defined(IA32_ARCH) \|\| defined(IPF_ARCH) \|\| defined(EM64T_ARCH) \|\| defined(ALPHA_ARCH)	203	#if defined(WIN32) \|\| defined(IA32_ARCH) \|\| defined(IPF_ARCH) \|\| defined(EM64T_ARCH) \|\| defined(ALPHA_ARCH)
199	# define BIG_ENDIAN_HW	204	# define BIG_ENDIAN_HW
200	#elif defined(SPARC_ARCH) \|\| defined(HPPA_ARCH) \|\| defined(PPC_ARCH) \|\| defined(AS400_ARCH) \|\| defined(OS390_ARCH) \|\| defined(LINUX_PPC_ARCH)	205	#elif defined(SPARC_ARCH) \|\| defined(HPPA_ARCH) \|\| defined(PPC_ARCH) \|\| defined(AS400_ARCH) \|\| defined(OS390_ARCH)
201	# define LITTLE_ENDIAN_HW	206	# define LITTLE_ENDIAN_HW
202	#else	207	#else
203	# error "Platform-specific configuration required"	208	# error "Platform-specific configuration required"

Lines 50-55 Link Here

(-)src-native/BCI/Common/JavaDef.h (-1 / +16 lines)
50	#define CONSTANT_InterfaceMethodref 11 // Interface method refernce constant	50	#define CONSTANT_InterfaceMethodref 11 // Interface method refernce constant
51	#define CONSTANT_NameAndType 12 // Name and type constant	51	#define CONSTANT_NameAndType 12 // Name and type constant
52		52
		53	#define CONSTANT_Unknown 0
53	// Array types	54	// Array types
54	#define T_BOOLEAN 4 // bool	55	#define T_BOOLEAN 4 // bool
55	#define T_CHAR 5 // char	56	#define T_CHAR 5 // char
Lines 60-66 Link Here
60	#define T_INT 10 // int	61	#define T_INT 10 // int
61	#define T_LONG 11 // long	62	#define T_LONG 11 // long
62		63
63	#define CONSTANT_Unknown 0	64	// stack map frame types (new in Java 6.0)
		65	#define SAME_LOCALS_1_STACK_ITEM_EXTENDED 247
		66	#define SAME_FRAME_EXTENDED 251
		67	#define FULL_FRAME 255
		68
		69	// verification types (new in Java 6.0)
		70	#define ITEM_Top 0
		71	#define ITEM_Integer 1
		72	#define ITEM_Float 2
		73	#define ITEM_Double 3
		74	#define ITEM_Long 4
		75	#define ITEM_Null 5
		76	#define ITEM_UninitializedThis 6
		77	#define ITEM_Object 7
		78	#define ITEM_Uninitialized 8
64		79
65	// ToDo: other Java specific definitions	80	// ToDo: other Java specific definitions
66	typedef unsigned char u1; // 1 byte	81	typedef unsigned char u1; // 1 byte

Lines 80-86 CJClassBuilder::GetThisClassName() Link Here

(-)src-native/BCI/JClass/JClassBuilder.cpp (-1 / +19 lines)
80	string	80	string
81	CJClassBuilder::GetSuperClassName()	81	CJClassBuilder::GetSuperClassName()
82	{	82	{
83	CCPUtf8Info* pcpUtf8 = (CCPUtf8Info)((m_pConstPool)[GetSuperClass()]);	83	CCPClassInfo* pccpClassInfo = (CCPClassInfo)((m_pConstPool)[GetSuperClass()]);
		84	CCPUtf8Info* pcpUtf8 = (CCPUtf8Info)((m_pConstPool)[pccpClassInfo->GetClassInd()]);
84	string strSuperClass = (string)*pcpUtf8;	85	string strSuperClass = (string)*pcpUtf8;
85	return strSuperClass;	86	return strSuperClass;
86	}	87	}
Lines 245-250 CJClassBuilder::FindClass(CSTR i_szName) Link Here
245	CConstPool::iterator itr = m_pConstPool->begin();	246	CConstPool::iterator itr = m_pConstPool->begin();
246	while(itr != m_pConstPool->end())	247	while(itr != m_pConstPool->end())
247	{	248	{
		249	if (*itr == NULL) return NULL;
248	if((*itr)->GetTag() == CONSTANT_Class)	250	if((*itr)->GetTag() == CONSTANT_Class)
249	{	251	{
250	CCPClassInfo* pcpci = (CCPClassInfo)itr;	252	CCPClassInfo* pcpci = (CCPClassInfo)itr;
Lines 278-283 CJClassBuilder::CreateStringConstant(CST Link Here
278	}	280	}
279		281
280	//------------------------------------------------------------------------------	282	//------------------------------------------------------------------------------
		283	// CreateClassConstant
		284	// In:
		285	// i_szClassName - class name
		286	// Returns:
		287	// CCPClassInfo* - pointer to the class infoin the constant pool
		288	//
		289	CCPClassInfo*
		290	CJClassBuilder::CreateClassConstant(CSTR i_szClassName)
		291	{
		292	u2 u2ClassName = m_pConstPool->Add(new CCPUtf8Info(i_szClassName));
		293	u2 u2ClassRef = m_pConstPool->Add(new CCPClassInfo(u2ClassName));
		294	CCPClassInfo* pcpClass = (CCPClassInfo)((m_pConstPool)[u2ClassRef]);
		295	return pcpClass;
		296	}
		297
		298	//------------------------------------------------------------------------------
281	// CreateIntegerConstant	299	// CreateIntegerConstant
282	// In:	300	// In:
283	// i_int - Integer value to add	301	// i_int - Integer value to add