Mercurial > hg > graal-compiler
annotate agent/src/share/classes/sun/jvm/hotspot/jdi/ConnectorImpl.java @ 5936:970cbbba54b0
7130404: [macosx] "os.arch" value should be "x86_64" for compatibility with Apple JDK6
Summary: On Mac OS X, align system property "os.arch" with Apple legacy JDKs. Also, improve os.name string matching by using contains() method instead of .startsWith().
Reviewed-by: dcubed, phh, ohair, katleman
Contributed-by: james.melvin@oracle.com
author | jmelvin |
---|---|
date | Fri, 16 Mar 2012 15:13:22 -0400 |
parents | 37be97a58393 |
children |
rev | line source |
---|---|
0 | 1 /* |
5936
970cbbba54b0
7130404: [macosx] "os.arch" value should be "x86_64" for compatibility with Apple JDK6
jmelvin
parents:
2471
diff
changeset
|
2 * Copyright (c) 2002, 2012, Oracle and/or its affiliates. All rights reserved. |
0 | 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 * | |
1552
c18cbe5936b8
6941466: Oracle rebranding changes for Hotspot repositories
trims
parents:
0
diff
changeset
|
19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA |
c18cbe5936b8
6941466: Oracle rebranding changes for Hotspot repositories
trims
parents:
0
diff
changeset
|
20 * or visit www.oracle.com if you need additional information or have any |
c18cbe5936b8
6941466: Oracle rebranding changes for Hotspot repositories
trims
parents:
0
diff
changeset
|
21 * questions. |
0 | 22 * |
23 */ | |
24 | |
25 package sun.jvm.hotspot.jdi; | |
26 | |
27 import com.sun.jdi.connect.*; | |
28 import com.sun.jdi.InternalException; | |
29 | |
30 import java.io.*; | |
31 import java.lang.ref.*; | |
32 import java.lang.reflect.*; | |
33 import java.util.*; | |
34 | |
35 abstract class ConnectorImpl implements Connector { | |
36 Map defaultArguments = new LinkedHashMap(); | |
37 | |
38 // Used by BooleanArgument | |
39 static String trueString = null; | |
40 static String falseString; | |
41 | |
42 | |
43 /** This is not public in VirtualMachineManagerImpl | |
44 ThreadGroup mainGroupForJDI() { | |
45 return ((VirtualMachineManagerImpl)manager).mainGroupForJDI(); | |
46 } | |
47 ***/ | |
48 | |
49 // multiple debuggee support for SA/JDI | |
50 private static List freeVMClasses; // List<SoftReference<Class>> | |
51 private static ClassLoader myLoader; | |
52 // debug mode for SA/JDI connectors | |
53 static final protected boolean DEBUG; | |
54 static { | |
55 myLoader = ConnectorImpl.class.getClassLoader(); | |
56 freeVMClasses = new ArrayList(0); | |
57 DEBUG = System.getProperty("sun.jvm.hotspot.jdi.ConnectorImpl.DEBUG") != null; | |
58 } | |
59 | |
60 // add a new free VirtualMachineImpl class | |
61 private static synchronized void addFreeVMImplClass(Class clazz) { | |
62 if (DEBUG) { | |
63 System.out.println("adding free VirtualMachineImpl class"); | |
64 } | |
65 freeVMClasses.add(new SoftReference(clazz)); | |
66 } | |
67 | |
68 // returns null if we don't have anything free | |
69 private static synchronized Class getFreeVMImplClass() { | |
70 while (!freeVMClasses.isEmpty()) { | |
71 SoftReference ref = (SoftReference) freeVMClasses.remove(0); | |
72 Object o = ref.get(); | |
73 if (o != null) { | |
74 if (DEBUG) { | |
75 System.out.println("re-using loaded VirtualMachineImpl"); | |
76 } | |
77 return (Class) o; | |
78 } | |
79 } | |
80 return null; | |
81 } | |
82 | |
83 private static Class getVMImplClassFrom(ClassLoader cl) | |
84 throws ClassNotFoundException { | |
85 return Class.forName("sun.jvm.hotspot.jdi.VirtualMachineImpl", true, cl); | |
86 } | |
87 | |
88 /* SA has not been designed to support multiple debuggee VMs | |
89 * at-a-time. But, JDI supports multiple debuggee VMs. We | |
90 * support multiple debuggee VMs in SA/JDI, by creating a new | |
91 * class loader instance (refer to comment in SAJDIClassLoader | |
92 * for details). But, to avoid excessive class loading (and | |
93 * thereby resulting in larger footprint), we re-use 'dispose'd | |
94 * VirtualMachineImpl classes. | |
95 */ | |
96 protected static Class loadVirtualMachineImplClass() | |
97 throws ClassNotFoundException { | |
98 Class vmImplClass = getFreeVMImplClass(); | |
99 if (vmImplClass == null) { | |
100 ClassLoader cl = new SAJDIClassLoader(myLoader); | |
101 vmImplClass = getVMImplClassFrom(cl); | |
102 } | |
103 return vmImplClass; | |
104 } | |
105 | |
106 /* We look for System property sun.jvm.hotspot.jdi.<vm version>. | |
107 * This property should have the value of JDK HOME directory for | |
108 * the given <vm version>. | |
109 */ | |
110 private static String getSAClassPathForVM(String vmVersion) { | |
111 final String prefix = "sun.jvm.hotspot.jdi."; | |
112 // look for exact match of VM version | |
113 String jvmHome = System.getProperty(prefix + vmVersion); | |
114 if (DEBUG) { | |
115 System.out.println("looking for System property " + prefix + vmVersion); | |
116 } | |
117 | |
118 if (jvmHome == null) { | |
119 // omit chars after first '-' in VM version and try | |
120 // for example, in '1.5.0-b55' we take '1.5.0' | |
121 int index = vmVersion.indexOf('-'); | |
122 if (index != -1) { | |
123 vmVersion = vmVersion.substring(0, index); | |
124 if (DEBUG) { | |
125 System.out.println("looking for System property " + prefix + vmVersion); | |
126 } | |
127 jvmHome = System.getProperty(prefix + vmVersion); | |
128 } | |
129 | |
130 if (jvmHome == null) { | |
131 // System property is not set | |
132 if (DEBUG) { | |
133 System.out.println("can't locate JDK home for " + vmVersion); | |
134 } | |
135 return null; | |
136 } | |
137 } | |
138 | |
139 if (DEBUG) { | |
140 System.out.println("JDK home for " + vmVersion + " is " + jvmHome); | |
141 } | |
142 | |
143 // sa-jdi is in $JDK_HOME/lib directory | |
144 StringBuffer buf = new StringBuffer(); | |
145 buf.append(jvmHome); | |
146 buf.append(File.separatorChar); | |
147 buf.append("lib"); | |
148 buf.append(File.separatorChar); | |
149 buf.append("sa-jdi.jar"); | |
150 return buf.toString(); | |
151 } | |
152 | |
153 /* This method loads VirtualMachineImpl class by a ClassLoader | |
154 * configured with sa-jdi.jar path of given 'vmVersion'. This is | |
155 * used for cross VM version debugging. Refer to comments in | |
156 * SAJDIClassLoader as well. | |
157 */ | |
158 protected static Class loadVirtualMachineImplClass(String vmVersion) | |
159 throws ClassNotFoundException { | |
160 if (DEBUG) { | |
161 System.out.println("attemping to load sa-jdi.jar for version " + vmVersion); | |
162 } | |
163 String classPath = getSAClassPathForVM(vmVersion); | |
164 if (classPath != null) { | |
165 ClassLoader cl = new SAJDIClassLoader(myLoader, classPath); | |
166 return getVMImplClassFrom(cl); | |
167 } else { | |
168 return null; | |
169 } | |
170 } | |
171 | |
172 /* Is the given throwable an instanceof VMVersionMismatchException? | |
173 * Note that we can't do instanceof check because the exception | |
174 * class might have been loaded by a different class loader. | |
175 */ | |
176 private static boolean isVMVersionMismatch(Throwable throwable) { | |
177 String className = throwable.getClass().getName(); | |
178 return className.equals("sun.jvm.hotspot.runtime.VMVersionMismatchException"); | |
179 } | |
180 | |
181 /* gets target VM version from the given VMVersionMismatchException. | |
182 * Note that we need to reflectively call the method because of we may | |
183 * have got this from different classloader's namespace */ | |
184 private static String getVMVersion(Throwable throwable) | |
185 throws NoSuchMethodException, InvocationTargetException, IllegalAccessException { | |
186 // assert isVMVersionMismatch(throwable), "not a VMVersionMismatch" | |
187 Class expClass = throwable.getClass(); | |
188 Method targetVersionMethod = expClass.getMethod("getTargetVersion", new Class[0]); | |
2471
37be97a58393
7010849: 5/5 Extraneous javac source/target options when building sa-jdi
andrew
parents:
1552
diff
changeset
|
189 return (String) targetVersionMethod.invoke(throwable); |
0 | 190 } |
191 | |
192 /** If the causal chain has a sun.jvm.hotspot.runtime.VMVersionMismatchException, | |
193 attempt to load VirtualMachineImpl class for target VM version. */ | |
194 protected static Class handleVMVersionMismatch(InvocationTargetException ite) { | |
195 Throwable cause = ite.getCause(); | |
196 if (DEBUG) { | |
197 System.out.println("checking for version mismatch..."); | |
198 } | |
199 while (cause != null) { | |
200 try { | |
201 if (isVMVersionMismatch(cause)) { | |
202 if (DEBUG) { | |
203 System.out.println("Triggering cross VM version support..."); | |
204 } | |
205 return loadVirtualMachineImplClass(getVMVersion(cause)); | |
206 } | |
207 } catch (Exception exp) { | |
208 if (DEBUG) { | |
209 System.out.println("failed to load VirtualMachineImpl class"); | |
210 exp.printStackTrace(); | |
211 } | |
212 return null; | |
213 } | |
214 cause = cause.getCause(); | |
215 } | |
216 return null; | |
217 } | |
218 | |
219 protected void checkNativeLink(SecurityManager sm, String os) { | |
5936
970cbbba54b0
7130404: [macosx] "os.arch" value should be "x86_64" for compatibility with Apple JDK6
jmelvin
parents:
2471
diff
changeset
|
220 if (os.equals("SunOS") || os.equals("Linux") || os.contains("OS X")) { |
970cbbba54b0
7130404: [macosx] "os.arch" value should be "x86_64" for compatibility with Apple JDK6
jmelvin
parents:
2471
diff
changeset
|
221 // link "saproc" - SA native library on SunOS, Linux, and Mac OS X |
0 | 222 sm.checkLink("saproc"); |
223 } else if (os.startsWith("Windows")) { | |
224 // link "sawindbg" - SA native library on Windows. | |
225 sm.checkLink("sawindbg"); | |
226 } else { | |
227 throw new RuntimeException(os + " is not yet supported"); | |
228 } | |
229 } | |
230 | |
231 // we set an observer to detect VirtualMachineImpl.dispose call | |
232 // and on dispose we add corresponding VirtualMachineImpl.class to | |
233 // free VirtualMachimeImpl Class list. | |
234 protected static void setVMDisposeObserver(final Object vm) { | |
235 try { | |
236 Method setDisposeObserverMethod = vm.getClass().getDeclaredMethod("setDisposeObserver", | |
237 new Class[] { java.util.Observer.class }); | |
238 setDisposeObserverMethod.setAccessible(true); | |
239 setDisposeObserverMethod.invoke(vm, | |
240 new Object[] { | |
241 new Observer() { | |
242 public void update(Observable o, Object data) { | |
243 if (DEBUG) { | |
244 System.out.println("got VM.dispose notification"); | |
245 } | |
246 addFreeVMImplClass(vm.getClass()); | |
247 } | |
248 } | |
249 }); | |
250 } catch (Exception exp) { | |
251 if (DEBUG) { | |
252 System.out.println("setVMDisposeObserver() got an exception:"); | |
253 exp.printStackTrace(); | |
254 } | |
255 } | |
256 } | |
257 | |
258 public Map defaultArguments() { | |
259 Map defaults = new LinkedHashMap(); | |
260 Collection values = defaultArguments.values(); | |
261 | |
262 Iterator iter = values.iterator(); | |
263 while (iter.hasNext()) { | |
264 ArgumentImpl argument = (ArgumentImpl)iter.next(); | |
265 defaults.put(argument.name(), argument.clone()); | |
266 } | |
267 return defaults; | |
268 } | |
269 | |
270 void addStringArgument(String name, String label, String description, | |
271 String defaultValue, boolean mustSpecify) { | |
272 defaultArguments.put(name, | |
273 new StringArgumentImpl(name, label, | |
274 description, | |
275 defaultValue, | |
276 mustSpecify)); | |
277 } | |
278 | |
279 void addBooleanArgument(String name, String label, String description, | |
280 boolean defaultValue, boolean mustSpecify) { | |
281 defaultArguments.put(name, | |
282 new BooleanArgumentImpl(name, label, | |
283 description, | |
284 defaultValue, | |
285 mustSpecify)); | |
286 } | |
287 | |
288 void addIntegerArgument(String name, String label, String description, | |
289 String defaultValue, boolean mustSpecify, | |
290 int min, int max) { | |
291 defaultArguments.put(name, | |
292 new IntegerArgumentImpl(name, label, | |
293 description, | |
294 defaultValue, | |
295 mustSpecify, | |
296 min, max)); | |
297 } | |
298 | |
299 void addSelectedArgument(String name, String label, String description, | |
300 String defaultValue, boolean mustSpecify, | |
301 List list) { | |
302 defaultArguments.put(name, | |
303 new SelectedArgumentImpl(name, label, | |
304 description, | |
305 defaultValue, | |
306 mustSpecify, list)); | |
307 } | |
308 | |
309 ArgumentImpl argument(String name, Map arguments) | |
310 throws IllegalConnectorArgumentsException { | |
311 | |
312 ArgumentImpl argument = (ArgumentImpl)arguments.get(name); | |
313 if (argument == null) { | |
314 throw new IllegalConnectorArgumentsException( | |
315 "Argument missing", name); | |
316 } | |
317 String value = argument.value(); | |
318 if (value == null || value.length() == 0) { | |
319 if (argument.mustSpecify()) { | |
320 throw new IllegalConnectorArgumentsException( | |
321 "Argument unspecified", name); | |
322 } | |
323 } else if(!argument.isValid(value)) { | |
324 throw new IllegalConnectorArgumentsException( | |
325 "Argument invalid", name); | |
326 } | |
327 | |
328 return argument; | |
329 } | |
330 | |
331 String getString(String key) { | |
332 //fixme jjh; needs i18n | |
333 // this is not public return ((VirtualMachineManagerImpl)manager).getString(key); | |
334 return key; | |
335 } | |
336 | |
337 public String toString() { | |
338 String string = name() + " (defaults: "; | |
339 Iterator iter = defaultArguments().values().iterator(); | |
340 boolean first = true; | |
341 while (iter.hasNext()) { | |
342 ArgumentImpl argument = (ArgumentImpl)iter.next(); | |
343 if (!first) { | |
344 string += ", "; | |
345 } | |
346 string += argument.toString(); | |
347 first = false; | |
348 } | |
349 return string + ")"; | |
350 } | |
351 | |
352 abstract class ArgumentImpl implements Connector.Argument, Cloneable, Serializable { | |
353 private String name; | |
354 private String label; | |
355 private String description; | |
356 private String value; | |
357 private boolean mustSpecify; | |
358 | |
359 ArgumentImpl(String name, String label, String description, | |
360 String value, | |
361 boolean mustSpecify) { | |
362 this.name = name; | |
363 this.label = label; | |
364 this.description = description; | |
365 this.value = value; | |
366 this.mustSpecify = mustSpecify; | |
367 } | |
368 | |
369 public abstract boolean isValid(String value); | |
370 | |
371 public String name() { | |
372 return name; | |
373 } | |
374 | |
375 public String label() { | |
376 return label; | |
377 } | |
378 | |
379 public String description() { | |
380 return description; | |
381 } | |
382 | |
383 public String value() { | |
384 return value; | |
385 } | |
386 | |
387 public void setValue(String value) { | |
388 if (value == null) { | |
389 throw new NullPointerException("Can't set null value"); | |
390 } | |
391 this.value = value; | |
392 } | |
393 | |
394 public boolean mustSpecify() { | |
395 return mustSpecify; | |
396 } | |
397 | |
398 public boolean equals(Object obj) { | |
399 if ((obj != null) && (obj instanceof Connector.Argument)) { | |
400 Connector.Argument other = (Connector.Argument)obj; | |
401 return (name().equals(other.name())) && | |
402 (description().equals(other.description())) && | |
403 (mustSpecify() == other.mustSpecify()) && | |
404 (value().equals(other.value())); | |
405 } else { | |
406 return false; | |
407 } | |
408 } | |
409 | |
410 public int hashCode() { | |
411 return description().hashCode(); | |
412 } | |
413 | |
414 public Object clone() { | |
415 try { | |
416 return super.clone(); | |
417 } catch (CloneNotSupportedException e) { | |
418 // Object should always support clone | |
419 throw (InternalException) new InternalException().initCause(e); | |
420 } | |
421 } | |
422 | |
423 public String toString() { | |
424 return name() + "=" + value(); | |
425 } | |
426 } | |
427 | |
428 class BooleanArgumentImpl extends ConnectorImpl.ArgumentImpl | |
429 implements Connector.BooleanArgument { | |
430 | |
431 BooleanArgumentImpl(String name, String label, String description, | |
432 boolean value, | |
433 boolean mustSpecify) { | |
434 super(name, label, description, null, mustSpecify); | |
435 if(trueString == null) { | |
436 trueString = getString("true"); | |
437 falseString = getString("false"); | |
438 } | |
439 setValue(value); | |
440 } | |
441 | |
442 /** | |
443 * Sets the value of the argument. | |
444 */ | |
445 public void setValue(boolean value) { | |
446 setValue(stringValueOf(value)); | |
447 } | |
448 | |
449 /** | |
450 * Performs basic sanity check of argument. | |
451 * @return <code>true</code> if value is a string | |
452 * representation of a boolean value. | |
453 * @see #stringValueOf(boolean) | |
454 */ | |
455 public boolean isValid(String value) { | |
456 return value.equals(trueString) || value.equals(falseString); | |
457 } | |
458 | |
459 /** | |
460 * Return the string representation of the <code>value</code> | |
461 * parameter. | |
462 * Does not set or examine the value or the argument. | |
463 * @return the localized String representation of the | |
464 * boolean value. | |
465 */ | |
466 public String stringValueOf(boolean value) { | |
467 return value? trueString : falseString; | |
468 } | |
469 | |
470 /** | |
471 * Return the value of the argument as a boolean. Since | |
472 * the argument may not have been set or may have an invalid | |
473 * value {@link #isValid(String)} should be called on | |
474 * {@link #value()} to check its validity. If it is invalid | |
475 * the boolean returned by this method is undefined. | |
476 * @return the value of the argument as a boolean. | |
477 */ | |
478 public boolean booleanValue() { | |
479 return value().equals(trueString); | |
480 } | |
481 } | |
482 | |
483 class IntegerArgumentImpl extends ConnectorImpl.ArgumentImpl | |
484 implements Connector.IntegerArgument { | |
485 | |
486 private final int min; | |
487 private final int max; | |
488 | |
489 IntegerArgumentImpl(String name, String label, String description, | |
490 String value, | |
491 boolean mustSpecify, int min, int max) { | |
492 super(name, label, description, value, mustSpecify); | |
493 this.min = min; | |
494 this.max = max; | |
495 } | |
496 | |
497 /** | |
498 * Sets the value of the argument. | |
499 * The value should be checked with {@link #isValid(int)} | |
500 * before setting it; invalid values will throw an exception | |
501 * when the connection is established - for example, | |
502 * on {@link LaunchingConnector#launch} | |
503 */ | |
504 public void setValue(int value) { | |
505 setValue(stringValueOf(value)); | |
506 } | |
507 | |
508 /** | |
509 * Performs basic sanity check of argument. | |
510 * @return <code>true</code> if value represents an int that is | |
511 * <code>{@link #min()} <= value <= {@link #max()}</code> | |
512 */ | |
513 public boolean isValid(String value) { | |
514 if (value == null) { | |
515 return false; | |
516 } | |
517 try { | |
518 return isValid(Integer.decode(value).intValue()); | |
519 } catch(NumberFormatException exc) { | |
520 return false; | |
521 } | |
522 } | |
523 | |
524 /** | |
525 * Performs basic sanity check of argument. | |
526 * @return <code>true</code> if | |
527 * <code>{@link #min()} <= value <= {@link #max()}</code> | |
528 */ | |
529 public boolean isValid(int value) { | |
530 return min <= value && value <= max; | |
531 } | |
532 | |
533 /** | |
534 * Return the string representation of the <code>value</code> | |
535 * parameter. | |
536 * Does not set or examine the value or the argument. | |
537 * @return the String representation of the | |
538 * int value. | |
539 */ | |
540 public String stringValueOf(int value) { | |
541 // *** Should this be internationalized???? | |
542 // *** Even Brian Beck was unsure if an Arabic programmer | |
543 // *** would expect port numbers in Arabic numerals, | |
544 // *** so punt for now. | |
545 return ""+value; | |
546 } | |
547 | |
548 /** | |
549 * Return the value of the argument as a int. Since | |
550 * the argument may not have been set or may have an invalid | |
551 * value {@link #isValid(String)} should be called on | |
552 * {@link #value()} to check its validity. If it is invalid | |
553 * the int returned by this method is undefined. | |
554 * @return the value of the argument as a int. | |
555 */ | |
556 public int intValue() { | |
557 if (value() == null) { | |
558 return 0; | |
559 } | |
560 try { | |
561 return Integer.decode(value()).intValue(); | |
562 } catch(NumberFormatException exc) { | |
563 return 0; | |
564 } | |
565 } | |
566 | |
567 /** | |
568 * The upper bound for the value. | |
569 * @return the maximum allowed value for this argument. | |
570 */ | |
571 public int max() { | |
572 return max; | |
573 } | |
574 | |
575 /** | |
576 * The lower bound for the value. | |
577 * @return the minimum allowed value for this argument. | |
578 */ | |
579 public int min() { | |
580 return min; | |
581 } | |
582 } | |
583 | |
584 class StringArgumentImpl extends ConnectorImpl.ArgumentImpl | |
585 implements Connector.StringArgument { | |
586 | |
587 StringArgumentImpl(String name, String label, String description, | |
588 String value, | |
589 boolean mustSpecify) { | |
590 super(name, label, description, value, mustSpecify); | |
591 } | |
592 | |
593 /** | |
594 * Performs basic sanity check of argument. | |
595 * @return <code>true</code> always | |
596 */ | |
597 public boolean isValid(String value) { | |
598 return true; | |
599 } | |
600 } | |
601 | |
602 class SelectedArgumentImpl extends ConnectorImpl.ArgumentImpl | |
603 implements Connector.SelectedArgument { | |
604 | |
605 private final List choices; | |
606 | |
607 SelectedArgumentImpl(String name, String label, String description, | |
608 String value, | |
609 boolean mustSpecify, List choices) { | |
610 super(name, label, description, value, mustSpecify); | |
611 this.choices = Collections.unmodifiableList( | |
612 new ArrayList(choices)); | |
613 } | |
614 | |
615 /** | |
616 * Return the possible values for the argument | |
617 * @return {@link List} of {@link String} | |
618 */ | |
619 public List choices() { | |
620 return choices; | |
621 } | |
622 | |
623 /** | |
624 * Performs basic sanity check of argument. | |
625 * @return <code>true</code> if value is one of {@link #choices()}. | |
626 */ | |
627 public boolean isValid(String value) { | |
628 return choices.contains(value); | |
629 } | |
630 } | |
631 } |