JDWP features hidden under JDI

[David Holmes]

Hi Anton,

There may be someone who recalls this detail of ancient history but it 
is ancient. :) As a low-level protocol JDWP exposes a lot of things. But 
then the higher-level API's, like the original JVM DI, and its 
replacement JVM TI, provide a different level of abstraction and need 
not expose as much low-level detail (but may need that lower-level 
information to implement their own APIs). Then JDI is a higher-level API 
again. Answering "why" 20+ years later is not an easy thing. :)

Cheers,
David

On 23/11/2021 7:25 pm, Anton W. Haubner wrote:
> Hello!
> 
> I am working on a new kind of debugger which extracts information about the
> state of Java programs through the JDI to build RDF knowledge graphs.
> 
> While working on the project, I noticed that there is certain 
> information about
> the program state that is accessible through JDWP, but which is hidden 
> by the
> JDI interfaces (see below for examples).
> 
> I am curious, whether this was done to simplify the interface, or if 
> there is
> a deeper reason behind this, e.g. because the information in question is
> unreliable etc.
> If there is no such reason, I might try to modify the JDI reference
> implementation to provide this information to me.
> 
> *First Example: Retrieving Objects by ID*
> 
> The ObjectReference JDI interface does allow to retrieve the unique id 
> assigned to
> an object by the JDWP agent.
> 
> However, it seems it is not possible to construct an ObjectReference 
> from such
> an id. That is, one can not quickly look up an object by its id, but has to
> search through all objects to find it again.
> 
> Looking at the JDWP specification, it seems that the underlying JDWP 
> protocol
> does support looking up objects using just their id:
> https://docs.oracle.com/en/java/javase/17/docs/specs/jdwp/jdwp-protocol.html#JDWP_ObjectReference
> 
> The reference implementation of the `ObjectReference` interface also 
> seems to
> only require this id to retrieve all required information:
> https://github.com/openjdk/jdk/blob/dfacda488bfbe2e11e8d607a6d08527710286982/src/jdk.jdi/share/classes/com/sun/tools/jdi/ObjectReferenceImpl.java#L109
> 
> /My question now is:/
> Is there a specific reason that there is no public factory method to 
> construct
> an ObjectReference from an object id?
> Or would it be "safe" to create a custom `ObjectReference` 
> implementation that
> allows this, as long as it deals with the `INVALID_OBJECT` error case of 
> JDWP?
> 
> *Second Example: Variable Locations*
> 
> The JDWP `VariableTable` command reply does contain the code index of 
> variables.
> Nevertheless, it is neither possible to retrieve the code index of a 
> variable
> through the `LocalVariable` JDI interface, nor through the `Method` 
> interface.
> 
> Meanwhile, internally, the `LocalVariable` reference implementation does 
> seem
> to store the scope of a variable:
> https://github.com/openjdk/jdk/blob/dfacda488bfbe2e11e8d607a6d08527710286982/src/jdk.jdi/share/classes/com/sun/tools/jdi/LocalVariableImpl.java#L56
> 
> The Eclipse JDI implementation also stores the plain code index value:
> https://git.eclipse.org/c/jdt/eclipse.jdt.debug.git/tree/org.eclipse.jdt.debug/jdi/org/eclipse/jdi/internal/LocalVariableImpl.java#n63
> 
> Is there a specific reason, why this location information is not exposed 
> in the
> public interface?
> 
> 
> 
> 
> Thank you very much for reading my questions.
> Can you help me to answer them?
> 
> Best regards,
> 
> Anton Haubner
>