1 /* 2 * Copyright (c) 1998, 2017, 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. Oracle designates this 8 * particular file as subject to the "Classpath" exception as provided 9 * by Oracle in the LICENSE file that accompanied this code. 10 * 11 * This code is distributed in the hope that it will be useful, but WITHOUT 12 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or 13 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License 14 * version 2 for more details (a copy is included in the LICENSE file that 15 * accompanied this code). 16 * 17 * You should have received a copy of the GNU General Public License version 18 * 2 along with this work; if not, write to the Free Software Foundation, 19 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. 20 * 21 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA 22 * or visit www.oracle.com if you need additional information or have any 23 * questions. 24 */ 25 26 package com.sun.jdi; 27 28 import java.util.List; 29 import java.util.Map; 30 31 import com.sun.jdi.event.EventQueue; 32 import com.sun.jdi.event.VMDisconnectEvent; 33 34 /** 35 * An object that currently exists in the target VM. An ObjectReference 36 * mirrors only the object itself and is not specific to any 37 * {@link Field} or {@link LocalVariable} to which it is currently 38 * assigned. An ObjectReference can have 0 or more references from 39 * field(s) and/or variable(s). 40 * <p> 41 * Any method on <code>ObjectReference</code> which directly or indirectly 42 * takes <code>ObjectReference</code> as a parameter may throw 43 * {@link VMDisconnectedException} if the target VM is disconnected and the 44 * {@link VMDisconnectEvent} has been or is available to be read from the 45 * {@link EventQueue}. 46 * <p> 47 * Any method on <code>ObjectReference</code> which directly or indirectly 48 * takes <code>ObjectReference</code> as a parameter may throw 49 * {@link VMOutOfMemoryException} if the target VM has run out of memory. 50 * <p> 51 * Any method on <code>ObjectReference</code> or which directly or indirectly 52 * takes <code>ObjectReference</code> as parameter may throw 53 * {@link ObjectCollectedException} if the mirrored object has been 54 * garbage collected. 55 * 56 * @author Robert Field 57 * @author Gordon Hirsch 58 * @author James McIlree 59 * @since 1.3 60 */ 61 public interface ObjectReference extends Value { 62 63 /** 64 * Gets the {@link ReferenceType} that mirrors the type 65 * of this object. The type may be a subclass or implementor of the 66 * declared type of any field or variable which currently holds it. 67 * For example, right after the following statement. 68 * <p> 69 * <code>Object obj = new String("Hello, world!");</code> 70 * <p> 71 * The ReferenceType of obj will mirror java.lang.String and not 72 * java.lang.Object. 73 * <p> 74 * The type of an object never changes, so this method will 75 * always return the same ReferenceType over the lifetime of the 76 * mirrored object. 77 * <p> 78 * The returned ReferenceType will be a {@link ClassType} or 79 * {@link ArrayType} and never an {@link InterfaceType}. 80 * 81 * @return the {@link ReferenceType} for this object. 82 */ referenceType()83 ReferenceType referenceType(); 84 85 /** 86 * Gets the value of a given instance or static field in this object. 87 * The Field must be valid for this ObjectReference; 88 * that is, it must be from 89 * the mirrored object's class or a superclass of that class. 90 * 91 * @param sig the field containing the requested value 92 * @return the {@link Value} of the instance field. 93 * @throws java.lang.IllegalArgumentException if the field is not valid for 94 * this object's class. 95 */ getValue(Field sig)96 Value getValue(Field sig); 97 98 /** 99 * Gets the value of multiple instance and/or static fields in this object. 100 * The Fields must be valid for this ObjectReference; 101 * that is, they must be from 102 * the mirrored object's class or a superclass of that class. 103 * 104 * @param fields a list of {@link Field} objects containing the 105 * requested values. 106 * @return a Map of the requested {@link Field} objects with 107 * their {@link Value}. 108 * @throws java.lang.IllegalArgumentException if any field is not valid for 109 * this object's class. 110 */ getValues(List<? extends Field> fields)111 Map<Field,Value> getValues(List<? extends Field> fields); 112 113 /** 114 * Sets the value of a given instance or static field in this object. 115 * The {@link Field} must be valid for this ObjectReference; that is, 116 * it must be from the mirrored object's class or a superclass of that class. 117 * If static, the field must not be final. 118 * <p> 119 * Object values must be assignment compatible with the field type 120 * (This implies that the field type must be loaded through the 121 * enclosing class's class loader). Primitive values must be 122 * either assignment compatible with the field type or must be 123 * convertible to the field type without loss of information. 124 * See section 5.2 of 125 * <cite>The Java™ Language Specification</cite> 126 * for more information on assignment 127 * compatibility. 128 * 129 * @param field the field containing the requested value 130 * @param value the new value to assign 131 * @throws java.lang.IllegalArgumentException if the field is not valid for 132 * this object's class. 133 * @throws InvalidTypeException if the value's type does not match 134 * the field's type. 135 * @throws ClassNotLoadedException if 'value' is not null, and the field 136 * type has not yet been loaded through the appropriate class loader. 137 * @throws VMCannotBeModifiedException if the VirtualMachine is read-only - see {@link VirtualMachine#canBeModified()}. 138 */ setValue(Field field, Value value)139 void setValue(Field field, Value value) 140 throws InvalidTypeException, ClassNotLoadedException; 141 142 /** Perform method invocation with only the invoking thread resumed */ 143 static final int INVOKE_SINGLE_THREADED = 0x1; 144 /** Perform non-virtual method invocation */ 145 static final int INVOKE_NONVIRTUAL = 0x2; 146 147 /** 148 * Invokes the specified {@link Method} on this object in the 149 * target VM. The 150 * specified method can be defined in this object's class, 151 * in a superclass of this object's class, or in an interface 152 * implemented by this object. The method may be a static method 153 * or an instance method, but not a static initializer or constructor. 154 * Use {@link ClassType#newInstance} to create a new object and 155 * run its constructor. 156 * <p> 157 * The method invocation will occur in the specified thread. 158 * Method invocation can occur only if the specified thread 159 * has been suspended by an event which occurred in that thread. 160 * Method invocation is not supported 161 * when the target VM has been suspended through 162 * {@link VirtualMachine#suspend} or when the specified thread 163 * is suspended through {@link ThreadReference#suspend}. 164 * <p> 165 * The specified method is invoked with the arguments in the specified 166 * argument list. The method invocation is synchronous; this method 167 * does not return until the invoked method returns in the target VM. 168 * If the invoked method throws an exception, this method 169 * will throw an {@link InvocationException} which contains 170 * a mirror to the exception object thrown. 171 * <p> 172 * Object arguments must be assignment compatible with the argument type 173 * (This implies that the argument type must be loaded through the 174 * enclosing class's class loader). Primitive arguments must be 175 * either assignment compatible with the argument type or must be 176 * convertible to the argument type without loss of information. 177 * If the method being called accepts a variable number of arguments, 178 * then the last argument type is an array of some component type. 179 * The argument in the matching position can be omitted, or can be null, 180 * an array of the same component type, or an argument of the 181 * component type followed by any number of other arguments of the same 182 * type. If the argument is omitted, then a 0 length array of the 183 * component type is passed. The component type can be a primitive type. 184 * Autoboxing is not supported. 185 * 186 * See section 5.2 of 187 * <cite>The Java™ Language Specification</cite> 188 * for more information on assignment compatibility. 189 * <p> 190 * By default, the method is invoked using dynamic lookup as 191 * documented in section 15.12.4.4 of 192 * <cite>The Java™ Language Specification</cite> 193 * in particular, overriding based on the runtime type of the object 194 * mirrored by this {@link ObjectReference} will occur. This 195 * behavior can be changed by specifying the 196 * {@link #INVOKE_NONVIRTUAL} bit flag in the <code>options</code> 197 * argument. If this flag is set, the specified method is invoked 198 * whether or not it is overridden for this object's runtime type. 199 * The method, in this case, must have an implementation, either in a class 200 * or an interface. This option is useful for performing method invocations 201 * like those done with the <code>super</code> keyword in the Java programming 202 * language. 203 * <p> 204 * By default, all threads in the target VM are resumed while 205 * the method is being invoked if they were previously 206 * suspended by an event or by {@link VirtualMachine#suspend} or 207 * {@link ThreadReference#suspend}. This is done to prevent the deadlocks 208 * that will occur if any of the threads own monitors 209 * that will be needed by the invoked method. 210 * Note, however, that this implicit resume acts exactly like 211 * {@link ThreadReference#resume}, so if the thread's suspend 212 * count is greater than 1, it will remain in a suspended state 213 * during the invocation and thus a deadlock could still occur. 214 * By default, when the invocation completes, 215 * all threads in the target VM are suspended, regardless their state 216 * before the invocation. 217 * It is possible that 218 * breakpoints or other events might occur during the invocation. 219 * This can cause deadlocks as described above. It can also cause a deadlock 220 * if invokeMethod is called from the client's event handler thread. In this 221 * case, this thread will be waiting for the invokeMethod to complete and 222 * won't read the EventSet that comes in for the new event. If this 223 * new EventSet is SUSPEND_ALL, then a deadlock will occur because no 224 * one will resume the EventSet. To avoid this, all EventRequests should 225 * be disabled before doing the invokeMethod, or the invokeMethod should 226 * not be done from the client's event handler thread. 227 * <p> 228 * The resumption of other threads during the invocation can be prevented 229 * by specifying the {@link #INVOKE_SINGLE_THREADED} 230 * bit flag in the <code>options</code> argument; however, 231 * there is no protection against or recovery from the deadlocks 232 * described above, so this option should be used with great caution. 233 * Only the specified thread will be resumed (as described for all 234 * threads above). Upon completion of a single threaded invoke, the invoking thread 235 * will be suspended once again. Note that any threads started during 236 * the single threaded invocation will not be suspended when the 237 * invocation completes. 238 * <p> 239 * If the target VM is disconnected during the invoke (for example, through 240 * {@link VirtualMachine#dispose}) the method invocation continues. 241 * 242 * @param thread the thread in which to invoke. 243 * @param method the {@link Method} to invoke. 244 * @param arguments the list of {@link Value} arguments bound to the 245 * invoked method. Values from the list are assigned to arguments 246 * in the order they appear in the method signature. 247 * @param options the integer bit flag options. 248 * @return a {@link Value} mirror of the invoked method's return value. 249 * @throws java.lang.IllegalArgumentException if the method is not 250 * a member of this object's class, if the size of the argument list 251 * does not match the number of declared arguments for the method, 252 * if the method is a constructor or static initializer, or 253 * if {@link #INVOKE_NONVIRTUAL} is specified and the method is 254 * abstract. 255 * @throws ClassNotLoadedException if any argument type has not yet been loaded 256 * through the appropriate class loader. 257 * @throws IncompatibleThreadStateException if the specified thread has not 258 * been suspended by an event. 259 * @throws InvocationException if the method invocation resulted in 260 * an exception in the target VM. 261 * @throws InvalidTypeException If the arguments do not meet this requirement -- 262 * Object arguments must be assignment compatible with the argument 263 * type. This implies that the argument type must be 264 * loaded through the enclosing class's class loader. 265 * Primitive arguments must be either assignment compatible with the 266 * argument type or must be convertible to the argument type without loss 267 * of information. See JLS section 5.2 for more information on assignment 268 * compatibility. 269 * @throws VMCannotBeModifiedException if the VirtualMachine is read-only - see {@link VirtualMachine#canBeModified()}. 270 */ invokeMethod(ThreadReference thread, Method method, List<? extends Value> arguments, int options)271 Value invokeMethod(ThreadReference thread, Method method, 272 List<? extends Value> arguments, int options) 273 throws InvalidTypeException, 274 ClassNotLoadedException, 275 IncompatibleThreadStateException, 276 InvocationException; 277 278 /** 279 * Prevents garbage collection for this object. By default all 280 * {@link ObjectReference} values returned by JDI may be collected 281 * at any time the target VM is running. A call to this method 282 * guarantees that the object will not be collected. 283 * {@link #enableCollection} can be used to allow collection once 284 * again. 285 * <p> 286 * Calls to this method are counted. Every call to this method 287 * requires a corresponding call to {@link #enableCollection} before 288 * garbage collection is re-enabled. 289 * <p> 290 * Note that while the target VM is suspended, no garbage collection 291 * will occur because all threads are suspended. The typical 292 * examination of variables, fields, and arrays during the suspension 293 * is safe without explicitly disabling garbage collection. 294 * <p> 295 * This method should be used sparingly, as it alters the 296 * pattern of garbage collection in the target VM and, 297 * consequently, may result in application behavior under the 298 * debugger that differs from its non-debugged behavior. 299 * @throws VMCannotBeModifiedException if the VirtualMachine is read-only 300 * -see {@link VirtualMachine#canBeModified()}. 301 */ disableCollection()302 void disableCollection(); 303 304 /** 305 * Permits garbage collection for this object. By default all 306 * {@link ObjectReference} values returned by JDI may be collected 307 * at any time the target VM is running. A call to this method 308 * is necessary only if garbage collection was previously disabled 309 * with {@link #disableCollection}. 310 * @throws VMCannotBeModifiedException if the VirtualMachine is read-only 311 * -see {@link VirtualMachine#canBeModified()}. 312 */ enableCollection()313 void enableCollection(); 314 315 /** 316 * Determines if this object has been garbage collected in the target 317 * VM. 318 * 319 * @return <code>true</code> if this {@link ObjectReference} has been collected; 320 * <code>false</code> otherwise. 321 * @throws VMCannotBeModifiedException if the VirtualMachine is read-only 322 * -see {@link VirtualMachine#canBeModified()}. 323 */ isCollected()324 boolean isCollected(); 325 326 /** 327 * Returns a unique identifier for this ObjectReference. 328 * It is guaranteed to be unique among all 329 * ObjectReferences from the same VM that have not yet been disposed. 330 * The guarantee applies as long 331 * as this ObjectReference has not yet been disposed. 332 * 333 * @return a long unique ID 334 */ uniqueID()335 long uniqueID(); 336 337 /** 338 * Returns a List containing a {@link ThreadReference} for 339 * each thread currently waiting for this object's monitor. 340 * See {@link ThreadReference#currentContendedMonitor} for 341 * information about when a thread is considered to be waiting 342 * for a monitor. 343 * <p> 344 * Not all target VMs support this operation. See 345 * VirtualMachine#canGetMonitorInfo to determine if the 346 * operation is supported. 347 * 348 * @return a List of {@link ThreadReference} objects. The list 349 * has zero length if no threads are waiting for the monitor. 350 * @throws java.lang.UnsupportedOperationException if the 351 * target VM does not support this operation. 352 * @throws IncompatibleThreadStateException if any 353 * waiting thread is not suspended 354 * in the target VM 355 */ waitingThreads()356 List<ThreadReference> waitingThreads() 357 throws IncompatibleThreadStateException; 358 359 /** 360 * Returns an {@link ThreadReference} for the thread, if any, 361 * which currently owns this object's monitor. 362 * See {@link ThreadReference#ownedMonitors} for a definition 363 * of ownership. 364 * <p> 365 * Not all target VMs support this operation. See 366 * VirtualMachine#canGetMonitorInfo to determine if the 367 * operation is supported. 368 * 369 * @return the {@link ThreadReference} which currently owns the 370 * monitor, or null if it is unowned. 371 * 372 * @throws java.lang.UnsupportedOperationException if the 373 * target VM does not support this operation. 374 * @throws IncompatibleThreadStateException if the owning thread is 375 * not suspended in the target VM 376 */ owningThread()377 ThreadReference owningThread() throws IncompatibleThreadStateException; 378 379 /** 380 * Returns the number times this object's monitor has been 381 * entered by the current owning thread. 382 * See {@link ThreadReference#ownedMonitors} for a definition 383 * of ownership. 384 * <p> 385 * Not all target VMs support this operation. See 386 * VirtualMachine#canGetMonitorInfo to determine if the 387 * operation is supported. 388 * 389 * @see #owningThread 390 * @return the integer count of the number of entries. 391 * 392 * @throws java.lang.UnsupportedOperationException if the 393 * target VM does not support this operation. 394 * @throws IncompatibleThreadStateException if the owning thread is 395 * not suspended in the target VM 396 */ entryCount()397 int entryCount() throws IncompatibleThreadStateException; 398 399 /** 400 * Returns objects that directly reference this object. 401 * Only objects that are reachable for the purposes of garbage collection 402 * are returned. Note that an object can also be referenced in other ways, 403 * such as from a local variable in a stack frame, or from a JNI global 404 * reference. Such non-object referrers are not returned by this method. 405 * <p> 406 * Not all target virtual machines support this operation. 407 * Use {@link VirtualMachine#canGetInstanceInfo()} 408 * to determine if the operation is supported. 409 * 410 * @see VirtualMachine#instanceCounts(List) 411 * @see ReferenceType#instances(long) 412 413 * @param maxReferrers The maximum number of referring objects to return. 414 * Must be non-negative. If zero, all referring 415 * objects are returned. 416 * @return a of List of {@link ObjectReference} objects. If there are 417 * no objects that reference this object, a zero-length list is returned.. 418 * @throws java.lang.UnsupportedOperationException if 419 * the target virtual machine does not support this 420 * operation - see 421 * {@link VirtualMachine#canGetInstanceInfo() canGetInstanceInfo()} 422 * @throws java.lang.IllegalArgumentException if maxReferrers is less 423 * than zero. 424 * @since 1.6 425 */ referringObjects(long maxReferrers)426 List<ObjectReference> referringObjects(long maxReferrers); 427 428 /** 429 * Compares the specified Object with this ObjectReference for equality. 430 * 431 * @return true if the Object is an ObjectReference, if the 432 * ObjectReferences belong to the same VM, and if applying the 433 * "==" operator on the mirrored objects in that VM evaluates to true. 434 */ equals(Object obj)435 boolean equals(Object obj); 436 437 /** 438 * Returns the hash code value for this ObjectReference. 439 * 440 * @return the integer hash code 441 */ hashCode()442 int hashCode(); 443 } 444