Skip to content

Commit e507405

Browse files
author
Serguei Spitsyn
committedApr 23, 2020
8241214: Test debugging of hidden classes using jdb
Add test and enable jdb support for hidden classes Reviewed-by: cjplummer, amenkov, mchung, lmesnik
·
JEP-429-branchpoint
1 parent 8d38838 commit e507405

File tree

3 files changed

+530
-1
lines changed

3 files changed

+530
-1
lines changed
 

‎src/jdk.jdi/share/classes/com/sun/tools/example/debug/tty/PatternReferenceTypeSpec.java

+31-1
Original file line numberDiff line numberDiff line change
@@ -1,5 +1,5 @@
11
/*
2-
* Copyright (c) 1998, 2011, Oracle and/or its affiliates. All rights reserved.
2+
* Copyright (c) 1998, 2020, Oracle and/or its affiliates. All rights reserved.
33
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
44
*
55
* This code is free software; you can redistribute it and/or modify it
@@ -101,6 +101,28 @@ public boolean equals(Object obj) {
101101
}
102102

103103
private void checkClassName(String className) throws ClassNotFoundException {
104+
int slashIdx = className.indexOf("/");
105+
106+
// Slash is present in hidden class names only. It looks like p.Foo/0x1234.
107+
if (slashIdx != -1) {
108+
// A hidden class name is ending with a slash following by a suffix.
109+
int lastSlashIdx = className.lastIndexOf("/");
110+
int lastDotIdx = className.lastIndexOf(".");
111+
112+
// There must be just one slash with a following suffix but no dots.
113+
if (slashIdx != lastSlashIdx || lastDotIdx > slashIdx || slashIdx + 1 == className.length()) {
114+
throw new ClassNotFoundException();
115+
}
116+
// Check prefix and suffix separately.
117+
String[] parts = className.split("/");
118+
assert parts.length == 2;
119+
className = parts[0];
120+
String hcSuffix = parts[1];
121+
if (!isUnqualifiedName(hcSuffix)) {
122+
throw new ClassNotFoundException();
123+
}
124+
}
125+
104126
// Do stricter checking of class name validity on deferred
105127
// because if the name is invalid, it will
106128
// never match a future loaded class, and we'll be silent
@@ -118,6 +140,14 @@ private void checkClassName(String className) throws ClassNotFoundException {
118140
}
119141
}
120142

143+
private boolean isUnqualifiedName(String s) {
144+
if (s.length() == 0) {
145+
return false;
146+
}
147+
// unqualified names should have no characters: ".;/["
148+
return !s.matches("[.;/\091]*"); // \091 is '['
149+
}
150+
121151
private boolean isJavaIdentifier(String s) {
122152
if (s.length() == 0) {
123153
return false;

‎test/hotspot/jtreg/vmTestbase/nsk/jdb/hidden_class/hc001/hc001.java

+357
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,357 @@
1+
/*
2+
* Copyright (c) 2020, Oracle and/or its affiliates. All rights reserved.
3+
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4+
*
5+
* This code is free software; you can redistribute it and/or modify it
6+
* under the terms of the GNU General Public License version 2 only, as
7+
* published by the Free Software Foundation.
8+
*
9+
* This code is distributed in the hope that it will be useful, but WITHOUT
10+
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
11+
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
12+
* version 2 for more details (a copy is included in the LICENSE file that
13+
* accompanied this code).
14+
*
15+
* You should have received a copy of the GNU General Public License version
16+
* 2 along with this work; if not, write to the Free Software Foundation,
17+
* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
18+
*
19+
* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
20+
* or visit www.oracle.com if you need additional information or have any
21+
* questions.
22+
*/
23+
24+
/*
25+
* @test
26+
* @summary JDB test for hidden classes
27+
*
28+
* @library /vmTestbase
29+
* /test/lib
30+
* @modules jdk.jdi
31+
* jdk.jdwp.agent
32+
* @run driver jdk.test.lib.FileInstaller . .
33+
* @build nsk.jdb.hidden_class.hc001.hc001
34+
* nsk.jdb.hidden_class.hc001.hc001a
35+
*
36+
* @run main/othervm PropertyResolvingWrapper nsk.jdb.hidden_class.hc001.hc001
37+
* -arch=${os.family}-${os.simpleArch}
38+
* -waittime=5
39+
* -debugee.vmkind=java
40+
* -transport.address=dynamic
41+
* -jdb=${test.jdk}/bin/jdb
42+
* -java.options="${test.vm.opts} ${test.java.opts}"
43+
* -workdir=.
44+
* -debugee.vmkeys="${test.vm.opts} ${test.java.opts}"
45+
*/
46+
47+
package nsk.jdb.hidden_class.hc001;
48+
49+
import java.io.*;
50+
import java.util.*;
51+
import nsk.share.*;
52+
import nsk.share.jdb.*;
53+
54+
public class hc001 extends JdbTest {
55+
static final String DEBUGGEE_CLASS = hc001a.class.getTypeName();
56+
static final String HC_NAME_FIELD = DEBUGGEE_CLASS + ".hcName";
57+
static final String MAIN_METHOD_NAME = DEBUGGEE_CLASS + ".main";
58+
static final String EMPTY_METHOD_NAME = DEBUGGEE_CLASS + ".emptyMethod";
59+
static final String HC_METHOD_NAME = "hcMethod";
60+
static final String HC_FIELD_NAME = "hcField";
61+
static final int MAX_SLEEP_CNT = 3;
62+
63+
public static void main(String argv[]) {
64+
System.exit(run(argv, System.out) + JCK_STATUS_BASE);
65+
}
66+
67+
public static int run(String argv[], PrintStream out) {
68+
debuggeeClass = DEBUGGEE_CLASS; // needed for JdbTest.runTest
69+
firstBreak = MAIN_METHOD_NAME; // needed for JdbTest.runTest
70+
return new hc001().runTest(argv, out);
71+
}
72+
73+
static boolean checkPattern(String[] arr, String pattern) {
74+
for (int idx = 0; idx < arr.length; idx++) {
75+
String str = arr[idx];
76+
if (str.indexOf(pattern) != -1) {
77+
return true;
78+
}
79+
}
80+
return false;
81+
}
82+
83+
static void throwFailure(String msg) throws Failure {
84+
throw new Failure(msg);
85+
}
86+
87+
/* Make a required cooperated setup with the debuggee:
88+
* - transition the debuggee's execution to expected execution point
89+
* (emptyMethod start) at which hidden class has been already loaded
90+
* - get the hidden class name from the debuggee
91+
* Return the hidden class name.
92+
*/
93+
private String runPrologue() {
94+
String[] reply = null;
95+
96+
log.println("\n### Debugger: runPrologue");
97+
98+
// uncomment this line to enable verbose output from jdb
99+
// log.enableVerbose(true);
100+
101+
// run jdb command "stop in"
102+
jdb.setBreakpointInMethod(EMPTY_METHOD_NAME);
103+
log.println("\nDebugger: breakpoint is set at:\n\t" + EMPTY_METHOD_NAME);
104+
105+
// run jdb command "cont"
106+
reply = jdb.receiveReplyFor(JdbCommand.cont);
107+
if (!jdb.isAtBreakpoint(reply, EMPTY_METHOD_NAME)) {
108+
throwFailure("Debugger: Missed breakpoint at:\n\t" + EMPTY_METHOD_NAME);
109+
}
110+
log.println("\nDebugger: breakpoint is hit at:\n\t" + EMPTY_METHOD_NAME);
111+
112+
// run jdb command "eval" for hidden class field HC_NAME_FIELD
113+
reply = jdb.receiveReplyFor(JdbCommand.eval + HC_NAME_FIELD);
114+
int beg = reply[0].indexOf('"') + 1;
115+
int end = reply[0].lastIndexOf('"');
116+
if (end == -1 || beg > end) {
117+
log.println("\nDebugger: the jdb command:\n\t" + JdbCommand.eval + HC_NAME_FIELD);
118+
log.println("\treturned bad reply:\n\t" + reply[0]);
119+
throwFailure("Debugger: failed to evaluate debuggee field:\n\t" + HC_NAME_FIELD);
120+
}
121+
String hiddenClassName = reply[0].substring(beg, end); // we know the hidden class name now
122+
log.println("\nDebugger: jdb command eval returned hidden class name:\n\t" + hiddenClassName);
123+
124+
return hiddenClassName;
125+
}
126+
127+
/* Test jdb commands "classes" and "class" for hidden class. */
128+
private void testClassCommands(String hcName) {
129+
String[] reply = null;
130+
131+
log.println("\n### Debugger: testClassCommands");
132+
133+
// run jdb command "classes"
134+
reply = jdb.receiveReplyFor(JdbCommand.classes);
135+
if (!checkPattern(reply, hcName)) {
136+
throwFailure("Debugger: expected jdb command classes to list hidden class:\n\t" + hcName);
137+
}
138+
log.println("\nDebugger: found matched class in jdb command classes reply:\n\t" + hcName);
139+
140+
// run jdb command "class" for hidden class
141+
reply = jdb.receiveReplyFor(JdbCommand._class + hcName);
142+
if (!checkPattern(reply, hcName)) {
143+
throwFailure("Debugger: expected hiddenclass name in jdb command class reply: " + hcName);
144+
}
145+
log.println("\nDebugger: found matched class in jdb command class reply:\n\t" + hcName);
146+
}
147+
148+
/* Transition the debuggee's execution to the hidden class method start. */
149+
private void stopInHiddenClassMethod(String hcName) {
150+
String hcMethodName = hcName + "." + HC_METHOD_NAME;
151+
String[] reply = null;
152+
153+
log.println("\n### Debugger: stopInHiddenClassMethod");
154+
155+
// set a breakpoint in hidden class method hcMethodName()
156+
jdb.setBreakpointInMethod(hcMethodName);
157+
log.println("\nDebugger: breakpoint is set at:\n\t" + hcMethodName);
158+
159+
// run jdb command "clear": should list breakpoint in hcMethodName
160+
reply = jdb.receiveReplyFor(JdbCommand.clear);
161+
if (!checkPattern(reply, hcMethodName)) {
162+
throwFailure("Debugger: expected jdb clear command to list breakpoint: " + hcMethodName);
163+
}
164+
log.println("\nDebugger: jdb command clear lists breakpoint at:\n\t" + hcMethodName);
165+
166+
// run jdb command "cont"
167+
jdb.receiveReplyFor(JdbCommand.cont);
168+
log.println("\nDebugger: executed jdb command cont");
169+
}
170+
171+
/* Test the jdb commands "up" and "where" for hidden class. */
172+
private void testUpWhereCommands(String hcName) {
173+
String hcMethodName = hcName + "." + HC_METHOD_NAME;
174+
String[] reply = null;
175+
176+
log.println("\n### Debugger: testUpWhereCommands");
177+
178+
// run jdb command "where": should list hcMethodName frame
179+
reply = jdb.receiveReplyFor(JdbCommand.where);
180+
if (!checkPattern(reply, hcMethodName)) {
181+
throwFailure("Debugger: jdb command where does not show expected frame: " + hcMethodName);
182+
}
183+
log.println("\nDebugger: jdb command where showed expected frame:\n\t" + hcMethodName);
184+
185+
// run jdb command "up"
186+
jdb.receiveReplyFor(JdbCommand.up);
187+
log.println("\nDebugger: executed jdb command up");
188+
189+
// run jdb command "where": should not list hcMethodName frame
190+
reply = jdb.receiveReplyFor(JdbCommand.where);
191+
if (checkPattern(reply, hcMethodName)) {
192+
throwFailure("Debugger: jdb command where showed unexpected frame: " + hcMethodName);
193+
}
194+
log.println("\nDebugger: jdb command where does not show unexpected frame:\n\t" + hcMethodName);
195+
}
196+
197+
/* Test the jdb commands "down" and "where" for hidden class. */
198+
private void testDownWhereCommands(String hcName) {
199+
String hcMethodName = hcName + "." + HC_METHOD_NAME;
200+
String[] reply = null;
201+
202+
log.println("\n### Debugger: testDownWhereCommands");
203+
204+
// run jdb command "down"
205+
jdb.receiveReplyFor(JdbCommand.down);
206+
log.println("\nDebugger: executed jdb command down");
207+
208+
// run jdb command "where": should list hcMethodName frame again
209+
reply = jdb.receiveReplyFor(JdbCommand.where);
210+
if (!checkPattern(reply, hcMethodName)) {
211+
throwFailure("Debugger: jdb command where does not show expected frame: " + hcMethodName);
212+
}
213+
log.println("\nDebugger: jdb command where showed expected frame:\n\t" + hcMethodName);
214+
}
215+
216+
/* Test the jdb commands "fields" and "methods" for hidden class. */
217+
private void testFieldsMethods(String hcName) {
218+
String[] reply = null;
219+
220+
log.println("\n### Debugger: testFieldsMethods");
221+
222+
// run jdb command "methods" for hidden class
223+
reply = jdb.receiveReplyFor(JdbCommand.methods + hcName);
224+
if (!checkPattern(reply, hcName)) {
225+
throwFailure("Debugger: no expected hidden class name in its methods: " + hcName);
226+
}
227+
log.println("\nDebugger: jdb command \"methods\" showed expected method:\n\t" + HC_METHOD_NAME);
228+
229+
// run jdb command "fields" for hidden class
230+
reply = jdb.receiveReplyFor(JdbCommand.fields + hcName);
231+
if (!checkPattern(reply, HC_FIELD_NAME)) {
232+
throwFailure("Debugger: no expected hidden class field in its fields: " + HC_FIELD_NAME);
233+
}
234+
log.println("\nDebugger: jdb command \"fields\" showed expected field:\n\t" + HC_FIELD_NAME);
235+
}
236+
237+
/* Test the jdb commands "watch" and "unwatch" for hidden class. */
238+
private void testWatchCommands(String hcName) {
239+
String hcFieldName = hcName + "." + HC_FIELD_NAME;
240+
String[] reply = null;
241+
242+
log.println("\n### Debugger: testWatchCommands");
243+
244+
// run jdb command "watch" for hidden class field HC_FIELD_NAME
245+
reply = jdb.receiveReplyFor(JdbCommand.watch + hcFieldName);
246+
if (!checkPattern(reply, HC_FIELD_NAME)) {
247+
throwFailure("Debugger: was not able to set watch point: " + hcFieldName);
248+
}
249+
log.println("\nDebugger: jdb command \"watch\" added expected field to watch:\n\t" + hcFieldName);
250+
251+
// run jdb command "cont"
252+
jdb.receiveReplyFor(JdbCommand.cont);
253+
jdb.receiveReplyFor(JdbCommand.next);
254+
255+
// run jdb command "unwatch" for hidden class field HC_FIELD_NAME
256+
reply = jdb.receiveReplyFor(JdbCommand.unwatch + hcFieldName);
257+
if (!checkPattern(reply, HC_FIELD_NAME)) {
258+
throwFailure("Debugger: expect field name in unwatch reply: " + hcFieldName);
259+
}
260+
log.println("\nDebugger: jdb command \"unwatch\" removed expected field from watch:\n\t" + hcFieldName);
261+
}
262+
263+
/* Test the jdb commands "eval", "print" and "dump" for hidden class. */
264+
private void testEvalCommands(String hcName) {
265+
String hcFieldName = hcName + "." + HC_FIELD_NAME;
266+
String[] reply = null;
267+
268+
log.println("\n### Debugger: testEvalCommands");
269+
270+
// run jdb command "eval" for hidden class field HC_FIELD_NAME
271+
reply = jdb.receiveReplyFor(JdbCommand.eval + hcFieldName);
272+
if (!checkPattern(reply, hcFieldName)) {
273+
throwFailure("Debugger: expected field name in jdb command eval field reply: " + hcFieldName);
274+
}
275+
log.println("\nDebugger: jdb command \"eval\" showed expected hidden class field name:\n\t" + hcFieldName);
276+
277+
// run jdb command "print" for hidden class field HC_FIELD_NAME
278+
reply = jdb.receiveReplyFor(JdbCommand.print + hcFieldName);
279+
if (!checkPattern(reply, hcFieldName)) {
280+
throwFailure("Debugger: expected field name in jdb command print field reply: " + hcFieldName);
281+
}
282+
log.println("\nDebugger: jdb command \"print\" showed expected hidden class field name:\n\t" + hcFieldName);
283+
284+
// execute jdb command "dump" for hidden class field HC_FIELD_NAME
285+
reply = jdb.receiveReplyFor(JdbCommand.dump + hcFieldName);
286+
if (!checkPattern(reply, hcFieldName)) {
287+
throwFailure("Debugger: expected field name in jdb command dump field reply: " + hcFieldName);
288+
}
289+
log.println("\nDebugger: jdb command \"dump\" showed expected hidden class field name:\n\t" + hcFieldName);
290+
}
291+
292+
/* Test the jdb command "watch" with an invalid class name. */
293+
private void testInvWatchCommand(String hcName) {
294+
String hcFieldName = hcName + "." + HC_FIELD_NAME;
295+
String MsgBase = "\nDebugger: jdb command \"watch\" with invalid field " + hcFieldName;
296+
String[] reply = null;
297+
298+
// run jdb command "watch" with an invalid class name
299+
reply = jdb.receiveReplyFor(JdbCommand.watch + hcFieldName);
300+
if (checkPattern(reply, "Deferring watch modification")) {
301+
throwFailure(MsgBase + " must not set deferred watch point");
302+
}
303+
log.println(MsgBase + " did not set deferred watch point");
304+
}
305+
306+
/* Test the jdb command "eval" with an invalid class name. */
307+
private void testInvEvalCommand(String hcName) {
308+
String hcFieldName = hcName + "." + HC_FIELD_NAME;
309+
String MsgBase = "\nDebugger: jdb command \"eval\" with invalid field " + hcFieldName;
310+
String[] reply = null;
311+
312+
// run jdb command "eval" with an invalid class name
313+
reply = jdb.receiveReplyFor(JdbCommand.eval + hcFieldName);
314+
if (!checkPattern(reply, "ParseException")) {
315+
throwFailure(MsgBase + " must be rejected with ParseException");
316+
}
317+
log.println(MsgBase + " was rejected with ParseException");
318+
}
319+
320+
/* Test the jdb commands "watch" and "eval" with various invalid class names. */
321+
private void testInvalidCommands() {
322+
String className = null;
323+
String[] invClassNames = {
324+
"xx.yyy/0x111/0x222",
325+
"xx./0x111.0x222",
326+
"xx.yyy.zzz/"
327+
};
328+
329+
log.println("\n### Debugger: testInvalidCommands");
330+
331+
// run jdb commands "watch" and "eval" with invalid class names
332+
for (int idx = 0; idx < invClassNames.length; idx++) {
333+
className = invClassNames[idx];
334+
testInvWatchCommand(className + "." + HC_FIELD_NAME);
335+
testInvEvalCommand(className + "." + HC_FIELD_NAME);
336+
}
337+
}
338+
339+
/* Main testing method. */
340+
protected void runCases() {
341+
String hcName = runPrologue();
342+
343+
testClassCommands(hcName);
344+
stopInHiddenClassMethod(hcName);
345+
346+
testUpWhereCommands(hcName);
347+
testDownWhereCommands(hcName);
348+
349+
testFieldsMethods(hcName);
350+
testWatchCommands(hcName);
351+
352+
testEvalCommands(hcName);
353+
testInvalidCommands();
354+
355+
jdb.contToExit(1);
356+
}
357+
}

‎test/hotspot/jtreg/vmTestbase/nsk/jdb/hidden_class/hc001/hc001a.java

+142
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,142 @@
1+
/*
2+
* Copyright (c) 2020, Oracle and/or its affiliates. All rights reserved.
3+
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4+
*
5+
* This code is free software; you can redistribute it and/or modify it
6+
* under the terms of the GNU General Public License version 2 only, as
7+
* published by the Free Software Foundation.
8+
*
9+
* This code is distributed in the hope that it will be useful, but WITHOUT
10+
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
11+
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
12+
* version 2 for more details (a copy is included in the LICENSE file that
13+
* accompanied this code).
14+
*
15+
* You should have received a copy of the GNU General Public License version
16+
* 2 along with this work; if not, write to the Free Software Foundation,
17+
* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
18+
*
19+
* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
20+
* or visit www.oracle.com if you need additional information or have any
21+
* questions.
22+
*/
23+
24+
package nsk.jdb.hidden_class.hc001;
25+
26+
import java.io.File;
27+
import java.io.PrintStream;
28+
import java.lang.invoke.MethodHandles;
29+
import java.lang.invoke.MethodHandles.Lookup;
30+
import java.nio.file.Files;
31+
import java.nio.file.Paths;
32+
33+
import nsk.share.jdb.*;
34+
35+
/* Interface for tested hidden class to implement. */
36+
interface HCInterf {
37+
void hcMethod();
38+
}
39+
40+
/* Hidden class definition used to define tested hidden class
41+
* with lookup.defineHiddenClass. */
42+
class HiddenClass implements HCInterf {
43+
static String hcField = null;
44+
45+
private String getClassName() {
46+
return this.getClass().getName();
47+
}
48+
49+
public void hcMethod() {
50+
hcField = getClassName();
51+
if (hcField.indexOf("HiddenClass") == -1) {
52+
throw new RuntimeException("Debuggee: Unexpected HiddenClass name: " + hcField);
53+
}
54+
}
55+
}
56+
57+
/* This is debuggee aplication */
58+
public class hc001a {
59+
static PrintStream log = null;
60+
static void logMsg(String msg) { log.println(msg); log.flush(); }
61+
62+
static final String JAVA_CP = System.getProperty("java.class.path");
63+
static final String HC_NAME = HiddenClass.class.getName().replace(".", File.separator) + ".class";
64+
static final String HC_PATH = getClassPath(HiddenClass.class);
65+
static String hcName = null; // the debugger gets value of this field
66+
67+
static String getClassPath(Class<?> klass) {
68+
String classPath = klass.getTypeName().replace(".", File.separator) + ".class";
69+
for (String path: JAVA_CP.split(File.pathSeparator)) {
70+
String fullClassPath = path + File.separator + classPath;
71+
if (new File(fullClassPath).exists()) {
72+
return fullClassPath;
73+
}
74+
}
75+
throw new RuntimeException("class path for " + klass.getName() + " not found");
76+
}
77+
78+
public static void main(String args[]) throws Exception {
79+
// The Jdb framework uses stdout for commands reply,
80+
// so it is not usable for normal logging.
81+
// Use a separate log file for debuggee located in JTwork/scratch.
82+
log = new PrintStream("Debuggee.log");
83+
84+
hc001a testApp = new hc001a();
85+
int status = testApp.runIt(args);
86+
System.exit(hc001.JCK_STATUS_BASE + status);
87+
}
88+
89+
// This method is to hit a breakpoint at expected execution point.
90+
void emptyMethod() {}
91+
92+
public int runIt(String args[]) throws Exception {
93+
JdbArgumentHandler argumentHandler = new JdbArgumentHandler(args);
94+
95+
logMsg("Debuggee: runIt: started");
96+
logMsg("Debuggee: JAVA_CP: " + JAVA_CP);
97+
logMsg("Debuggee: HC_NAME: " + HC_NAME);
98+
logMsg("Debuggee: HC_PATH: " + HC_PATH);
99+
100+
// Define tested hidden class.
101+
Class<?> hc = defineHiddenClass(HC_PATH);
102+
103+
// A hidden class name has an unpredictable suffix at the end,
104+
// and so, can not be hard coded and known to debugger in advance.
105+
// Store the hidden class name in field, so the debugger can read it from there.
106+
hcName = hc.getName();
107+
logMsg("Debuggee: Defined HiddenClass: " + hcName);
108+
109+
// It is impossible to use a hidden class name to define a variable,
110+
// so we use the interface which the tested hidden class implements.
111+
HCInterf hcObj = (HCInterf)hc.newInstance();
112+
logMsg("Debuggee: created an instance of a hidden class: " + hcName);
113+
114+
// It is for debuuger to set a breakpoint at a well known execution point.
115+
logMsg("Debuggee: invoking emptyMethod to hit expected breakpoint");
116+
emptyMethod();
117+
118+
// Invoke a hidden class method.
119+
logMsg("Debuggee: invoking a method of a hidden class: " + hcName);
120+
hcObj.hcMethod();
121+
122+
logMsg("Debuggee: runIt finished");
123+
return hc001.PASSED;
124+
}
125+
126+
static Class<?> defineHiddenClass(String classFileName) throws Exception {
127+
try {
128+
Lookup lookup = MethodHandles.lookup();
129+
byte[] bytes = Files.readAllBytes(Paths.get(classFileName));
130+
// The class name from class file is a normal binary name but the
131+
// defineHiddenClass appends a suffix "/<unqualified-name>" to it,
132+
// so it is not a valid binary name anymore.
133+
Class<?> hc = lookup.defineHiddenClass(bytes, false).lookupClass();
134+
return hc;
135+
} catch (Exception ex) {
136+
logMsg("Debuggee: defineHiddenClass: caught Exception " + ex.getMessage());
137+
ex.printStackTrace(log);
138+
log.flush();
139+
throw ex;
140+
}
141+
}
142+
}

0 commit comments

Comments
 (0)
Please sign in to comment.