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