541 lines
24 KiB
HTML
541 lines
24 KiB
HTML
|
<HTML>
|
||
|
|
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
|
||
|
|
<!-- Created on March, 27 2008 by texi2html 1.64 -->
|
||
|
|
<!--
|
||
|
|
Written by: Lionel Cons <Lionel.Cons@cern.ch> (original author)
|
||
|
|
Karl Berry <karl@freefriends.org>
|
||
|
|
Olaf Bachmann <obachman@mathematik.uni-kl.de>
|
||
|
|
and many others.
|
||
|
|
Maintained by: Olaf Bachmann <obachman@mathematik.uni-kl.de>
|
||
|
|
Send bugs and suggestions to <texi2html@mathematik.uni-kl.de>
|
||
|
|
|
||
|
|
-->
|
||
|
|
<HEAD>
|
||
|
|
<TITLE>Debugging with GDB: Overlays</TITLE>
|
||
|
|
|
||
|
|
<META NAME="description" CONTENT="Debugging with GDB: Overlays">
|
||
|
|
<META NAME="keywords" CONTENT="Debugging with GDB: Overlays">
|
||
|
|
<META NAME="resource-type" CONTENT="document">
|
||
|
|
<META NAME="distribution" CONTENT="global">
|
||
|
|
<META NAME="Generator" CONTENT="texi2html 1.64">
|
||
|
|
|
||
|
|
</HEAD>
|
||
|
|
|
||
|
|
<BODY LANG="" BGCOLOR="#FFFFFF" TEXT="#000000" LINK="#0000FF" VLINK="#800080" ALINK="#FF0000">
|
||
|
|
|
||
|
|
<A NAME="SEC97"></A>
|
||
|
|
<TABLE CELLPADDING=1 CELLSPACING=1 BORDER=0>
|
||
|
|
<TR><TD VALIGN="MIDDLE" ALIGN="LEFT">[<A HREF="gdb_11.html#SEC96"> < </A>]</TD>
|
||
|
|
<TD VALIGN="MIDDLE" ALIGN="LEFT">[<A HREF="gdb_12.html#SEC98"> > </A>]</TD>
|
||
|
|
<TD VALIGN="MIDDLE" ALIGN="LEFT"> <TD VALIGN="MIDDLE" ALIGN="LEFT">[<A HREF="gdb_3.html#SEC6"> << </A>]</TD>
|
||
|
|
<TD VALIGN="MIDDLE" ALIGN="LEFT">[<A HREF="gdb.html#SEC_Top"> Up </A>]</TD>
|
||
|
|
<TD VALIGN="MIDDLE" ALIGN="LEFT">[<A HREF="gdb_13.html#SEC102"> >> </A>]</TD>
|
||
|
|
<TD VALIGN="MIDDLE" ALIGN="LEFT"> <TD VALIGN="MIDDLE" ALIGN="LEFT"> <TD VALIGN="MIDDLE" ALIGN="LEFT"> <TD VALIGN="MIDDLE" ALIGN="LEFT"> <TD VALIGN="MIDDLE" ALIGN="LEFT">[<A HREF="gdb.html#SEC_Top">Top</A>]</TD>
|
||
|
|
<TD VALIGN="MIDDLE" ALIGN="LEFT">[<A HREF="gdb_toc.html#SEC_Contents">Contents</A>]</TD>
|
||
|
|
<TD VALIGN="MIDDLE" ALIGN="LEFT">[<A HREF="gdb_38.html#SEC764">Index</A>]</TD>
|
||
|
|
<TD VALIGN="MIDDLE" ALIGN="LEFT">[<A HREF="gdb_abt.html#SEC_About"> ? </A>]</TD>
|
||
|
|
</TR></TABLE>
|
||
|
|
<H1> 11. Debugging Programs That Use Overlays </H1>
|
||
|
|
<!--docid::SEC97::-->
|
||
|
|
<P>
|
||
|
|
|
||
|
|
If your program is too large to fit completely in your target system's
|
||
|
|
memory, you can sometimes use <EM>overlays</EM> to work around this
|
||
|
|
problem. GDB provides some support for debugging programs that
|
||
|
|
use overlays.
|
||
|
|
</P><P>
|
||
|
|
|
||
|
|
<BLOCKQUOTE><TABLE BORDER=0 CELLSPACING=0>
|
||
|
|
<TR><TD ALIGN="left" VALIGN="TOP"><A HREF="gdb_12.html#SEC98">11.1 How Overlays Work</A></TD><TD> </TD><TD ALIGN="left" VALIGN="TOP">A general explanation of overlays.</TD></TR>
|
||
|
|
<TR><TD ALIGN="left" VALIGN="TOP"><A HREF="gdb_12.html#SEC99">11.2 Overlay Commands</A></TD><TD> </TD><TD ALIGN="left" VALIGN="TOP">Managing overlays in GDB.</TD></TR>
|
||
|
|
<TR><TD ALIGN="left" VALIGN="TOP"><A HREF="gdb_12.html#SEC100">11.3 Automatic Overlay Debugging</A></TD><TD> </TD><TD ALIGN="left" VALIGN="TOP">GDB can find out which overlays are
|
||
|
|
mapped by asking the inferior.</TD></TR>
|
||
|
|
<TR><TD ALIGN="left" VALIGN="TOP"><A HREF="gdb_12.html#SEC101">11.4 Overlay Sample Program</A></TD><TD> </TD><TD ALIGN="left" VALIGN="TOP">A sample program using overlays.</TD></TR>
|
||
|
|
</TABLE></BLOCKQUOTE>
|
||
|
|
<P>
|
||
|
|
|
||
|
|
<A NAME="How Overlays Work"></A>
|
||
|
|
<HR SIZE="6">
|
||
|
|
<A NAME="SEC98"></A>
|
||
|
|
<TABLE CELLPADDING=1 CELLSPACING=1 BORDER=0>
|
||
|
|
<TR><TD VALIGN="MIDDLE" ALIGN="LEFT">[<A HREF="gdb_12.html#SEC97"> < </A>]</TD>
|
||
|
|
<TD VALIGN="MIDDLE" ALIGN="LEFT">[<A HREF="gdb_12.html#SEC99"> > </A>]</TD>
|
||
|
|
<TD VALIGN="MIDDLE" ALIGN="LEFT"> <TD VALIGN="MIDDLE" ALIGN="LEFT">[<A HREF="gdb_12.html#SEC97"> << </A>]</TD>
|
||
|
|
<TD VALIGN="MIDDLE" ALIGN="LEFT">[<A HREF="gdb_12.html#SEC97"> Up </A>]</TD>
|
||
|
|
<TD VALIGN="MIDDLE" ALIGN="LEFT">[<A HREF="gdb_13.html#SEC102"> >> </A>]</TD>
|
||
|
|
<TD VALIGN="MIDDLE" ALIGN="LEFT"> <TD VALIGN="MIDDLE" ALIGN="LEFT"> <TD VALIGN="MIDDLE" ALIGN="LEFT"> <TD VALIGN="MIDDLE" ALIGN="LEFT"> <TD VALIGN="MIDDLE" ALIGN="LEFT">[<A HREF="gdb.html#SEC_Top">Top</A>]</TD>
|
||
|
|
<TD VALIGN="MIDDLE" ALIGN="LEFT">[<A HREF="gdb_toc.html#SEC_Contents">Contents</A>]</TD>
|
||
|
|
<TD VALIGN="MIDDLE" ALIGN="LEFT">[<A HREF="gdb_38.html#SEC764">Index</A>]</TD>
|
||
|
|
<TD VALIGN="MIDDLE" ALIGN="LEFT">[<A HREF="gdb_abt.html#SEC_About"> ? </A>]</TD>
|
||
|
|
</TR></TABLE>
|
||
|
|
<H2> 11.1 How Overlays Work </H2>
|
||
|
|
<!--docid::SEC98::-->
|
||
|
|
<P>
|
||
|
|
|
||
|
|
Suppose you have a computer whose instruction address space is only 64
|
||
|
|
kilobytes long, but which has much more memory which can be accessed by
|
||
|
|
other means: special instructions, segment registers, or memory
|
||
|
|
management hardware, for example. Suppose further that you want to
|
||
|
|
adapt a program which is larger than 64 kilobytes to run on this system.
|
||
|
|
</P><P>
|
||
|
|
|
||
|
|
One solution is to identify modules of your program which are relatively
|
||
|
|
independent, and need not call each other directly; call these modules
|
||
|
|
<EM>overlays</EM>. Separate the overlays from the main program, and place
|
||
|
|
their machine code in the larger memory. Place your main program in
|
||
|
|
instruction memory, but leave at least enough space there to hold the
|
||
|
|
largest overlay as well.
|
||
|
|
</P><P>
|
||
|
|
|
||
|
|
Now, to call a function located in an overlay, you must first copy that
|
||
|
|
overlay's machine code from the large memory into the space set aside
|
||
|
|
for it in the instruction memory, and then jump to its entry point
|
||
|
|
there.
|
||
|
|
</P><P>
|
||
|
|
|
||
|
|
<TABLE><tr><td> </td><td class=smallexample><FONT SIZE=-1><pre> Data Instruction Larger
|
||
|
|
Address Space Address Space Address Space
|
||
|
|
+-----------+ +-----------+ +-----------+
|
||
|
|
| | | | | |
|
||
|
|
+-----------+ +-----------+ +-----------+<-- overlay 1
|
||
|
|
| program | | main | .----| overlay 1 | load address
|
||
|
|
| variables | | program | | +-----------+
|
||
|
|
| and heap | | | | | |
|
||
|
|
+-----------+ | | | +-----------+<-- overlay 2
|
||
|
|
| | +-----------+ | | | load address
|
||
|
|
+-----------+ | | | .-| overlay 2 |
|
||
|
|
| | | | | |
|
||
|
|
mapped --->+-----------+ | | +-----------+
|
||
|
|
address | | | | | |
|
||
|
|
| overlay | <-' | | |
|
||
|
|
| area | <---' +-----------+<-- overlay 3
|
||
|
|
| | <---. | | load address
|
||
|
|
+-----------+ `--| overlay 3 |
|
||
|
|
| | | |
|
||
|
|
+-----------+ | |
|
||
|
|
+-----------+
|
||
|
|
| |
|
||
|
|
+-----------+
|
||
|
|
|
||
|
|
<A NAME="A code overlay"></A>
|
||
|
|
A code overlay
|
||
|
|
</FONT></pre></td></tr></table></P><P>
|
||
|
|
|
||
|
|
The diagram (see <A HREF="gdb_12.html#A code overlay">A code overlay</A>) shows a system with separate data
|
||
|
|
and instruction address spaces. To map an overlay, the program copies
|
||
|
|
its code from the larger address space to the instruction address space.
|
||
|
|
Since the overlays shown here all use the same mapped address, only one
|
||
|
|
may be mapped at a time. For a system with a single address space for
|
||
|
|
data and instructions, the diagram would be similar, except that the
|
||
|
|
program variables and heap would share an address space with the main
|
||
|
|
program and the overlay area.
|
||
|
|
</P><P>
|
||
|
|
|
||
|
|
An overlay loaded into instruction memory and ready for use is called a
|
||
|
|
<EM>mapped</EM> overlay; its <EM>mapped address</EM> is its address in the
|
||
|
|
instruction memory. An overlay not present (or only partially present)
|
||
|
|
in instruction memory is called <EM>unmapped</EM>; its <EM>load address</EM>
|
||
|
|
is its address in the larger memory. The mapped address is also called
|
||
|
|
the <EM>virtual memory address</EM>, or <EM>VMA</EM>; the load address is also
|
||
|
|
called the <EM>load memory address</EM>, or <EM>LMA</EM>.
|
||
|
|
</P><P>
|
||
|
|
|
||
|
|
Unfortunately, overlays are not a completely transparent way to adapt a
|
||
|
|
program to limited instruction memory. They introduce a new set of
|
||
|
|
global constraints you must keep in mind as you design your program:
|
||
|
|
</P><P>
|
||
|
|
|
||
|
|
<UL>
|
||
|
|
|
||
|
|
<LI>
|
||
|
|
Before calling or returning to a function in an overlay, your program
|
||
|
|
must make sure that overlay is actually mapped. Otherwise, the call or
|
||
|
|
return will transfer control to the right address, but in the wrong
|
||
|
|
overlay, and your program will probably crash.
|
||
|
|
<P>
|
||
|
|
|
||
|
|
<LI>
|
||
|
|
If the process of mapping an overlay is expensive on your system, you
|
||
|
|
will need to choose your overlays carefully to minimize their effect on
|
||
|
|
your program's performance.
|
||
|
|
<P>
|
||
|
|
|
||
|
|
<LI>
|
||
|
|
The executable file you load onto your system must contain each
|
||
|
|
overlay's instructions, appearing at the overlay's load address, not its
|
||
|
|
mapped address. However, each overlay's instructions must be relocated
|
||
|
|
and its symbols defined as if the overlay were at its mapped address.
|
||
|
|
You can use GNU linker scripts to specify different load and relocation
|
||
|
|
addresses for pieces of your program; see section `Overlay Description' in <CITE>Using ld: the GNU linker</CITE>.
|
||
|
|
<P>
|
||
|
|
|
||
|
|
<LI>
|
||
|
|
The procedure for loading executable files onto your system must be able
|
||
|
|
to load their contents into the larger address space as well as the
|
||
|
|
instruction and data spaces.
|
||
|
|
<P>
|
||
|
|
|
||
|
|
</UL>
|
||
|
|
<P>
|
||
|
|
|
||
|
|
The overlay system described above is rather simple, and could be
|
||
|
|
improved in many ways:
|
||
|
|
</P><P>
|
||
|
|
|
||
|
|
<UL>
|
||
|
|
|
||
|
|
<LI>
|
||
|
|
If your system has suitable bank switch registers or memory management
|
||
|
|
hardware, you could use those facilities to make an overlay's load area
|
||
|
|
contents simply appear at their mapped address in instruction space.
|
||
|
|
This would probably be faster than copying the overlay to its mapped
|
||
|
|
area in the usual way.
|
||
|
|
<P>
|
||
|
|
|
||
|
|
<LI>
|
||
|
|
If your overlays are small enough, you could set aside more than one
|
||
|
|
overlay area, and have more than one overlay mapped at a time.
|
||
|
|
<P>
|
||
|
|
|
||
|
|
<LI>
|
||
|
|
You can use overlays to manage data, as well as instructions. In
|
||
|
|
general, data overlays are even less transparent to your design than
|
||
|
|
code overlays: whereas code overlays only require care when you call or
|
||
|
|
return to functions, data overlays require care every time you access
|
||
|
|
the data. Also, if you change the contents of a data overlay, you
|
||
|
|
must copy its contents back out to its load address before you can copy a
|
||
|
|
different data overlay into the same mapped area.
|
||
|
|
<P>
|
||
|
|
|
||
|
|
</UL>
|
||
|
|
<P>
|
||
|
|
|
||
|
|
<A NAME="Overlay Commands"></A>
|
||
|
|
<HR SIZE="6">
|
||
|
|
<A NAME="SEC99"></A>
|
||
|
|
<TABLE CELLPADDING=1 CELLSPACING=1 BORDER=0>
|
||
|
|
<TR><TD VALIGN="MIDDLE" ALIGN="LEFT">[<A HREF="gdb_12.html#SEC98"> < </A>]</TD>
|
||
|
|
<TD VALIGN="MIDDLE" ALIGN="LEFT">[<A HREF="gdb_12.html#SEC100"> > </A>]</TD>
|
||
|
|
<TD VALIGN="MIDDLE" ALIGN="LEFT"> <TD VALIGN="MIDDLE" ALIGN="LEFT">[<A HREF="gdb_12.html#SEC100"> << </A>]</TD>
|
||
|
|
<TD VALIGN="MIDDLE" ALIGN="LEFT">[<A HREF="gdb_12.html#SEC97"> Up </A>]</TD>
|
||
|
|
<TD VALIGN="MIDDLE" ALIGN="LEFT">[<A HREF="gdb_13.html#SEC102"> >> </A>]</TD>
|
||
|
|
<TD VALIGN="MIDDLE" ALIGN="LEFT"> <TD VALIGN="MIDDLE" ALIGN="LEFT"> <TD VALIGN="MIDDLE" ALIGN="LEFT"> <TD VALIGN="MIDDLE" ALIGN="LEFT"> <TD VALIGN="MIDDLE" ALIGN="LEFT">[<A HREF="gdb.html#SEC_Top">Top</A>]</TD>
|
||
|
|
<TD VALIGN="MIDDLE" ALIGN="LEFT">[<A HREF="gdb_toc.html#SEC_Contents">Contents</A>]</TD>
|
||
|
|
<TD VALIGN="MIDDLE" ALIGN="LEFT">[<A HREF="gdb_38.html#SEC764">Index</A>]</TD>
|
||
|
|
<TD VALIGN="MIDDLE" ALIGN="LEFT">[<A HREF="gdb_abt.html#SEC_About"> ? </A>]</TD>
|
||
|
|
</TR></TABLE>
|
||
|
|
<H2> 11.2 Overlay Commands </H2>
|
||
|
|
<!--docid::SEC99::-->
|
||
|
|
<P>
|
||
|
|
|
||
|
|
To use GDB's overlay support, each overlay in your program must
|
||
|
|
correspond to a separate section of the executable file. The section's
|
||
|
|
virtual memory address and load memory address must be the overlay's
|
||
|
|
mapped and load addresses. Identifying overlays with sections allows
|
||
|
|
GDB to determine the appropriate address of a function or
|
||
|
|
variable, depending on whether the overlay is mapped or not.
|
||
|
|
</P><P>
|
||
|
|
|
||
|
|
GDB's overlay commands all start with the word <CODE>overlay</CODE>;
|
||
|
|
you can abbreviate this as <CODE>ov</CODE> or <CODE>ovly</CODE>. The commands are:
|
||
|
|
</P><P>
|
||
|
|
|
||
|
|
<DL COMPACT>
|
||
|
|
<DT><CODE>overlay off</CODE>
|
||
|
|
<DD><A NAME="IDX560"></A>
|
||
|
|
Disable GDB's overlay support. When overlay support is
|
||
|
|
disabled, GDB assumes that all functions and variables are
|
||
|
|
always present at their mapped addresses. By default, GDB's
|
||
|
|
overlay support is disabled.
|
||
|
|
<P>
|
||
|
|
|
||
|
|
<DT><CODE>overlay manual</CODE>
|
||
|
|
<DD><A NAME="IDX561"></A>
|
||
|
|
Enable <EM>manual</EM> overlay debugging. In this mode, GDB
|
||
|
|
relies on you to tell it which overlays are mapped, and which are not,
|
||
|
|
using the <CODE>overlay map-overlay</CODE> and <CODE>overlay unmap-overlay</CODE>
|
||
|
|
commands described below.
|
||
|
|
<P>
|
||
|
|
|
||
|
|
<DT><CODE>overlay map-overlay <VAR>overlay</VAR></CODE>
|
||
|
|
<DD><DT><CODE>overlay map <VAR>overlay</VAR></CODE>
|
||
|
|
<DD><A NAME="IDX562"></A>
|
||
|
|
Tell GDB that <VAR>overlay</VAR> is now mapped; <VAR>overlay</VAR> must
|
||
|
|
be the name of the object file section containing the overlay. When an
|
||
|
|
overlay is mapped, GDB assumes it can find the overlay's
|
||
|
|
functions and variables at their mapped addresses. GDB assumes
|
||
|
|
that any other overlays whose mapped ranges overlap that of
|
||
|
|
<VAR>overlay</VAR> are now unmapped.
|
||
|
|
<P>
|
||
|
|
|
||
|
|
<DT><CODE>overlay unmap-overlay <VAR>overlay</VAR></CODE>
|
||
|
|
<DD><DT><CODE>overlay unmap <VAR>overlay</VAR></CODE>
|
||
|
|
<DD><A NAME="IDX563"></A>
|
||
|
|
Tell GDB that <VAR>overlay</VAR> is no longer mapped; <VAR>overlay</VAR>
|
||
|
|
must be the name of the object file section containing the overlay.
|
||
|
|
When an overlay is unmapped, GDB assumes it can find the
|
||
|
|
overlay's functions and variables at their load addresses.
|
||
|
|
<P>
|
||
|
|
|
||
|
|
<DT><CODE>overlay auto</CODE>
|
||
|
|
<DD>Enable <EM>automatic</EM> overlay debugging. In this mode, GDB
|
||
|
|
consults a data structure the overlay manager maintains in the inferior
|
||
|
|
to see which overlays are mapped. For details, see <A HREF="gdb_12.html#SEC100">11.3 Automatic Overlay Debugging</A>.
|
||
|
|
<P>
|
||
|
|
|
||
|
|
<DT><CODE>overlay load-target</CODE>
|
||
|
|
<DD><DT><CODE>overlay load</CODE>
|
||
|
|
<DD><A NAME="IDX564"></A>
|
||
|
|
Re-read the overlay table from the inferior. Normally, GDB
|
||
|
|
re-reads the table GDB automatically each time the inferior
|
||
|
|
stops, so this command should only be necessary if you have changed the
|
||
|
|
overlay mapping yourself using GDB. This command is only
|
||
|
|
useful when using automatic overlay debugging.
|
||
|
|
<P>
|
||
|
|
|
||
|
|
<DT><CODE>overlay list-overlays</CODE>
|
||
|
|
<DD><DT><CODE>overlay list</CODE>
|
||
|
|
<DD><A NAME="IDX565"></A>
|
||
|
|
Display a list of the overlays currently mapped, along with their mapped
|
||
|
|
addresses, load addresses, and sizes.
|
||
|
|
<P>
|
||
|
|
|
||
|
|
</DL>
|
||
|
|
<P>
|
||
|
|
|
||
|
|
Normally, when GDB prints a code address, it includes the name
|
||
|
|
of the function the address falls in:
|
||
|
|
</P><P>
|
||
|
|
|
||
|
|
<TABLE><tr><td> </td><td class=smallexample><FONT SIZE=-1><pre>(gdb) print main
|
||
|
|
$3 = {int ()} 0x11a0 <main>
|
||
|
|
</FONT></pre></td></tr></table>When overlay debugging is enabled, GDB recognizes code in
|
||
|
|
unmapped overlays, and prints the names of unmapped functions with
|
||
|
|
asterisks around them. For example, if <CODE>foo</CODE> is a function in an
|
||
|
|
unmapped overlay, GDB prints it this way:
|
||
|
|
</P><P>
|
||
|
|
|
||
|
|
<TABLE><tr><td> </td><td class=smallexample><FONT SIZE=-1><pre>(gdb) overlay list
|
||
|
|
No sections are mapped.
|
||
|
|
(gdb) print foo
|
||
|
|
$5 = {int (int)} 0x100000 <*foo*>
|
||
|
|
</FONT></pre></td></tr></table>When <CODE>foo</CODE>'s overlay is mapped, GDB prints the function's
|
||
|
|
name normally:
|
||
|
|
</P><P>
|
||
|
|
|
||
|
|
<TABLE><tr><td> </td><td class=smallexample><FONT SIZE=-1><pre>(gdb) overlay list
|
||
|
|
Section .ov.foo.text, loaded at 0x100000 - 0x100034,
|
||
|
|
mapped at 0x1016 - 0x104a
|
||
|
|
(gdb) print foo
|
||
|
|
$6 = {int (int)} 0x1016 <foo>
|
||
|
|
</FONT></pre></td></tr></table></P><P>
|
||
|
|
|
||
|
|
When overlay debugging is enabled, GDB can find the correct
|
||
|
|
address for functions and variables in an overlay, whether or not the
|
||
|
|
overlay is mapped. This allows most GDB commands, like
|
||
|
|
<CODE>break</CODE> and <CODE>disassemble</CODE>, to work normally, even on unmapped
|
||
|
|
code. However, GDB's breakpoint support has some limitations:
|
||
|
|
</P><P>
|
||
|
|
|
||
|
|
<UL>
|
||
|
|
<LI>
|
||
|
|
<A NAME="IDX566"></A>
|
||
|
|
<A NAME="IDX567"></A>
|
||
|
|
You can set breakpoints in functions in unmapped overlays, as long as
|
||
|
|
GDB can write to the overlay at its load address.
|
||
|
|
<LI>
|
||
|
|
GDB can not set hardware or simulator-based breakpoints in
|
||
|
|
unmapped overlays. However, if you set a breakpoint at the end of your
|
||
|
|
overlay manager (and tell GDB which overlays are now mapped, if
|
||
|
|
you are using manual overlay management), GDB will re-set its
|
||
|
|
breakpoints properly.
|
||
|
|
</UL>
|
||
|
|
<P>
|
||
|
|
|
||
|
|
<A NAME="Automatic Overlay Debugging"></A>
|
||
|
|
<HR SIZE="6">
|
||
|
|
<A NAME="SEC100"></A>
|
||
|
|
<TABLE CELLPADDING=1 CELLSPACING=1 BORDER=0>
|
||
|
|
<TR><TD VALIGN="MIDDLE" ALIGN="LEFT">[<A HREF="gdb_12.html#SEC99"> < </A>]</TD>
|
||
|
|
<TD VALIGN="MIDDLE" ALIGN="LEFT">[<A HREF="gdb_12.html#SEC101"> > </A>]</TD>
|
||
|
|
<TD VALIGN="MIDDLE" ALIGN="LEFT"> <TD VALIGN="MIDDLE" ALIGN="LEFT">[<A HREF="gdb_12.html#SEC101"> << </A>]</TD>
|
||
|
|
<TD VALIGN="MIDDLE" ALIGN="LEFT">[<A HREF="gdb_12.html#SEC97"> Up </A>]</TD>
|
||
|
|
<TD VALIGN="MIDDLE" ALIGN="LEFT">[<A HREF="gdb_13.html#SEC102"> >> </A>]</TD>
|
||
|
|
<TD VALIGN="MIDDLE" ALIGN="LEFT"> <TD VALIGN="MIDDLE" ALIGN="LEFT"> <TD VALIGN="MIDDLE" ALIGN="LEFT"> <TD VALIGN="MIDDLE" ALIGN="LEFT"> <TD VALIGN="MIDDLE" ALIGN="LEFT">[<A HREF="gdb.html#SEC_Top">Top</A>]</TD>
|
||
|
|
<TD VALIGN="MIDDLE" ALIGN="LEFT">[<A HREF="gdb_toc.html#SEC_Contents">Contents</A>]</TD>
|
||
|
|
<TD VALIGN="MIDDLE" ALIGN="LEFT">[<A HREF="gdb_38.html#SEC764">Index</A>]</TD>
|
||
|
|
<TD VALIGN="MIDDLE" ALIGN="LEFT">[<A HREF="gdb_abt.html#SEC_About"> ? </A>]</TD>
|
||
|
|
</TR></TABLE>
|
||
|
|
<H2> 11.3 Automatic Overlay Debugging </H2>
|
||
|
|
<!--docid::SEC100::-->
|
||
|
|
<P>
|
||
|
|
|
||
|
|
GDB can automatically track which overlays are mapped and which
|
||
|
|
are not, given some simple co-operation from the overlay manager in the
|
||
|
|
inferior. If you enable automatic overlay debugging with the
|
||
|
|
<CODE>overlay auto</CODE> command (see section <A HREF="gdb_12.html#SEC99">11.2 Overlay Commands</A>), GDB
|
||
|
|
looks in the inferior's memory for certain variables describing the
|
||
|
|
current state of the overlays.
|
||
|
|
</P><P>
|
||
|
|
|
||
|
|
Here are the variables your overlay manager must define to support
|
||
|
|
GDB's automatic overlay debugging:
|
||
|
|
</P><P>
|
||
|
|
|
||
|
|
<DL COMPACT>
|
||
|
|
|
||
|
|
<DT><CODE>_ovly_table</CODE>:
|
||
|
|
<DD>This variable must be an array of the following structures:
|
||
|
|
<P>
|
||
|
|
|
||
|
|
<TABLE><tr><td> </td><td class=smallexample><FONT SIZE=-1><pre>struct
|
||
|
|
{
|
||
|
|
/* The overlay's mapped address. */
|
||
|
|
unsigned long vma;
|
||
|
|
|
||
|
|
/* The size of the overlay, in bytes. */
|
||
|
|
unsigned long size;
|
||
|
|
|
||
|
|
/* The overlay's load address. */
|
||
|
|
unsigned long lma;
|
||
|
|
|
||
|
|
/* Non-zero if the overlay is currently mapped;
|
||
|
|
zero otherwise. */
|
||
|
|
unsigned long mapped;
|
||
|
|
}
|
||
|
|
</FONT></pre></td></tr></table></P><P>
|
||
|
|
|
||
|
|
<DT><CODE>_novlys</CODE>:
|
||
|
|
<DD>This variable must be a four-byte signed integer, holding the total
|
||
|
|
number of elements in <CODE>_ovly_table</CODE>.
|
||
|
|
<P>
|
||
|
|
|
||
|
|
</DL>
|
||
|
|
<P>
|
||
|
|
|
||
|
|
To decide whether a particular overlay is mapped or not, GDB
|
||
|
|
looks for an entry in <CODE>_ovly_table</CODE> whose <CODE>vma</CODE> and
|
||
|
|
<CODE>lma</CODE> members equal the VMA and LMA of the overlay's section in the
|
||
|
|
executable file. When GDB finds a matching entry, it consults
|
||
|
|
the entry's <CODE>mapped</CODE> member to determine whether the overlay is
|
||
|
|
currently mapped.
|
||
|
|
</P><P>
|
||
|
|
|
||
|
|
In addition, your overlay manager may define a function called
|
||
|
|
<CODE>_ovly_debug_event</CODE>. If this function is defined, GDB
|
||
|
|
will silently set a breakpoint there. If the overlay manager then
|
||
|
|
calls this function whenever it has changed the overlay table, this
|
||
|
|
will enable GDB to accurately keep track of which overlays
|
||
|
|
are in program memory, and update any breakpoints that may be set
|
||
|
|
in overlays. This will allow breakpoints to work even if the
|
||
|
|
overlays are kept in ROM or other non-writable memory while they
|
||
|
|
are not being executed.
|
||
|
|
</P><P>
|
||
|
|
|
||
|
|
<A NAME="Overlay Sample Program"></A>
|
||
|
|
<HR SIZE="6">
|
||
|
|
<A NAME="SEC101"></A>
|
||
|
|
<TABLE CELLPADDING=1 CELLSPACING=1 BORDER=0>
|
||
|
|
<TR><TD VALIGN="MIDDLE" ALIGN="LEFT">[<A HREF="gdb_12.html#SEC100"> < </A>]</TD>
|
||
|
|
<TD VALIGN="MIDDLE" ALIGN="LEFT">[<A HREF="gdb_13.html#SEC102"> > </A>]</TD>
|
||
|
|
<TD VALIGN="MIDDLE" ALIGN="LEFT"> <TD VALIGN="MIDDLE" ALIGN="LEFT">[<A HREF="gdb_12.html#SEC97"> << </A>]</TD>
|
||
|
|
<TD VALIGN="MIDDLE" ALIGN="LEFT">[<A HREF="gdb_12.html#SEC97"> Up </A>]</TD>
|
||
|
|
<TD VALIGN="MIDDLE" ALIGN="LEFT">[<A HREF="gdb_13.html#SEC102"> >> </A>]</TD>
|
||
|
|
<TD VALIGN="MIDDLE" ALIGN="LEFT"> <TD VALIGN="MIDDLE" ALIGN="LEFT"> <TD VALIGN="MIDDLE" ALIGN="LEFT"> <TD VALIGN="MIDDLE" ALIGN="LEFT"> <TD VALIGN="MIDDLE" ALIGN="LEFT">[<A HREF="gdb.html#SEC_Top">Top</A>]</TD>
|
||
|
|
<TD VALIGN="MIDDLE" ALIGN="LEFT">[<A HREF="gdb_toc.html#SEC_Contents">Contents</A>]</TD>
|
||
|
|
<TD VALIGN="MIDDLE" ALIGN="LEFT">[<A HREF="gdb_38.html#SEC764">Index</A>]</TD>
|
||
|
|
<TD VALIGN="MIDDLE" ALIGN="LEFT">[<A HREF="gdb_abt.html#SEC_About"> ? </A>]</TD>
|
||
|
|
</TR></TABLE>
|
||
|
|
<H2> 11.4 Overlay Sample Program </H2>
|
||
|
|
<!--docid::SEC101::-->
|
||
|
|
<P>
|
||
|
|
|
||
|
|
When linking a program which uses overlays, you must place the overlays
|
||
|
|
at their load addresses, while relocating them to run at their mapped
|
||
|
|
addresses. To do this, you must write a linker script (see section `Overlay Description' in <CITE>Using ld: the GNU linker</CITE>). Unfortunately,
|
||
|
|
since linker scripts are specific to a particular host system, target
|
||
|
|
architecture, and target memory layout, this manual cannot provide
|
||
|
|
portable sample code demonstrating GDB's overlay support.
|
||
|
|
</P><P>
|
||
|
|
|
||
|
|
However, the GDB source distribution does contain an overlaid
|
||
|
|
program, with linker scripts for a few systems, as part of its test
|
||
|
|
suite. The program consists of the following files from
|
||
|
|
<TT>`gdb/testsuite/gdb.base'</TT>:
|
||
|
|
</P><P>
|
||
|
|
|
||
|
|
<DL COMPACT>
|
||
|
|
<DT><TT>`overlays.c'</TT>
|
||
|
|
<DD>The main program file.
|
||
|
|
<DT><TT>`ovlymgr.c'</TT>
|
||
|
|
<DD>A simple overlay manager, used by <TT>`overlays.c'</TT>.
|
||
|
|
<DT><TT>`foo.c'</TT>
|
||
|
|
<DD><DT><TT>`bar.c'</TT>
|
||
|
|
<DD><DT><TT>`baz.c'</TT>
|
||
|
|
<DD><DT><TT>`grbx.c'</TT>
|
||
|
|
<DD>Overlay modules, loaded and used by <TT>`overlays.c'</TT>.
|
||
|
|
<DT><TT>`d10v.ld'</TT>
|
||
|
|
<DD><DT><TT>`m32r.ld'</TT>
|
||
|
|
<DD>Linker scripts for linking the test program on the <CODE>d10v-elf</CODE>
|
||
|
|
and <CODE>m32r-elf</CODE> targets.
|
||
|
|
</DL>
|
||
|
|
<P>
|
||
|
|
|
||
|
|
You can build the test program using the <CODE>d10v-elf</CODE> GCC
|
||
|
|
cross-compiler like this:
|
||
|
|
</P><P>
|
||
|
|
|
||
|
|
<TABLE><tr><td> </td><td class=smallexample><FONT SIZE=-1><pre>$ d10v-elf-gcc -g -c overlays.c
|
||
|
|
$ d10v-elf-gcc -g -c ovlymgr.c
|
||
|
|
$ d10v-elf-gcc -g -c foo.c
|
||
|
|
$ d10v-elf-gcc -g -c bar.c
|
||
|
|
$ d10v-elf-gcc -g -c baz.c
|
||
|
|
$ d10v-elf-gcc -g -c grbx.c
|
||
|
|
$ d10v-elf-gcc -g overlays.o ovlymgr.o foo.o bar.o \
|
||
|
|
baz.o grbx.o -Wl,-Td10v.ld -o overlays
|
||
|
|
</FONT></pre></td></tr></table></P><P>
|
||
|
|
|
||
|
|
The build process is identical for any other architecture, except that
|
||
|
|
you must substitute the appropriate compiler and linker script for the
|
||
|
|
target system for <CODE>d10v-elf-gcc</CODE> and <CODE>d10v.ld</CODE>.
|
||
|
|
</P><P>
|
||
|
|
|
||
|
|
<A NAME="Languages"></A>
|
||
|
|
<HR SIZE="6">
|
||
|
|
<TABLE CELLPADDING=1 CELLSPACING=1 BORDER=0>
|
||
|
|
<TR><TD VALIGN="MIDDLE" ALIGN="LEFT">[<A HREF="gdb_12.html#SEC97"> << </A>]</TD>
|
||
|
|
<TD VALIGN="MIDDLE" ALIGN="LEFT">[<A HREF="gdb_13.html#SEC102"> >> </A>]</TD>
|
||
|
|
<TD VALIGN="MIDDLE" ALIGN="LEFT"> <TD VALIGN="MIDDLE" ALIGN="LEFT"> <TD VALIGN="MIDDLE" ALIGN="LEFT"> <TD VALIGN="MIDDLE" ALIGN="LEFT"> <TD VALIGN="MIDDLE" ALIGN="LEFT"> <TD VALIGN="MIDDLE" ALIGN="LEFT">[<A HREF="gdb.html#SEC_Top">Top</A>]</TD>
|
||
|
|
<TD VALIGN="MIDDLE" ALIGN="LEFT">[<A HREF="gdb_toc.html#SEC_Contents">Contents</A>]</TD>
|
||
|
|
<TD VALIGN="MIDDLE" ALIGN="LEFT">[<A HREF="gdb_38.html#SEC764">Index</A>]</TD>
|
||
|
|
<TD VALIGN="MIDDLE" ALIGN="LEFT">[<A HREF="gdb_abt.html#SEC_About"> ? </A>]</TD>
|
||
|
|
</TR></TABLE>
|
||
|
|
<BR>
|
||
|
|
<FONT SIZE="-1">
|
||
|
|
|
||
|
|
<address>
|
||
|
|
|
||
|
|
<p>Please send FSF & GNU inquiries & questions to <a
|
||
|
|
href="mailto:gnu@gnu.org">gnu@gnu.org</a>. There are also <a
|
||
|
|
href="http://www.gnu.org/home.html#ContactInfo">other ways to
|
||
|
|
contact</a> the FSF.</p>
|
||
|
|
|
||
|
|
<p>These pages are maintained by <a
|
||
|
|
href="http://www.gnu.org/software/gdb/">the GDB developers</a>.</p>
|
||
|
|
|
||
|
|
<p>Copyright Free Software Foundation, Inc., 59 Temple Place - Suite
|
||
|
|
330, Boston, MA 02111, USA.</p>
|
||
|
|
|
||
|
|
<p>Verbatim copying and distribution of this entire article is
|
||
|
|
permitted in any medium, provided this notice is preserved.</p>
|
||
|
|
|
||
|
|
</address>
|
||
|
|
|
||
|
|
This document was generated
|
||
|
|
by <I>GDB Administrator</I> on <I>March, 27 2008</I>
|
||
|
|
using <A HREF="http://www.mathematik.uni-kl.de/~obachman/Texi2html
|
||
|
|
"><I>texi2html</I></A>
|
||
|
|
|
||
|
|
</BODY>
|
||
|
|
</HTML>
|