Lines Matching refs:overlay
7285 @cindex load address, overlay's
7287 @cindex overlay area
7300 largest overlay as well.
7302 Now, to call a function located in an overlay, you must first copy that
7303 overlay's machine code from the large memory into the space set aside
7317 +-----------+ +-----------+ +-----------+<-- overlay 1
7318 | program | | main | .----| overlay 1 | load address
7321 +-----------+ | | | +-----------+<-- overlay 2
7323 +-----------+ | | | .-| overlay 2 |
7327 | overlay | <-' | | |
7328 | area | <---' +-----------+<-- overlay 3
7330 +-----------+ `--| overlay 3 |
7337 @anchor{A code overlay}A code overlay
7341 The diagram (@pxref{A code overlay}) shows a system with separate data
7342 and instruction address spaces. To map an overlay, the program copies
7348 program and the overlay area.
7350 An overlay loaded into instruction memory and ready for use is called a
7351 @dfn{mapped} overlay; its @dfn{mapped address} is its address in the
7352 instruction memory. An overlay not present (or only partially present)
7365 Before calling or returning to a function in an overlay, your program
7366 must make sure that overlay is actually mapped. Otherwise, the call or
7368 overlay, and your program will probably crash.
7371 If the process of mapping an overlay is expensive on your system, you
7377 overlay's instructions, appearing at the overlay's load address, not its
7378 mapped address. However, each overlay's instructions must be relocated
7379 and its symbols defined as if the overlay were at its mapped address.
7391 The overlay system described above is rather simple, and could be
7398 hardware, you could use those facilities to make an overlay's load area
7400 This would probably be faster than copying the overlay to its mapped
7405 overlay area, and have more than one overlay mapped at a time.
7412 the data. Also, if you change the contents of a data overlay, you
7414 different data overlay into the same mapped area.
7422 To use @value{GDBN}'s overlay support, each overlay in your program must
7424 virtual memory address and load memory address must be the overlay's
7427 variable, depending on whether the overlay is mapped or not.
7429 @value{GDBN}'s overlay commands all start with the word @code{overlay};
7433 @item overlay off
7434 @kindex overlay
7435 Disable @value{GDBN}'s overlay support. When overlay support is
7438 overlay support is disabled.
7440 @item overlay manual
7441 @cindex manual overlay debugging
7442 Enable @dfn{manual} overlay debugging. In this mode, @value{GDBN}
7444 using the @code{overlay map-overlay} and @code{overlay unmap-overlay}
7447 @item overlay map-overlay @var{overlay}
7448 @itemx overlay map @var{overlay}
7449 @cindex map an overlay
7450 Tell @value{GDBN} that @var{overlay} is now mapped; @var{overlay} must
7451 be the name of the object file section containing the overlay. When an
7452 overlay is mapped, @value{GDBN} assumes it can find the overlay's
7455 @var{overlay} are now unmapped.
7457 @item overlay unmap-overlay @var{overlay}
7458 @itemx overlay unmap @var{overlay}
7459 @cindex unmap an overlay
7460 Tell @value{GDBN} that @var{overlay} is no longer mapped; @var{overlay}
7461 must be the name of the object file section containing the overlay.
7462 When an overlay is unmapped, @value{GDBN} assumes it can find the
7463 overlay's functions and variables at their load addresses.
7465 @item overlay auto
7466 Enable @dfn{automatic} overlay debugging. In this mode, @value{GDBN}
7467 consults a data structure the overlay manager maintains in the inferior
7471 @item overlay load-target
7472 @itemx overlay load
7473 @cindex reloading the overlay table
7474 Re-read the overlay table from the inferior. Normally, @value{GDBN}
7477 overlay mapping yourself using @value{GDBN}. This command is only
7478 useful when using automatic overlay debugging.
7480 @item overlay list-overlays
7481 @itemx overlay list
7496 When overlay debugging is enabled, @value{GDBN} recognizes code in
7499 unmapped overlay, @value{GDBN} prints it this way:
7502 (@value{GDBP}) overlay list
7508 When @code{foo}'s overlay is mapped, @value{GDBN} prints the function's
7512 (@value{GDBP}) overlay list
7519 When overlay debugging is enabled, @value{GDBN} can find the correct
7520 address for functions and variables in an overlay, whether or not the
7521 overlay is mapped. This allows most @value{GDBN} commands, like
7530 @value{GDBN} can write to the overlay at its load address.
7534 overlay manager (and tell @value{GDBN} which overlays are now mapped, if
7535 you are using manual overlay management), @value{GDBN} will re-set its
7542 @cindex automatic overlay debugging
7545 are not, given some simple co-operation from the overlay manager in the
7546 inferior. If you enable automatic overlay debugging with the
7547 @code{overlay auto} command (@pxref{Overlay Commands}), @value{GDBN}
7551 Here are the variables your overlay manager must define to support
7552 @value{GDBN}'s automatic overlay debugging:
7562 /* The overlay's mapped address. */
7565 /* The size of the overlay, in bytes. */
7568 /* The overlay's load address. */
7571 /* Non-zero if the overlay is currently mapped;
7583 To decide whether a particular overlay is mapped or not, @value{GDBN}
7585 @code{lma} members equal the VMA and LMA of the overlay's section in the
7587 the entry's @code{mapped} member to determine whether the overlay is
7590 In addition, your overlay manager may define a function called
7592 will silently set a breakpoint there. If the overlay manager then
7593 calls this function whenever it has changed the overlay table, this
7602 @cindex overlay example program
7610 portable sample code demonstrating @value{GDBN}'s overlay support.
7621 A simple overlay manager, used by @file{overlays.c}.
17431 The memory overlay commands are not implemented.
17433 @c @subheading -overlay-auto
17435 @c @subheading -overlay-list-mapping-state
17437 @c @subheading -overlay-list-overlays
17439 @c @subheading -overlay-map
17441 @c @subheading -overlay-off
17443 @c @subheading -overlay-on
17445 @c @subheading -overlay-unmap