contrast-agent 3.8.4

data/funchook/distorm/examples/java/distorm/src/diStorm3/Operand.java

@@ -0,0 +1,24 @@
+package diStorm3;
+
+public class Operand {
+
+	public enum OperandType {
+		None, Reg, Imm, Imm1, Imm2, Disp, Smem, Mem, Pc, Ptr
+	}
+
+	private int mType;
+	private int mIndex;
+	private int mSize;
+
+	public OperandType getType() {
+		return OperandType.values()[mType];
+	}
+
+	public int getIndex() {
+		return mIndex;
+	}
+
+	public int getSize() {
+		return mSize;
+	}
+}

data/funchook/distorm/examples/java/distorm/src/diStorm3/distorm3.java

@@ -0,0 +1,41 @@
+/*
+ *  diStorm3 JNI
+ *  Gil Dabah, Sep 2010
+ *
+ */
+package diStorm3;
+import diStorm3.CodeInfo;
+import diStorm3.DecodedResult;
+import diStorm3.DecomposedResult;
+import diStorm3.Opcodes;
+
+public class distorm3 {
+
+	public enum DecodeType {
+		Decode16Bits, Decode32Bits, Decode64Bits
+	}
+
+	public static native void Decompose(CodeInfo ci, DecomposedResult dr);
+	public static native void Decode(CodeInfo ci, DecodedResult dr);
+	public static native DecodedInst Format(CodeInfo ci, DecomposedInst di);
+
+	public enum Registers {
+		RAX, RCX, RDX, RBX, RSP, RBP, RSI, RDI, R8, R9, R10, R11, R12, R13, R14, R15,
+		EAX, ECX, EDX, EBX, ESP, EBP, ESI, EDI, R8D, R9D, R10D, R11D, R12D, R13D, R14D, R15D,
+		AX, CX, DX, BX, SP, BP, SI, DI, R8W, R9W, R10W, R11W, R12W, R13W, R14W, R15W,
+		AL, CL, DL, BL, AH, CH, DH, BH, R8B, R9B, R10B, R11B, R12B, R13B, R14B, R15B,
+		SPL, BPL, SIL, DIL,
+		ES, CS, SS, DS, FS, GS,
+		RIP,
+		ST0, ST1, ST2, ST3, ST4, ST5, ST6, ST7,
+		MM0, MM1, MM2, MM3, MM4, MM5, MM6, MM7,
+		XMM0, XMM1, XMM2, XMM3, XMM4, XMM5, XMM6, XMM7, XMM8, XMM9, XMM10, XMM11, XMM12, XMM13, XMM14, XMM15,
+		YMM0, YMM1, YMM2, YMM3, YMM4, YMM5, YMM6, YMM7, YMM8, YMM9, YMM10, YMM11, YMM12, YMM13, YMM14, YMM15,
+		CR0, UNUSED0, CR2, CR3, CR4, UNUSED1, UNUSED2, UNUSED3, CR8,
+		DR0, DR1, DR2, DR3, UNUSED4, UNUSED5, DR6, DR7
+	};
+
+	static {
+		System.loadLibrary("jdistorm");
+	}
+}

data/funchook/distorm/examples/java/jdistorm.c

@@ -0,0 +1,405 @@
+/*
+ * diStorm3 JNI wrapper.
+ * Gil Dabah, October 2010.
+ */
+
+#include "jdistorm.h"
+#include "../../include/distorm.h"
+
+#include <string.h>
+#include <stdio.h>
+#include <stdlib.h>
+
+#pragma comment(lib, "../../distorm.lib")
+
+static struct _CodeInfoIds {
+	jclass jCls;
+	jfieldID ID_CodeOffset;
+	jfieldID ID_Code;
+	jfieldID ID_DecodeType;
+	jfieldID ID_Features;
+} g_CodeInfoIds;
+
+static struct _DecodedResultIds {
+	jclass jCls;
+	jfieldID ID_Instructions;
+	jfieldID ID_MaxInstructions;
+} g_DecodedResultIds;
+
+static struct _DecodedInstIds {
+	jclass jCls;
+	jfieldID ID_Mnemonic;
+	jfieldID ID_Operands;
+	jfieldID ID_Hex;
+	jfieldID ID_Size;
+	jfieldID ID_Offset;
+} g_DecodedInstIds;
+
+static struct _DecomposedResultIds {
+	jclass jCls;
+	jfieldID ID_Instructions;
+	jfieldID ID_MaxInstructions;
+} g_DecomposedResultIds;
+
+static struct _DecomposedInstIds {
+	jclass jCls;
+	jfieldID ID_Address;
+	jfieldID ID_Size;
+	jfieldID ID_Flags;
+	jfieldID ID_Segment;
+	jfieldID ID_Base;
+	jfieldID ID_Scale;
+	jfieldID ID_Opcode;
+	jfieldID ID_Operands;
+	jfieldID ID_Disp;
+	jfieldID ID_Imm;
+	jfieldID ID_UnusedPrefixesMask;
+	jfieldID ID_Meta;
+	jfieldID ID_RegistersMask;
+	jfieldID ID_ModifiedFlagsMask;
+	jfieldID ID_TestedFlagsMask;
+	jfieldID ID_UndefinedFlagsMask;
+} g_DecomposedInstIds;
+
+static struct _OperandIds {
+	jclass jCls;
+	jfieldID ID_Type;
+	jfieldID ID_Index;
+	jfieldID ID_Size;
+} g_OperandIds;
+
+static struct _ImmIds {
+	jclass jCls;
+	jfieldID ID_Value;
+	jfieldID ID_Size;
+} g_ImmIds;
+
+static struct _DispIds {
+	jclass jCls;
+	jfieldID ID_Displacement;
+	jfieldID ID_Size;
+} g_DispIds;
+
+void JThrowByName(JNIEnv* env, const char *name, const char* msg)
+{
+    jclass cls = (*env)->FindClass(env, name);
+    if (cls != NULL) {
+        (*env)->ThrowNew(env, cls, msg);
+    }
+    (*env)->DeleteLocalRef(env, cls);
+}
+
+_CodeInfo* AcquireCodeInfoStruct(JNIEnv *env, jobject jciObj)
+{
+	jobject jCodeObj = NULL;
+	_CodeInfo* ci = (_CodeInfo*)malloc(sizeof(_CodeInfo));
+	if (ci == NULL) {
+		JThrowByName(env, "java/lang/OutOfMemoryError", NULL);
+		return NULL;
+	}
+	memset(ci, 0, sizeof(_CodeInfo));
+
+	ci->codeOffset = (*env)->GetLongField(env, jciObj, g_CodeInfoIds.ID_CodeOffset);
+
+	jCodeObj = (*env)->GetObjectField(env, jciObj, g_CodeInfoIds.ID_Code);
+	ci->code = (uint8_t*) (*env)->GetDirectBufferAddress(env, jCodeObj);
+	ci->codeLen = (int)(*env)->GetDirectBufferCapacity(env, jCodeObj);
+
+	ci->dt = (*env)->GetIntField(env, jciObj, g_CodeInfoIds.ID_DecodeType);
+
+	ci->features = (*env)->GetIntField(env, jciObj, g_CodeInfoIds.ID_Features);
+
+	return ci;
+}
+
+jobject CreateDecodedInstObj(JNIEnv* env, const _DecodedInst* inst)
+{
+	jobject jInst = (*env)->AllocObject(env, g_DecodedInstIds.jCls);
+	if (jInst == NULL) return NULL;
+	(*env)->SetObjectField(env, jInst, g_DecodedInstIds.ID_Mnemonic, (*env)->NewStringUTF(env, (const char*)inst->mnemonic.p));
+	(*env)->SetObjectField(env, jInst, g_DecodedInstIds.ID_Operands, (*env)->NewStringUTF(env, (const char*)inst->operands.p));
+	(*env)->SetObjectField(env, jInst, g_DecodedInstIds.ID_Hex, (*env)->NewStringUTF(env, (const char*)inst->instructionHex.p));
+	(*env)->SetIntField(env, jInst, g_DecodedInstIds.ID_Size, inst->size);
+	(*env)->SetLongField(env, jInst, g_DecodedInstIds.ID_Offset, inst->offset);
+	return jInst;
+}
+
+JNIEXPORT void JNICALL Java_diStorm3_distorm3_Decode
+  (JNIEnv *env, jobject thiz, jobject jciObj, jobject jdrObj)
+{
+	jarray jInsts = NULL;
+	jobject jInst = NULL;
+	_CodeInfo* ci = NULL;
+	_DecodedInst* insts = NULL;
+	jint maxInstructions = 0;
+	unsigned int usedInstructionsCount = 0, i = 0;
+
+	thiz; /* Unused. */
+
+	ci = AcquireCodeInfoStruct(env, jciObj);
+	if (ci == NULL) {
+		JThrowByName(env, "java/lang/OutOfMemoryError", NULL);
+		return;
+	}
+
+	maxInstructions = (*env)->GetIntField(env, jdrObj, g_DecodedResultIds.ID_MaxInstructions);
+
+	insts = (_DecodedInst*)malloc(maxInstructions * sizeof(_DecodedInst));
+	if (insts == NULL) goto Cleanup;
+
+	distorm_decode(ci->codeOffset, ci->code, ci->codeLen, ci->dt, insts, maxInstructions, &usedInstructionsCount);
+
+	jInsts = (*env)->NewObjectArray(env, usedInstructionsCount, g_DecodedInstIds.jCls, NULL);
+	if (jInsts == NULL) goto Cleanup;
+
+	for (i = 0; i < usedInstructionsCount; i++) {
+		jInst = CreateDecodedInstObj(env, &insts[i]);
+		if (jInst == NULL) goto Cleanup;
+		(*env)->SetObjectArrayElement(env, jInsts, i, jInst);
+	}
+
+	(*env)->SetObjectField(env, jdrObj, g_DecodedResultIds.ID_Instructions, jInsts);
+
+Cleanup:
+	/* In case of an error, jInsts will get cleaned automatically. */
+	if (ci != NULL) free(ci);
+	if (insts != NULL) free(insts);
+}
+
+JNIEXPORT void JNICALL Java_diStorm3_distorm3_Decompose
+  (JNIEnv *env, jobject thiz, jobject jciObj, jobject jdrObj)
+{
+	jarray jInsts = NULL, jOperands = NULL;
+	jobject jInst = NULL, jOperand = NULL, jImm = NULL, jDisp = NULL;
+	_CodeInfo* ci = NULL;
+	_DInst* insts = NULL;
+	jint maxInstructions = 0;
+	unsigned int usedInstructionsCount = 0, i = 0, j = 0, operandsNo = 0;
+	int success = 0;
+
+	thiz; /* Unused. */
+
+	ci = AcquireCodeInfoStruct(env, jciObj);
+	if (ci == NULL) {
+		JThrowByName(env, "java/lang/OutOfMemoryError", NULL);
+		return;
+	}
+
+	maxInstructions = (*env)->GetIntField(env, jdrObj, g_DecomposedResultIds.ID_MaxInstructions);
+
+	insts = (_DInst*)malloc(maxInstructions * sizeof(_DInst));
+	if (insts == NULL) goto Cleanup;
+
+	distorm_decompose(ci, insts, maxInstructions, &usedInstructionsCount);
+
+	jInsts = (*env)->NewObjectArray(env, usedInstructionsCount, g_DecomposedInstIds.jCls, NULL);
+	if (jInsts == NULL) goto Cleanup;
+
+	for (i = 0; i < usedInstructionsCount; i++) {
+		jInst = (*env)->AllocObject(env, g_DecomposedInstIds.jCls);
+		if (jInst == NULL) goto Cleanup;
+
+		/* Simple fields: */
+		(*env)->SetLongField(env, jInst, g_DecomposedInstIds.ID_Address, insts[i].addr);
+		(*env)->SetIntField(env, jInst, g_DecomposedInstIds.ID_Flags, insts[i].flags);
+		(*env)->SetIntField(env, jInst, g_DecomposedInstIds.ID_Size, insts[i].size);
+		(*env)->SetIntField(env, jInst, g_DecomposedInstIds.ID_Segment, insts[i].segment);
+		(*env)->SetIntField(env, jInst, g_DecomposedInstIds.ID_Base, insts[i].base);
+		(*env)->SetIntField(env, jInst, g_DecomposedInstIds.ID_Scale, insts[i].scale);
+		(*env)->SetIntField(env, jInst, g_DecomposedInstIds.ID_Opcode, insts[i].opcode);
+		(*env)->SetIntField(env, jInst, g_DecomposedInstIds.ID_UnusedPrefixesMask, insts[i].unusedPrefixesMask);
+		(*env)->SetIntField(env, jInst, g_DecomposedInstIds.ID_Meta, insts[i].meta);
+		(*env)->SetIntField(env, jInst, g_DecomposedInstIds.ID_RegistersMask, insts[i].usedRegistersMask);
+		(*env)->SetIntField(env, jInst, g_DecomposedInstIds.ID_ModifiedFlagsMask, insts[i].modifiedFlagsMask);
+		(*env)->SetIntField(env, jInst, g_DecomposedInstIds.ID_TestedFlagsMask, insts[i].testedFlagsMask);
+		(*env)->SetIntField(env, jInst, g_DecomposedInstIds.ID_UndefinedFlagsMask, insts[i].undefinedFlagsMask);
+
+		/* Immediate variant. */
+		jImm = (*env)->AllocObject(env, g_ImmIds.jCls);
+		if (jImm == NULL) goto Cleanup;
+		(*env)->SetLongField(env, jImm, g_ImmIds.ID_Value, insts[i].imm.qword);
+		/* The size of the immediate is in one of the operands, if at all. Look for it below. Zero by default. */
+		(*env)->SetIntField(env, jImm, g_ImmIds.ID_Size, 0);
+
+		/* Count operands. */
+		for (operandsNo = 0; operandsNo < OPERANDS_NO; operandsNo++) {
+			if (insts[i].ops[operandsNo].type == O_NONE) break;
+		}
+
+		jOperands = (*env)->NewObjectArray(env, operandsNo, g_OperandIds.jCls, NULL);
+		if (jOperands == NULL) goto Cleanup;
+
+		for (j = 0; j < operandsNo; j++) {
+			if (insts[i].ops[j].type == O_IMM) {
+				/* Set the size of the immediate operand. */
+				(*env)->SetIntField(env, jImm, g_ImmIds.ID_Size, insts[i].ops[j].size);
+			}
+
+			jOperand = (*env)->AllocObject(env, g_OperandIds.jCls);
+			if (jOperand == NULL) goto Cleanup;
+			(*env)->SetIntField(env, jOperand, g_OperandIds.ID_Type, insts[i].ops[j].type);
+			(*env)->SetIntField(env, jOperand, g_OperandIds.ID_Index, insts[i].ops[j].index);
+			(*env)->SetIntField(env, jOperand, g_OperandIds.ID_Size, insts[i].ops[j].size);
+			(*env)->SetObjectArrayElement(env, jOperands, j, jOperand);
+		}
+		(*env)->SetObjectField(env, jInst, g_DecomposedInstIds.ID_Operands, jOperands);
+
+		/* Attach the immediate variant. */
+		(*env)->SetObjectField(env, jInst, g_DecomposedInstIds.ID_Imm, jImm);
+
+		/* Displacement variant. */
+		jDisp = (*env)->AllocObject(env, g_DispIds.jCls);
+		if (jDisp == NULL) goto Cleanup;
+		(*env)->SetLongField(env, jDisp, g_DispIds.ID_Displacement, insts[i].disp);
+		(*env)->SetIntField(env, jDisp, g_DispIds.ID_Size, insts[i].dispSize);
+		(*env)->SetObjectField(env, jInst, g_DecomposedInstIds.ID_Disp, jDisp);
+
+		(*env)->SetObjectArrayElement(env, jInsts, i, jInst);
+	}
+
+	(*env)->SetObjectField(env, jdrObj, g_DecodedResultIds.ID_Instructions, jInsts);
+
+Cleanup:
+	/* In case of an error, jInsts will get cleaned automatically. */
+	if (ci != NULL) free(ci);
+	if (insts != NULL) free(insts);
+}
+
+JNIEXPORT jobject JNICALL Java_diStorm3_distorm3_Format
+  (JNIEnv *env, jobject thiz, jobject jciObj, jobject jdiObj)
+{
+	_CodeInfo* ci = NULL;
+	_DInst input = {0};
+	_DecodedInst output = {0};
+	jobject ret = NULL, jOperands = NULL, jOp = NULL, jTmp = NULL;
+	jsize i, opsCount;
+
+	thiz; /* Unused. */
+
+	ci = AcquireCodeInfoStruct(env, jciObj);
+	if (ci == NULL) {
+		JThrowByName(env, "java/lang/OutOfMemoryError", NULL);
+		return NULL;
+	}
+
+	input.addr = (*env)->GetLongField(env, jdiObj, g_DecomposedInstIds.ID_Address);
+	input.flags = (uint16_t) (*env)->GetIntField(env, jdiObj, g_DecomposedInstIds.ID_Flags);
+	input.size = (uint8_t) (*env)->GetIntField(env, jdiObj, g_DecomposedInstIds.ID_Size);
+	input.segment = (uint8_t) (*env)->GetIntField(env, jdiObj, g_DecomposedInstIds.ID_Segment);
+	input.base = (uint8_t) (*env)->GetIntField(env, jdiObj, g_DecomposedInstIds.ID_Base);
+	input.scale = (uint8_t) (*env)->GetIntField(env, jdiObj, g_DecomposedInstIds.ID_Scale);
+	input.opcode = (uint16_t) (*env)->GetIntField(env, jdiObj, g_DecomposedInstIds.ID_Opcode);
+	/* unusedPrefixesMask is unused indeed, lol. */
+	input.meta = (uint8_t) (*env)->GetIntField(env, jdiObj, g_DecomposedInstIds.ID_Meta);
+	/* Nor usedRegistersMask. */
+
+	jOperands = (*env)->GetObjectField(env, jdiObj, g_DecomposedInstIds.ID_Operands);
+	if (jOperands != NULL) {
+		opsCount = (*env)->GetArrayLength(env, jOperands);
+		for (i = 0; i < opsCount; i++) {
+			jOp = (*env)->GetObjectArrayElement(env, jOperands, i);
+			if (jOp != NULL) {
+				input.ops[i].index = (uint8_t) (*env)->GetIntField(env, jOp, g_OperandIds.ID_Index);
+				input.ops[i].type = (uint8_t) (*env)->GetIntField(env, jOp, g_OperandIds.ID_Type);
+				input.ops[i].size = (uint16_t) (*env)->GetIntField(env, jOp, g_OperandIds.ID_Size);
+			}
+		}
+	}
+
+	jTmp = (*env)->GetObjectField(env, jdiObj, g_DecomposedInstIds.ID_Imm);
+	if (jTmp != NULL) {
+		input.imm.qword = (uint64_t) (*env)->GetLongField(env, jTmp, g_ImmIds.ID_Value);
+	}
+
+	jTmp = (*env)->GetObjectField(env, jdiObj, g_DecomposedInstIds.ID_Disp);
+	if (jTmp != NULL) {
+		input.disp = (uint64_t) (*env)->GetLongField(env, jTmp, g_DispIds.ID_Displacement);
+		input.dispSize = (uint8_t) (*env)->GetIntField(env, jTmp, g_DispIds.ID_Size);
+	}
+
+	distorm_format(ci, &input, &output);
+
+	ret = CreateDecodedInstObj(env, &output);
+
+	if (ci != NULL) free(ci);
+	return ret;
+}
+
+/* Cache all ID's and classes! Release in unload. */
+jint JNI_OnLoad(JavaVM *vm, void *reserved)
+{
+	jclass jCls = NULL;
+	JNIEnv* env = NULL;
+
+	if ((*vm)->GetEnv(vm, (void**)&env, JNI_VERSION_1_6) != JNI_OK) {
+		return JNI_VERSION_1_6;
+	}
+
+	jCls = (*env)->FindClass(env, PACKAGE_PREFIX "CodeInfo");
+	g_CodeInfoIds.jCls = (*env)->NewWeakGlobalRef(env, jCls);
+	g_CodeInfoIds.ID_CodeOffset = (*env)->GetFieldID(env, jCls, "mCodeOffset", "J");
+	g_CodeInfoIds.ID_Code = (*env)->GetFieldID(env, jCls, "mCode", "Ljava/nio/ByteBuffer;");
+	g_CodeInfoIds.ID_DecodeType = (*env)->GetFieldID(env, jCls, "mDecodeType", "I");
+	g_CodeInfoIds.ID_Features = (*env)->GetFieldID(env, jCls, "mFeatures", "I");
+
+	jCls = (*env)->FindClass(env, PACKAGE_PREFIX "DecodedResult");
+	g_DecodedResultIds.jCls = (*env)->NewWeakGlobalRef(env, jCls);
+	g_DecodedResultIds.ID_MaxInstructions = (*env)->GetFieldID(env, jCls, "mMaxInstructions", "I");
+	g_DecodedResultIds.ID_Instructions = (*env)->GetFieldID(env, jCls, "mInstructions", "[L" PACKAGE_PREFIX "DecodedInst;");
+
+	jCls = (*env)->FindClass(env, PACKAGE_PREFIX "DecodedInst");
+	g_DecodedInstIds.jCls = (*env)->NewWeakGlobalRef(env, jCls);
+	g_DecodedInstIds.ID_Mnemonic = (*env)->GetFieldID(env, jCls, "mMnemonic", "Ljava/lang/String;");
+	g_DecodedInstIds.ID_Operands = (*env)->GetFieldID(env, jCls, "mOperands", "Ljava/lang/String;");
+	g_DecodedInstIds.ID_Hex = (*env)->GetFieldID(env, jCls, "mHex", "Ljava/lang/String;");
+	g_DecodedInstIds.ID_Size = (*env)->GetFieldID(env, jCls, "mSize", "I");
+	g_DecodedInstIds.ID_Offset = (*env)->GetFieldID(env, jCls, "mOffset", "J");
+
+	jCls = (*env)->FindClass(env, PACKAGE_PREFIX "DecomposedResult");
+	g_DecomposedResultIds.jCls = (*env)->NewWeakGlobalRef(env, jCls);
+	g_DecomposedResultIds.ID_Instructions = (*env)->GetFieldID(env, jCls, "mInstructions", "[L" PACKAGE_PREFIX "DecomposedInst;");
+	g_DecomposedResultIds.ID_MaxInstructions = (*env)->GetFieldID(env, jCls, "mMaxInstructions", "I");
+
+	jCls = (*env)->FindClass(env, PACKAGE_PREFIX "DecomposedInst");
+	g_DecomposedInstIds.jCls = (*env)->NewWeakGlobalRef(env, jCls);
+	g_DecomposedInstIds.ID_Address = (*env)->GetFieldID(env, jCls, "mAddr", "J");
+	g_DecomposedInstIds.ID_Size = (*env)->GetFieldID(env, jCls, "mSize", "I");
+	g_DecomposedInstIds.ID_Flags = (*env)->GetFieldID(env, jCls, "mFlags", "I");
+	g_DecomposedInstIds.ID_Segment = (*env)->GetFieldID(env, jCls, "mSegment", "I");
+	g_DecomposedInstIds.ID_Base = (*env)->GetFieldID(env, jCls, "mBase", "I");
+	g_DecomposedInstIds.ID_Scale = (*env)->GetFieldID(env, jCls, "mScale", "I");
+	g_DecomposedInstIds.ID_Opcode = (*env)->GetFieldID(env, jCls, "mOpcode", "I");
+	g_DecomposedInstIds.ID_Operands = (*env)->GetFieldID(env, jCls, "mOperands", "[L" PACKAGE_PREFIX "Operand;");
+	g_DecomposedInstIds.ID_Disp = (*env)->GetFieldID(env, jCls, "mDisp", "L" PACKAGE_PREFIX "DecomposedInst$DispVariant;");
+	g_DecomposedInstIds.ID_Imm = (*env)->GetFieldID(env, jCls, "mImm", "L" PACKAGE_PREFIX "DecomposedInst$ImmVariant;");
+	g_DecomposedInstIds.ID_UnusedPrefixesMask = (*env)->GetFieldID(env, jCls, "mUnusedPrefixesMask", "I");
+	g_DecomposedInstIds.ID_Meta = (*env)->GetFieldID(env, jCls, "mMeta", "I");
+	g_DecomposedInstIds.ID_RegistersMask = (*env)->GetFieldID(env, jCls, "mRegistersMask", "I");
+	g_DecomposedInstIds.ID_ModifiedFlagsMask = (*env)->GetFieldID(env, jCls, "mModifiedFlagsMask", "I");
+	g_DecomposedInstIds.ID_TestedFlagsMask = (*env)->GetFieldID(env, jCls, "mTestedFlagsMask", "I");
+	g_DecomposedInstIds.ID_UndefinedFlagsMask = (*env)->GetFieldID(env, jCls, "mUndefinedFlagsMask", "I");
+
+	jCls = (*env)->FindClass(env, PACKAGE_PREFIX "Operand");
+	g_OperandIds.jCls = (*env)->NewWeakGlobalRef(env, jCls);
+	g_OperandIds.ID_Type = (*env)->GetFieldID(env, jCls, "mType", "I");
+	g_OperandIds.ID_Index = (*env)->GetFieldID(env, jCls, "mIndex", "I");
+	g_OperandIds.ID_Size = (*env)->GetFieldID(env, jCls, "mSize", "I");
+
+	jCls = (*env)->FindClass(env, PACKAGE_PREFIX "DecomposedInst$ImmVariant");
+	g_ImmIds.jCls = (*env)->NewWeakGlobalRef(env, jCls);
+	g_ImmIds.ID_Value = (*env)->GetFieldID(env, jCls, "mValue", "J");
+	g_ImmIds.ID_Size = (*env)->GetFieldID(env, jCls, "mSize", "I");
+
+	jCls = (*env)->FindClass(env, PACKAGE_PREFIX "DecomposedInst$DispVariant");
+	g_DispIds.jCls = (*env)->NewWeakGlobalRef(env, jCls);
+	g_DispIds.ID_Displacement = (*env)->GetFieldID(env, jCls, "mDisplacement", "J");
+	g_DispIds.ID_Size = (*env)->GetFieldID(env, jCls, "mSize", "I");
+
+	return JNI_VERSION_1_6;
+}
+
+
+JNIEXPORT void JNICALL JNI_OnUnload(JavaVM *vm, void *reserved)
+{
+	/* Free global weak refs. */
+}