- Drop to frame and Hot code replace: Do not use the drop to frame and hot code replace features while debugging other languages called from Java™.
- Suspending all threads with Java breakpoints: Do not set Java breakpoints to suspend all threads when debugging mixed language applications.
- Step over and step return: Step over and step return are only supported for the top stack frame.
- Suspending: Suspend might not work properly when debugging a mixed language application. Use breakpoints instead.
- Missing labels for logical structure variables: Occasionally, the name or value of a logical structure variable will be blank. The label should be correct after the next step or resume operation completes.
- Variables view stops updating, or no variables shown: If the Variables view stops updating or shows no variables at all, close the Variables view and then reopen it to display variables properly again.
- Step return stops in unexpected location: If the step return action stops in runtime code rather than returning back into user code, continue to step return until you stop in the expected source code.
Hot Method Replace
- Changes to source that affect the shape of the class are not supported.
This means that changes to method bodies will be hot replaced, while these
are examples of changes that will not be hot replaced:
- changes to class structure, such as the removal/addition of methods
- modification of class variables
- changes to inner classes
If you change the shape of the class by adding or removing a field or method, or as described above, you might receive an error with the message "Scheme change not implemented", as pictured below:
This error indicates that you have performed an unsupported hot code replacement, and the change was not processed by the virtual machine. You might also see an "(out of synch)" message on the stack frames or threads in the debug view. These messages should disappear if you undo the unsupported change.
- Changes to the code in the bottom stack frame (the main(...) method) cannot be hot replaced.
- Changes to the code that is directly referenced by native methods cannot
be hot replaced. For example, imagine that the debugger is currently suspended
in methodA, called from methodB, and you make
a change in the body of methodA. The hot code replacement will
not succeed if methodB is a native method. You will not be
able to replace methods invoked through reflection while you are suspended in
these methods. Some examples of methods invoked through reflection, are
constructors called through Class.newInstance() and
Method.invoke().
If you change the body of a method invoked by native code while the debugger is suspended there, you might see an error dialog titled "Obsolete Methods on the Stack" like the one below:
Continuing the previous example, since methodA has been changed, the original methodA before the change is now obsolete. However, the virtual machine is unable to execute the new methodA because it is called from a native method, and so will continue to use the old, now obsolete contents of methodA.
- JSP page debugging does not support hot method replace of Java code.