Re: [rfa/doco] Srink the overlay diagram

[Andrew Cagney <ac131313@cygnus.com>]

[-- Attachment #1: Type: text/plain, Size: 228 bytes --]

> I think:
> 
>     @example @group
>     <figure>
>     @anchor{x-spot the title}<title>
>     @end end
> 
> Diagram @xref{x-spot the title} .... would work better.


The attached does this.  I ended up using @pxref{}.

Andrew

[-- Attachment #2: diffs --]
[-- Type: text/plain, Size: 5333 bytes --]

2002-01-21  Andrew Cagney  <ac131313@redhat.com>

	* gdb.texinfo (How Overlays Work): Srink the overlay diagram.

Index: gdb.texinfo
===================================================================
RCS file: /cvs/src/src/gdb/doc/gdb.texinfo,v
retrieving revision 1.76
diff -p -r1.76 gdb.texinfo
*** gdb.texinfo	2002/01/20 11:59:38	1.76
--- gdb.texinfo	2002/01/29 21:55:57
*************** overlay's machine code from the large me
*** 6418,6461 ****
  for it in the instruction memory, and then jump to its entry point
  there.
  
  @example
  @group
!     Data                   Instruction            Larger
! Address Space             Address Space        Address Space
! +-----------+             +-----------+        +-----------+
! |           |             |           |        |           |
! +-----------+             +-----------+        +-----------+<-- overlay 1
! | program   |             |   main    |        |           | load address
! | variables |             |  program  |        | overlay 1 |
! | and heap  |             |           |    ,---|           |
! +-----------+             |           |    |   |           |
! |           |             +-----------+    |   +-----------+
! +-----------+             |           |    |   |           |
!                mapped --->+-----------+    /   +-----------+<-- overlay 2
!                address    |  overlay  | <-'    | overlay 2 | load address
!                           |   area    |  <-----|           |
!                           |           | <---.  +-----------+
!                           |           |     |  |           |
!                           +-----------+     |  |           |
!                           |           |     |  +-----------+<-- overlay 3
!                           +-----------+     `--|           | load address
!                                                | overlay 3 |
!                                                |           |
!                                                +-----------+
!                                                |           |
!                                                +-----------+
  
!     To map an overlay, copy 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.
  @end group
  @end example
  
! This diagram shows a system with separate data and instruction address
! spaces.  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.
  
  An overlay loaded into instruction memory and ready for use is called a
  @dfn{mapped} overlay; its @dfn{mapped address} is its address in the
--- 6418,6465 ----
  for it in the instruction memory, and then jump to its entry point
  there.
  
+ @c NB:  In the below the mapped area's size is greater or equal to the
+ @c size of all overlays.  This is intentional to remind the developer
+ @c overlays don't necessarily need to be the same size.
+ 
  @example
  @group
!     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 |
!                     |           |        |           |
!                     +-----------+        |           |
!                                          +-----------+
!                                          |           |
!                                          +-----------+
  
!                     @anchor{A code overlay}A code overlay
  @end group
  @end example
  
! The diagram (@pxref{A code overlay}) 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.
  
  An overlay loaded into instruction memory and ready for use is called a
  @dfn{mapped} overlay; its @dfn{mapped address} is its address in the