Skip to main content

[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index] [List Home]
RE: [dsdp-dd-dev] Memory View Technology Subgroup Discussion

Hello Samantha, Mikhail,

your attachment named "disassembly.jpg"
is really a *.bmp file that is 4MB in size.

Since mails to the list go to lots of people,
please try keeping attachments smaller by 
using GIF format (ideal for screenshots)
or real JPG.

Thanks,
Martin
--
Martin Oberhuber - WindRiver, Austria
+43(662)457915-85
 

> -----Original Message-----
> From: dsdp-dd-dev-bounces@xxxxxxxxxxx 
> [mailto:dsdp-dd-dev-bounces@xxxxxxxxxxx] On Behalf Of Mikhail 
> Khodjaiants
> Sent: Thursday, May 18, 2006 9:25 PM
> To: Device Debugging developer discussions
> Subject: Re: [dsdp-dd-dev] Memory View Technology Subgroup Discussion
> 
> Samantha and Ted,
> 
> We have a very similar iimplementation in CDT. Our 
> Disassembly view is not 
> linked with an editor, but with the current debug context. 
> The global step 
> actions depend on the active part and can configured to use 
> instruction 
> stepping in the disassembly and source stepping in the editor.
> The attached a snapshot of the Disassembly view.
> 
> Mikhail
> ----- Original Message ----- 
> From: "Samantha Chan" <chanskw@xxxxxxxxxx>
> To: "Device Debugging developer discussions" <dsdp-dd-dev@xxxxxxxxxxx>
> Sent: Thursday, May 18, 2006 3:02 PM
> Subject: RE: [dsdp-dd-dev] Memory View Technology Subgroup Discussion
> 
> 
> > 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
> >
> >
> > _______________________________________________
> > dsdp-dd-dev mailing list
> > dsdp-dd-dev@xxxxxxxxxxx
> > https://dev.eclipse.org/mailman/listinfo/dsdp-dd-dev 
> 


Back to the top