1 /*
2 * Copyright (c) 2004, 2012, 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 package sun.jvm.hotspot.utilities.soql;
26
27 import java.io.*;
28 import java.util.*;
29 import javax.script.Invocable;
30 import javax.script.ScriptContext;
31 import javax.script.ScriptEngine;
32 import javax.script.ScriptEngineManager;
33 import javax.script.ScriptException;
34 import sun.jvm.hotspot.debugger.*;
35 import sun.jvm.hotspot.oops.*;
36 import sun.jvm.hotspot.runtime.*;
37 import sun.jvm.hotspot.utilities.*;
38 import sun.jvm.hotspot.tools.*;
39 import sun.jvm.hotspot.tools.jcore.*;
40 import java.lang.reflect.Method;
41 import java.lang.reflect.Modifier;
42
43 /**
44 * Simple wrapper around jsr-223 JavaScript script engine.
45 * In addition to wrapping useful functionality of jsr-223 engine,
46 * this class exposed certain "global" functions to the script.
47 */
48 public abstract class JSJavaScriptEngine extends MapScriptObject {
49 /**
50 * Start a read-eval-print loop with this engine.
51 */
52 public void startConsole() {
53 start(true);
54 }
55
56 /**
57 * Initialize the engine so that we can "eval" strings
58 * and files later.
59 */
60 public void start() {
61 start(false);
62 }
63
64 /**
65 * Define a global function that invokes given Method.
66 */
67 public void defineFunction(Object target, Method method) {
68 putFunction(target, method, false);
69 }
70
71 /**
72 * Call the script function of given name passing the
73 * given arguments.
74 */
75 public Object call(String name, Object[] args) {
76 Invocable invocable = (Invocable)engine;
77 try {
78 return invocable.invokeFunction(name, args);
79 } catch (RuntimeException re) {
80 throw re;
81 } catch (Exception exp) {
82 throw new RuntimeException(exp);
83 }
84 }
85
86 /**
87 address function returns address of JSJavaObject as String. For other
88 type of objects, the result is undefined.
89 */
90 public Object address(Object[] args) {
91 if (args.length != 1) return UNDEFINED;
92 Object o = args[0];
93 if (o != null && o instanceof JSJavaObject) {
94 return ((JSJavaObject)o).getOop().getHandle().toString();
95 } else {
96 return UNDEFINED;
97 }
98 }
99
100
101 /**
102 classof function gets type of given JSJavaInstance or JSJavaArray. Or
103 given a string class name, this function gets the class object. For
104 other type of objects, the result is undefined.
105 */
106 public Object classof(Object[] args) {
107 if (args.length != 1) {
108 return UNDEFINED;
109 }
110 Object o = args[0];
111 if (o != null) {
112 if (o instanceof JSJavaObject) {
113 if (o instanceof JSJavaInstance) {
114 return ((JSJavaInstance)o).getJSJavaClass();
115 } else if (o instanceof JSJavaArray) {
116 return ((JSJavaArray)o).getJSJavaClass();
117 } else {
118 return UNDEFINED;
119 }
120 } else if (o instanceof String) {
121 InstanceKlass ik = SystemDictionaryHelper.findInstanceKlass((String) o);
122 return getJSJavaFactory().newJSJavaKlass(ik).getJSJavaClass();
123 } else {
124 return UNDEFINED;
125 }
126 } else {
127 return UNDEFINED;
128 }
129 }
130
131 /**
132 * dumpClass function creates a .class file for a given Class object.
133 * On success, returns true. Else, returns false. Second optional argument
134 * specifies the directory in which .class content is dumped. This defaults
135 * to '.'
136 */
137 public Object dumpClass(Object[] args) {
138 if (args.length == 0) {
139 return Boolean.FALSE;
140 }
141 Object clazz = args[0];
142 if (clazz == null) {
143 return Boolean.FALSE;
144 }
145 InstanceKlass ik = null;
146 if (clazz instanceof String) {
147 String name = (String) clazz;
148 if (name.startsWith("0x")) {
149 // treat it as address
150 VM vm = VM.getVM();
151 Address addr = vm.getDebugger().parseAddress(name);
152 Metadata metadata = Metadata.instantiateWrapperFor(addr.addOffsetTo(0));
153 if (metadata instanceof InstanceKlass) {
154 ik = (InstanceKlass) metadata;
155 } else {
156 return Boolean.FALSE;
157 }
158 } else {
159 ik = SystemDictionaryHelper.findInstanceKlass((String) clazz);
160 }
161 } else if (clazz instanceof JSJavaClass) {
162 JSJavaKlass jk = ((JSJavaClass)clazz).getJSJavaKlass();
163 if (jk != null && jk instanceof JSJavaInstanceKlass) {
164 ik = ((JSJavaInstanceKlass)jk).getInstanceKlass();
165 }
166 } else {
167 return Boolean.FALSE;
168 }
169
170 if (ik == null) return Boolean.FALSE;
171 StringBuffer buf = new StringBuffer();
172 if (args.length > 1) {
173 buf.append(args[1].toString());
174 } else {
175 buf.append('.');
176 }
177
178 buf.append(File.separatorChar);
179 buf.append(ik.getName().asString().replace('/', File.separatorChar));
180 buf.append(".class");
181 String fileName = buf.toString();
182 File file = new File(fileName);
183
184 try {
185 int index = fileName.lastIndexOf(File.separatorChar);
186 File dir = new File(fileName.substring(0, index));
187 dir.mkdirs();
188 FileOutputStream fos = new FileOutputStream(file);
189 ClassWriter cw = new ClassWriter(ik, fos);
190 cw.write();
191 fos.close();
192 } catch (IOException exp) {
193 printError(exp.toString(), exp);
194 return Boolean.FALSE;
195 }
196
197 return Boolean.TRUE;
198 }
199
200 /**
201 * dumpHeap function creates a heap dump file.
202 * On success, returns true. Else, returns false.
203 */
204 public Object dumpHeap(Object[] args) {
205 String fileName = "heap.bin";
206 if (args.length > 0) {
207 fileName = args[0].toString();
208 }
209 return new JMap().writeHeapHprofBin(fileName)? Boolean.TRUE: Boolean.FALSE;
210 }
211
212 /**
213 help function prints help message for global functions and variables.
214 */
215 public void help(Object[] args) {
216 println("Function/Variable Description");
217 println("================= ===========");
218 println("address(jobject) returns the address of the Java object");
219 println("classof(jobject) returns the class object of the Java object");
220 println("dumpClass(jclass,[dir]) writes .class for the given Java Class");
221 println("dumpHeap([file]) writes heap in hprof binary format");
222 println("help() prints this help message");
223 println("identityHash(jobject) returns the hashCode of the Java object");
224 println("mirror(jobject) returns a local mirror of the Java object");
225 println("load([file1, file2,...]) loads JavaScript file(s). With no files, reads <stdin>");
226 println("object(string) converts a string address into Java object");
227 println("owner(jobject) returns the owner thread of this monitor or null");
228 println("sizeof(jobject) returns the size of Java object in bytes");
229 println("staticof(jclass, field) returns a static field of the given Java class");
230 println("read([prompt]) reads a single line from standard input");
231 println("quit() quits the interactive load call");
232 println("jvm the target jvm that is being debugged");
233 }
234
235 /**
236 identityHash function gets identity hash code value of given
237 JSJavaObject. For other type of objects, the result is undefined.
238 */
239 public Object identityHash(Object[] args) {
240 if (args.length != 1) return UNDEFINED;
241 Object o = args[0];
242 if (o != null && o instanceof JSJavaObject) {
243 return new Long(((JSJavaObject)o).getOop().identityHash());
244 } else {
245 return UNDEFINED;
246 }
247 }
248
249
250 /**
251 * Load and execute a set of JavaScript source files.
252 * This method is defined as a JavaScript function.
253 */
254 public void load(Object[] args) {
255 for (int i = 0; i < args.length; i++) {
256 processSource(args[i].toString());
257 }
258 }
259
260 /**
261 mirror function creats local copy of the Oop wrapper supplied.
262 if mirror can not be created, return undefined. For other types,
263 mirror is undefined.
264 */
265 public Object mirror(Object[] args) {
266 Object o = args[0];
267 Object res = UNDEFINED;
268 if (o != null) {
269 if (o instanceof JSJavaObject) {
270 Oop oop = ((JSJavaObject)o).getOop();
271 try {
272 res = getObjectReader().readObject(oop);
273 } catch (Exception e) {
274 if (debug) e.printStackTrace(getErrorStream());
275 }
276 } else if (o instanceof JSMetadata) {
277 Metadata metadata = ((JSMetadata)o).getMetadata();
278 try {
279 if (metadata instanceof InstanceKlass) {
280 res = getObjectReader().readClass((InstanceKlass) metadata);
281 }
282 } catch (Exception e) {
283 if (debug) e.printStackTrace(getErrorStream());
284 }
285 }
286 }
287 return res;
288 }
289
290 /**
291 owner function gets owning thread of given JSJavaObjec, if any, else
292 returns null. For other type of objects, the result is undefined.
293 */
294 public Object owner(Object[] args) {
295 Object o = args[0];
296 if (o != null && o instanceof JSJavaObject) {
297 return getOwningThread((JSJavaObject)o);
298 } else {
299 return UNDEFINED;
300 }
301 }
302
303 /**
304 object function takes a string address and returns a JSJavaObject.
305 For other type of objects, the result is undefined.
306 */
307 public Object object(Object[] args) {
308 Object o = args[0];
309 if (o != null && o instanceof String) {
310 VM vm = VM.getVM();
311 Address addr = vm.getDebugger().parseAddress((String)o);
312 Oop oop = vm.getObjectHeap().newOop(addr.addOffsetToAsOopHandle(0));
313 return getJSJavaFactory().newJSJavaObject(oop);
314 } else {
315 return UNDEFINED;
316 }
317 }
318
319 /**
320 sizeof function returns size of a Java object in bytes. For other type
321 of objects, the result is undefined.
322 */
323 public Object sizeof(Object[] args) {
324 if (args.length != 1) return UNDEFINED;
325 Object o = args[0];
326 if (o != null && o instanceof JSJavaObject) {
327 return new Long(((JSJavaObject)o).getOop().getObjectSize());
328 } else {
329 return UNDEFINED;
330 }
331 }
332
333 /**
334 staticof function gets static field of given class. Both class and
335 field name are specified as strings. undefined is returned if there is
336 no such named field.
337 */
338 public Object staticof(Object[] args) {
339 Object classname = args[0];
340 Object fieldname = args[1];
341 if (fieldname == null || classname == null ||
342 !(fieldname instanceof String)) {
343 return UNDEFINED;
344 }
345
346 InstanceKlass ik = null;
347 if (classname instanceof JSJavaClass) {
348 JSJavaClass jclass = (JSJavaClass) classname;
349 JSJavaKlass jk = jclass.getJSJavaKlass();
350 if (jk != null && jk instanceof JSJavaInstanceKlass) {
351 ik = ((JSJavaInstanceKlass)jk).getInstanceKlass();
352 }
353 } else if (classname instanceof String) {
354 ik = SystemDictionaryHelper.findInstanceKlass((String)classname);
355 } else {
356 return UNDEFINED;
357 }
358
359 if (ik == null) {
360 return UNDEFINED;
361 }
362 JSJavaFactory factory = getJSJavaFactory();
363 try {
364 return ((JSJavaInstanceKlass) factory.newJSJavaKlass(ik)).getStaticFieldValue((String)fieldname);
365 } catch (NoSuchFieldException e) {
366 return UNDEFINED;
367 }
368 }
369
370 /**
371 * read function reads a single line of input from standard input
372 */
373 public Object read(Object[] args) {
374 BufferedReader in = getInputReader();
375 if (in == null) {
376 return null;
377 }
378 if (args.length > 0) {
379 print(args[0].toString());
380 print(":");
381 }
382 try {
383 return in.readLine();
384 } catch (IOException exp) {
385 exp.printStackTrace();
386 throw new RuntimeException(exp);
387 }
388 }
389
390 /**
391 * Quit the shell.
392 * This only affects the interactive mode.
393 */
394 public void quit(Object[] args) {
395 quit();
396 }
397
398 public void writeln(Object[] args) {
399 for (int i = 0; i < args.length; i++) {
400 print(args[i].toString());
401 print(" ");
402 }
403 println("");
404 }
405
406 public void write(Object[] args) {
407 for (int i = 0; i < args.length; i++) {
408 print(args[i].toString());
409 print(" ");
410 }
411 }
412
413 //-- Internals only below this point
414 protected void start(boolean console) {
415 ScriptContext context = engine.getContext();
416 OutputStream out = getOutputStream();
417 if (out != null) {
418 context.setWriter(new PrintWriter(out));
419 }
420 OutputStream err = getErrorStream();
421 if (err != null) {
422 context.setErrorWriter(new PrintWriter(err));
423 }
424 // load "sa.js" initialization file
425 loadInitFile();
426 // load "~/jsdb.js" (if found) to perform user specific
427 // initialization steps, if any.
428 loadUserInitFile();
429
430 JSJavaFactory fac = getJSJavaFactory();
431 JSJavaVM jvm = (fac != null)? fac.newJSJavaVM() : null;
432 // call "main" function from "sa.js" -- main expects
433 // 'this' object and jvm object
434 call("main", new Object[] { this, jvm });
435
436 // if asked, start read-eval-print console
437 if (console) {
438 processSource(null);
439 }
440 }
441
442 protected JSJavaScriptEngine(boolean debug) {
443 this.debug = debug;
444 ScriptEngineManager manager = new ScriptEngineManager();
445 engine = manager.getEngineByName("javascript");
446 if (engine == null) {
447 throw new RuntimeException("can't load JavaScript engine");
448 }
449 Method[] methods = getClass().getMethods();
450 for (int i = 0; i < methods.length; i++) {
451 Method m = methods[i];
452 if (! Modifier.isPublic(m.getModifiers())) {
453 continue;
454 }
455 Class[] argTypes = m.getParameterTypes();
456 if (argTypes.length == 1 &&
457 argTypes[0] == Object[].class) {
458 putFunction(this, m);
459 }
460 }
461 }
462
463 protected JSJavaScriptEngine() {
464 this(false);
465 }
466
467 protected abstract ObjectReader getObjectReader();
468 protected abstract JSJavaFactory getJSJavaFactory();
469 protected void printPrompt(String str) {
470 System.err.print(str);
471 System.err.flush();
472 }
473
474 protected void loadInitFile() {
475 InputStream is = JSJavaScriptEngine.class.getResourceAsStream("sa.js");
476 BufferedReader reader = new BufferedReader(new InputStreamReader(is));
477 evalReader(reader, "sa.js");
478 }
479
480 protected void loadUserInitFile() {
481 File initFile = new File(getUserInitFileDir(), getUserInitFileName());
482 if (initFile.exists() && initFile.isFile()) {
483 // load the init script
484 processSource(initFile.getAbsolutePath());
485 }
486 }
487
488 protected String getUserInitFileDir() {
489 return System.getProperty("user.home");
490 }
491
492 protected String getUserInitFileName() {
493 return "jsdb.js";
494 }
495
496 protected BufferedReader getInputReader() {
497 if (inReader == null) {
498 inReader = new BufferedReader(new InputStreamReader(System.in));
499 }
500 return inReader;
501 }
502
503 protected PrintStream getOutputStream() {
504 return System.out;
505 }
506
507 protected PrintStream getErrorStream() {
508 return System.err;
509 }
510
511 protected void print(String name) {
512 getOutputStream().print(name);
513 }
514
515 protected void println(String name) {
516 getOutputStream().println(name);
517 }
518
519 protected void printError(String message) {
520 printError(message, null);
521 }
522
523 protected void printError(String message, Exception exp) {
524 getErrorStream().println(message);
525 if (exp != null && debug) {
526 exp.printStackTrace(getErrorStream());
527 }
528 }
529
530 protected boolean isQuitting() {
531 return quitting;
532 }
533
534 protected void quit() {
535 quitting = true;
536 }
537
538 protected ScriptEngine getScriptEngine() {
539 return engine;
540 }
541
542 private JSJavaThread getOwningThread(JSJavaObject jo) {
543 Oop oop = jo.getOop();
544 Mark mark = oop.getMark();
545 ObjectMonitor mon = null;
546 Address owner = null;
547 JSJavaThread owningThread = null;
548 // check for heavyweight monitor
549 if (! mark.hasMonitor()) {
550 // check for lightweight monitor
551 if (mark.hasLocker()) {
552 owner = mark.locker().getAddress(); // save the address of the Lock word
553 }
554 // implied else: no owner
555 } else {
556 // this object has a heavyweight monitor
557 mon = mark.monitor();
558
559 // The owner field of a heavyweight monitor may be NULL for no
560 // owner, a JavaThread * or it may still be the address of the
561 // Lock word in a JavaThread's stack. A monitor can be inflated
562 // by a non-owning JavaThread, but only the owning JavaThread
563 // can change the owner field from the Lock word to the
564 // JavaThread * and it may not have done that yet.
565 owner = mon.owner();
566 }
567
568 // find the owning thread
569 if (owner != null) {
570 JSJavaFactory factory = getJSJavaFactory();
571 owningThread = (JSJavaThread) factory.newJSJavaThread(VM.getVM().getThreads().owningThreadFromMonitor(owner));
572 }
573 return owningThread;
574 }
575
576 /**
577 * Evaluate JavaScript source.
578 * @param filename the name of the file to compile, or null
579 * for interactive mode.
580 */
581 private void processSource(String filename) {
582 if (filename == null) {
583 BufferedReader in = getInputReader();
584 String sourceName = "<stdin>";
585 int lineno = 0;
586 boolean hitEOF = false;
587 do {
588 int startline = lineno;
589 printPrompt("jsdb> ");
590 Object source = read(EMPTY_ARRAY);
591 if (source == null) {
592 hitEOF = true;
593 break;
594 }
595 lineno++;
596 Object result = evalString(source.toString(), sourceName, startline);
597 if (result != null) {
598 printError(result.toString());
599 }
600 if (isQuitting()) {
601 // The user executed the quit() function.
602 break;
603 }
604 } while (!hitEOF);
605 } else {
606 Reader in = null;
607 try {
608 in = new BufferedReader(new FileReader(filename));
609 evalReader(in, filename);
610 } catch (FileNotFoundException ex) {
611 println("File '" + filename + "' not found");
612 throw new RuntimeException(ex);
613 }
614 }
615 }
616
617 protected Object evalString(String source, String filename, int lineNum) {
618 try {
619 engine.put(ScriptEngine.FILENAME, filename);
620 return engine.eval(source);
621 } catch (ScriptException sexp) {
622 printError(sexp.toString(), sexp);
623 } catch (Exception exp) {
624 printError(exp.toString(), exp);
625 }
626 return null;
627 }
628
629 private Object evalReader(Reader in, String filename) {
630 try {
631 engine.put(ScriptEngine.FILENAME, filename);
632 return engine.eval(in);
633 } catch (ScriptException sexp) {
634 System.err.println(sexp);
635 printError(sexp.toString(), sexp);
636 } finally {
637 try {
638 in.close();
639 } catch (IOException ioe) {
640 printError(ioe.toString(), ioe);
641 }
642 }
643 return null;
644 }
645
646 // lazily initialized input reader
647 private BufferedReader inReader;
648 // debug mode or not
649 protected final boolean debug;
650 private boolean quitting;
651 // underlying jsr-223 script engine
652 private ScriptEngine engine;
653 }