RE: [dsdp-dd-dev] Memory View Technology Subgroup Discussion

[Samantha Chan <chanskw@xxxxxxxxxx>]

Hi Ted -

Here's how I envision this to work when embedding a disassembly rendering
in the editor.  The editor could be a mult-pane editor.  It has two panes,
a source pane and an optional disassembly pane.

The source pane acts as the master of the editor.  The disassembly pane
acts as a slave to the source pane.  The content of the disassembly pane is
controlled by the cursor location of the source pane, meaning that we can
show instructions that are associated with the selected line of source
code.   The disassembly rendering should also be able to show disassembly
from an arbitrary address.

When a debug session is suspended, an instructional pointer is put in the
source pane.  The disassembly pane would show disassembly code from the
current source line.  It should also have an instructional pointer placed
at the current instruction.  Depending on which editor has focus, stepping
could mean different things.  If the source pane has focus, stepping would
mean stepping a line of code.  If the disassembly pane has focus, stepping
would mean stepping a line of instruction.

You can continue to edit source from the source editor.  (Not sure if hot
code replace is possible, but if you edit a line of source, the disassembly
pane can be updated to show changes too...)

When debugging, user has the option of hiding the source pane and only look
at the disassembly pane.  I think this is a different way of having a mixed
mode where source and disassembly are shown together.  Instead of having
them interlaced, source and disassembly are shown side-by-side.

Of course, when the debug session is terminated, the disassembly pane
should be removed / hidden.  Also need to think about how breakpoints
should be handled in this case.

This makes it more obvious that the disassembly source is generated and
that user cannot edit the disassembly source.  But user can continue to
edit the source code from the source pane.

Thanks...
Samantha




                                                                           
             "Williams, Ted"                                               
             <ted.williams@win                                             
             driver.com>                                                To 
             Sent by:                  "Device Debugging developer         
             dsdp-dd-dev-bounc         discussions"                        
             es@xxxxxxxxxxx            <dsdp-dd-dev@xxxxxxxxxxx>           
                                                                        cc 
                                                                           
             05/17/2006 08:44                                      Subject 
             PM                        RE: [dsdp-dd-dev] Memory View       
                                       Technology Subgroup Discussion      
                                                                           
             Please respond to                                             
             Device Debugging                                              
                 developer                                                 
                discussions                                                
             <dsdp-dd-dev@ecli                                             
                 pse.org>                                                  
                                                                           
                                                                           






Samantha> "What I meant was that if the editor that we use implements
the IMemoryRenderingContainer and IMemoryRenderingSite interfaces, an
editor can potentially display a memory rendering.  In this case, the
disassembly rendering can be shown in the editor.  We can resuse the
code in a disassembly rendering and do not have to come up with two
different solutions for showing disasembly in the Memory View and in an
editor."

When I think of mixed mode, two distinctly different use cases come to
mind: source based and address based. Source based (mixed mode) is
useful when I'm debugging source. I might instruction step in this mode,
but mainly, I enable it because I'm curious which instructions were
generated by the compiler. I think the editor provides the better
experience for this mode. I often edit while I'm stepping, if only to
add comments. When I do edit code, completion and syntax highlighting
are essential -- I don't see any advantage to editing source outside of
the editor. The second mode, address based, is useful when my focus is
instruction stepping. No matter how many times I step, I never leave the
frame. Additionally, this mode allows me to see instructions beyond a
single source file. The memory view is a close fit, but its real estate
is poor. I want to step disassembly in the editor region, where there
will be sufficient width for the interspersed source lines.

Samantha, can you elaborate on your proposal (above)? A disassembly
editor could implement IMemoryRenderingContainer and share the memory
view rendering. This sounds useful for the address based mode. But, how
would the rendering enhance the source based mode? What would the
connection be between the source editor and the memory rendering?

ted

_______________________________________________
dsdp-dd-dev mailing list
dsdp-dd-dev@xxxxxxxxxxx
https://dev.eclipse.org/mailman/listinfo/dsdp-dd-dev