8234541: C1 emits an empty message when it inlines successfully
Summary: Use "inline" as the message when successfull
Reviewed-by: thartmann, mdoerr
Contributed-by: navy.xliu@gmail.com
/*
* Copyright (c) 2004, 2018, Oracle and/or its affiliates. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
* under the terms of the GNU General Public License version 2 only, as
* published by the Free Software Foundation.
*
* This code is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
* version 2 for more details (a copy is included in the LICENSE file that
* accompanied this code).
*
* You should have received a copy of the GNU General Public License version
* 2 along with this work; if not, write to the Free Software Foundation,
* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
*
* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
* or visit www.oracle.com if you need additional information or have any
* questions.
*/
#include <stdlib.h>
#include <string.h>
#include "jni_tools.h"
#include "jvmti_tools.h"
#include "Injector.h"
/* ========================================================================== */
/* Opcode Lengths */
static const u1 opcLengths[] = {
1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 3, 2, 3, /* 0- 19 */
3, 2, 2, 2, 2, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, /* 20- 39 */
1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 2, 2, 2, 2, 1, /* 40- 59 */
1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, /* 60- 79 */
1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, /* 80- 99 */
1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, /* 100-119 */
1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 3, 1, 1, 1, 1, 1, 1, 1, /* 120-139 */
1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 3, 3, 3, 3, 3, 3, 3, /* 140-159 */
3, 3, 3, 3, 3, 3, 3, 3, 3, 2, 0, 0, 1, 1, 1, 1, 1, 1, 3, 3, /* 160-179 */
3, 3, 3, 3, 3, 5, 5, 3, 2, 3, 1, 1, 3, 3, 1, 1, 0, 4, 3, 3, /* 180-199 */
5, 5, 1 /* 200- */
};
static const int GROWTH_FACTOR = 2;
static const char* codeAttributeName = "Code";
static const char* lineNumberAttributeName = "LineNumberTable";
static const char* localVarAttributeName = "LocalVariableTable";
static const char* localVarTypeAttributeName = "LocalVariableTypeTable";
static const char* stackMapAttributeName= "StackMapTable";
static u2 codeAttributeIndex;
static u2 lineNumberAttributeIndex;
static u2 localVarAttributeIndex;
static u2 localVarTypeAttributeIndex;
static u2 stackMapAttributeIndex;
static const u1 SAME_BEGIN = 0;
static const u1 SAME_END = 63;
static const u1 SAME_LOCALS_1_STACK_ITEM_BEGIN = 64;
static const u1 SAME_LOCALS_1_STACK_ITEM_END = 127;
//Tags in the range [128-246] are reserved for future use.
static const u1 SAME_LOCALS_1_STACK_ITEM_EXTENDED = 247;
static const u1 CHOP_BEGIN = 248;
static const u1 CHOP_END = 250;
static const u1 SAME_FRAME_EXTENDED = 251;
static const u1 APPEND_BEGIN = 252;
static const u1 APPEND_END = 254;
static const u1 FULL_FRAME = 255;
static const u1 ITEM_Object = 7;
static const u1 ITEM_Uninitialized = 8;
static u2 stackFrameOffset = 0;
static int mode;
static const u1* orig;
static u1* gen;
static u1* inputPos;
static const u1* endPos;
static u1* genPos;
static u1* markPos;
static char** constantPool;
static u2 constantPoolSize;
static u2 constantPoolCount;
static u1 callBytes[] = { opc_invokestatic, 0, 0 };
static u1 allocBytes[] = { opc_invokestatic, 0, 0 };
static u1 zeroBytes[] = { 0, 0, 0 };
static u4 codeLength;
static u4* map;
static jbyte* widening;
/* ========================================================================== */
extern "C" {
static u1 get_u1() {
return *inputPos++;
}
static u2 get_u2() {
u1* p = inputPos;
inputPos += 2;
return (u2)p[1] | ((u2)p[0]<<8);
}
static u4 get_u4() {
u1* p = inputPos;
inputPos += 4;
return (u4)p[3] | ((u4)p[2]<<8) | ((u4)p[1]<<16) | ((u4)p[0]<<24);
}
static void put_u1(u1 v) {
*genPos++ = v;
}
static void put_u2(u2 v) {
*genPos++ = (u1)(v>>8);
*genPos++ = (u1)(v & 0xFF);
}
static void put_u4(u4 v) {
*genPos++ = (u1)(v>>24);
*genPos++ = (u1)(v>>16);
*genPos++ = (u1)(v>>8);
*genPos++ = (u1)(v & 0xFF);
}
static void set_u4(u1* pos, u4 v) {
*pos++ = (u1)(v>>24);
*pos++ = (u1)(v>>16);
*pos++ = (u1)(v>>8);
*pos++ = (u1)(v & 0xFF);
}
static u1 copy_u1() {
u1 v = get_u1();
put_u1(v);
return v;
}
static u2 copy_u2() {
u2 v = get_u2();
put_u2(v);
return v;
}
static u4 copy_u4() {
u4 v = get_u4();
put_u4(v);
return v;
}
static void copy(int count) {
memcpy(genPos, inputPos, count);
inputPos += count;
genPos += count;
}
static void skip(int count) {
inputPos += count;
}
static void get(u1* bytes, int count) {
memcpy(bytes, inputPos, count);
inputPos += count;
}
static void put(u1* bytes, int count) {
memcpy(genPos, bytes, count);
genPos += count;
}
static void markLocalPositionStart() {
markPos = inputPos;
}
static u4 localPosition() {
return (u4) (inputPos - markPos);
}
void recallPosition() {
inputPos = markPos;
}
static u4 generatedPosition() {
return (u4) (genPos - gen);
}
static void randomAccessWriteU2(int pos, u2 v) {
gen[pos] = (u1)(v>>8);
gen[pos+1] = (u1)(v & 0xFF);
}
static void randomAccessWriteU4(int pos, u4 v) {
gen[pos] = (u1)(v>>24);
gen[pos+1] = (u1)(v>>16);
gen[pos+2] = (u1)(v>>8);
gen[pos+3] = (u1)(v & 0xFF);
}
static int copyConstantPool(u2 constantPoolCount) {
u2 i;
u2 len;
char* utf8;
constantPoolSize = constantPoolCount;
NSK_DISPLAY1("copying ConstantPool: %d\n", constantPoolSize);
constantPool = (char**) malloc(constantPoolSize * sizeof(char*));
if (!NSK_VERIFY(constantPool != NULL)) {
NSK_COMPLAIN0("out of memory\n");
return NSK_FALSE;
}
memset(constantPool, 0, constantPoolSize * sizeof(char*));
codeAttributeIndex = 0;
lineNumberAttributeIndex = 0;
localVarAttributeIndex = 0;
localVarTypeAttributeIndex = 0;
stackMapAttributeIndex = 0;
for (i = 1; i < constantPoolSize; i++) {
u1 tag = copy_u1();
switch (tag) {
case CONSTANT_Class:
case CONSTANT_String:
case CONSTANT_MethodType:
copy(2);
break;
case CONSTANT_MethodHandle:
copy(3);
break;
case CONSTANT_Fieldref:
case CONSTANT_Methodref:
case CONSTANT_InterfaceMethodref:
case CONSTANT_Integer:
case CONSTANT_Float:
case CONSTANT_NameAndType:
case CONSTANT_InvokeDynamic:
copy(4);
break;
case CONSTANT_Long:
case CONSTANT_Double:
copy(8);
i++; /* takes two CP entries */
break;
case CONSTANT_Utf8:
len = copy_u2();
utf8 = (char*) malloc(len + 1);
if (!NSK_VERIFY(utf8 != NULL)) {
NSK_COMPLAIN0("out of memory\n");
return NSK_FALSE;
}
get((u1*) utf8, len);
utf8[len] = 0;
constantPool[i] = utf8;
if (strcmp(utf8, codeAttributeName) == 0) {
codeAttributeIndex = i;
} else if (strcmp(utf8, lineNumberAttributeName) == 0) {
lineNumberAttributeIndex = i;
} else if (strcmp(utf8, localVarAttributeName) == 0) {
localVarAttributeIndex = i;
} else if (strcmp(utf8, localVarTypeAttributeName) == 0) {
localVarTypeAttributeIndex = i;
} else if (strcmp(utf8, stackMapAttributeName) == 0) {
stackMapAttributeIndex = i;
}
put((u1*) utf8, len);
break;
default:
NSK_COMPLAIN2("%d unexpected constant pool tag: %d\n", i, tag);
return NSK_FALSE;
}
}
return NSK_TRUE;
}
static void freeConstantPool() {
u2 i;
for (i = 1; i < constantPoolSize; i++) {
if (constantPool[i] != NULL) {
free(constantPool[i]);
}
}
free(constantPool);
}
/* ========================================================================== */
/* Copy the exception table for this method code */
static void copyExceptionTable() {
u2 tableLength;
u2 i;
tableLength = copy_u2();
NSK_DISPLAY1("ExceptionTable length: %d\n", tableLength);
for (i = tableLength; i > 0; i--) {
put_u2((u2) map[get_u2()]); /* start_pc */
put_u2((u2) map[get_u2()]); /* end_pc */
put_u2((u2) map[get_u2()]); /* handler_pc */
copy(2); /* catch_type */
}
}
/* Copy the line number table for this method code */
static void copyLineNumberAttr() {
u2 tableLength;
u2 i;
copy(4); /* attr len */
tableLength = copy_u2();
NSK_DISPLAY1("LineNumberTable length: %d\n", tableLength);
for (i = tableLength; i > 0; i--) {
put_u2((u2) map[get_u2()]); /* start_pc */
copy(2); /* line_number */
}
}
/* Copy the local variable table for this method code */
static void copyLocalVarAttr() {
u2 tableLength;
u2 startPC;
u2 i;
copy(4); /* attr len */
tableLength = copy_u2();
NSK_DISPLAY1("LocalVariableTable length: %d\n", tableLength);
for (i = tableLength; i > 0; i--) {
startPC = get_u2();
put_u2((u2) map[startPC]); /* start_pc */
put_u2((u2) (map[startPC + get_u2()] - map[startPC])); /* length */
copy(6); /* name_index, descriptor_index, index */
}
}
/* Copy the local variable type table for this method code */
static void copyLocalVarTypeAttr() {
u2 tableLength;
u2 startPC;
u2 i;
copy(4); /* attr len */
tableLength = copy_u2();
NSK_DISPLAY1("LocalVariableTypeTable length: %d\n", tableLength);
for (i = tableLength; i > 0; i--) {
startPC = get_u2();
put_u2((u2) map[startPC]); /* start_pc */
put_u2((u2) (map[startPC + get_u2()] - map[startPC])); /* length */
copy(6); /* name_index, signature_index, index */
}
}
static u2 calculateOffsetDelta(u2 frameNumber, u2 frameOffsetDelta) {
u2 oldOffset;
u2 newOffset;
if (frameNumber == 0) {
stackFrameOffset = frameOffsetDelta;
return (u2) map[stackFrameOffset];
} else {
oldOffset = (u2) map[stackFrameOffset];
stackFrameOffset = stackFrameOffset + frameOffsetDelta + 1;
newOffset = (u2) map[stackFrameOffset - 1];
return newOffset - oldOffset;
}
}
static void copyVerificationTypeInfo(u2 count) {
u2 i;
u2 offset;
u1 tag;
for (i=0; i<count; i++) {
tag = get_u1();
put_u1(tag);
if (tag == ITEM_Object) {
copy_u2();
} else if (tag == ITEM_Uninitialized) {
copy_u2();
offset = get_u2();
put_u2((u2)map[offset]);
}
}
}
static void copyStackMapAttr() {
u2 number_of_entries;
u2 i;
u4 len;
unsigned int frame_type;
u2 frameOffsetDelta;
u2 number_of_stack_items;
u2 number_of_locals;
u1* lenPtr = genPos;
len=copy_u4(); /* attr len */
number_of_entries = copy_u2();
for (i=0; i<number_of_entries; i++) {
frame_type = get_u1();
if (frame_type <= SAME_END) {
// same_frame {
// u1 frame_type = SAME; /* 0-63 */
// }
put_u1(SAME_FRAME_EXTENDED);
put_u2(calculateOffsetDelta(i, (u2) frame_type));
} else if ((frame_type >= SAME_LOCALS_1_STACK_ITEM_BEGIN) && (frame_type <= SAME_LOCALS_1_STACK_ITEM_END)) {
// same_locals_1_stack_item_frame {
// u1 frame_type = SAME_LOCALS_1_STACK_ITEM;/* 64-127 */
// verification_type_info stack[1];
// }
put_u1(SAME_LOCALS_1_STACK_ITEM_EXTENDED);
put_u2(calculateOffsetDelta(i, (u2) (frame_type-64)));
copyVerificationTypeInfo(1);
// Tags in the range [128-246] are reserved for future use.
} else if (frame_type == SAME_LOCALS_1_STACK_ITEM_EXTENDED) {
// same_locals_1_stack_item_frame_extended {
// u1 frame_type = SAME_LOCALS_1_STACK_ITEM_EXTENDED; /* 247 */
// u2 offset_delta;
// verification_type_info stack[1];
// }
put_u1(SAME_LOCALS_1_STACK_ITEM_EXTENDED);
frameOffsetDelta = get_u2();
put_u2(calculateOffsetDelta(i, frameOffsetDelta));
copyVerificationTypeInfo(1);
} else if ((frame_type >= CHOP_BEGIN) && (frame_type <= CHOP_END)) {
// chop_frame {
// u1 frame_type = CHOP; /* 248-250 */
// u2 offset_delta;
// }
put_u1((u1)frame_type);
frameOffsetDelta = get_u2();
put_u2(calculateOffsetDelta(i, frameOffsetDelta));
} else if (frame_type == SAME_FRAME_EXTENDED) {
// same_frame_extended {
// u1 frame_type = SAME_FRAME_EXTENDED; /* 251 */
// u2 offset_delta;
// }
put_u1(SAME_FRAME_EXTENDED);
frameOffsetDelta = get_u2();
put_u2(calculateOffsetDelta(i, frameOffsetDelta));
} else if ((frame_type >= APPEND_BEGIN) && (frame_type <= APPEND_END)) {
// append_frame {
// u1 frame_type = APPEND; /* 252-254 */
// u2 offset_delta;
// verification_type_info locals[frame_type - 251];
// }
put_u1((u1)frame_type);
frameOffsetDelta = get_u2();
put_u2(calculateOffsetDelta(i, frameOffsetDelta));
copyVerificationTypeInfo((u1)(frame_type - 251));
} else if (frame_type == FULL_FRAME) {
// sfull_frame {
// u1 frame_type = FULL_FRAME; /* 255 */
// u2 offset_delta;
// u2 number_of_locals;
// verification_type_info locals[number_of_locals];
// u2 number_of_stack_items;
// verification_type_info stack[number_of_stack_items];
// }
put_u1(FULL_FRAME);
frameOffsetDelta = get_u2();
put_u2(calculateOffsetDelta(i, frameOffsetDelta));
number_of_locals = copy_u2();
copyVerificationTypeInfo(number_of_locals);
number_of_stack_items = copy_u2();
copyVerificationTypeInfo(number_of_stack_items);
}
}
set_u4(lenPtr,(u4)((genPos-lenPtr) - 4));
}
/* ========================================================================== */
static void injectBytes(u4 at, u4 len) {
u4 i;
NSK_DISPLAY2("Injecting %d bytes at %d\n", len, at);
for (i = at; i <= codeLength; i++) {
map[i] += len;
}
}
static void widen(u4 at, jbyte len) {
u4 i;
jbyte delta = len - widening[at];
NSK_DISPLAY2("Widening to %d bytes at %d\n", len, at);
/* mark at beginning of instruction */
widening[at] = len;
/* inject at end of instruction */
for (i = localPosition(); i <= codeLength; i++) {
map[i] += delta;
}
}
/* ========================================================================== */
/**
* Walk one instruction writing the transformed instruction.
*/
static void writeInstruction() {
u4 pos = localPosition();
u4 newPos = map[pos];
u1 opcode = get_u1();
switch (opcode) {
case opc_wide:
put_u1(opcode);
copy(copy_u1() == opc_iinc ? 4 : 2);
break;
case opc_new:
case opc_newarray:
case opc_anewarray:
case opc_multianewarray:
put_u1(opcode);
copy(opcLengths[opcode] - 1);
if (mode == BCI_MODE_ALLOC) {
put(allocBytes, 3);
}
break;
case opc_jsr_w:
case opc_goto_w:
put_u1(opcode);
put_u4(map[pos + get_u4()] - newPos);
break;
case opc_jsr:
case opc_goto:
case opc_ifeq:
case opc_ifge:
case opc_ifgt:
case opc_ifle:
case opc_iflt:
case opc_ifne:
case opc_if_icmpeq:
case opc_if_icmpne:
case opc_if_icmpge:
case opc_if_icmpgt:
case opc_if_icmple:
case opc_if_icmplt:
case opc_if_acmpeq:
case opc_if_acmpne:
case opc_ifnull:
case opc_ifnonnull: {
u1 newOpcode = opcode;
jbyte widened = widening[pos];
if (widened == 0) { /* not widened */
put_u1(opcode);
put_u2((u2) (map[pos + (jshort) get_u2()] - newPos));
} else if (widened == 2) { /* wide form */
if (opcode == opc_jsr) {
newOpcode = opc_jsr_w;
} else if (opcode == opc_jsr) {
newOpcode = opc_goto_w;
} else {
NSK_COMPLAIN1("unexpected opcode: %d\n", opcode);
}
put_u1(newOpcode);
put_u4(map[pos + (jshort) get_u2()] - newPos);
} else if (widened == 5) { /* insert goto_w */
switch (opcode) {
case opc_ifeq:
newOpcode = opc_ifne;
break;
case opc_ifge:
newOpcode = opc_iflt;
break;
case opc_ifgt:
newOpcode = opc_ifle;
break;
case opc_ifle:
newOpcode = opc_ifgt;
break;
case opc_iflt:
newOpcode = opc_ifge;
break;
case opc_ifne:
newOpcode = opc_ifeq;
break;
case opc_if_icmpeq:
newOpcode = opc_if_icmpne;
break;
case opc_if_icmpne:
newOpcode = opc_if_icmpeq;
break;
case opc_if_icmpge:
newOpcode = opc_if_icmplt;
break;
case opc_if_icmpgt:
newOpcode = opc_if_icmple;
break;
case opc_if_icmple:
newOpcode = opc_if_icmpgt;
break;
case opc_if_icmplt:
newOpcode = opc_if_icmpge;
break;
case opc_if_acmpeq:
newOpcode = opc_if_acmpne;
break;
case opc_if_acmpne:
newOpcode = opc_if_acmpeq;
break;
case opc_ifnull:
newOpcode = opc_ifnonnull;
break;
case opc_ifnonnull:
newOpcode = opc_ifnull;
break;
default:
NSK_COMPLAIN1("unexpected opcode: %d\n", opcode);
break;
}
put_u1(newOpcode); /* write inverse branch */
put_u1(3 + 5); /* beyond if and goto_w */
put_u1(opc_goto_w); /* add a goto_w */
put_u4(map[pos + (jshort) get_u2()] - newPos);
} else {
NSK_COMPLAIN2("unexpected widening: %d, pos=0x%x\n",
widened, pos);
}
break;
}
case opc_tableswitch: {
u4 i, low, high;
put_u1(opcode);
/* skip old padding */
skip(((pos+4) & (~3)) - (pos+1));
/* write new padding */
put(zeroBytes, ((newPos+4) & (~3)) - (newPos+1));
put_u4(map[pos + get_u4()] - newPos);
low = copy_u4();
high = copy_u4();
for (i = low; i <= high; i++) {
put_u4(map[pos + get_u4()] - newPos);
}
break;
}
case opc_lookupswitch: {
u4 i, npairs;
put_u1(opcode);
/* skip old padding */
skip(((pos+4) & (~3)) - (pos+1));
/* write new padding */
put(zeroBytes, ((newPos+4) & (~3)) - (newPos+1));
put_u4(map[pos + get_u4()] - newPos);
npairs = copy_u4();
for (i = npairs; i > 0; i--) {
copy_u4();
put_u4(map[pos + get_u4()] - newPos);
}
break;
}
default:
put_u1(opcode);
copy(opcLengths[opcode] - 1);
break;
}
}
/* ========================================================================== */
/**
* Walk one instruction adjusting for insertions
*/
static int adjustInstruction() {
u4 pos = localPosition();
u4 newPos = map[pos];
u1 opcode = get_u1();
switch (opcode) {
case opc_wide:
skip(get_u1() == opc_iinc ? 4 : 2);
break;
case opc_jsr:
case opc_goto:
case opc_ifeq:
case opc_ifge:
case opc_ifgt:
case opc_ifle:
case opc_iflt:
case opc_ifne:
case opc_if_icmpeq:
case opc_if_icmpne:
case opc_if_icmpge:
case opc_if_icmpgt:
case opc_if_icmple:
case opc_if_icmplt:
case opc_if_acmpeq:
case opc_if_acmpne:
case opc_ifnull:
case opc_ifnonnull: {
jbyte widened = widening[pos];
if (widened == 0) { /* not yet widened */
jint delta = (jshort) get_u2();
u4 target = pos + delta;
u4 newTarget = map[target];
jint newDelta = newTarget - newPos;
if ((newDelta < -32768) || (newDelta > 32767)) {
if ((opcode == opc_jsr) || (opcode == opc_goto)) {
widen(pos, 2); /* will convert to wide */
} else {
widen(pos, 5); /* will inject goto_w */
}
return NSK_FALSE; /* cause restart */
}
}
break;
}
case opc_tableswitch: {
jbyte widened = widening[pos];
u4 low;
jbyte deltaPadding;
/* skip old padding and default */
skip(((pos+4) & (~3)) - (pos+1) + 4);
low = get_u4();
skip((get_u4() - low + 1) * 4);
deltaPadding = ((newPos+4) & (~3)) - newPos - ((pos+4) & (~3)) + pos;
if (widened != deltaPadding) {
widen(pos, deltaPadding);
return NSK_FALSE; /* cause restart */
}
break;
}
case opc_lookupswitch: {
jbyte widened = widening[pos];
jbyte deltaPadding;
/* skip old padding and default */
skip(((pos+4) & (~3)) - (pos+1) + 4);
skip(get_u4() * 8);
deltaPadding = ((newPos+4) & (~3)) - newPos - ((pos+4) & (~3)) + pos;
if (widened != deltaPadding) {
widen(pos, deltaPadding);
return NSK_FALSE; /* cause restart */
}
break;
}
default:
skip(opcLengths[opcode] - 1);
break;
}
return NSK_TRUE;
}
/* ========================================================================== */
/**
* Walk one instruction inserting instrumentation at specified instructions
*/
static void insertAtInstruction() {
u4 pos = localPosition();
u1 opcode = get_u1();
switch (opcode) {
case opc_wide:
/* no support for instrumenting wide instructions */
skip(get_u1() == opc_iinc ? 4 : 2);
break;
case opc_new:
case opc_newarray:
case opc_anewarray:
case opc_multianewarray:
skip(opcLengths[opcode] - 1);
injectBytes(localPosition(), 3);
break;
case opc_tableswitch:
/* skip 4-byte boundry padding and default */
skip(((pos+4) & (~3)) - (pos+1) + 4);
{
u4 low = get_u4();
skip((get_u4() - low + 1) * 4);
}
break;
case opc_lookupswitch:
/* skip 4-byte boundry padding and default */
skip(((pos+4) & (~3)) - (pos+1) + 4);
skip(get_u4() * 8);
break;
default:
skip(opcLengths[opcode] - 1);
break;
}
}
static void adjustOffsets() {
recallPosition();
if (mode == BCI_MODE_CALL) {
/* instrument calls - method entry */
injectBytes(0, 3);
}
if (mode == BCI_MODE_ALLOC) {
/* instrument allocations */
while (localPosition() < codeLength) {
insertAtInstruction();
}
recallPosition();
}
NSK_DISPLAY0("Searching for adjustments...\n");
while (localPosition() < codeLength) {
if (!adjustInstruction()) {
recallPosition();
NSK_DISPLAY0("Restarting adjustments after change...\n");
}
}
NSK_DISPLAY0("Writing new code...\n");
recallPosition();
if (mode == BCI_MODE_CALL) {
put(callBytes, 3);
}
while (localPosition() < codeLength) {
writeInstruction();
}
}
/* ========================================================================== */
static void copyAttr() {
u4 len;
copy(2);
len = copy_u4();
NSK_DISPLAY1("attr len: %d\n", len);
copy(len);
}
static void copyAttrs(u2 attrCount) {
u2 i;
for (i = attrCount; i > 0; i--) {
copyAttr();
}
}
static void copyFields() {
u2 count;
u2 attrCount;
u2 i;
count = copy_u2();
NSK_DISPLAY1("fields count: %d\n", count);
for (i = count; i > 0; i--) {
/* access, name, descriptor */
copy(2 + 2 + 2);
attrCount = copy_u2();
NSK_DISPLAY1("field attrCount: %d\n", attrCount);
copyAttrs(attrCount);
}
}
static void copyAttrForCode() {
u2 nameIndex = copy_u2();
/* check for Code attr */
if (nameIndex == lineNumberAttributeIndex) {
copyLineNumberAttr();
} else if (nameIndex == localVarAttributeIndex) {
copyLocalVarAttr();
} else if (nameIndex == localVarTypeAttributeIndex) {
copyLocalVarTypeAttr();
} else if (nameIndex == stackMapAttributeIndex) {
copyStackMapAttr();
} else {
u4 len = copy_u4();
NSK_DISPLAY1("code attr len: %d\n", len);
copy(len);
}
}
static void copyCodeAttr(char* name) {
u4 attrLengthPos;
u4 attrLength;
u4 newAttrLength;
u4 codeLengthPos;
u4 newCodeLength;
u2 attrCount;
u4 i;
attrLengthPos = generatedPosition();
attrLength = copy_u4();
NSK_DISPLAY2("Code attr found: %s, pos=0x%x\n", name,
inputPos - orig - 6);
/* max_stack, max_locals */
copy(2 + 2);
codeLengthPos = generatedPosition();
codeLength = copy_u4();
if (codeLength == 0) {
NSK_COMPLAIN0("code_length must be greater than zero\n");
return;
}
if (mode == BCI_MODE_EMCP) {
/* copy remainder minus already copied */
copy(attrLength - 8);
return;
}
markLocalPositionStart();
map = (u4*) malloc((codeLength + 1) * sizeof(u4));
for (i = 0; i <= codeLength; i++) {
map[i] = i;
}
widening = (jbyte*) malloc(codeLength + 1);
memset(widening, 0, codeLength + 1);
adjustOffsets();
/* fix up code length */
newCodeLength = generatedPosition() - (codeLengthPos + 4);
randomAccessWriteU4(codeLengthPos, newCodeLength);
NSK_DISPLAY2("code length old: %d, new: %d\n",
codeLength, newCodeLength);
copyExceptionTable();
attrCount = copy_u2();
for (i = attrCount; i > 0; i--) {
copyAttrForCode();
}
free(map);
free(widening);
/* fix up attr length */
newAttrLength = generatedPosition() - (attrLengthPos + 4);
randomAccessWriteU4(attrLengthPos, newAttrLength);
NSK_DISPLAY2("attr length old: %d, new: %d\n",
attrLength, newAttrLength);
}
static void copyAttrForMethod(char* name) {
u2 nameIndex;
nameIndex = copy_u2();
if (nameIndex == codeAttributeIndex) {
copyCodeAttr(name);
} else {
u4 len = copy_u4();
NSK_DISPLAY1("method attr len: %d\n", len);
copy(len);
}
}
static void copyMethod() {
u2 accessFlags;
u2 methodNameIdx;
char* name;
u2 attrCount;
u2 i;
accessFlags = copy_u2();
methodNameIdx = copy_u2();
name = constantPool[methodNameIdx];
/* descriptor */
copy(2);
attrCount = copy_u2();
NSK_DISPLAY1("method attrCount: %d\n", attrCount);
for (i = attrCount; i > 0; i--) {
copyAttrForMethod(name);
}
}
static void copyMethods() {
u2 count;
u2 i;
count = copy_u2();
NSK_DISPLAY1("methods count: %d\n", count);
for (i = count; i > 0; i--) {
copyMethod();
}
}
static u2 writeCPEntryUtf8(const char* str) {
u2 i;
u2 len = (u2) strlen(str);
put_u1(CONSTANT_Utf8);
put_u2(len);
for (i = 0; i < len; i++) {
put_u1(str[i]);
}
return constantPoolCount++;
}
static u2 writeCPEntryClass(u2 classNameIndex) {
put_u1(CONSTANT_Class);
put_u2(classNameIndex);
return constantPoolCount++;
}
static u2 writeCPEntryNameAndType(u2 nameIndex, u2 descrIndex) {
put_u1(CONSTANT_NameAndType);
put_u2(nameIndex);
put_u2(descrIndex);
return constantPoolCount++;
}
static u2 writeCPEntryMethodRef(u2 classIndex, u2 nameAndTypeIndex) {
put_u1(CONSTANT_Methodref);
put_u2(classIndex);
put_u2(nameAndTypeIndex);
return constantPoolCount++;
}
static u2 writeCPEntryFieldRef(u2 classIndex, u2 nameAndTypeIndex) {
put_u1(CONSTANT_Fieldref);
put_u2(classIndex);
put_u2(nameAndTypeIndex);
return constantPoolCount++;
}
static u2 addFieldToConstantPool(u2 classIndex, char* fieldName, char* descr) {
u2 fieldNameIndex = writeCPEntryUtf8(fieldName);
u2 descrIndex = writeCPEntryUtf8(descr);
u2 nameAndTypeIndex = writeCPEntryNameAndType(fieldNameIndex, descrIndex);
u2 fieldIndex = writeCPEntryFieldRef(classIndex, nameAndTypeIndex);
return fieldIndex;
}
static u2 addMethodToConstantPool(u2 classIndex, const char* methodName, const char* descr) {
u2 methodNameIndex = writeCPEntryUtf8(methodName);
u2 descrIndex = writeCPEntryUtf8(descr);
u2 nameAndTypeIndex = writeCPEntryNameAndType(methodNameIndex, descrIndex);
u2 methodIndex = writeCPEntryMethodRef(classIndex, nameAndTypeIndex);
return methodIndex;
}
static u2 addClassToConstantPool(const char* className) {
u2 classNameIndex = writeCPEntryUtf8(className);
u2 classIndex = writeCPEntryClass(classNameIndex);
return classIndex;
}
/* ========================================================================== */
int Inject(const u1* old_bytes, const jint old_length,
u1** new_bytes, jint* new_length, int bci_mode) {
u4 constantPoolCountPos;
u2 profiler;
u2 interfaceCount;
u2 attrCount;
//printf("inject\n");
NSK_DISPLAY3("Injecting bytecodes: mode=%d, bytes=0x%p, len=%d\n",
bci_mode, old_bytes, old_length);
mode = bci_mode;
orig = old_bytes;
inputPos = (u1*) orig;
endPos = orig + old_length;
gen = (u1*) malloc(old_length * GROWTH_FACTOR);
if (!NSK_VERIFY(gen != NULL)) {
NSK_COMPLAIN0("out of memory\n");
return NSK_FALSE;
}
genPos = gen;
/* magic + minor/major version */
copy(4 + 2 + 2);
constantPoolCountPos = generatedPosition();
constantPoolCount = copy_u2();
/* copy old constant pool */
if (!copyConstantPool(constantPoolCount)) {
return NSK_FALSE;
}
NSK_DISPLAY1("ConstantPool expanded from: %d\n", constantPoolCount);
profiler = addClassToConstantPool("nsk/share/jvmti/ProfileCollector");
if (mode == BCI_MODE_ALLOC) {
u2 allocTracker =
addMethodToConstantPool(profiler, "allocTracker", "()V");
allocBytes[1] = (u1) (allocTracker >> 8);
allocBytes[2] = (u1) (allocTracker & 0xFF);
}
if (mode == BCI_MODE_CALL) {
u2 callTracker =
addMethodToConstantPool(profiler, "callTracker", "()V");
callBytes[1] = (u1) (callTracker >> 8);
callBytes[2] = (u1) (callTracker & 0xFF);
}
/* access, this, super */
copy(2 + 2 + 2);
interfaceCount = copy_u2();
NSK_DISPLAY1("interfaceCount: %d\n", interfaceCount);
copy(interfaceCount * 2);
copyFields();
copyMethods();
attrCount = copy_u2();
NSK_DISPLAY1("class attrCount: %d\n", attrCount);
copyAttrs(attrCount);
randomAccessWriteU2(constantPoolCountPos, constantPoolCount);
NSK_DISPLAY1("New constant pool size: %d\n", constantPoolCount);
*new_length = (jint) (genPos - gen);
*new_bytes = (u1*) realloc(gen, *new_length);
freeConstantPool();
return NSK_TRUE;
}
/* ========================================================================== */
}