URL https://opencores.org/ocsvn/openrisc_2011-10-31/openrisc_2011-10-31/trunk

Subversion Repositories openrisc_2011-10-31

[/] [openrisc/] [tags/] [gnu-src/] [gdb-6.8/] [pre-binutils-2.20.1-sync/] [gdb/] [doc/] [gdbint.info-1] - Diff between revs 157 and 223

Go to most recent revision | Only display areas with differences | Details | Blame | View Log

Rev 157 Rev 223

This is gdbint.info, produced by makeinfo version 4.8 from

This is gdbint.info, produced by makeinfo version 4.8 from

../.././gdb/doc/gdbint.texinfo.

../.././gdb/doc/gdbint.texinfo.

INFO-DIR-SECTION Software development

INFO-DIR-SECTION Software development

START-INFO-DIR-ENTRY

START-INFO-DIR-ENTRY

* Gdb-Internals: (gdbint).      The GNU debugger's internals.

* Gdb-Internals: (gdbint).      The GNU debugger's internals.

END-INFO-DIR-ENTRY

END-INFO-DIR-ENTRY

   This file documents the internals of the GNU debugger GDB.

   This file documents the internals of the GNU debugger GDB.

Copyright (C) 1990, 1991, 1992, 1993, 1994, 1996, 1998, 1999, 2000,

Copyright (C) 1990, 1991, 1992, 1993, 1994, 1996, 1998, 1999, 2000,

2001,    2002, 2003, 2004, 2005, 2006    Free Software Foundation, Inc.

2001,    2002, 2003, 2004, 2005, 2006    Free Software Foundation, Inc.

Contributed by Cygnus Solutions.  Written by John Gilmore.  Second

Contributed by Cygnus Solutions.  Written by John Gilmore.  Second

Edition by Stan Shebs.

Edition by Stan Shebs.

   Permission is granted to copy, distribute and/or modify this document

   Permission is granted to copy, distribute and/or modify this document

under the terms of the GNU Free Documentation License, Version 1.1 or

under the terms of the GNU Free Documentation License, Version 1.1 or

any later version published by the Free Software Foundation; with no

any later version published by the Free Software Foundation; with no

Invariant Sections, with no Front-Cover Texts, and with no Back-Cover

Invariant Sections, with no Front-Cover Texts, and with no Back-Cover

Texts.  A copy of the license is included in the section entitled "GNU

Texts.  A copy of the license is included in the section entitled "GNU

Free Documentation License".

Free Documentation License".

File: gdbint.info,  Node: Top,  Next: Requirements,  Up: (dir)

File: gdbint.info,  Node: Top,  Next: Requirements,  Up: (dir)

Scope of this Document

Scope of this Document

**********************

**********************

This document documents the internals of the GNU debugger, GDB.  It

This document documents the internals of the GNU debugger, GDB.  It

includes description of GDB's key algorithms and operations, as well as

includes description of GDB's key algorithms and operations, as well as

the mechanisms that adapt GDB to specific hosts and targets.

the mechanisms that adapt GDB to specific hosts and targets.

* Menu:

* Menu:

* Requirements::

* Requirements::

* Overall Structure::

* Overall Structure::

* Algorithms::

* Algorithms::

* User Interface::

* User Interface::

* libgdb::

* libgdb::

* Symbol Handling::

* Symbol Handling::

* Language Support::

* Language Support::

* Host Definition::

* Host Definition::

* Target Architecture Definition::

* Target Architecture Definition::

* Target Descriptions::

* Target Descriptions::

* Target Vector Definition::

* Target Vector Definition::

* Native Debugging::

* Native Debugging::

* Support Libraries::

* Support Libraries::

* Coding::

* Coding::

* Porting GDB::

* Porting GDB::

* Versions and Branches::

* Versions and Branches::

* Start of New Year Procedure::

* Start of New Year Procedure::

* Releasing GDB::

* Releasing GDB::

* Testsuite::

* Testsuite::

* Hints::

* Hints::

* GDB Observers::  GDB Currently available observers

* GDB Observers::  GDB Currently available observers

* GNU Free Documentation License::  The license for this documentation

* GNU Free Documentation License::  The license for this documentation

* Index::

* Index::

File: gdbint.info,  Node: Requirements,  Next: Overall Structure,  Prev: Top,  Up: Top

File: gdbint.info,  Node: Requirements,  Next: Overall Structure,  Prev: Top,  Up: Top

1 Requirements

1 Requirements

**************

**************

Before diving into the internals, you should understand the formal

Before diving into the internals, you should understand the formal

requirements and other expectations for GDB.  Although some of these

requirements and other expectations for GDB.  Although some of these

may seem obvious, there have been proposals for GDB that have run

may seem obvious, there have been proposals for GDB that have run

counter to these requirements.

counter to these requirements.

   First of all, GDB is a debugger.  It's not designed to be a front

   First of all, GDB is a debugger.  It's not designed to be a front

panel for embedded systems.  It's not a text editor.  It's not a shell.

panel for embedded systems.  It's not a text editor.  It's not a shell.

It's not a programming environment.

It's not a programming environment.

   GDB is an interactive tool.  Although a batch mode is available,

   GDB is an interactive tool.  Although a batch mode is available,

GDB's primary role is to interact with a human programmer.

GDB's primary role is to interact with a human programmer.

   GDB should be responsive to the user.  A programmer hot on the trail

   GDB should be responsive to the user.  A programmer hot on the trail

of a nasty bug, and operating under a looming deadline, is going to be

of a nasty bug, and operating under a looming deadline, is going to be

very impatient of everything, including the response time to debugger

very impatient of everything, including the response time to debugger

commands.

commands.

   GDB should be relatively permissive, such as for expressions.  While

   GDB should be relatively permissive, such as for expressions.  While

the compiler should be picky (or have the option to be made picky),

the compiler should be picky (or have the option to be made picky),

since source code lives for a long time usually, the programmer doing

since source code lives for a long time usually, the programmer doing

debugging shouldn't be spending time figuring out to mollify the

debugging shouldn't be spending time figuring out to mollify the

debugger.

debugger.

   GDB will be called upon to deal with really large programs.

   GDB will be called upon to deal with really large programs.

Executable sizes of 50 to 100 megabytes occur regularly, and we've

Executable sizes of 50 to 100 megabytes occur regularly, and we've

heard reports of programs approaching 1 gigabyte in size.

heard reports of programs approaching 1 gigabyte in size.

   GDB should be able to run everywhere.  No other debugger is

   GDB should be able to run everywhere.  No other debugger is

available for even half as many configurations as GDB supports.

available for even half as many configurations as GDB supports.

File: gdbint.info,  Node: Overall Structure,  Next: Algorithms,  Prev: Requirements,  Up: Top

File: gdbint.info,  Node: Overall Structure,  Next: Algorithms,  Prev: Requirements,  Up: Top

2 Overall Structure

2 Overall Structure

*******************

*******************

GDB consists of three major subsystems: user interface, symbol handling

GDB consists of three major subsystems: user interface, symbol handling

(the "symbol side"), and target system handling (the "target side").

(the "symbol side"), and target system handling (the "target side").

   The user interface consists of several actual interfaces, plus

   The user interface consists of several actual interfaces, plus

supporting code.

supporting code.

   The symbol side consists of object file readers, debugging info

   The symbol side consists of object file readers, debugging info

interpreters, symbol table management, source language expression

interpreters, symbol table management, source language expression

parsing, type and value printing.

parsing, type and value printing.

   The target side consists of execution control, stack frame analysis,

   The target side consists of execution control, stack frame analysis,

and physical target manipulation.

and physical target manipulation.

   The target side/symbol side division is not formal, and there are a

   The target side/symbol side division is not formal, and there are a

number of exceptions.  For instance, core file support involves symbolic

number of exceptions.  For instance, core file support involves symbolic

elements (the basic core file reader is in BFD) and target elements (it

elements (the basic core file reader is in BFD) and target elements (it

supplies the contents of memory and the values of registers).  Instead,

supplies the contents of memory and the values of registers).  Instead,

this division is useful for understanding how the minor subsystems

this division is useful for understanding how the minor subsystems

should fit together.

should fit together.

2.1 The Symbol Side

2.1 The Symbol Side

===================

===================

The symbolic side of GDB can be thought of as "everything you can do in

The symbolic side of GDB can be thought of as "everything you can do in

GDB without having a live program running".  For instance, you can look

GDB without having a live program running".  For instance, you can look

at the types of variables, and evaluate many kinds of expressions.

at the types of variables, and evaluate many kinds of expressions.

2.2 The Target Side

2.2 The Target Side

===================

===================

The target side of GDB is the "bits and bytes manipulator".  Although

The target side of GDB is the "bits and bytes manipulator".  Although

it may make reference to symbolic info here and there, most of the

it may make reference to symbolic info here and there, most of the

target side will run with only a stripped executable available--or even

target side will run with only a stripped executable available--or even

no executable at all, in remote debugging cases.

no executable at all, in remote debugging cases.

   Operations such as disassembly, stack frame crawls, and register

   Operations such as disassembly, stack frame crawls, and register

display, are able to work with no symbolic info at all.  In some cases,

display, are able to work with no symbolic info at all.  In some cases,

such as disassembly, GDB will use symbolic info to present addresses

such as disassembly, GDB will use symbolic info to present addresses

relative to symbols rather than as raw numbers, but it will work either

relative to symbols rather than as raw numbers, but it will work either

way.

way.

2.3 Configurations

2.3 Configurations

==================

==================

"Host" refers to attributes of the system where GDB runs.  "Target"

"Host" refers to attributes of the system where GDB runs.  "Target"

refers to the system where the program being debugged executes.  In

refers to the system where the program being debugged executes.  In

most cases they are the same machine, in which case a third type of

most cases they are the same machine, in which case a third type of

"Native" attributes come into play.

"Native" attributes come into play.

   Defines and include files needed to build on the host are host

   Defines and include files needed to build on the host are host

support.  Examples are tty support, system defined types, host byte

support.  Examples are tty support, system defined types, host byte

order, host float format.

order, host float format.

   Defines and information needed to handle the target format are target

   Defines and information needed to handle the target format are target

dependent.  Examples are the stack frame format, instruction set,

dependent.  Examples are the stack frame format, instruction set,

breakpoint instruction, registers, and how to set up and tear down the

breakpoint instruction, registers, and how to set up and tear down the

stack to call a function.

stack to call a function.

   Information that is only needed when the host and target are the

   Information that is only needed when the host and target are the

same, is native dependent.  One example is Unix child process support;

same, is native dependent.  One example is Unix child process support;

if the host and target are not the same, doing a fork to start the

if the host and target are not the same, doing a fork to start the

target process is a bad idea.  The various macros needed for finding the

target process is a bad idea.  The various macros needed for finding the

registers in the `upage', running `ptrace', and such are all in the

registers in the `upage', running `ptrace', and such are all in the

native-dependent files.

native-dependent files.

   Another example of native-dependent code is support for features that

   Another example of native-dependent code is support for features that

are really part of the target environment, but which require `#include'

are really part of the target environment, but which require `#include'

files that are only available on the host system.  Core file handling

files that are only available on the host system.  Core file handling

and `setjmp' handling are two common cases.

and `setjmp' handling are two common cases.

   When you want to make GDB work "native" on a particular machine, you

   When you want to make GDB work "native" on a particular machine, you

have to include all three kinds of information.

have to include all three kinds of information.

2.4 Source Tree Structure

2.4 Source Tree Structure

=========================

=========================

The GDB source directory has a mostly flat structure--there are only a

The GDB source directory has a mostly flat structure--there are only a

few subdirectories.  A file's name usually gives a hint as to what it

few subdirectories.  A file's name usually gives a hint as to what it

does; for example, `stabsread.c' reads stabs, `dwarf2read.c' reads

does; for example, `stabsread.c' reads stabs, `dwarf2read.c' reads

DWARF 2, etc.

DWARF 2, etc.

   Files that are related to some common task have names that share

   Files that are related to some common task have names that share

common substrings.  For example, `*-thread.c' files deal with debugging

common substrings.  For example, `*-thread.c' files deal with debugging

threads on various platforms; `*read.c' files deal with reading various

threads on various platforms; `*read.c' files deal with reading various

kinds of symbol and object files; `inf*.c' files deal with direct

kinds of symbol and object files; `inf*.c' files deal with direct

control of the "inferior program" (GDB parlance for the program being

control of the "inferior program" (GDB parlance for the program being

debugged).

debugged).

   There are several dozens of files in the `*-tdep.c' family.  `tdep'

   There are several dozens of files in the `*-tdep.c' family.  `tdep'

stands for "target-dependent code"--each of these files implements

stands for "target-dependent code"--each of these files implements

debug support for a specific target architecture (sparc, mips, etc).

debug support for a specific target architecture (sparc, mips, etc).

Usually, only one of these will be used in a specific GDB configuration

Usually, only one of these will be used in a specific GDB configuration

(sometimes two, closely related).

(sometimes two, closely related).

   Similarly, there are many `*-nat.c' files, each one for native

   Similarly, there are many `*-nat.c' files, each one for native

debugging on a specific system (e.g., `sparc-linux-nat.c' is for native

debugging on a specific system (e.g., `sparc-linux-nat.c' is for native

debugging of Sparc machines running the Linux kernel).

debugging of Sparc machines running the Linux kernel).

   The few subdirectories of the source tree are:

   The few subdirectories of the source tree are:

`cli'

`cli'

     Code that implements "CLI", the GDB Command-Line Interpreter.

     Code that implements "CLI", the GDB Command-Line Interpreter.

     *Note Command Interpreter: User Interface.

     *Note Command Interpreter: User Interface.

`gdbserver'

`gdbserver'

     Code for the GDB remote server.

     Code for the GDB remote server.

`gdbtk'

`gdbtk'

     Code for Insight, the GDB TK-based GUI front-end.

     Code for Insight, the GDB TK-based GUI front-end.

`mi'

`mi'

     The "GDB/MI", the GDB Machine Interface interpreter.

     The "GDB/MI", the GDB Machine Interface interpreter.

`signals'

`signals'

     Target signal translation code.

     Target signal translation code.

`tui'

`tui'

     Code for "TUI", the GDB Text-mode full-screen User Interface.

     Code for "TUI", the GDB Text-mode full-screen User Interface.

     *Note TUI: User Interface.

     *Note TUI: User Interface.

File: gdbint.info,  Node: Algorithms,  Next: User Interface,  Prev: Overall Structure,  Up: Top

File: gdbint.info,  Node: Algorithms,  Next: User Interface,  Prev: Overall Structure,  Up: Top

3 Algorithms

3 Algorithms

************

************

GDB uses a number of debugging-specific algorithms.  They are often not

GDB uses a number of debugging-specific algorithms.  They are often not

very complicated, but get lost in the thicket of special cases and

very complicated, but get lost in the thicket of special cases and

real-world issues.  This chapter describes the basic algorithms and

real-world issues.  This chapter describes the basic algorithms and

mentions some of the specific target definitions that they use.

mentions some of the specific target definitions that they use.

3.1 Frames

3.1 Frames

==========

==========

A frame is a construct that GDB uses to keep track of calling and

A frame is a construct that GDB uses to keep track of calling and

called functions.

called functions.

   GDB's frame model, a fresh design, was implemented with the need to

   GDB's frame model, a fresh design, was implemented with the need to

support DWARF's Call Frame Information in mind.  In fact, the term

support DWARF's Call Frame Information in mind.  In fact, the term

"unwind" is taken directly from that specification.  Developers wishing

"unwind" is taken directly from that specification.  Developers wishing

to learn more about unwinders, are encouraged to read the DWARF

to learn more about unwinders, are encouraged to read the DWARF

specification.

specification.

   GDB's model is that you find a frame's registers by "unwinding" them

   GDB's model is that you find a frame's registers by "unwinding" them

from the next younger frame.  That is, `get_frame_register' which

from the next younger frame.  That is, `get_frame_register' which

returns the value of a register in frame #1 (the next-to-youngest

returns the value of a register in frame #1 (the next-to-youngest

frame), is implemented by calling frame #0's `frame_register_unwind'

frame), is implemented by calling frame #0's `frame_register_unwind'

(the youngest frame).  But then the obvious question is: how do you

(the youngest frame).  But then the obvious question is: how do you

access the registers of the youngest frame itself?

access the registers of the youngest frame itself?

   To answer this question, GDB has the "sentinel" frame, the "-1st"

   To answer this question, GDB has the "sentinel" frame, the "-1st"

frame.  Unwinding registers from the sentinel frame gives you the

frame.  Unwinding registers from the sentinel frame gives you the

current values of the youngest real frame's registers.  If F is a

current values of the youngest real frame's registers.  If F is a

sentinel frame, then `get_frame_type (F) == SENTINEL_FRAME'.

sentinel frame, then `get_frame_type (F) == SENTINEL_FRAME'.

3.2 Prologue Analysis

3.2 Prologue Analysis

=====================

=====================

To produce a backtrace and allow the user to manipulate older frames'

To produce a backtrace and allow the user to manipulate older frames'

variables and arguments, GDB needs to find the base addresses of older

variables and arguments, GDB needs to find the base addresses of older

frames, and discover where those frames' registers have been saved.

frames, and discover where those frames' registers have been saved.

Since a frame's "callee-saves" registers get saved by younger frames if

Since a frame's "callee-saves" registers get saved by younger frames if

and when they're reused, a frame's registers may be scattered

and when they're reused, a frame's registers may be scattered

unpredictably across younger frames.  This means that changing the

unpredictably across younger frames.  This means that changing the

value of a register-allocated variable in an older frame may actually

value of a register-allocated variable in an older frame may actually

entail writing to a save slot in some younger frame.

entail writing to a save slot in some younger frame.

   Modern versions of GCC emit Dwarf call frame information ("CFI"),

   Modern versions of GCC emit Dwarf call frame information ("CFI"),

which describes how to find frame base addresses and saved registers.

which describes how to find frame base addresses and saved registers.

But CFI is not always available, so as a fallback GDB uses a technique

But CFI is not always available, so as a fallback GDB uses a technique

called "prologue analysis" to find frame sizes and saved registers.  A

called "prologue analysis" to find frame sizes and saved registers.  A

prologue analyzer disassembles the function's machine code starting

prologue analyzer disassembles the function's machine code starting

from its entry point, and looks for instructions that allocate frame

from its entry point, and looks for instructions that allocate frame

space, save the stack pointer in a frame pointer register, save

space, save the stack pointer in a frame pointer register, save

registers, and so on.  Obviously, this can't be done accurately in

registers, and so on.  Obviously, this can't be done accurately in

general, but it's tractable to do well enough to be very helpful.

general, but it's tractable to do well enough to be very helpful.

Prologue analysis predates the GNU toolchain's support for CFI; at one

Prologue analysis predates the GNU toolchain's support for CFI; at one

time, prologue analysis was the only mechanism GDB used for stack

time, prologue analysis was the only mechanism GDB used for stack

unwinding at all, when the function calling conventions didn't specify

unwinding at all, when the function calling conventions didn't specify

a fixed frame layout.

a fixed frame layout.

   In the olden days, function prologues were generated by hand-written,

   In the olden days, function prologues were generated by hand-written,

target-specific code in GCC, and treated as opaque and untouchable by

target-specific code in GCC, and treated as opaque and untouchable by

optimizers.  Looking at this code, it was usually straightforward to

optimizers.  Looking at this code, it was usually straightforward to

write a prologue analyzer for GDB that would accurately understand all

write a prologue analyzer for GDB that would accurately understand all

the prologues GCC would generate.  However, over time GCC became more

the prologues GCC would generate.  However, over time GCC became more

aggressive about instruction scheduling, and began to understand more

aggressive about instruction scheduling, and began to understand more

about the semantics of the prologue instructions themselves; in

about the semantics of the prologue instructions themselves; in

response, GDB's analyzers became more complex and fragile.  Keeping the

response, GDB's analyzers became more complex and fragile.  Keeping the

prologue analyzers working as GCC (and the instruction sets themselves)

prologue analyzers working as GCC (and the instruction sets themselves)

evolved became a substantial task.

evolved became a substantial task.

   To try to address this problem, the code in `prologue-value.h' and

   To try to address this problem, the code in `prologue-value.h' and

`prologue-value.c' provides a general framework for writing prologue

`prologue-value.c' provides a general framework for writing prologue

analyzers that are simpler and more robust than ad-hoc analyzers.  When

analyzers that are simpler and more robust than ad-hoc analyzers.  When

we analyze a prologue using the prologue-value framework, we're really

we analyze a prologue using the prologue-value framework, we're really

doing "abstract interpretation" or "pseudo-evaluation": running the

doing "abstract interpretation" or "pseudo-evaluation": running the

function's code in simulation, but using conservative approximations of

function's code in simulation, but using conservative approximations of

the values registers and memory would hold when the code actually runs.

the values registers and memory would hold when the code actually runs.

For example, if our function starts with the instruction:

For example, if our function starts with the instruction:

     addi r1, 42     # add 42 to r1

     addi r1, 42     # add 42 to r1

   we don't know exactly what value will be in `r1' after executing

   we don't know exactly what value will be in `r1' after executing

this instruction, but we do know it'll be 42 greater than its original

this instruction, but we do know it'll be 42 greater than its original

value.

value.

   If we then see an instruction like:

   If we then see an instruction like:

     addi r1, 22     # add 22 to r1

     addi r1, 22     # add 22 to r1

   we still don't know what `r1's' value is, but again, we can say it

   we still don't know what `r1's' value is, but again, we can say it

is now 64 greater than its original value.

is now 64 greater than its original value.

   If the next instruction were:

   If the next instruction were:

     mov r2, r1      # set r2 to r1's value

     mov r2, r1      # set r2 to r1's value

   then we can say that `r2's' value is now the original value of `r1'

   then we can say that `r2's' value is now the original value of `r1'

plus 64.

plus 64.

   It's common for prologues to save registers on the stack, so we'll

   It's common for prologues to save registers on the stack, so we'll

need to track the values of stack frame slots, as well as the

need to track the values of stack frame slots, as well as the

registers.  So after an instruction like this:

registers.  So after an instruction like this:

     mov (fp+4), r2

     mov (fp+4), r2

   then we'd know that the stack slot four bytes above the frame pointer

   then we'd know that the stack slot four bytes above the frame pointer

holds the original value of `r1' plus 64.

holds the original value of `r1' plus 64.

   And so on.

   And so on.

   Of course, this can only go so far before it gets unreasonable.  If

   Of course, this can only go so far before it gets unreasonable.  If

we wanted to be able to say anything about the value of `r1' after the

we wanted to be able to say anything about the value of `r1' after the

instruction:

instruction:

     xor r1, r3      # exclusive-or r1 and r3, place result in r1

     xor r1, r3      # exclusive-or r1 and r3, place result in r1

   then things would get pretty complex.  But remember, we're just doing

   then things would get pretty complex.  But remember, we're just doing

a conservative approximation; if exclusive-or instructions aren't

a conservative approximation; if exclusive-or instructions aren't

relevant to prologues, we can just say `r1''s value is now "unknown".

relevant to prologues, we can just say `r1''s value is now "unknown".

We can ignore things that are too complex, if that loss of information

We can ignore things that are too complex, if that loss of information

is acceptable for our application.

is acceptable for our application.

   So when we say "conservative approximation" here, what we mean is an

   So when we say "conservative approximation" here, what we mean is an

approximation that is either accurate, or marked "unknown", but never

approximation that is either accurate, or marked "unknown", but never

inaccurate.

inaccurate.

   Using this framework, a prologue analyzer is simply an interpreter

   Using this framework, a prologue analyzer is simply an interpreter

for machine code, but one that uses conservative approximations for the

for machine code, but one that uses conservative approximations for the

contents of registers and memory instead of actual values.  Starting

contents of registers and memory instead of actual values.  Starting

from the function's entry point, you simulate instructions up to the

from the function's entry point, you simulate instructions up to the

current PC, or an instruction that you don't know how to simulate.  Now

current PC, or an instruction that you don't know how to simulate.  Now

you can examine the state of the registers and stack slots you've kept

you can examine the state of the registers and stack slots you've kept

track of.

track of.

   * To see how large your stack frame is, just check the value of the

   * To see how large your stack frame is, just check the value of the

     stack pointer register; if it's the original value of the SP minus

     stack pointer register; if it's the original value of the SP minus

     a constant, then that constant is the stack frame's size.  If the

     a constant, then that constant is the stack frame's size.  If the

     SP's value has been marked as "unknown", then that means the

     SP's value has been marked as "unknown", then that means the

     prologue has done something too complex for us to track, and we

     prologue has done something too complex for us to track, and we

     don't know the frame size.

     don't know the frame size.

   * To see where we've saved the previous frame's registers, we just

   * To see where we've saved the previous frame's registers, we just

     search the values we've tracked -- stack slots, usually, but

     search the values we've tracked -- stack slots, usually, but

     registers, too, if you want -- for something equal to the

     registers, too, if you want -- for something equal to the

     register's original value.  If the calling conventions suggest a

     register's original value.  If the calling conventions suggest a

     standard place to save a given register, then we can check there

     standard place to save a given register, then we can check there

     first, but really, anything that will get us back the original

     first, but really, anything that will get us back the original

     value will probably work.

     value will probably work.

   This does take some work.  But prologue analyzers aren't

   This does take some work.  But prologue analyzers aren't

quick-and-simple pattern patching to recognize a few fixed prologue

quick-and-simple pattern patching to recognize a few fixed prologue

forms any more; they're big, hairy functions.  Along with inferior

forms any more; they're big, hairy functions.  Along with inferior

function calls, prologue analysis accounts for a substantial portion of

function calls, prologue analysis accounts for a substantial portion of

the time needed to stabilize a GDB port.  So it's worthwhile to look

the time needed to stabilize a GDB port.  So it's worthwhile to look

for an approach that will be easier to understand and maintain.  In the

for an approach that will be easier to understand and maintain.  In the

approach described above:

approach described above:

   * It's easier to see that the analyzer is correct: you just see

   * It's easier to see that the analyzer is correct: you just see

     whether the analyzer properly (albeit conservatively) simulates

     whether the analyzer properly (albeit conservatively) simulates

     the effect of each instruction.

     the effect of each instruction.

   * It's easier to extend the analyzer: you can add support for new

   * It's easier to extend the analyzer: you can add support for new

     instructions, and know that you haven't broken anything that

     instructions, and know that you haven't broken anything that

     wasn't already broken before.

     wasn't already broken before.

   * It's orthogonal: to gather new information, you don't need to

   * It's orthogonal: to gather new information, you don't need to

     complicate the code for each instruction.  As long as your domain

     complicate the code for each instruction.  As long as your domain

     of conservative values is already detailed enough to tell you what

     of conservative values is already detailed enough to tell you what

     you need, then all the existing instruction simulations are

     you need, then all the existing instruction simulations are

     already gathering the right data for you.

     already gathering the right data for you.

   The file `prologue-value.h' contains detailed comments explaining

   The file `prologue-value.h' contains detailed comments explaining

the framework and how to use it.

the framework and how to use it.

3.3 Breakpoint Handling

3.3 Breakpoint Handling

=======================

=======================

In general, a breakpoint is a user-designated location in the program

In general, a breakpoint is a user-designated location in the program

where the user wants to regain control if program execution ever reaches

where the user wants to regain control if program execution ever reaches

that location.

that location.

   There are two main ways to implement breakpoints; either as

   There are two main ways to implement breakpoints; either as

"hardware" breakpoints or as "software" breakpoints.

"hardware" breakpoints or as "software" breakpoints.

   Hardware breakpoints are sometimes available as a builtin debugging

   Hardware breakpoints are sometimes available as a builtin debugging

features with some chips.  Typically these work by having dedicated

features with some chips.  Typically these work by having dedicated

register into which the breakpoint address may be stored.  If the PC

register into which the breakpoint address may be stored.  If the PC

(shorthand for "program counter") ever matches a value in a breakpoint

(shorthand for "program counter") ever matches a value in a breakpoint

registers, the CPU raises an exception and reports it to GDB.

registers, the CPU raises an exception and reports it to GDB.

   Another possibility is when an emulator is in use; many emulators

   Another possibility is when an emulator is in use; many emulators

include circuitry that watches the address lines coming out from the

include circuitry that watches the address lines coming out from the

processor, and force it to stop if the address matches a breakpoint's

processor, and force it to stop if the address matches a breakpoint's

address.

address.

   A third possibility is that the target already has the ability to do

   A third possibility is that the target already has the ability to do

breakpoints somehow; for instance, a ROM monitor may do its own

breakpoints somehow; for instance, a ROM monitor may do its own

software breakpoints.  So although these are not literally "hardware

software breakpoints.  So although these are not literally "hardware

breakpoints", from GDB's point of view they work the same; GDB need not

breakpoints", from GDB's point of view they work the same; GDB need not

do anything more than set the breakpoint and wait for something to

do anything more than set the breakpoint and wait for something to

happen.

happen.

   Since they depend on hardware resources, hardware breakpoints may be

   Since they depend on hardware resources, hardware breakpoints may be

limited in number; when the user asks for more, GDB will start trying

limited in number; when the user asks for more, GDB will start trying

to set software breakpoints.  (On some architectures, notably the

to set software breakpoints.  (On some architectures, notably the

32-bit x86 platforms, GDB cannot always know whether there's enough

32-bit x86 platforms, GDB cannot always know whether there's enough

hardware resources to insert all the hardware breakpoints and

hardware resources to insert all the hardware breakpoints and

watchpoints.  On those platforms, GDB prints an error message only when

watchpoints.  On those platforms, GDB prints an error message only when

the program being debugged is continued.)

the program being debugged is continued.)

   Software breakpoints require GDB to do somewhat more work.  The

   Software breakpoints require GDB to do somewhat more work.  The

basic theory is that GDB will replace a program instruction with a

basic theory is that GDB will replace a program instruction with a

trap, illegal divide, or some other instruction that will cause an

trap, illegal divide, or some other instruction that will cause an

exception, and then when it's encountered, GDB will take the exception

exception, and then when it's encountered, GDB will take the exception

and stop the program.  When the user says to continue, GDB will restore

and stop the program.  When the user says to continue, GDB will restore

the original instruction, single-step, re-insert the trap, and continue

the original instruction, single-step, re-insert the trap, and continue

on.

on.

   Since it literally overwrites the program being tested, the program

   Since it literally overwrites the program being tested, the program

area must be writable, so this technique won't work on programs in ROM.

area must be writable, so this technique won't work on programs in ROM.

It can also distort the behavior of programs that examine themselves,

It can also distort the behavior of programs that examine themselves,

although such a situation would be highly unusual.

although such a situation would be highly unusual.

   Also, the software breakpoint instruction should be the smallest

   Also, the software breakpoint instruction should be the smallest

size of instruction, so it doesn't overwrite an instruction that might

size of instruction, so it doesn't overwrite an instruction that might

be a jump target, and cause disaster when the program jumps into the

be a jump target, and cause disaster when the program jumps into the

middle of the breakpoint instruction.  (Strictly speaking, the

middle of the breakpoint instruction.  (Strictly speaking, the

breakpoint must be no larger than the smallest interval between

breakpoint must be no larger than the smallest interval between

instructions that may be jump targets; perhaps there is an architecture

instructions that may be jump targets; perhaps there is an architecture

where only even-numbered instructions may jumped to.)  Note that it's

where only even-numbered instructions may jumped to.)  Note that it's

possible for an instruction set not to have any instructions usable for

possible for an instruction set not to have any instructions usable for

a software breakpoint, although in practice only the ARC has failed to

a software breakpoint, although in practice only the ARC has failed to

define such an instruction.

define such an instruction.

   The basic definition of the software breakpoint is the macro

   The basic definition of the software breakpoint is the macro

`BREAKPOINT'.

`BREAKPOINT'.

   Basic breakpoint object handling is in `breakpoint.c'.  However,

   Basic breakpoint object handling is in `breakpoint.c'.  However,

much of the interesting breakpoint action is in `infrun.c'.

much of the interesting breakpoint action is in `infrun.c'.

`target_remove_breakpoint (BP_TGT)'

`target_remove_breakpoint (BP_TGT)'

`target_insert_breakpoint (BP_TGT)'

`target_insert_breakpoint (BP_TGT)'

     Insert or remove a software breakpoint at address

     Insert or remove a software breakpoint at address

     `BP_TGT->placed_address'.  Returns zero for success, non-zero for

     `BP_TGT->placed_address'.  Returns zero for success, non-zero for

     failure.  On input, BP_TGT contains the address of the breakpoint,

     failure.  On input, BP_TGT contains the address of the breakpoint,

     and is otherwise initialized to zero.  The fields of the `struct

     and is otherwise initialized to zero.  The fields of the `struct

     bp_target_info' pointed to by BP_TGT are updated to contain other

     bp_target_info' pointed to by BP_TGT are updated to contain other

     information about the breakpoint on output.  The field

     information about the breakpoint on output.  The field

     `placed_address' may be updated if the breakpoint was placed at a

     `placed_address' may be updated if the breakpoint was placed at a

     related address; the field `shadow_contents' contains the real

     related address; the field `shadow_contents' contains the real

     contents of the bytes where the breakpoint has been inserted, if

     contents of the bytes where the breakpoint has been inserted, if

     reading memory would return the breakpoint instead of the

     reading memory would return the breakpoint instead of the

     underlying memory; the field `shadow_len' is the length of memory

     underlying memory; the field `shadow_len' is the length of memory

     cached in `shadow_contents', if any; and the field `placed_size'

     cached in `shadow_contents', if any; and the field `placed_size'

     is optionally set and used by the target, if it could differ from

     is optionally set and used by the target, if it could differ from

     `shadow_len'.

     `shadow_len'.

     For example, the remote target `Z0' packet does not require

     For example, the remote target `Z0' packet does not require

     shadowing memory, so `shadow_len' is left at zero.  However, the

     shadowing memory, so `shadow_len' is left at zero.  However, the

     length reported by `gdbarch_breakpoint_from_pc' is cached in

     length reported by `gdbarch_breakpoint_from_pc' is cached in

     `placed_size', so that a matching `z0' packet can be used to

     `placed_size', so that a matching `z0' packet can be used to

     remove the breakpoint.

     remove the breakpoint.

`target_remove_hw_breakpoint (BP_TGT)'

`target_remove_hw_breakpoint (BP_TGT)'

`target_insert_hw_breakpoint (BP_TGT)'

`target_insert_hw_breakpoint (BP_TGT)'

     Insert or remove a hardware-assisted breakpoint at address

     Insert or remove a hardware-assisted breakpoint at address

     `BP_TGT->placed_address'.  Returns zero for success, non-zero for

     `BP_TGT->placed_address'.  Returns zero for success, non-zero for

     failure.  See `target_insert_breakpoint' for a description of the

     failure.  See `target_insert_breakpoint' for a description of the

     `struct bp_target_info' pointed to by BP_TGT; the

     `struct bp_target_info' pointed to by BP_TGT; the

     `shadow_contents' and `shadow_len' members are not used for

     `shadow_contents' and `shadow_len' members are not used for

     hardware breakpoints, but `placed_size' may be.

     hardware breakpoints, but `placed_size' may be.

3.4 Single Stepping

3.4 Single Stepping

===================

===================

3.5 Signal Handling

3.5 Signal Handling

===================

===================

3.6 Thread Handling

3.6 Thread Handling

===================

===================

3.7 Inferior Function Calls

3.7 Inferior Function Calls

===========================

===========================

3.8 Longjmp Support

3.8 Longjmp Support

===================

===================

GDB has support for figuring out that the target is doing a `longjmp'

GDB has support for figuring out that the target is doing a `longjmp'

and for stopping at the target of the jump, if we are stepping.  This

and for stopping at the target of the jump, if we are stepping.  This

is done with a few specialized internal breakpoints, which are visible

is done with a few specialized internal breakpoints, which are visible

in the output of the `maint info breakpoint' command.

in the output of the `maint info breakpoint' command.

   To make this work, you need to define a function called

   To make this work, you need to define a function called

`gdbarch_get_longjmp_target', which will examine the `jmp_buf'

`gdbarch_get_longjmp_target', which will examine the `jmp_buf'

structure and extract the longjmp target address.  Since `jmp_buf' is

structure and extract the longjmp target address.  Since `jmp_buf' is

target specific, you will need to define it in the appropriate

target specific, you will need to define it in the appropriate

`tm-TARGET.h' file.  Look in `tm-sun4os4.h' and `sparc-tdep.c' for

`tm-TARGET.h' file.  Look in `tm-sun4os4.h' and `sparc-tdep.c' for

examples of how to do this.

examples of how to do this.

3.9 Watchpoints

3.9 Watchpoints

===============

===============

Watchpoints are a special kind of breakpoints (*note breakpoints:

Watchpoints are a special kind of breakpoints (*note breakpoints:

Algorithms.) which break when data is accessed rather than when some

Algorithms.) which break when data is accessed rather than when some

instruction is executed.  When you have data which changes without your

instruction is executed.  When you have data which changes without your

knowing what code does that, watchpoints are the silver bullet to hunt

knowing what code does that, watchpoints are the silver bullet to hunt

down and kill such bugs.

down and kill such bugs.

   Watchpoints can be either hardware-assisted or not; the latter type

   Watchpoints can be either hardware-assisted or not; the latter type

is known as "software watchpoints."  GDB always uses hardware-assisted

is known as "software watchpoints."  GDB always uses hardware-assisted

watchpoints if they are available, and falls back on software

watchpoints if they are available, and falls back on software

watchpoints otherwise.  Typical situations where GDB will use software

watchpoints otherwise.  Typical situations where GDB will use software

watchpoints are:

watchpoints are:

   * The watched memory region is too large for the underlying hardware

   * The watched memory region is too large for the underlying hardware

     watchpoint support.  For example, each x86 debug register can

     watchpoint support.  For example, each x86 debug register can

     watch up to 4 bytes of memory, so trying to watch data structures

     watch up to 4 bytes of memory, so trying to watch data structures

     whose size is more than 16 bytes will cause GDB to use software

     whose size is more than 16 bytes will cause GDB to use software

     watchpoints.

     watchpoints.

   * The value of the expression to be watched depends on data held in

   * The value of the expression to be watched depends on data held in

     registers (as opposed to memory).

     registers (as opposed to memory).

   * Too many different watchpoints requested.  (On some architectures,

   * Too many different watchpoints requested.  (On some architectures,

     this situation is impossible to detect until the debugged program

     this situation is impossible to detect until the debugged program

     is resumed.)  Note that x86 debug registers are used both for

     is resumed.)  Note that x86 debug registers are used both for

     hardware breakpoints and for watchpoints, so setting too many

     hardware breakpoints and for watchpoints, so setting too many

     hardware breakpoints might cause watchpoint insertion to fail.

     hardware breakpoints might cause watchpoint insertion to fail.

   * No hardware-assisted watchpoints provided by the target

   * No hardware-assisted watchpoints provided by the target

     implementation.

     implementation.

   Software watchpoints are very slow, since GDB needs to single-step

   Software watchpoints are very slow, since GDB needs to single-step

the program being debugged and test the value of the watched

the program being debugged and test the value of the watched

expression(s) after each instruction.  The rest of this section is

expression(s) after each instruction.  The rest of this section is

mostly irrelevant for software watchpoints.

mostly irrelevant for software watchpoints.

   When the inferior stops, GDB tries to establish, among other

   When the inferior stops, GDB tries to establish, among other

possible reasons, whether it stopped due to a watchpoint being hit.  It

possible reasons, whether it stopped due to a watchpoint being hit.  It

first uses `STOPPED_BY_WATCHPOINT' to see if any watchpoint was hit.

first uses `STOPPED_BY_WATCHPOINT' to see if any watchpoint was hit.

If not, all watchpoint checking is skipped.

If not, all watchpoint checking is skipped.

   Then GDB calls `target_stopped_data_address' exactly once.  This

   Then GDB calls `target_stopped_data_address' exactly once.  This

method returns the address of the watchpoint which triggered, if the

method returns the address of the watchpoint which triggered, if the

target can determine it.  If the triggered address is available, GDB

target can determine it.  If the triggered address is available, GDB

compares the address returned by this method with each watched memory

compares the address returned by this method with each watched memory

address in each active watchpoint.  For data-read and data-access

address in each active watchpoint.  For data-read and data-access

watchpoints, GDB announces every watchpoint that watches the triggered

watchpoints, GDB announces every watchpoint that watches the triggered

address as being hit.  For this reason, data-read and data-access

address as being hit.  For this reason, data-read and data-access

watchpoints _require_ that the triggered address be available; if not,

watchpoints _require_ that the triggered address be available; if not,

read and access watchpoints will never be considered hit.  For

read and access watchpoints will never be considered hit.  For

data-write watchpoints, if the triggered address is available, GDB

data-write watchpoints, if the triggered address is available, GDB

considers only those watchpoints which match that address; otherwise,

considers only those watchpoints which match that address; otherwise,

GDB considers all data-write watchpoints.  For each data-write

GDB considers all data-write watchpoints.  For each data-write

watchpoint that GDB considers, it evaluates the expression whose value

watchpoint that GDB considers, it evaluates the expression whose value

is being watched, and tests whether the watched value has changed.

is being watched, and tests whether the watched value has changed.

Watchpoints whose watched values have changed are announced as hit.

Watchpoints whose watched values have changed are announced as hit.

   GDB uses several macros and primitives to support hardware

   GDB uses several macros and primitives to support hardware

watchpoints:

watchpoints:

`TARGET_HAS_HARDWARE_WATCHPOINTS'

`TARGET_HAS_HARDWARE_WATCHPOINTS'

     If defined, the target supports hardware watchpoints.

     If defined, the target supports hardware watchpoints.

`TARGET_CAN_USE_HARDWARE_WATCHPOINT (TYPE, COUNT, OTHER)'

`TARGET_CAN_USE_HARDWARE_WATCHPOINT (TYPE, COUNT, OTHER)'

     Return the number of hardware watchpoints of type TYPE that are

     Return the number of hardware watchpoints of type TYPE that are

     possible to be set.  The value is positive if COUNT watchpoints of

     possible to be set.  The value is positive if COUNT watchpoints of

     this type can be set, zero if setting watchpoints of this type is

     this type can be set, zero if setting watchpoints of this type is

     not supported, and negative if COUNT is more than the maximum

     not supported, and negative if COUNT is more than the maximum

     number of watchpoints of type TYPE that can be set.  OTHER is

     number of watchpoints of type TYPE that can be set.  OTHER is

     non-zero if other types of watchpoints are currently enabled (there

     non-zero if other types of watchpoints are currently enabled (there

     are architectures which cannot set watchpoints of different types

     are architectures which cannot set watchpoints of different types

     at the same time).

     at the same time).

`TARGET_REGION_OK_FOR_HW_WATCHPOINT (ADDR, LEN)'

`TARGET_REGION_OK_FOR_HW_WATCHPOINT (ADDR, LEN)'

     Return non-zero if hardware watchpoints can be used to watch a

     Return non-zero if hardware watchpoints can be used to watch a

     region whose address is ADDR and whose length in bytes is LEN.

     region whose address is ADDR and whose length in bytes is LEN.

`target_insert_watchpoint (ADDR, LEN, TYPE)'

`target_insert_watchpoint (ADDR, LEN, TYPE)'

`target_remove_watchpoint (ADDR, LEN, TYPE)'

`target_remove_watchpoint (ADDR, LEN, TYPE)'

     Insert or remove a hardware watchpoint starting at ADDR, for LEN

     Insert or remove a hardware watchpoint starting at ADDR, for LEN

     bytes.  TYPE is the watchpoint type, one of the possible values of

     bytes.  TYPE is the watchpoint type, one of the possible values of

     the enumerated data type `target_hw_bp_type', defined by

     the enumerated data type `target_hw_bp_type', defined by

     `breakpoint.h' as follows:

     `breakpoint.h' as follows:

           enum target_hw_bp_type

           enum target_hw_bp_type

               hw_write   = 0, /* Common (write) HW watchpoint */

               hw_write   = 0, /* Common (write) HW watchpoint */

               hw_read    = 1, /* Read    HW watchpoint */

               hw_read    = 1, /* Read    HW watchpoint */

               hw_access  = 2, /* Access (read or write) HW watchpoint */

               hw_access  = 2, /* Access (read or write) HW watchpoint */

               hw_execute = 3  /* Execute HW breakpoint */

               hw_execute = 3  /* Execute HW breakpoint */

};

};

     These two macros should return 0 for success, non-zero for failure.

     These two macros should return 0 for success, non-zero for failure.

`target_stopped_data_address (ADDR_P)'

`target_stopped_data_address (ADDR_P)'

     If the inferior has some watchpoint that triggered, place the

     If the inferior has some watchpoint that triggered, place the

     address associated with the watchpoint at the location pointed to

     address associated with the watchpoint at the location pointed to

     by ADDR_P and return non-zero.  Otherwise, return zero.  This is

     by ADDR_P and return non-zero.  Otherwise, return zero.  This is

     required for data-read and data-access watchpoints.  It is not

     required for data-read and data-access watchpoints.  It is not

     required for data-write watchpoints, but GDB uses it to improve

     required for data-write watchpoints, but GDB uses it to improve

     handling of those also.

     handling of those also.

     GDB will only call this method once per watchpoint stop,

     GDB will only call this method once per watchpoint stop,

     immediately after calling `STOPPED_BY_WATCHPOINT'.  If the

     immediately after calling `STOPPED_BY_WATCHPOINT'.  If the

     target's watchpoint indication is sticky, i.e., stays set after

     target's watchpoint indication is sticky, i.e., stays set after

     resuming, this method should clear it.  For instance, the x86 debug

     resuming, this method should clear it.  For instance, the x86 debug

     control register has sticky triggered flags.

     control register has sticky triggered flags.

`HAVE_STEPPABLE_WATCHPOINT'

`HAVE_STEPPABLE_WATCHPOINT'

     If defined to a non-zero value, it is not necessary to disable a

     If defined to a non-zero value, it is not necessary to disable a

     watchpoint to step over it.    Like

     watchpoint to step over it.    Like

     `gdbarch_have_nonsteppable_watchpoint', this is usually set when

     `gdbarch_have_nonsteppable_watchpoint', this is usually set when

     watchpoints trigger at the instruction which will perform an

     watchpoints trigger at the instruction which will perform an

     interesting read or write.  It should be set if there is a

     interesting read or write.  It should be set if there is a

     temporary disable bit which allows the processor to step over the

     temporary disable bit which allows the processor to step over the

     interesting instruction without raising the watchpoint exception

     interesting instruction without raising the watchpoint exception

     again.

     again.

`int gdbarch_have_nonsteppable_watchpoint (GDBARCH)'

`int gdbarch_have_nonsteppable_watchpoint (GDBARCH)'

     If it returns a non-zero value, GDB should disable a watchpoint to

     If it returns a non-zero value, GDB should disable a watchpoint to

     step the inferior over it.  This is usually set when watchpoints

     step the inferior over it.  This is usually set when watchpoints

     trigger at the instruction which will perform an interesting read

     trigger at the instruction which will perform an interesting read

     or write.

     or write.

`HAVE_CONTINUABLE_WATCHPOINT'

`HAVE_CONTINUABLE_WATCHPOINT'

     If defined to a non-zero value, it is possible to continue the

     If defined to a non-zero value, it is possible to continue the

     inferior after a watchpoint has been hit.  This is usually set

     inferior after a watchpoint has been hit.  This is usually set

     when watchpoints trigger at the instruction following an

     when watchpoints trigger at the instruction following an

     interesting read or write.

     interesting read or write.

`CANNOT_STEP_HW_WATCHPOINTS'

`CANNOT_STEP_HW_WATCHPOINTS'

     If this is defined to a non-zero value, GDB will remove all

     If this is defined to a non-zero value, GDB will remove all

     watchpoints before stepping the inferior.

     watchpoints before stepping the inferior.

`STOPPED_BY_WATCHPOINT (WAIT_STATUS)'

`STOPPED_BY_WATCHPOINT (WAIT_STATUS)'

     Return non-zero if stopped by a watchpoint.  WAIT_STATUS is of the

     Return non-zero if stopped by a watchpoint.  WAIT_STATUS is of the

     type `struct target_waitstatus', defined by `target.h'.  Normally,

     type `struct target_waitstatus', defined by `target.h'.  Normally,

     this macro is defined to invoke the function pointed to by the

     this macro is defined to invoke the function pointed to by the

     `to_stopped_by_watchpoint' member of the structure (of the type

     `to_stopped_by_watchpoint' member of the structure (of the type

     `target_ops', defined on `target.h') that describes the

     `target_ops', defined on `target.h') that describes the

     target-specific operations; `to_stopped_by_watchpoint' ignores the

     target-specific operations; `to_stopped_by_watchpoint' ignores the

     WAIT_STATUS argument.

     WAIT_STATUS argument.

     GDB does not require the non-zero value returned by

     GDB does not require the non-zero value returned by

     `STOPPED_BY_WATCHPOINT' to be 100% correct, so if a target cannot

     `STOPPED_BY_WATCHPOINT' to be 100% correct, so if a target cannot

     determine for sure whether the inferior stopped due to a

     determine for sure whether the inferior stopped due to a

     watchpoint, it could return non-zero "just in case".

     watchpoint, it could return non-zero "just in case".

3.9.1 Watchpoints and Threads

3.9.1 Watchpoints and Threads

-----------------------------

-----------------------------

GDB only supports process-wide watchpoints, which trigger in all

GDB only supports process-wide watchpoints, which trigger in all

threads.  GDB uses the thread ID to make watchpoints act as if they

threads.  GDB uses the thread ID to make watchpoints act as if they

were thread-specific, but it cannot set hardware watchpoints that only

were thread-specific, but it cannot set hardware watchpoints that only

trigger in a specific thread.  Therefore, even if the target supports

trigger in a specific thread.  Therefore, even if the target supports

threads, per-thread debug registers, and watchpoints which only affect

threads, per-thread debug registers, and watchpoints which only affect

a single thread, it should set the per-thread debug registers for all

a single thread, it should set the per-thread debug registers for all

threads to the same value.  On GNU/Linux native targets, this is

threads to the same value.  On GNU/Linux native targets, this is

accomplished by using `ALL_LWPS' in `target_insert_watchpoint' and

accomplished by using `ALL_LWPS' in `target_insert_watchpoint' and

`target_remove_watchpoint' and by using `linux_set_new_thread' to

`target_remove_watchpoint' and by using `linux_set_new_thread' to

register a handler for newly created threads.

register a handler for newly created threads.

   GDB's GNU/Linux support only reports a single event at a time,

   GDB's GNU/Linux support only reports a single event at a time,

although multiple events can trigger simultaneously for multi-threaded

although multiple events can trigger simultaneously for multi-threaded

programs.  When multiple events occur, `linux-nat.c' queues subsequent

programs.  When multiple events occur, `linux-nat.c' queues subsequent

events and returns them the next time the program is resumed.  This

events and returns them the next time the program is resumed.  This

means that `STOPPED_BY_WATCHPOINT' and `target_stopped_data_address'

means that `STOPPED_BY_WATCHPOINT' and `target_stopped_data_address'

only need to consult the current thread's state--the thread indicated

only need to consult the current thread's state--the thread indicated

by `inferior_ptid'.  If two threads have hit watchpoints

by `inferior_ptid'.  If two threads have hit watchpoints

simultaneously, those routines will be called a second time for the

simultaneously, those routines will be called a second time for the

second thread.

second thread.

3.9.2 x86 Watchpoints

3.9.2 x86 Watchpoints

---------------------

---------------------

The 32-bit Intel x86 (a.k.a. ia32) processors feature special debug

The 32-bit Intel x86 (a.k.a. ia32) processors feature special debug

registers designed to facilitate debugging.  GDB provides a generic

registers designed to facilitate debugging.  GDB provides a generic

library of functions that x86-based ports can use to implement support

library of functions that x86-based ports can use to implement support

for watchpoints and hardware-assisted breakpoints.  This subsection

for watchpoints and hardware-assisted breakpoints.  This subsection

documents the x86 watchpoint facilities in GDB.

documents the x86 watchpoint facilities in GDB.

   To use the generic x86 watchpoint support, a port should do the

   To use the generic x86 watchpoint support, a port should do the

following:

following:

   * Define the macro `I386_USE_GENERIC_WATCHPOINTS' somewhere in the

   * Define the macro `I386_USE_GENERIC_WATCHPOINTS' somewhere in the

     target-dependent headers.

     target-dependent headers.

   * Include the `config/i386/nm-i386.h' header file _after_ defining

   * Include the `config/i386/nm-i386.h' header file _after_ defining

     `I386_USE_GENERIC_WATCHPOINTS'.

     `I386_USE_GENERIC_WATCHPOINTS'.

   * Add `i386-nat.o' to the value of the Make variable `NATDEPFILES'

   * Add `i386-nat.o' to the value of the Make variable `NATDEPFILES'

     (*note NATDEPFILES: Native Debugging.) or `TDEPFILES' (*note

     (*note NATDEPFILES: Native Debugging.) or `TDEPFILES' (*note

     TDEPFILES: Target Architecture Definition.).

     TDEPFILES: Target Architecture Definition.).

   * Provide implementations for the `I386_DR_LOW_*' macros described

   * Provide implementations for the `I386_DR_LOW_*' macros described

     below.  Typically, each macro should call a target-specific

     below.  Typically, each macro should call a target-specific

     function which does the real work.

     function which does the real work.

   The x86 watchpoint support works by maintaining mirror images of the

   The x86 watchpoint support works by maintaining mirror images of the

debug registers.  Values are copied between the mirror images and the

debug registers.  Values are copied between the mirror images and the

real debug registers via a set of macros which each target needs to

real debug registers via a set of macros which each target needs to

provide:

provide:

`I386_DR_LOW_SET_CONTROL (VAL)'

`I386_DR_LOW_SET_CONTROL (VAL)'

     Set the Debug Control (DR7) register to the value VAL.

     Set the Debug Control (DR7) register to the value VAL.

`I386_DR_LOW_SET_ADDR (IDX, ADDR)'

`I386_DR_LOW_SET_ADDR (IDX, ADDR)'

     Put the address ADDR into the debug register number IDX.

     Put the address ADDR into the debug register number IDX.

`I386_DR_LOW_RESET_ADDR (IDX)'

`I386_DR_LOW_RESET_ADDR (IDX)'

     Reset (i.e. zero out) the address stored in the debug register

     Reset (i.e. zero out) the address stored in the debug register

     number IDX.

     number IDX.

`I386_DR_LOW_GET_STATUS'

`I386_DR_LOW_GET_STATUS'

     Return the value of the Debug Status (DR6) register.  This value is

     Return the value of the Debug Status (DR6) register.  This value is

     used immediately after it is returned by `I386_DR_LOW_GET_STATUS',

     used immediately after it is returned by `I386_DR_LOW_GET_STATUS',

     so as to support per-thread status register values.

     so as to support per-thread status register values.

   For each one of the 4 debug registers (whose indices are from 0 to 3)

   For each one of the 4 debug registers (whose indices are from 0 to 3)

that store addresses, a reference count is maintained by GDB, to allow

that store addresses, a reference count is maintained by GDB, to allow

sharing of debug registers by several watchpoints.  This allows users

sharing of debug registers by several watchpoints.  This allows users

to define several watchpoints that watch the same expression, but with

to define several watchpoints that watch the same expression, but with

different conditions and/or commands, without wasting debug registers

different conditions and/or commands, without wasting debug registers

which are in short supply.  GDB maintains the reference counts

which are in short supply.  GDB maintains the reference counts

internally, targets don't have to do anything to use this feature.

internally, targets don't have to do anything to use this feature.

   The x86 debug registers can each watch a region that is 1, 2, or 4

   The x86 debug registers can each watch a region that is 1, 2, or 4

bytes long.  The ia32 architecture requires that each watched region be

bytes long.  The ia32 architecture requires that each watched region be

appropriately aligned: 2-byte region on 2-byte boundary, 4-byte region

appropriately aligned: 2-byte region on 2-byte boundary, 4-byte region

on 4-byte boundary.  However, the x86 watchpoint support in GDB can

on 4-byte boundary.  However, the x86 watchpoint support in GDB can

watch unaligned regions and regions larger than 4 bytes (up to 16

watch unaligned regions and regions larger than 4 bytes (up to 16

bytes) by allocating several debug registers to watch a single region.

bytes) by allocating several debug registers to watch a single region.

This allocation of several registers per a watched region is also done

This allocation of several registers per a watched region is also done

automatically without target code intervention.

automatically without target code intervention.

   The generic x86 watchpoint support provides the following API for the

   The generic x86 watchpoint support provides the following API for the

GDB's application code:

GDB's application code:

`i386_region_ok_for_watchpoint (ADDR, LEN)'

`i386_region_ok_for_watchpoint (ADDR, LEN)'

     The macro `TARGET_REGION_OK_FOR_HW_WATCHPOINT' is set to call this

     The macro `TARGET_REGION_OK_FOR_HW_WATCHPOINT' is set to call this

     function.  It counts the number of debug registers required to

     function.  It counts the number of debug registers required to

     watch a given region, and returns a non-zero value if that number

     watch a given region, and returns a non-zero value if that number

     is less than 4, the number of debug registers available to x86

     is less than 4, the number of debug registers available to x86

     processors.

     processors.

`i386_stopped_data_address (ADDR_P)'

`i386_stopped_data_address (ADDR_P)'

     The target function `target_stopped_data_address' is set to call

     The target function `target_stopped_data_address' is set to call

     this function.  This function examines the breakpoint condition

     this function.  This function examines the breakpoint condition

     bits in the DR6 Debug Status register, as returned by the

     bits in the DR6 Debug Status register, as returned by the

     `I386_DR_LOW_GET_STATUS' macro, and returns the address associated

     `I386_DR_LOW_GET_STATUS' macro, and returns the address associated

     with the first bit that is set in DR6.

     with the first bit that is set in DR6.

`i386_stopped_by_watchpoint (void)'

`i386_stopped_by_watchpoint (void)'

     The macro `STOPPED_BY_WATCHPOINT' is set to call this function.

     The macro `STOPPED_BY_WATCHPOINT' is set to call this function.

     The argument passed to `STOPPED_BY_WATCHPOINT' is ignored.  This

     The argument passed to `STOPPED_BY_WATCHPOINT' is ignored.  This

     function examines the breakpoint condition bits in the DR6 Debug

     function examines the breakpoint condition bits in the DR6 Debug

     Status register, as returned by the `I386_DR_LOW_GET_STATUS'

     Status register, as returned by the `I386_DR_LOW_GET_STATUS'

     macro, and returns true if any bit is set.  Otherwise, false is

     macro, and returns true if any bit is set.  Otherwise, false is

     returned.

     returned.

`i386_insert_watchpoint (ADDR, LEN, TYPE)'

`i386_insert_watchpoint (ADDR, LEN, TYPE)'

`i386_remove_watchpoint (ADDR, LEN, TYPE)'

`i386_remove_watchpoint (ADDR, LEN, TYPE)'

     Insert or remove a watchpoint.  The macros

     Insert or remove a watchpoint.  The macros

     `target_insert_watchpoint' and `target_remove_watchpoint' are set

     `target_insert_watchpoint' and `target_remove_watchpoint' are set

     to call these functions.  `i386_insert_watchpoint' first looks for

     to call these functions.  `i386_insert_watchpoint' first looks for

     a debug register which is already set to watch the same region for

     a debug register which is already set to watch the same region for

     the same access types; if found, it just increments the reference

     the same access types; if found, it just increments the reference

     count of that debug register, thus implementing debug register

     count of that debug register, thus implementing debug register

     sharing between watchpoints.  If no such register is found, the

     sharing between watchpoints.  If no such register is found, the

     function looks for a vacant debug register, sets its mirrored

     function looks for a vacant debug register, sets its mirrored

     value to ADDR, sets the mirrored value of DR7 Debug Control

     value to ADDR, sets the mirrored value of DR7 Debug Control

     register as appropriate for the LEN and TYPE parameters, and then

     register as appropriate for the LEN and TYPE parameters, and then

     passes the new values of the debug register and DR7 to the

     passes the new values of the debug register and DR7 to the

     inferior by calling `I386_DR_LOW_SET_ADDR' and

     inferior by calling `I386_DR_LOW_SET_ADDR' and

     `I386_DR_LOW_SET_CONTROL'.  If more than one debug register is

     `I386_DR_LOW_SET_CONTROL'.  If more than one debug register is

     required to cover the given region, the above process is repeated

     required to cover the given region, the above process is repeated

     for each debug register.

     for each debug register.

     `i386_remove_watchpoint' does the opposite: it resets the address

     `i386_remove_watchpoint' does the opposite: it resets the address

     in the mirrored value of the debug register and its read/write and

     in the mirrored value of the debug register and its read/write and

     length bits in the mirrored value of DR7, then passes these new

     length bits in the mirrored value of DR7, then passes these new

     values to the inferior via `I386_DR_LOW_RESET_ADDR' and

     values to the inferior via `I386_DR_LOW_RESET_ADDR' and

     `I386_DR_LOW_SET_CONTROL'.  If a register is shared by several

     `I386_DR_LOW_SET_CONTROL'.  If a register is shared by several

     watchpoints, each time a `i386_remove_watchpoint' is called, it

     watchpoints, each time a `i386_remove_watchpoint' is called, it

     decrements the reference count, and only calls

     decrements the reference count, and only calls

     `I386_DR_LOW_RESET_ADDR' and `I386_DR_LOW_SET_CONTROL' when the

     `I386_DR_LOW_RESET_ADDR' and `I386_DR_LOW_SET_CONTROL' when the

     count goes to zero.

     count goes to zero.

`i386_insert_hw_breakpoint (BP_TGT)'

`i386_insert_hw_breakpoint (BP_TGT)'

`i386_remove_hw_breakpoint (BP_TGT)'

`i386_remove_hw_breakpoint (BP_TGT)'

     These functions insert and remove hardware-assisted breakpoints.

     These functions insert and remove hardware-assisted breakpoints.

     The macros `target_insert_hw_breakpoint' and

     The macros `target_insert_hw_breakpoint' and

     `target_remove_hw_breakpoint' are set to call these functions.

     `target_remove_hw_breakpoint' are set to call these functions.

     The argument is a `struct bp_target_info *', as described in the

     The argument is a `struct bp_target_info *', as described in the

     documentation for `target_insert_breakpoint'.  These functions

     documentation for `target_insert_breakpoint'.  These functions

     work like `i386_insert_watchpoint' and `i386_remove_watchpoint',

     work like `i386_insert_watchpoint' and `i386_remove_watchpoint',

     respectively, except that they set up the debug registers to watch

     respectively, except that they set up the debug registers to watch

     instruction execution, and each hardware-assisted breakpoint

     instruction execution, and each hardware-assisted breakpoint

     always requires exactly one debug register.

     always requires exactly one debug register.

`i386_stopped_by_hwbp (void)'

`i386_stopped_by_hwbp (void)'

     This function returns non-zero if the inferior has some watchpoint

     This function returns non-zero if the inferior has some watchpoint

     or hardware breakpoint that triggered.  It works like

     or hardware breakpoint that triggered.  It works like

     `i386_stopped_data_address', except that it doesn't record the

     `i386_stopped_data_address', except that it doesn't record the

     address whose watchpoint triggered.

     address whose watchpoint triggered.

`i386_cleanup_dregs (void)'

`i386_cleanup_dregs (void)'

     This function clears all the reference counts, addresses, and

     This function clears all the reference counts, addresses, and

     control bits in the mirror images of the debug registers.  It

     control bits in the mirror images of the debug registers.  It

     doesn't affect the actual debug registers in the inferior process.

     doesn't affect the actual debug registers in the inferior process.

*Notes:*

*Notes:*

  1. x86 processors support setting watchpoints on I/O reads or writes.

  1. x86 processors support setting watchpoints on I/O reads or writes.

     However, since no target supports this (as of March 2001), and

     However, since no target supports this (as of March 2001), and

     since `enum target_hw_bp_type' doesn't even have an enumeration

     since `enum target_hw_bp_type' doesn't even have an enumeration

     for I/O watchpoints, this feature is not yet available to GDB

     for I/O watchpoints, this feature is not yet available to GDB

     running on x86.

     running on x86.

  2. x86 processors can enable watchpoints locally, for the current task

  2. x86 processors can enable watchpoints locally, for the current task

     only, or globally, for all the tasks.  For each debug register,

     only, or globally, for all the tasks.  For each debug register,

     there's a bit in the DR7 Debug Control register that determines

     there's a bit in the DR7 Debug Control register that determines

     whether the associated address is watched locally or globally.  The

     whether the associated address is watched locally or globally.  The

     current implementation of x86 watchpoint support in GDB always

     current implementation of x86 watchpoint support in GDB always

     sets watchpoints to be locally enabled, since global watchpoints

     sets watchpoints to be locally enabled, since global watchpoints

     might interfere with the underlying OS and are probably

     might interfere with the underlying OS and are probably

     unavailable in many platforms.

     unavailable in many platforms.

3.10 Checkpoints

3.10 Checkpoints

================

================

In the abstract, a checkpoint is a point in the execution history of

In the abstract, a checkpoint is a point in the execution history of

the program, which the user may wish to return to at some later time.

the program, which the user may wish to return to at some later time.

   Internally, a checkpoint is a saved copy of the program state,

   Internally, a checkpoint is a saved copy of the program state,

including whatever information is required in order to restore the

including whatever information is required in order to restore the

program to that state at a later time.  This can be expected to include

program to that state at a later time.  This can be expected to include

the state of registers and memory, and may include external state such

the state of registers and memory, and may include external state such

as the state of open files and devices.

as the state of open files and devices.

   There are a number of ways in which checkpoints may be implemented

   There are a number of ways in which checkpoints may be implemented

in gdb, e.g. as corefiles, as forked processes, and as some opaque

in gdb, e.g. as corefiles, as forked processes, and as some opaque

method implemented on the target side.

method implemented on the target side.

   A corefile can be used to save an image of target memory and register

   A corefile can be used to save an image of target memory and register

state, which can in principle be restored later -- but corefiles do not

state, which can in principle be restored later -- but corefiles do not

typically include information about external entities such as open

typically include information about external entities such as open

files.  Currently this method is not implemented in gdb.

files.  Currently this method is not implemented in gdb.

   A forked process can save the state of user memory and registers, as

   A forked process can save the state of user memory and registers, as

well as some subset of external (kernel) state.  This method is used to

well as some subset of external (kernel) state.  This method is used to

implement checkpoints on Linux, and in principle might be used on other

implement checkpoints on Linux, and in principle might be used on other

systems.

systems.

   Some targets, e.g. simulators, might have their own built-in method

   Some targets, e.g. simulators, might have their own built-in method

for saving checkpoints, and gdb might be able to take advantage of that

for saving checkpoints, and gdb might be able to take advantage of that

capability without necessarily knowing any details of how it is done.

capability without necessarily knowing any details of how it is done.

3.11 Observing changes in GDB internals

3.11 Observing changes in GDB internals

=======================================

=======================================

In order to function properly, several modules need to be notified when

In order to function properly, several modules need to be notified when

some changes occur in the GDB internals.  Traditionally, these modules

some changes occur in the GDB internals.  Traditionally, these modules

have relied on several paradigms, the most common ones being hooks and

have relied on several paradigms, the most common ones being hooks and

gdb-events.  Unfortunately, none of these paradigms was versatile

gdb-events.  Unfortunately, none of these paradigms was versatile

enough to become the standard notification mechanism in GDB.  The fact

enough to become the standard notification mechanism in GDB.  The fact

that they only supported one "client" was also a strong limitation.

that they only supported one "client" was also a strong limitation.

   A new paradigm, based on the Observer pattern of the `Design

   A new paradigm, based on the Observer pattern of the `Design

Patterns' book, has therefore been implemented.  The goal was to provide

Patterns' book, has therefore been implemented.  The goal was to provide

a new interface overcoming the issues with the notification mechanisms

a new interface overcoming the issues with the notification mechanisms

previously available.  This new interface needed to be strongly typed,

previously available.  This new interface needed to be strongly typed,

easy to extend, and versatile enough to be used as the standard

easy to extend, and versatile enough to be used as the standard

interface when adding new notifications.

interface when adding new notifications.

   See *Note GDB Observers:: for a brief description of the observers

   See *Note GDB Observers:: for a brief description of the observers

currently implemented in GDB. The rationale for the current

currently implemented in GDB. The rationale for the current

implementation is also briefly discussed.

implementation is also briefly discussed.

File: gdbint.info,  Node: User Interface,  Next: libgdb,  Prev: Algorithms,  Up: Top

File: gdbint.info,  Node: User Interface,  Next: libgdb,  Prev: Algorithms,  Up: Top

4 User Interface

4 User Interface

****************

****************

GDB has several user interfaces.  Although the command-line interface

GDB has several user interfaces.  Although the command-line interface

is the most common and most familiar, there are others.

is the most common and most familiar, there are others.

4.1 Command Interpreter

4.1 Command Interpreter

=======================

=======================

The command interpreter in GDB is fairly simple.  It is designed to

The command interpreter in GDB is fairly simple.  It is designed to

allow for the set of commands to be augmented dynamically, and also has

allow for the set of commands to be augmented dynamically, and also has

a recursive subcommand capability, where the first argument to a

a recursive subcommand capability, where the first argument to a

command may itself direct a lookup on a different command list.

command may itself direct a lookup on a different command list.

   For instance, the `set' command just starts a lookup on the

   For instance, the `set' command just starts a lookup on the

`setlist' command list, while `set thread' recurses to the

`setlist' command list, while `set thread' recurses to the

`set_thread_cmd_list'.

`set_thread_cmd_list'.

   To add commands in general, use `add_cmd'.  `add_com' adds to the

   To add commands in general, use `add_cmd'.  `add_com' adds to the

main command list, and should be used for those commands.  The usual

main command list, and should be used for those commands.  The usual

place to add commands is in the `_initialize_XYZ' routines at the ends

place to add commands is in the `_initialize_XYZ' routines at the ends

of most source files.

of most source files.

   To add paired `set' and `show' commands, use `add_setshow_cmd' or

   To add paired `set' and `show' commands, use `add_setshow_cmd' or

`add_setshow_cmd_full'.  The former is a slightly simpler interface

`add_setshow_cmd_full'.  The former is a slightly simpler interface

which is useful when you don't need to further modify the new command

which is useful when you don't need to further modify the new command

structures, while the latter returns the new command structures for

structures, while the latter returns the new command structures for

manipulation.

manipulation.

   Before removing commands from the command set it is a good idea to

   Before removing commands from the command set it is a good idea to

deprecate them for some time.  Use `deprecate_cmd' on commands or

deprecate them for some time.  Use `deprecate_cmd' on commands or

aliases to set the deprecated flag.  `deprecate_cmd' takes a `struct

aliases to set the deprecated flag.  `deprecate_cmd' takes a `struct

cmd_list_element' as it's first argument.  You can use the return value

cmd_list_element' as it's first argument.  You can use the return value

from `add_com' or `add_cmd' to deprecate the command immediately after

from `add_com' or `add_cmd' to deprecate the command immediately after

it is created.

it is created.

   The first time a command is used the user will be warned and offered

   The first time a command is used the user will be warned and offered

a replacement (if one exists). Note that the replacement string passed

a replacement (if one exists). Note that the replacement string passed

to `deprecate_cmd' should be the full name of the command, i.e., the

to `deprecate_cmd' should be the full name of the command, i.e., the

entire string the user should type at the command line.

entire string the user should type at the command line.

4.2 UI-Independent Output--the `ui_out' Functions

4.2 UI-Independent Output--the `ui_out' Functions

=================================================

=================================================

The `ui_out' functions present an abstraction level for the GDB output

The `ui_out' functions present an abstraction level for the GDB output

code.  They hide the specifics of different user interfaces supported

code.  They hide the specifics of different user interfaces supported

by GDB, and thus free the programmer from the need to write several

by GDB, and thus free the programmer from the need to write several

versions of the same code, one each for every UI, to produce output.

versions of the same code, one each for every UI, to produce output.

4.2.1 Overview and Terminology

4.2.1 Overview and Terminology

------------------------------

------------------------------

In general, execution of each GDB command produces some sort of output,

In general, execution of each GDB command produces some sort of output,

and can even generate an input request.

and can even generate an input request.

   Output can be generated for the following purposes:

   Output can be generated for the following purposes:

   * to display a _result_ of an operation;

   * to display a _result_ of an operation;

   * to convey _info_ or produce side-effects of a requested operation;

   * to convey _info_ or produce side-effects of a requested operation;

   * to provide a _notification_ of an asynchronous event (including

   * to provide a _notification_ of an asynchronous event (including

     progress indication of a prolonged asynchronous operation);

     progress indication of a prolonged asynchronous operation);

   * to display _error messages_ (including warnings);

   * to display _error messages_ (including warnings);

   * to show _debug data_;

   * to show _debug data_;

   * to _query_ or prompt a user for input (a special case).

   * to _query_ or prompt a user for input (a special case).

This section mainly concentrates on how to build result output,

This section mainly concentrates on how to build result output,

although some of it also applies to other kinds of output.

although some of it also applies to other kinds of output.

   Generation of output that displays the results of an operation

   Generation of output that displays the results of an operation

involves one or more of the following:

involves one or more of the following:

   * output of the actual data

   * output of the actual data

   * formatting the output as appropriate for console output, to make it

   * formatting the output as appropriate for console output, to make it

     easily readable by humans

     easily readable by humans

   * machine oriented formatting-a more terse formatting to allow for

   * machine oriented formatting-a more terse formatting to allow for

     easy parsing by programs which read GDB's output

     easy parsing by programs which read GDB's output

   * annotation, whose purpose is to help legacy GUIs to identify

   * annotation, whose purpose is to help legacy GUIs to identify

     interesting parts in the output

     interesting parts in the output

   The `ui_out' routines take care of the first three aspects.

   The `ui_out' routines take care of the first three aspects.

Annotations are provided by separate annotation routines.  Note that use

Annotations are provided by separate annotation routines.  Note that use

of annotations for an interface between a GUI and GDB is deprecated.

of annotations for an interface between a GUI and GDB is deprecated.

   Output can be in the form of a single item, which we call a "field";

   Output can be in the form of a single item, which we call a "field";

a "list" consisting of identical fields; a "tuple" consisting of

a "list" consisting of identical fields; a "tuple" consisting of

non-identical fields; or a "table", which is a tuple consisting of a

non-identical fields; or a "table", which is a tuple consisting of a

header and a body.  In a BNF-like form:

header and a body.  In a BNF-like form:

` ==>'
        ` ==>'
      
      
             ` '
             ` '
      
      
        
        
      
      
        ` ==>'
        ` ==>'
      
      
             `{  }'
             `{  }'
      
      
        
        
      
      
        ` ==>'
        ` ==>'
      
      
             `  '</code></pre></td>
        <td class="diff"><pre><code>     `<width> <alignment> <title>'</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>`<body> ==>'</code></pre></td>
        <td class="diff"><pre><code>`<body> ==>'</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     `{<row>}'</code></pre></td>
        <td class="diff"><pre><code>     `{<row>}'</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>4.2.2 General Conventions</code></pre></td>
        <td class="diff"><pre><code>4.2.2 General Conventions</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>-------------------------</code></pre></td>
        <td class="diff"><pre><code>-------------------------</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>Most `ui_out' routines are of type `void', the exceptions are</code></pre></td>
        <td class="diff"><pre><code>Most `ui_out' routines are of type `void', the exceptions are</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>`ui_out_stream_new' (which returns a pointer to the newly created</code></pre></td>
        <td class="diff"><pre><code>`ui_out_stream_new' (which returns a pointer to the newly created</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>object) and the `make_cleanup' routines.</code></pre></td>
        <td class="diff"><pre><code>object) and the `make_cleanup' routines.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>   The first parameter is always the `ui_out' vector object, a pointer</code></pre></td>
        <td class="diff"><pre><code>   The first parameter is always the `ui_out' vector object, a pointer</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>to a `struct ui_out'.</code></pre></td>
        <td class="diff"><pre><code>to a `struct ui_out'.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>   The FORMAT parameter is like in `printf' family of functions.  When</code></pre></td>
        <td class="diff"><pre><code>   The FORMAT parameter is like in `printf' family of functions.  When</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>it is present, there must also be a variable list of arguments</code></pre></td>
        <td class="diff"><pre><code>it is present, there must also be a variable list of arguments</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>sufficient used to satisfy the `%' specifiers in the supplied format.</code></pre></td>
        <td class="diff"><pre><code>sufficient used to satisfy the `%' specifiers in the supplied format.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>   When a character string argument is not used in a `ui_out' function</code></pre></td>
        <td class="diff"><pre><code>   When a character string argument is not used in a `ui_out' function</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>call, a `NULL' pointer has to be supplied instead.</code></pre></td>
        <td class="diff"><pre><code>call, a `NULL' pointer has to be supplied instead.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>4.2.3 Table, Tuple and List Functions</code></pre></td>
        <td class="diff"><pre><code>4.2.3 Table, Tuple and List Functions</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>-------------------------------------</code></pre></td>
        <td class="diff"><pre><code>-------------------------------------</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>This section introduces `ui_out' routines for building lists, tuples</code></pre></td>
        <td class="diff"><pre><code>This section introduces `ui_out' routines for building lists, tuples</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>and tables.  The routines to output the actual data items (fields) are</code></pre></td>
        <td class="diff"><pre><code>and tables.  The routines to output the actual data items (fields) are</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>presented in the next section.</code></pre></td>
        <td class="diff"><pre><code>presented in the next section.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>   To recap: A "tuple" is a sequence of "fields", each field containing</code></pre></td>
        <td class="diff"><pre><code>   To recap: A "tuple" is a sequence of "fields", each field containing</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>information about an object; a "list" is a sequence of fields where</code></pre></td>
        <td class="diff"><pre><code>information about an object; a "list" is a sequence of fields where</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>each field describes an identical object.</code></pre></td>
        <td class="diff"><pre><code>each field describes an identical object.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>   Use the "table" functions when your output consists of a list of</code></pre></td>
        <td class="diff"><pre><code>   Use the "table" functions when your output consists of a list of</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>rows (tuples) and the console output should include a heading.  Use this</code></pre></td>
        <td class="diff"><pre><code>rows (tuples) and the console output should include a heading.  Use this</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>even when you are listing just one object but you still want the header.</code></pre></td>
        <td class="diff"><pre><code>even when you are listing just one object but you still want the header.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>   Tables can not be nested.  Tuples and lists can be nested up to a</code></pre></td>
        <td class="diff"><pre><code>   Tables can not be nested.  Tuples and lists can be nested up to a</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>maximum of five levels.</code></pre></td>
        <td class="diff"><pre><code>maximum of five levels.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>   The overall structure of the table output code is something like</code></pre></td>
        <td class="diff"><pre><code>   The overall structure of the table output code is something like</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>this:</code></pre></td>
        <td class="diff"><pre><code>this:</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>       ui_out_table_begin</code></pre></td>
        <td class="diff"><pre><code>       ui_out_table_begin</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>         ui_out_table_header</code></pre></td>
        <td class="diff"><pre><code>         ui_out_table_header</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>         ...</code></pre></td>
        <td class="diff"><pre><code>         ...</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>         ui_out_table_body</code></pre></td>
        <td class="diff"><pre><code>         ui_out_table_body</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>           ui_out_tuple_begin</code></pre></td>
        <td class="diff"><pre><code>           ui_out_tuple_begin</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>             ui_out_field_*</code></pre></td>
        <td class="diff"><pre><code>             ui_out_field_*</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>             ...</code></pre></td>
        <td class="diff"><pre><code>             ...</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>           ui_out_tuple_end</code></pre></td>
        <td class="diff"><pre><code>           ui_out_tuple_end</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>           ...</code></pre></td>
        <td class="diff"><pre><code>           ...</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>       ui_out_table_end</code></pre></td>
        <td class="diff"><pre><code>       ui_out_table_end</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>   Here is the description of table-, tuple- and list-related `ui_out'</code></pre></td>
        <td class="diff"><pre><code>   Here is the description of table-, tuple- and list-related `ui_out'</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>functions:</code></pre></td>
        <td class="diff"><pre><code>functions:</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code> -- Function: void ui_out_table_begin (struct ui_out *UIOUT, int</code></pre></td>
        <td class="diff"><pre><code> -- Function: void ui_out_table_begin (struct ui_out *UIOUT, int</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>          NBROFCOLS, int NR_ROWS, const char *TBLID)</code></pre></td>
        <td class="diff"><pre><code>          NBROFCOLS, int NR_ROWS, const char *TBLID)</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     The function `ui_out_table_begin' marks the beginning of the output</code></pre></td>
        <td class="diff"><pre><code>     The function `ui_out_table_begin' marks the beginning of the output</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     of a table.  It should always be called before any other `ui_out'</code></pre></td>
        <td class="diff"><pre><code>     of a table.  It should always be called before any other `ui_out'</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     function for a given table.  NBROFCOLS is the number of columns in</code></pre></td>
        <td class="diff"><pre><code>     function for a given table.  NBROFCOLS is the number of columns in</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     the table. NR_ROWS is the number of rows in the table.  TBLID is</code></pre></td>
        <td class="diff"><pre><code>     the table. NR_ROWS is the number of rows in the table.  TBLID is</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     an optional string identifying the table.  The string pointed to</code></pre></td>
        <td class="diff"><pre><code>     an optional string identifying the table.  The string pointed to</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     by TBLID is copied by the implementation of `ui_out_table_begin',</code></pre></td>
        <td class="diff"><pre><code>     by TBLID is copied by the implementation of `ui_out_table_begin',</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     so the application can free the string if it was `malloc'ed.</code></pre></td>
        <td class="diff"><pre><code>     so the application can free the string if it was `malloc'ed.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     The companion function `ui_out_table_end', described below, marks</code></pre></td>
        <td class="diff"><pre><code>     The companion function `ui_out_table_end', described below, marks</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     the end of the table's output.</code></pre></td>
        <td class="diff"><pre><code>     the end of the table's output.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code> -- Function: void ui_out_table_header (struct ui_out *UIOUT, int</code></pre></td>
        <td class="diff"><pre><code> -- Function: void ui_out_table_header (struct ui_out *UIOUT, int</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>          WIDTH, enum ui_align ALIGNMENT, const char *COLHDR)</code></pre></td>
        <td class="diff"><pre><code>          WIDTH, enum ui_align ALIGNMENT, const char *COLHDR)</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     `ui_out_table_header' provides the header information for a single</code></pre></td>
        <td class="diff"><pre><code>     `ui_out_table_header' provides the header information for a single</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     table column.  You call this function several times, one each for</code></pre></td>
        <td class="diff"><pre><code>     table column.  You call this function several times, one each for</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     every column of the table, after `ui_out_table_begin', but before</code></pre></td>
        <td class="diff"><pre><code>     every column of the table, after `ui_out_table_begin', but before</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     `ui_out_table_body'.</code></pre></td>
        <td class="diff"><pre><code>     `ui_out_table_body'.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     The value of WIDTH gives the column width in characters.  The</code></pre></td>
        <td class="diff"><pre><code>     The value of WIDTH gives the column width in characters.  The</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     value of ALIGNMENT is one of `left', `center', and `right', and it</code></pre></td>
        <td class="diff"><pre><code>     value of ALIGNMENT is one of `left', `center', and `right', and it</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     specifies how to align the header: left-justify, center, or</code></pre></td>
        <td class="diff"><pre><code>     specifies how to align the header: left-justify, center, or</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     right-justify it.  COLHDR points to a string that specifies the</code></pre></td>
        <td class="diff"><pre><code>     right-justify it.  COLHDR points to a string that specifies the</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     column header; the implementation copies that string, so column</code></pre></td>
        <td class="diff"><pre><code>     column header; the implementation copies that string, so column</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     header strings in `malloc'ed storage can be freed after the call.</code></pre></td>
        <td class="diff"><pre><code>     header strings in `malloc'ed storage can be freed after the call.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code> -- Function: void ui_out_table_body (struct ui_out *UIOUT)</code></pre></td>
        <td class="diff"><pre><code> -- Function: void ui_out_table_body (struct ui_out *UIOUT)</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     This function delimits the table header from the table body.</code></pre></td>
        <td class="diff"><pre><code>     This function delimits the table header from the table body.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code> -- Function: void ui_out_table_end (struct ui_out *UIOUT)</code></pre></td>
        <td class="diff"><pre><code> -- Function: void ui_out_table_end (struct ui_out *UIOUT)</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     This function signals the end of a table's output.  It should be</code></pre></td>
        <td class="diff"><pre><code>     This function signals the end of a table's output.  It should be</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     called after the table body has been produced by the list and</code></pre></td>
        <td class="diff"><pre><code>     called after the table body has been produced by the list and</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     field output functions.</code></pre></td>
        <td class="diff"><pre><code>     field output functions.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     There should be exactly one call to `ui_out_table_end' for each</code></pre></td>
        <td class="diff"><pre><code>     There should be exactly one call to `ui_out_table_end' for each</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     call to `ui_out_table_begin', otherwise the `ui_out' functions</code></pre></td>
        <td class="diff"><pre><code>     call to `ui_out_table_begin', otherwise the `ui_out' functions</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     will signal an internal error.</code></pre></td>
        <td class="diff"><pre><code>     will signal an internal error.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>   The output of the tuples that represent the table rows must follow</code></pre></td>
        <td class="diff"><pre><code>   The output of the tuples that represent the table rows must follow</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>the call to `ui_out_table_body' and precede the call to</code></pre></td>
        <td class="diff"><pre><code>the call to `ui_out_table_body' and precede the call to</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>`ui_out_table_end'.  You build a tuple by calling `ui_out_tuple_begin'</code></pre></td>
        <td class="diff"><pre><code>`ui_out_table_end'.  You build a tuple by calling `ui_out_tuple_begin'</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>and `ui_out_tuple_end', with suitable calls to functions which actually</code></pre></td>
        <td class="diff"><pre><code>and `ui_out_tuple_end', with suitable calls to functions which actually</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>output fields between them.</code></pre></td>
        <td class="diff"><pre><code>output fields between them.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code> -- Function: void ui_out_tuple_begin (struct ui_out *UIOUT, const char</code></pre></td>
        <td class="diff"><pre><code> -- Function: void ui_out_tuple_begin (struct ui_out *UIOUT, const char</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>          *ID)</code></pre></td>
        <td class="diff"><pre><code>          *ID)</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     This function marks the beginning of a tuple output.  ID points to</code></pre></td>
        <td class="diff"><pre><code>     This function marks the beginning of a tuple output.  ID points to</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     an optional string that identifies the tuple; it is copied by the</code></pre></td>
        <td class="diff"><pre><code>     an optional string that identifies the tuple; it is copied by the</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     implementation, and so strings in `malloc'ed storage can be freed</code></pre></td>
        <td class="diff"><pre><code>     implementation, and so strings in `malloc'ed storage can be freed</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     after the call.</code></pre></td>
        <td class="diff"><pre><code>     after the call.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code> -- Function: void ui_out_tuple_end (struct ui_out *UIOUT)</code></pre></td>
        <td class="diff"><pre><code> -- Function: void ui_out_tuple_end (struct ui_out *UIOUT)</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     This function signals an end of a tuple output.  There should be</code></pre></td>
        <td class="diff"><pre><code>     This function signals an end of a tuple output.  There should be</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     exactly one call to `ui_out_tuple_end' for each call to</code></pre></td>
        <td class="diff"><pre><code>     exactly one call to `ui_out_tuple_end' for each call to</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     `ui_out_tuple_begin', otherwise an internal GDB error will be</code></pre></td>
        <td class="diff"><pre><code>     `ui_out_tuple_begin', otherwise an internal GDB error will be</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     signaled.</code></pre></td>
        <td class="diff"><pre><code>     signaled.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code> -- Function: struct cleanup *make_cleanup_ui_out_tuple_begin_end</code></pre></td>
        <td class="diff"><pre><code> -- Function: struct cleanup *make_cleanup_ui_out_tuple_begin_end</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>          (struct ui_out *UIOUT, const char *ID)</code></pre></td>
        <td class="diff"><pre><code>          (struct ui_out *UIOUT, const char *ID)</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     This function first opens the tuple and then establishes a cleanup</code></pre></td>
        <td class="diff"><pre><code>     This function first opens the tuple and then establishes a cleanup</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     (*note Cleanups: Coding.) to close the tuple.  It provides a</code></pre></td>
        <td class="diff"><pre><code>     (*note Cleanups: Coding.) to close the tuple.  It provides a</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     convenient and correct implementation of the non-portable(1) code</code></pre></td>
        <td class="diff"><pre><code>     convenient and correct implementation of the non-portable(1) code</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     sequence:</code></pre></td>
        <td class="diff"><pre><code>     sequence:</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>          struct cleanup *old_cleanup;</code></pre></td>
        <td class="diff"><pre><code>          struct cleanup *old_cleanup;</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>          ui_out_tuple_begin (uiout, "...");</code></pre></td>
        <td class="diff"><pre><code>          ui_out_tuple_begin (uiout, "...");</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>          old_cleanup = make_cleanup ((void(*)(void *)) ui_out_tuple_end,</code></pre></td>
        <td class="diff"><pre><code>          old_cleanup = make_cleanup ((void(*)(void *)) ui_out_tuple_end,</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>                                      uiout);</code></pre></td>
        <td class="diff"><pre><code>                                      uiout);</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code> -- Function: void ui_out_list_begin (struct ui_out *UIOUT, const char</code></pre></td>
        <td class="diff"><pre><code> -- Function: void ui_out_list_begin (struct ui_out *UIOUT, const char</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>          *ID)</code></pre></td>
        <td class="diff"><pre><code>          *ID)</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     This function marks the beginning of a list output.  ID points to</code></pre></td>
        <td class="diff"><pre><code>     This function marks the beginning of a list output.  ID points to</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     an optional string that identifies the list; it is copied by the</code></pre></td>
        <td class="diff"><pre><code>     an optional string that identifies the list; it is copied by the</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     implementation, and so strings in `malloc'ed storage can be freed</code></pre></td>
        <td class="diff"><pre><code>     implementation, and so strings in `malloc'ed storage can be freed</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     after the call.</code></pre></td>
        <td class="diff"><pre><code>     after the call.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code> -- Function: void ui_out_list_end (struct ui_out *UIOUT)</code></pre></td>
        <td class="diff"><pre><code> -- Function: void ui_out_list_end (struct ui_out *UIOUT)</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     This function signals an end of a list output.  There should be</code></pre></td>
        <td class="diff"><pre><code>     This function signals an end of a list output.  There should be</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     exactly one call to `ui_out_list_end' for each call to</code></pre></td>
        <td class="diff"><pre><code>     exactly one call to `ui_out_list_end' for each call to</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     `ui_out_list_begin', otherwise an internal GDB error will be</code></pre></td>
        <td class="diff"><pre><code>     `ui_out_list_begin', otherwise an internal GDB error will be</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     signaled.</code></pre></td>
        <td class="diff"><pre><code>     signaled.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code> -- Function: struct cleanup *make_cleanup_ui_out_list_begin_end</code></pre></td>
        <td class="diff"><pre><code> -- Function: struct cleanup *make_cleanup_ui_out_list_begin_end</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>          (struct ui_out *UIOUT, const char *ID)</code></pre></td>
        <td class="diff"><pre><code>          (struct ui_out *UIOUT, const char *ID)</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     Similar to `make_cleanup_ui_out_tuple_begin_end', this function</code></pre></td>
        <td class="diff"><pre><code>     Similar to `make_cleanup_ui_out_tuple_begin_end', this function</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     opens a list and then establishes cleanup (*note Cleanups: Coding.)</code></pre></td>
        <td class="diff"><pre><code>     opens a list and then establishes cleanup (*note Cleanups: Coding.)</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     that will close the list.</code></pre></td>
        <td class="diff"><pre><code>     that will close the list.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>4.2.4 Item Output Functions</code></pre></td>
        <td class="diff"><pre><code>4.2.4 Item Output Functions</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>---------------------------</code></pre></td>
        <td class="diff"><pre><code>---------------------------</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>The functions described below produce output for the actual data items,</code></pre></td>
        <td class="diff"><pre><code>The functions described below produce output for the actual data items,</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>or fields, which contain information about the object.</code></pre></td>
        <td class="diff"><pre><code>or fields, which contain information about the object.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>   Choose the appropriate function accordingly to your particular needs.</code></pre></td>
        <td class="diff"><pre><code>   Choose the appropriate function accordingly to your particular needs.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code> -- Function: void ui_out_field_fmt (struct ui_out *UIOUT, char</code></pre></td>
        <td class="diff"><pre><code> -- Function: void ui_out_field_fmt (struct ui_out *UIOUT, char</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>          *FLDNAME, char *FORMAT, ...)</code></pre></td>
        <td class="diff"><pre><code>          *FLDNAME, char *FORMAT, ...)</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     This is the most general output function.  It produces the</code></pre></td>
        <td class="diff"><pre><code>     This is the most general output function.  It produces the</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     representation of the data in the variable-length argument list</code></pre></td>
        <td class="diff"><pre><code>     representation of the data in the variable-length argument list</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     according to formatting specifications in FORMAT, a `printf'-like</code></pre></td>
        <td class="diff"><pre><code>     according to formatting specifications in FORMAT, a `printf'-like</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     format string.  The optional argument FLDNAME supplies the name of</code></pre></td>
        <td class="diff"><pre><code>     format string.  The optional argument FLDNAME supplies the name of</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     the field.  The data items themselves are supplied as additional</code></pre></td>
        <td class="diff"><pre><code>     the field.  The data items themselves are supplied as additional</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     arguments after FORMAT.</code></pre></td>
        <td class="diff"><pre><code>     arguments after FORMAT.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     This generic function should be used only when it is not possible</code></pre></td>
        <td class="diff"><pre><code>     This generic function should be used only when it is not possible</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     to use one of the specialized versions (see below).</code></pre></td>
        <td class="diff"><pre><code>     to use one of the specialized versions (see below).</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code> -- Function: void ui_out_field_int (struct ui_out *UIOUT, const char</code></pre></td>
        <td class="diff"><pre><code> -- Function: void ui_out_field_int (struct ui_out *UIOUT, const char</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>          *FLDNAME, int VALUE)</code></pre></td>
        <td class="diff"><pre><code>          *FLDNAME, int VALUE)</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     This function outputs a value of an `int' variable.  It uses the</code></pre></td>
        <td class="diff"><pre><code>     This function outputs a value of an `int' variable.  It uses the</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     `"%d"' output conversion specification.  FLDNAME specifies the</code></pre></td>
        <td class="diff"><pre><code>     `"%d"' output conversion specification.  FLDNAME specifies the</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     name of the field.</code></pre></td>
        <td class="diff"><pre><code>     name of the field.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code> -- Function: void ui_out_field_fmt_int (struct ui_out *UIOUT, int</code></pre></td>
        <td class="diff"><pre><code> -- Function: void ui_out_field_fmt_int (struct ui_out *UIOUT, int</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>          WIDTH, enum ui_align ALIGNMENT, const char *FLDNAME, int</code></pre></td>
        <td class="diff"><pre><code>          WIDTH, enum ui_align ALIGNMENT, const char *FLDNAME, int</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>          VALUE)</code></pre></td>
        <td class="diff"><pre><code>          VALUE)</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     This function outputs a value of an `int' variable.  It differs</code></pre></td>
        <td class="diff"><pre><code>     This function outputs a value of an `int' variable.  It differs</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     from `ui_out_field_int' in that the caller specifies the desired</code></pre></td>
        <td class="diff"><pre><code>     from `ui_out_field_int' in that the caller specifies the desired</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     WIDTH and ALIGNMENT of the output.  FLDNAME specifies the name of</code></pre></td>
        <td class="diff"><pre><code>     WIDTH and ALIGNMENT of the output.  FLDNAME specifies the name of</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     the field.</code></pre></td>
        <td class="diff"><pre><code>     the field.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code> -- Function: void ui_out_field_core_addr (struct ui_out *UIOUT, const</code></pre></td>
        <td class="diff"><pre><code> -- Function: void ui_out_field_core_addr (struct ui_out *UIOUT, const</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>          char *FLDNAME, CORE_ADDR ADDRESS)</code></pre></td>
        <td class="diff"><pre><code>          char *FLDNAME, CORE_ADDR ADDRESS)</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     This function outputs an address.</code></pre></td>
        <td class="diff"><pre><code>     This function outputs an address.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code> -- Function: void ui_out_field_string (struct ui_out *UIOUT, const</code></pre></td>
        <td class="diff"><pre><code> -- Function: void ui_out_field_string (struct ui_out *UIOUT, const</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>          char *FLDNAME, const char *STRING)</code></pre></td>
        <td class="diff"><pre><code>          char *FLDNAME, const char *STRING)</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     This function outputs a string using the `"%s"' conversion</code></pre></td>
        <td class="diff"><pre><code>     This function outputs a string using the `"%s"' conversion</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     specification.</code></pre></td>
        <td class="diff"><pre><code>     specification.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>   Sometimes, there's a need to compose your output piece by piece using</code></pre></td>
        <td class="diff"><pre><code>   Sometimes, there's a need to compose your output piece by piece using</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>functions that operate on a stream, such as `value_print' or</code></pre></td>
        <td class="diff"><pre><code>functions that operate on a stream, such as `value_print' or</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>`fprintf_symbol_filtered'.  These functions accept an argument of the</code></pre></td>
        <td class="diff"><pre><code>`fprintf_symbol_filtered'.  These functions accept an argument of the</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>type `struct ui_file *', a pointer to a `ui_file' object used to store</code></pre></td>
        <td class="diff"><pre><code>type `struct ui_file *', a pointer to a `ui_file' object used to store</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>the data stream used for the output.  When you use one of these</code></pre></td>
        <td class="diff"><pre><code>the data stream used for the output.  When you use one of these</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>functions, you need a way to pass their results stored in a `ui_file'</code></pre></td>
        <td class="diff"><pre><code>functions, you need a way to pass their results stored in a `ui_file'</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>object to the `ui_out' functions.  To this end, you first create a</code></pre></td>
        <td class="diff"><pre><code>object to the `ui_out' functions.  To this end, you first create a</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>`ui_stream' object by calling `ui_out_stream_new', pass the `stream'</code></pre></td>
        <td class="diff"><pre><code>`ui_stream' object by calling `ui_out_stream_new', pass the `stream'</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>member of that `ui_stream' object to `value_print' and similar</code></pre></td>
        <td class="diff"><pre><code>member of that `ui_stream' object to `value_print' and similar</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>functions, and finally call `ui_out_field_stream' to output the field</code></pre></td>
        <td class="diff"><pre><code>functions, and finally call `ui_out_field_stream' to output the field</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>you constructed.  When the `ui_stream' object is no longer needed, you</code></pre></td>
        <td class="diff"><pre><code>you constructed.  When the `ui_stream' object is no longer needed, you</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>should destroy it and free its memory by calling `ui_out_stream_delete'.</code></pre></td>
        <td class="diff"><pre><code>should destroy it and free its memory by calling `ui_out_stream_delete'.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code> -- Function: struct ui_stream *ui_out_stream_new (struct ui_out *UIOUT)</code></pre></td>
        <td class="diff"><pre><code> -- Function: struct ui_stream *ui_out_stream_new (struct ui_out *UIOUT)</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     This function creates a new `ui_stream' object which uses the same</code></pre></td>
        <td class="diff"><pre><code>     This function creates a new `ui_stream' object which uses the same</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     output methods as the `ui_out' object whose pointer is passed in</code></pre></td>
        <td class="diff"><pre><code>     output methods as the `ui_out' object whose pointer is passed in</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     UIOUT.  It returns a pointer to the newly created `ui_stream'</code></pre></td>
        <td class="diff"><pre><code>     UIOUT.  It returns a pointer to the newly created `ui_stream'</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     object.</code></pre></td>
        <td class="diff"><pre><code>     object.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code> -- Function: void ui_out_stream_delete (struct ui_stream *STREAMBUF)</code></pre></td>
        <td class="diff"><pre><code> -- Function: void ui_out_stream_delete (struct ui_stream *STREAMBUF)</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     This functions destroys a `ui_stream' object specified by</code></pre></td>
        <td class="diff"><pre><code>     This functions destroys a `ui_stream' object specified by</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     STREAMBUF.</code></pre></td>
        <td class="diff"><pre><code>     STREAMBUF.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code> -- Function: void ui_out_field_stream (struct ui_out *UIOUT, const</code></pre></td>
        <td class="diff"><pre><code> -- Function: void ui_out_field_stream (struct ui_out *UIOUT, const</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>          char *FIELDNAME, struct ui_stream *STREAMBUF)</code></pre></td>
        <td class="diff"><pre><code>          char *FIELDNAME, struct ui_stream *STREAMBUF)</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     This function consumes all the data accumulated in</code></pre></td>
        <td class="diff"><pre><code>     This function consumes all the data accumulated in</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     `streambuf->stream' and outputs it like `ui_out_field_string'</code></pre></td>
        <td class="diff"><pre><code>     `streambuf->stream' and outputs it like `ui_out_field_string'</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     does.  After a call to `ui_out_field_stream', the accumulated data</code></pre></td>
        <td class="diff"><pre><code>     does.  After a call to `ui_out_field_stream', the accumulated data</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     no longer exists, but the stream is still valid and may be used</code></pre></td>
        <td class="diff"><pre><code>     no longer exists, but the stream is still valid and may be used</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     for producing more fields.</code></pre></td>
        <td class="diff"><pre><code>     for producing more fields.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>   *Important:* If there is any chance that your code could bail out</code></pre></td>
        <td class="diff"><pre><code>   *Important:* If there is any chance that your code could bail out</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>before completing output generation and reaching the point where</code></pre></td>
        <td class="diff"><pre><code>before completing output generation and reaching the point where</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>`ui_out_stream_delete' is called, it is necessary to set up a cleanup,</code></pre></td>
        <td class="diff"><pre><code>`ui_out_stream_delete' is called, it is necessary to set up a cleanup,</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>to avoid leaking memory and other resources.  Here's a skeleton code to</code></pre></td>
        <td class="diff"><pre><code>to avoid leaking memory and other resources.  Here's a skeleton code to</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>do that:</code></pre></td>
        <td class="diff"><pre><code>do that:</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>      struct ui_stream *mybuf = ui_out_stream_new (uiout);</code></pre></td>
        <td class="diff"><pre><code>      struct ui_stream *mybuf = ui_out_stream_new (uiout);</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>      struct cleanup *old = make_cleanup (ui_out_stream_delete, mybuf);</code></pre></td>
        <td class="diff"><pre><code>      struct cleanup *old = make_cleanup (ui_out_stream_delete, mybuf);</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>      ...</code></pre></td>
        <td class="diff"><pre><code>      ...</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>      do_cleanups (old);</code></pre></td>
        <td class="diff"><pre><code>      do_cleanups (old);</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>   If the function already has the old cleanup chain set (for other</code></pre></td>
        <td class="diff"><pre><code>   If the function already has the old cleanup chain set (for other</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>kinds of cleanups), you just have to add your cleanup to it:</code></pre></td>
        <td class="diff"><pre><code>kinds of cleanups), you just have to add your cleanup to it:</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>       mybuf = ui_out_stream_new (uiout);</code></pre></td>
        <td class="diff"><pre><code>       mybuf = ui_out_stream_new (uiout);</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>       make_cleanup (ui_out_stream_delete, mybuf);</code></pre></td>
        <td class="diff"><pre><code>       make_cleanup (ui_out_stream_delete, mybuf);</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>   Note that with cleanups in place, you should not call</code></pre></td>
        <td class="diff"><pre><code>   Note that with cleanups in place, you should not call</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>`ui_out_stream_delete' directly, or you would attempt to free the same</code></pre></td>
        <td class="diff"><pre><code>`ui_out_stream_delete' directly, or you would attempt to free the same</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>buffer twice.</code></pre></td>
        <td class="diff"><pre><code>buffer twice.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>4.2.5 Utility Output Functions</code></pre></td>
        <td class="diff"><pre><code>4.2.5 Utility Output Functions</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>------------------------------</code></pre></td>
        <td class="diff"><pre><code>------------------------------</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code> -- Function: void ui_out_field_skip (struct ui_out *UIOUT, const char</code></pre></td>
        <td class="diff"><pre><code> -- Function: void ui_out_field_skip (struct ui_out *UIOUT, const char</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>          *FLDNAME)</code></pre></td>
        <td class="diff"><pre><code>          *FLDNAME)</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     This function skips a field in a table.  Use it if you have to</code></pre></td>
        <td class="diff"><pre><code>     This function skips a field in a table.  Use it if you have to</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     leave an empty field without disrupting the table alignment.  The</code></pre></td>
        <td class="diff"><pre><code>     leave an empty field without disrupting the table alignment.  The</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     argument FLDNAME specifies a name for the (missing) filed.</code></pre></td>
        <td class="diff"><pre><code>     argument FLDNAME specifies a name for the (missing) filed.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code> -- Function: void ui_out_text (struct ui_out *UIOUT, const char</code></pre></td>
        <td class="diff"><pre><code> -- Function: void ui_out_text (struct ui_out *UIOUT, const char</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>          *STRING)</code></pre></td>
        <td class="diff"><pre><code>          *STRING)</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     This function outputs the text in STRING in a way that makes it</code></pre></td>
        <td class="diff"><pre><code>     This function outputs the text in STRING in a way that makes it</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     easy to be read by humans.  For example, the console</code></pre></td>
        <td class="diff"><pre><code>     easy to be read by humans.  For example, the console</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     implementation of this method filters the text through a built-in</code></pre></td>
        <td class="diff"><pre><code>     implementation of this method filters the text through a built-in</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     pager, to prevent it from scrolling off the visible portion of the</code></pre></td>
        <td class="diff"><pre><code>     pager, to prevent it from scrolling off the visible portion of the</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     screen.</code></pre></td>
        <td class="diff"><pre><code>     screen.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     Use this function for printing relatively long chunks of text</code></pre></td>
        <td class="diff"><pre><code>     Use this function for printing relatively long chunks of text</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     around the actual field data: the text it produces is not aligned</code></pre></td>
        <td class="diff"><pre><code>     around the actual field data: the text it produces is not aligned</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     according to the table's format.  Use `ui_out_field_string' to</code></pre></td>
        <td class="diff"><pre><code>     according to the table's format.  Use `ui_out_field_string' to</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     output a string field, and use `ui_out_message', described below,</code></pre></td>
        <td class="diff"><pre><code>     output a string field, and use `ui_out_message', described below,</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     to output short messages.</code></pre></td>
        <td class="diff"><pre><code>     to output short messages.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code> -- Function: void ui_out_spaces (struct ui_out *UIOUT, int NSPACES)</code></pre></td>
        <td class="diff"><pre><code> -- Function: void ui_out_spaces (struct ui_out *UIOUT, int NSPACES)</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     This function outputs NSPACES spaces.  It is handy to align the</code></pre></td>
        <td class="diff"><pre><code>     This function outputs NSPACES spaces.  It is handy to align the</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     text produced by `ui_out_text' with the rest of the table or list.</code></pre></td>
        <td class="diff"><pre><code>     text produced by `ui_out_text' with the rest of the table or list.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code> -- Function: void ui_out_message (struct ui_out *UIOUT, int VERBOSITY,</code></pre></td>
        <td class="diff"><pre><code> -- Function: void ui_out_message (struct ui_out *UIOUT, int VERBOSITY,</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>          const char *FORMAT, ...)</code></pre></td>
        <td class="diff"><pre><code>          const char *FORMAT, ...)</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     This function produces a formatted message, provided that the</code></pre></td>
        <td class="diff"><pre><code>     This function produces a formatted message, provided that the</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     current verbosity level is at least as large as given by</code></pre></td>
        <td class="diff"><pre><code>     current verbosity level is at least as large as given by</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     VERBOSITY.  The current verbosity level is specified by the user</code></pre></td>
        <td class="diff"><pre><code>     VERBOSITY.  The current verbosity level is specified by the user</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     with the `set verbositylevel' command.(2)</code></pre></td>
        <td class="diff"><pre><code>     with the `set verbositylevel' command.(2)</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code> -- Function: void ui_out_wrap_hint (struct ui_out *UIOUT, char *INDENT)</code></pre></td>
        <td class="diff"><pre><code> -- Function: void ui_out_wrap_hint (struct ui_out *UIOUT, char *INDENT)</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     This function gives the console output filter (a paging filter) a</code></pre></td>
        <td class="diff"><pre><code>     This function gives the console output filter (a paging filter) a</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     hint of where to break lines which are too long.  Ignored for all</code></pre></td>
        <td class="diff"><pre><code>     hint of where to break lines which are too long.  Ignored for all</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     other output consumers.  INDENT, if non-`NULL', is the string to</code></pre></td>
        <td class="diff"><pre><code>     other output consumers.  INDENT, if non-`NULL', is the string to</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     be printed to indent the wrapped text on the next line; it must</code></pre></td>
        <td class="diff"><pre><code>     be printed to indent the wrapped text on the next line; it must</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     remain accessible until the next call to `ui_out_wrap_hint', or</code></pre></td>
        <td class="diff"><pre><code>     remain accessible until the next call to `ui_out_wrap_hint', or</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     until an explicit newline is produced by one of the other</code></pre></td>
        <td class="diff"><pre><code>     until an explicit newline is produced by one of the other</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     functions.  If INDENT is `NULL', the wrapped text will not be</code></pre></td>
        <td class="diff"><pre><code>     functions.  If INDENT is `NULL', the wrapped text will not be</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     indented.</code></pre></td>
        <td class="diff"><pre><code>     indented.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code> -- Function: void ui_out_flush (struct ui_out *UIOUT)</code></pre></td>
        <td class="diff"><pre><code> -- Function: void ui_out_flush (struct ui_out *UIOUT)</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     This function flushes whatever output has been accumulated so far,</code></pre></td>
        <td class="diff"><pre><code>     This function flushes whatever output has been accumulated so far,</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     if the UI buffers output.</code></pre></td>
        <td class="diff"><pre><code>     if the UI buffers output.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>4.2.6 Examples of Use of `ui_out' functions</code></pre></td>
        <td class="diff"><pre><code>4.2.6 Examples of Use of `ui_out' functions</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>-------------------------------------------</code></pre></td>
        <td class="diff"><pre><code>-------------------------------------------</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>This section gives some practical examples of using the `ui_out'</code></pre></td>
        <td class="diff"><pre><code>This section gives some practical examples of using the `ui_out'</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>functions to generalize the old console-oriented code in GDB.  The</code></pre></td>
        <td class="diff"><pre><code>functions to generalize the old console-oriented code in GDB.  The</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>examples all come from functions defined on the `breakpoints.c' file.</code></pre></td>
        <td class="diff"><pre><code>examples all come from functions defined on the `breakpoints.c' file.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>   This example, from the `breakpoint_1' function, shows how to produce</code></pre></td>
        <td class="diff"><pre><code>   This example, from the `breakpoint_1' function, shows how to produce</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>a table.</code></pre></td>
        <td class="diff"><pre><code>a table.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>   The original code was:</code></pre></td>
        <td class="diff"><pre><code>   The original code was:</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>      if (!found_a_breakpoint++)</code></pre></td>
        <td class="diff"><pre><code>      if (!found_a_breakpoint++)</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>        {</code></pre></td>
        <td class="diff"><pre><code>        {</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>          annotate_breakpoints_headers ();</code></pre></td>
        <td class="diff"><pre><code>          annotate_breakpoints_headers ();</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>          annotate_field (0);</code></pre></td>
        <td class="diff"><pre><code>          annotate_field (0);</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>          printf_filtered ("Num ");</code></pre></td>
        <td class="diff"><pre><code>          printf_filtered ("Num ");</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>          annotate_field (1);</code></pre></td>
        <td class="diff"><pre><code>          annotate_field (1);</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>          printf_filtered ("Type           ");</code></pre></td>
        <td class="diff"><pre><code>          printf_filtered ("Type           ");</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>          annotate_field (2);</code></pre></td>
        <td class="diff"><pre><code>          annotate_field (2);</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>          printf_filtered ("Disp ");</code></pre></td>
        <td class="diff"><pre><code>          printf_filtered ("Disp ");</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>          annotate_field (3);</code></pre></td>
        <td class="diff"><pre><code>          annotate_field (3);</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>          printf_filtered ("Enb ");</code></pre></td>
        <td class="diff"><pre><code>          printf_filtered ("Enb ");</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>          if (addressprint)</code></pre></td>
        <td class="diff"><pre><code>          if (addressprint)</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>            {</code></pre></td>
        <td class="diff"><pre><code>            {</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>              annotate_field (4);</code></pre></td>
        <td class="diff"><pre><code>              annotate_field (4);</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>              printf_filtered ("Address    ");</code></pre></td>
        <td class="diff"><pre><code>              printf_filtered ("Address    ");</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>            }</code></pre></td>
        <td class="diff"><pre><code>            }</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>          annotate_field (5);</code></pre></td>
        <td class="diff"><pre><code>          annotate_field (5);</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>          printf_filtered ("What\n");</code></pre></td>
        <td class="diff"><pre><code>          printf_filtered ("What\n");</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>          annotate_breakpoints_table ();</code></pre></td>
        <td class="diff"><pre><code>          annotate_breakpoints_table ();</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>        }</code></pre></td>
        <td class="diff"><pre><code>        }</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>   Here's the new version:</code></pre></td>
        <td class="diff"><pre><code>   Here's the new version:</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>       nr_printable_breakpoints = ...;</code></pre></td>
        <td class="diff"><pre><code>       nr_printable_breakpoints = ...;</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>       if (addressprint)</code></pre></td>
        <td class="diff"><pre><code>       if (addressprint)</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>         ui_out_table_begin (ui, 6, nr_printable_breakpoints, "BreakpointTable");</code></pre></td>
        <td class="diff"><pre><code>         ui_out_table_begin (ui, 6, nr_printable_breakpoints, "BreakpointTable");</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>       else</code></pre></td>
        <td class="diff"><pre><code>       else</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>         ui_out_table_begin (ui, 5, nr_printable_breakpoints, "BreakpointTable");</code></pre></td>
        <td class="diff"><pre><code>         ui_out_table_begin (ui, 5, nr_printable_breakpoints, "BreakpointTable");</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>       if (nr_printable_breakpoints > 0)</code></pre></td>
        <td class="diff"><pre><code>       if (nr_printable_breakpoints > 0)</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>         annotate_breakpoints_headers ();</code></pre></td>
        <td class="diff"><pre><code>         annotate_breakpoints_headers ();</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>       if (nr_printable_breakpoints > 0)</code></pre></td>
        <td class="diff"><pre><code>       if (nr_printable_breakpoints > 0)</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>         annotate_field (0);</code></pre></td>
        <td class="diff"><pre><code>         annotate_field (0);</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>       ui_out_table_header (uiout, 3, ui_left, "number", "Num");                /* 1 */</code></pre></td>
        <td class="diff"><pre><code>       ui_out_table_header (uiout, 3, ui_left, "number", "Num");                /* 1 */</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>       if (nr_printable_breakpoints > 0)</code></pre></td>
        <td class="diff"><pre><code>       if (nr_printable_breakpoints > 0)</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>         annotate_field (1);</code></pre></td>
        <td class="diff"><pre><code>         annotate_field (1);</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>       ui_out_table_header (uiout, 14, ui_left, "type", "Type");                /* 2 */</code></pre></td>
        <td class="diff"><pre><code>       ui_out_table_header (uiout, 14, ui_left, "type", "Type");                /* 2 */</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>       if (nr_printable_breakpoints > 0)</code></pre></td>
        <td class="diff"><pre><code>       if (nr_printable_breakpoints > 0)</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>         annotate_field (2);</code></pre></td>
        <td class="diff"><pre><code>         annotate_field (2);</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>       ui_out_table_header (uiout, 4, ui_left, "disp", "Disp");         /* 3 */</code></pre></td>
        <td class="diff"><pre><code>       ui_out_table_header (uiout, 4, ui_left, "disp", "Disp");         /* 3 */</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>       if (nr_printable_breakpoints > 0)</code></pre></td>
        <td class="diff"><pre><code>       if (nr_printable_breakpoints > 0)</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>         annotate_field (3);</code></pre></td>
        <td class="diff"><pre><code>         annotate_field (3);</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>       ui_out_table_header (uiout, 3, ui_left, "enabled", "Enb");       /* 4 */</code></pre></td>
        <td class="diff"><pre><code>       ui_out_table_header (uiout, 3, ui_left, "enabled", "Enb");       /* 4 */</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>       if (addressprint)</code></pre></td>
        <td class="diff"><pre><code>       if (addressprint)</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>         {</code></pre></td>
        <td class="diff"><pre><code>         {</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>          if (nr_printable_breakpoints > 0)</code></pre></td>
        <td class="diff"><pre><code>          if (nr_printable_breakpoints > 0)</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>            annotate_field (4);</code></pre></td>
        <td class="diff"><pre><code>            annotate_field (4);</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>          if (gdbarch_addr_bit (current_gdbarch) <= 32)</code></pre></td>
        <td class="diff"><pre><code>          if (gdbarch_addr_bit (current_gdbarch) <= 32)</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>            ui_out_table_header (uiout, 10, ui_left, "addr", "Address");/* 5 */</code></pre></td>
        <td class="diff"><pre><code>            ui_out_table_header (uiout, 10, ui_left, "addr", "Address");/* 5 */</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>          else</code></pre></td>
        <td class="diff"><pre><code>          else</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>            ui_out_table_header (uiout, 18, ui_left, "addr", "Address");/* 5 */</code></pre></td>
        <td class="diff"><pre><code>            ui_out_table_header (uiout, 18, ui_left, "addr", "Address");/* 5 */</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>         }</code></pre></td>
        <td class="diff"><pre><code>         }</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>       if (nr_printable_breakpoints > 0)</code></pre></td>
        <td class="diff"><pre><code>       if (nr_printable_breakpoints > 0)</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>         annotate_field (5);</code></pre></td>
        <td class="diff"><pre><code>         annotate_field (5);</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>       ui_out_table_header (uiout, 40, ui_noalign, "what", "What");     /* 6 */</code></pre></td>
        <td class="diff"><pre><code>       ui_out_table_header (uiout, 40, ui_noalign, "what", "What");     /* 6 */</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>       ui_out_table_body (uiout);</code></pre></td>
        <td class="diff"><pre><code>       ui_out_table_body (uiout);</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>       if (nr_printable_breakpoints > 0)</code></pre></td>
        <td class="diff"><pre><code>       if (nr_printable_breakpoints > 0)</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>         annotate_breakpoints_table ();</code></pre></td>
        <td class="diff"><pre><code>         annotate_breakpoints_table ();</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>   This example, from the `print_one_breakpoint' function, shows how to</code></pre></td>
        <td class="diff"><pre><code>   This example, from the `print_one_breakpoint' function, shows how to</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>produce the actual data for the table whose structure was defined in</code></pre></td>
        <td class="diff"><pre><code>produce the actual data for the table whose structure was defined in</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>the above example.  The original code was:</code></pre></td>
        <td class="diff"><pre><code>the above example.  The original code was:</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>        annotate_record ();</code></pre></td>
        <td class="diff"><pre><code>        annotate_record ();</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>        annotate_field (0);</code></pre></td>
        <td class="diff"><pre><code>        annotate_field (0);</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>        printf_filtered ("%-3d ", b->number);</code></pre></td>
        <td class="diff"><pre><code>        printf_filtered ("%-3d ", b->number);</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>        annotate_field (1);</code></pre></td>
        <td class="diff"><pre><code>        annotate_field (1);</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>        if ((int)b->type > (sizeof(bptypes)/sizeof(bptypes[0]))</code></pre></td>
        <td class="diff"><pre><code>        if ((int)b->type > (sizeof(bptypes)/sizeof(bptypes[0]))</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>            || ((int) b->type != bptypes[(int) b->type].type))</code></pre></td>
        <td class="diff"><pre><code>            || ((int) b->type != bptypes[(int) b->type].type))</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>          internal_error ("bptypes table does not describe type #%d.",</code></pre></td>
        <td class="diff"><pre><code>          internal_error ("bptypes table does not describe type #%d.",</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>                          (int)b->type);</code></pre></td>
        <td class="diff"><pre><code>                          (int)b->type);</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>        printf_filtered ("%-14s ", bptypes[(int)b->type].description);</code></pre></td>
        <td class="diff"><pre><code>        printf_filtered ("%-14s ", bptypes[(int)b->type].description);</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>        annotate_field (2);</code></pre></td>
        <td class="diff"><pre><code>        annotate_field (2);</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>        printf_filtered ("%-4s ", bpdisps[(int)b->disposition]);</code></pre></td>
        <td class="diff"><pre><code>        printf_filtered ("%-4s ", bpdisps[(int)b->disposition]);</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>        annotate_field (3);</code></pre></td>
        <td class="diff"><pre><code>        annotate_field (3);</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>        printf_filtered ("%-3c ", bpenables[(int)b->enable]);</code></pre></td>
        <td class="diff"><pre><code>        printf_filtered ("%-3c ", bpenables[(int)b->enable]);</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>        ...</code></pre></td>
        <td class="diff"><pre><code>        ...</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>   This is the new version:</code></pre></td>
        <td class="diff"><pre><code>   This is the new version:</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>        annotate_record ();</code></pre></td>
        <td class="diff"><pre><code>        annotate_record ();</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>        ui_out_tuple_begin (uiout, "bkpt");</code></pre></td>
        <td class="diff"><pre><code>        ui_out_tuple_begin (uiout, "bkpt");</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>        annotate_field (0);</code></pre></td>
        <td class="diff"><pre><code>        annotate_field (0);</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>        ui_out_field_int (uiout, "number", b->number);</code></pre></td>
        <td class="diff"><pre><code>        ui_out_field_int (uiout, "number", b->number);</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>        annotate_field (1);</code></pre></td>
        <td class="diff"><pre><code>        annotate_field (1);</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>        if (((int) b->type > (sizeof (bptypes) / sizeof (bptypes[0])))</code></pre></td>
        <td class="diff"><pre><code>        if (((int) b->type > (sizeof (bptypes) / sizeof (bptypes[0])))</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>            || ((int) b->type != bptypes[(int) b->type].type))</code></pre></td>
        <td class="diff"><pre><code>            || ((int) b->type != bptypes[(int) b->type].type))</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>          internal_error ("bptypes table does not describe type #%d.",</code></pre></td>
        <td class="diff"><pre><code>          internal_error ("bptypes table does not describe type #%d.",</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>                          (int) b->type);</code></pre></td>
        <td class="diff"><pre><code>                          (int) b->type);</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>        ui_out_field_string (uiout, "type", bptypes[(int)b->type].description);</code></pre></td>
        <td class="diff"><pre><code>        ui_out_field_string (uiout, "type", bptypes[(int)b->type].description);</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>        annotate_field (2);</code></pre></td>
        <td class="diff"><pre><code>        annotate_field (2);</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>        ui_out_field_string (uiout, "disp", bpdisps[(int)b->disposition]);</code></pre></td>
        <td class="diff"><pre><code>        ui_out_field_string (uiout, "disp", bpdisps[(int)b->disposition]);</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>        annotate_field (3);</code></pre></td>
        <td class="diff"><pre><code>        annotate_field (3);</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>        ui_out_field_fmt (uiout, "enabled", "%c", bpenables[(int)b->enable]);</code></pre></td>
        <td class="diff"><pre><code>        ui_out_field_fmt (uiout, "enabled", "%c", bpenables[(int)b->enable]);</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>        ...</code></pre></td>
        <td class="diff"><pre><code>        ...</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>   This example, also from `print_one_breakpoint', shows how to produce</code></pre></td>
        <td class="diff"><pre><code>   This example, also from `print_one_breakpoint', shows how to produce</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>a complicated output field using the `print_expression' functions which</code></pre></td>
        <td class="diff"><pre><code>a complicated output field using the `print_expression' functions which</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>requires a stream to be passed.  It also shows how to automate stream</code></pre></td>
        <td class="diff"><pre><code>requires a stream to be passed.  It also shows how to automate stream</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>destruction with cleanups.  The original code was:</code></pre></td>
        <td class="diff"><pre><code>destruction with cleanups.  The original code was:</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>         annotate_field (5);</code></pre></td>
        <td class="diff"><pre><code>         annotate_field (5);</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>         print_expression (b->exp, gdb_stdout);</code></pre></td>
        <td class="diff"><pre><code>         print_expression (b->exp, gdb_stdout);</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>   The new version is:</code></pre></td>
        <td class="diff"><pre><code>   The new version is:</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>       struct ui_stream *stb = ui_out_stream_new (uiout);</code></pre></td>
        <td class="diff"><pre><code>       struct ui_stream *stb = ui_out_stream_new (uiout);</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>       struct cleanup *old_chain = make_cleanup_ui_out_stream_delete (stb);</code></pre></td>
        <td class="diff"><pre><code>       struct cleanup *old_chain = make_cleanup_ui_out_stream_delete (stb);</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>       ...</code></pre></td>
        <td class="diff"><pre><code>       ...</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>       annotate_field (5);</code></pre></td>
        <td class="diff"><pre><code>       annotate_field (5);</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>       print_expression (b->exp, stb->stream);</code></pre></td>
        <td class="diff"><pre><code>       print_expression (b->exp, stb->stream);</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>       ui_out_field_stream (uiout, "what", local_stream);</code></pre></td>
        <td class="diff"><pre><code>       ui_out_field_stream (uiout, "what", local_stream);</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>   This example, also from `print_one_breakpoint', shows how to use</code></pre></td>
        <td class="diff"><pre><code>   This example, also from `print_one_breakpoint', shows how to use</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>`ui_out_text' and `ui_out_field_string'.  The original code was:</code></pre></td>
        <td class="diff"><pre><code>`ui_out_text' and `ui_out_field_string'.  The original code was:</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>       annotate_field (5);</code></pre></td>
        <td class="diff"><pre><code>       annotate_field (5);</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>       if (b->dll_pathname == NULL)</code></pre></td>
        <td class="diff"><pre><code>       if (b->dll_pathname == NULL)</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>         printf_filtered ("<any library> ");</code></pre></td>
        <td class="diff"><pre><code>         printf_filtered ("<any library> ");</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>       else</code></pre></td>
        <td class="diff"><pre><code>       else</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>         printf_filtered ("library \"%s\" ", b->dll_pathname);</code></pre></td>
        <td class="diff"><pre><code>         printf_filtered ("library \"%s\" ", b->dll_pathname);</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>   It became:</code></pre></td>
        <td class="diff"><pre><code>   It became:</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>       annotate_field (5);</code></pre></td>
        <td class="diff"><pre><code>       annotate_field (5);</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>       if (b->dll_pathname == NULL)</code></pre></td>
        <td class="diff"><pre><code>       if (b->dll_pathname == NULL)</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>         {</code></pre></td>
        <td class="diff"><pre><code>         {</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>           ui_out_field_string (uiout, "what", "<any library>");</code></pre></td>
        <td class="diff"><pre><code>           ui_out_field_string (uiout, "what", "<any library>");</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>           ui_out_spaces (uiout, 1);</code></pre></td>
        <td class="diff"><pre><code>           ui_out_spaces (uiout, 1);</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>         }</code></pre></td>
        <td class="diff"><pre><code>         }</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>       else</code></pre></td>
        <td class="diff"><pre><code>       else</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>         {</code></pre></td>
        <td class="diff"><pre><code>         {</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>           ui_out_text (uiout, "library \"");</code></pre></td>
        <td class="diff"><pre><code>           ui_out_text (uiout, "library \"");</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>           ui_out_field_string (uiout, "what", b->dll_pathname);</code></pre></td>
        <td class="diff"><pre><code>           ui_out_field_string (uiout, "what", b->dll_pathname);</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>           ui_out_text (uiout, "\" ");</code></pre></td>
        <td class="diff"><pre><code>           ui_out_text (uiout, "\" ");</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>         }</code></pre></td>
        <td class="diff"><pre><code>         }</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>   The following example from `print_one_breakpoint' shows how to use</code></pre></td>
        <td class="diff"><pre><code>   The following example from `print_one_breakpoint' shows how to use</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>`ui_out_field_int' and `ui_out_spaces'.  The original code was:</code></pre></td>
        <td class="diff"><pre><code>`ui_out_field_int' and `ui_out_spaces'.  The original code was:</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>       annotate_field (5);</code></pre></td>
        <td class="diff"><pre><code>       annotate_field (5);</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>       if (b->forked_inferior_pid != 0)</code></pre></td>
        <td class="diff"><pre><code>       if (b->forked_inferior_pid != 0)</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>         printf_filtered ("process %d ", b->forked_inferior_pid);</code></pre></td>
        <td class="diff"><pre><code>         printf_filtered ("process %d ", b->forked_inferior_pid);</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>   It became:</code></pre></td>
        <td class="diff"><pre><code>   It became:</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>       annotate_field (5);</code></pre></td>
        <td class="diff"><pre><code>       annotate_field (5);</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>       if (b->forked_inferior_pid != 0)</code></pre></td>
        <td class="diff"><pre><code>       if (b->forked_inferior_pid != 0)</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>         {</code></pre></td>
        <td class="diff"><pre><code>         {</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>           ui_out_text (uiout, "process ");</code></pre></td>
        <td class="diff"><pre><code>           ui_out_text (uiout, "process ");</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>           ui_out_field_int (uiout, "what", b->forked_inferior_pid);</code></pre></td>
        <td class="diff"><pre><code>           ui_out_field_int (uiout, "what", b->forked_inferior_pid);</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>           ui_out_spaces (uiout, 1);</code></pre></td>
        <td class="diff"><pre><code>           ui_out_spaces (uiout, 1);</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>         }</code></pre></td>
        <td class="diff"><pre><code>         }</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>   Here's an example of using `ui_out_field_string'.  The original code</code></pre></td>
        <td class="diff"><pre><code>   Here's an example of using `ui_out_field_string'.  The original code</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>was:</code></pre></td>
        <td class="diff"><pre><code>was:</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>       annotate_field (5);</code></pre></td>
        <td class="diff"><pre><code>       annotate_field (5);</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>       if (b->exec_pathname != NULL)</code></pre></td>
        <td class="diff"><pre><code>       if (b->exec_pathname != NULL)</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>         printf_filtered ("program \"%s\" ", b->exec_pathname);</code></pre></td>
        <td class="diff"><pre><code>         printf_filtered ("program \"%s\" ", b->exec_pathname);</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>   It became:</code></pre></td>
        <td class="diff"><pre><code>   It became:</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>       annotate_field (5);</code></pre></td>
        <td class="diff"><pre><code>       annotate_field (5);</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>       if (b->exec_pathname != NULL)</code></pre></td>
        <td class="diff"><pre><code>       if (b->exec_pathname != NULL)</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>         {</code></pre></td>
        <td class="diff"><pre><code>         {</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>           ui_out_text (uiout, "program \"");</code></pre></td>
        <td class="diff"><pre><code>           ui_out_text (uiout, "program \"");</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>           ui_out_field_string (uiout, "what", b->exec_pathname);</code></pre></td>
        <td class="diff"><pre><code>           ui_out_field_string (uiout, "what", b->exec_pathname);</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>           ui_out_text (uiout, "\" ");</code></pre></td>
        <td class="diff"><pre><code>           ui_out_text (uiout, "\" ");</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>         }</code></pre></td>
        <td class="diff"><pre><code>         }</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>   Finally, here's an example of printing an address.  The original</code></pre></td>
        <td class="diff"><pre><code>   Finally, here's an example of printing an address.  The original</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>code:</code></pre></td>
        <td class="diff"><pre><code>code:</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>       annotate_field (4);</code></pre></td>
        <td class="diff"><pre><code>       annotate_field (4);</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>       printf_filtered ("%s ",</code></pre></td>
        <td class="diff"><pre><code>       printf_filtered ("%s ",</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>             hex_string_custom ((unsigned long) b->address, 8));</code></pre></td>
        <td class="diff"><pre><code>             hex_string_custom ((unsigned long) b->address, 8));</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>   It became:</code></pre></td>
        <td class="diff"><pre><code>   It became:</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>       annotate_field (4);</code></pre></td>
        <td class="diff"><pre><code>       annotate_field (4);</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>       ui_out_field_core_addr (uiout, "Address", b->address);</code></pre></td>
        <td class="diff"><pre><code>       ui_out_field_core_addr (uiout, "Address", b->address);</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>4.3 Console Printing</code></pre></td>
        <td class="diff"><pre><code>4.3 Console Printing</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>====================</code></pre></td>
        <td class="diff"><pre><code>====================</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>4.4 TUI</code></pre></td>
        <td class="diff"><pre><code>4.4 TUI</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>=======</code></pre></td>
        <td class="diff"><pre><code>=======</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>---------- Footnotes ----------</code></pre></td>
        <td class="diff"><pre><code>---------- Footnotes ----------</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>   (1) The function cast is not portable ISO C.</code></pre></td>
        <td class="diff"><pre><code>   (1) The function cast is not portable ISO C.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>   (2) As of this writing (April 2001), setting verbosity level is not</code></pre></td>
        <td class="diff"><pre><code>   (2) As of this writing (April 2001), setting verbosity level is not</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>yet implemented, and is always returned as zero.  So calling</code></pre></td>
        <td class="diff"><pre><code>yet implemented, and is always returned as zero.  So calling</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>`ui_out_message' with a VERBOSITY argument more than zero will cause</code></pre></td>
        <td class="diff"><pre><code>`ui_out_message' with a VERBOSITY argument more than zero will cause</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>the message to never be printed.</code></pre></td>
        <td class="diff"><pre><code>the message to never be printed.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>File: gdbint.info,  Node: libgdb,  Next: Symbol Handling,  Prev: User Interface,  Up: Top</code></pre></td>
        <td class="diff"><pre><code>File: gdbint.info,  Node: libgdb,  Next: Symbol Handling,  Prev: User Interface,  Up: Top</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>5 libgdb</code></pre></td>
        <td class="diff"><pre><code>5 libgdb</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>********</code></pre></td>
        <td class="diff"><pre><code>********</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>5.1 libgdb 1.0</code></pre></td>
        <td class="diff"><pre><code>5.1 libgdb 1.0</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>==============</code></pre></td>
        <td class="diff"><pre><code>==============</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>`libgdb' 1.0 was an abortive project of years ago.  The theory was to</code></pre></td>
        <td class="diff"><pre><code>`libgdb' 1.0 was an abortive project of years ago.  The theory was to</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>provide an API to GDB's functionality.</code></pre></td>
        <td class="diff"><pre><code>provide an API to GDB's functionality.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>5.2 libgdb 2.0</code></pre></td>
        <td class="diff"><pre><code>5.2 libgdb 2.0</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>==============</code></pre></td>
        <td class="diff"><pre><code>==============</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>`libgdb' 2.0 is an ongoing effort to update GDB so that is better able</code></pre></td>
        <td class="diff"><pre><code>`libgdb' 2.0 is an ongoing effort to update GDB so that is better able</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>to support graphical and other environments.</code></pre></td>
        <td class="diff"><pre><code>to support graphical and other environments.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>   Since `libgdb' development is on-going, its architecture is still</code></pre></td>
        <td class="diff"><pre><code>   Since `libgdb' development is on-going, its architecture is still</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>evolving.  The following components have so far been identified:</code></pre></td>
        <td class="diff"><pre><code>evolving.  The following components have so far been identified:</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>   * Observer - `gdb-events.h'.</code></pre></td>
        <td class="diff"><pre><code>   * Observer - `gdb-events.h'.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>   * Builder - `ui-out.h'</code></pre></td>
        <td class="diff"><pre><code>   * Builder - `ui-out.h'</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>   * Event Loop - `event-loop.h'</code></pre></td>
        <td class="diff"><pre><code>   * Event Loop - `event-loop.h'</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>   * Library - `gdb.h'</code></pre></td>
        <td class="diff"><pre><code>   * Library - `gdb.h'</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>   The model that ties these components together is described below.</code></pre></td>
        <td class="diff"><pre><code>   The model that ties these components together is described below.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>5.3 The `libgdb' Model</code></pre></td>
        <td class="diff"><pre><code>5.3 The `libgdb' Model</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>======================</code></pre></td>
        <td class="diff"><pre><code>======================</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>A client of `libgdb' interacts with the library in two ways.</code></pre></td>
        <td class="diff"><pre><code>A client of `libgdb' interacts with the library in two ways.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>   * As an observer (using `gdb-events') receiving notifications from</code></pre></td>
        <td class="diff"><pre><code>   * As an observer (using `gdb-events') receiving notifications from</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     `libgdb' of any internal state changes (break point changes, run</code></pre></td>
        <td class="diff"><pre><code>     `libgdb' of any internal state changes (break point changes, run</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     state, etc).</code></pre></td>
        <td class="diff"><pre><code>     state, etc).</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>   * As a client querying `libgdb' (using the `ui-out' builder) to</code></pre></td>
        <td class="diff"><pre><code>   * As a client querying `libgdb' (using the `ui-out' builder) to</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     obtain various status values from GDB.</code></pre></td>
        <td class="diff"><pre><code>     obtain various status values from GDB.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>   Since `libgdb' could have multiple clients (e.g., a GUI supporting</code></pre></td>
        <td class="diff"><pre><code>   Since `libgdb' could have multiple clients (e.g., a GUI supporting</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>the existing GDB CLI), those clients must co-operate when controlling</code></pre></td>
        <td class="diff"><pre><code>the existing GDB CLI), those clients must co-operate when controlling</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>`libgdb'.  In particular, a client must ensure that `libgdb' is idle</code></pre></td>
        <td class="diff"><pre><code>`libgdb'.  In particular, a client must ensure that `libgdb' is idle</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>(i.e. no other client is using `libgdb') before responding to a</code></pre></td>
        <td class="diff"><pre><code>(i.e. no other client is using `libgdb') before responding to a</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>`gdb-event' by making a query.</code></pre></td>
        <td class="diff"><pre><code>`gdb-event' by making a query.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>5.4 CLI support</code></pre></td>
        <td class="diff"><pre><code>5.4 CLI support</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>===============</code></pre></td>
        <td class="diff"><pre><code>===============</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>At present GDB's CLI is very much entangled in with the core of</code></pre></td>
        <td class="diff"><pre><code>At present GDB's CLI is very much entangled in with the core of</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>`libgdb'.  Consequently, a client wishing to include the CLI in their</code></pre></td>
        <td class="diff"><pre><code>`libgdb'.  Consequently, a client wishing to include the CLI in their</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>interface needs to carefully co-ordinate its own and the CLI's</code></pre></td>
        <td class="diff"><pre><code>interface needs to carefully co-ordinate its own and the CLI's</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>requirements.</code></pre></td>
        <td class="diff"><pre><code>requirements.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>   It is suggested that the client set `libgdb' up to be bi-modal</code></pre></td>
        <td class="diff"><pre><code>   It is suggested that the client set `libgdb' up to be bi-modal</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>(alternate between CLI and client query modes).  The notes below sketch</code></pre></td>
        <td class="diff"><pre><code>(alternate between CLI and client query modes).  The notes below sketch</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>out the theory:</code></pre></td>
        <td class="diff"><pre><code>out the theory:</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>   * The client registers itself as an observer of `libgdb'.</code></pre></td>
        <td class="diff"><pre><code>   * The client registers itself as an observer of `libgdb'.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>   * The client create and install `cli-out' builder using its own</code></pre></td>
        <td class="diff"><pre><code>   * The client create and install `cli-out' builder using its own</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     versions of the `ui-file' `gdb_stderr', `gdb_stdtarg' and</code></pre></td>
        <td class="diff"><pre><code>     versions of the `ui-file' `gdb_stderr', `gdb_stdtarg' and</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     `gdb_stdout' streams.</code></pre></td>
        <td class="diff"><pre><code>     `gdb_stdout' streams.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>   * The client creates a separate custom `ui-out' builder that is only</code></pre></td>
        <td class="diff"><pre><code>   * The client creates a separate custom `ui-out' builder that is only</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     used while making direct queries to `libgdb'.</code></pre></td>
        <td class="diff"><pre><code>     used while making direct queries to `libgdb'.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>   When the client receives input intended for the CLI, it simply</code></pre></td>
        <td class="diff"><pre><code>   When the client receives input intended for the CLI, it simply</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>passes it along.  Since the `cli-out' builder is installed by default,</code></pre></td>
        <td class="diff"><pre><code>passes it along.  Since the `cli-out' builder is installed by default,</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>all the CLI output in response to that command is routed (pronounced</code></pre></td>
        <td class="diff"><pre><code>all the CLI output in response to that command is routed (pronounced</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>rooted) through to the client controlled `gdb_stdout' et. al. streams.</code></pre></td>
        <td class="diff"><pre><code>rooted) through to the client controlled `gdb_stdout' et. al. streams.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>At the same time, the client is kept abreast of internal changes by</code></pre></td>
        <td class="diff"><pre><code>At the same time, the client is kept abreast of internal changes by</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>virtue of being a `libgdb' observer.</code></pre></td>
        <td class="diff"><pre><code>virtue of being a `libgdb' observer.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>   The only restriction on the client is that it must wait until</code></pre></td>
        <td class="diff"><pre><code>   The only restriction on the client is that it must wait until</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>`libgdb' becomes idle before initiating any queries (using the client's</code></pre></td>
        <td class="diff"><pre><code>`libgdb' becomes idle before initiating any queries (using the client's</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>custom builder).</code></pre></td>
        <td class="diff"><pre><code>custom builder).</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>5.5 `libgdb' components</code></pre></td>
        <td class="diff"><pre><code>5.5 `libgdb' components</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>=======================</code></pre></td>
        <td class="diff"><pre><code>=======================</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>Observer - `gdb-events.h'</code></pre></td>
        <td class="diff"><pre><code>Observer - `gdb-events.h'</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>-------------------------</code></pre></td>
        <td class="diff"><pre><code>-------------------------</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>`gdb-events' provides the client with a very raw mechanism that can be</code></pre></td>
        <td class="diff"><pre><code>`gdb-events' provides the client with a very raw mechanism that can be</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>used to implement an observer.  At present it only allows for one</code></pre></td>
        <td class="diff"><pre><code>used to implement an observer.  At present it only allows for one</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>observer and that observer must, internally, handle the need to delay</code></pre></td>
        <td class="diff"><pre><code>observer and that observer must, internally, handle the need to delay</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>the processing of any event notifications until after `libgdb' has</code></pre></td>
        <td class="diff"><pre><code>the processing of any event notifications until after `libgdb' has</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>finished the current command.</code></pre></td>
        <td class="diff"><pre><code>finished the current command.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>Builder - `ui-out.h'</code></pre></td>
        <td class="diff"><pre><code>Builder - `ui-out.h'</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>--------------------</code></pre></td>
        <td class="diff"><pre><code>--------------------</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>`ui-out' provides the infrastructure necessary for a client to create a</code></pre></td>
        <td class="diff"><pre><code>`ui-out' provides the infrastructure necessary for a client to create a</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>builder.  That builder is then passed down to `libgdb' when doing any</code></pre></td>
        <td class="diff"><pre><code>builder.  That builder is then passed down to `libgdb' when doing any</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>queries.</code></pre></td>
        <td class="diff"><pre><code>queries.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>Event Loop - `event-loop.h'</code></pre></td>
        <td class="diff"><pre><code>Event Loop - `event-loop.h'</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>---------------------------</code></pre></td>
        <td class="diff"><pre><code>---------------------------</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>`event-loop', currently non-re-entrant, provides a simple event loop.</code></pre></td>
        <td class="diff"><pre><code>`event-loop', currently non-re-entrant, provides a simple event loop.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>A client would need to either plug its self into this loop or,</code></pre></td>
        <td class="diff"><pre><code>A client would need to either plug its self into this loop or,</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>implement a new event-loop that GDB would use.</code></pre></td>
        <td class="diff"><pre><code>implement a new event-loop that GDB would use.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>   The event-loop will eventually be made re-entrant.  This is so that</code></pre></td>
        <td class="diff"><pre><code>   The event-loop will eventually be made re-entrant.  This is so that</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>GDB can better handle the problem of some commands blocking instead of</code></pre></td>
        <td class="diff"><pre><code>GDB can better handle the problem of some commands blocking instead of</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>returning.</code></pre></td>
        <td class="diff"><pre><code>returning.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>Library - `gdb.h'</code></pre></td>
        <td class="diff"><pre><code>Library - `gdb.h'</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>-----------------</code></pre></td>
        <td class="diff"><pre><code>-----------------</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>`libgdb' is the most obvious component of this system.  It provides the</code></pre></td>
        <td class="diff"><pre><code>`libgdb' is the most obvious component of this system.  It provides the</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>query interface.  Each function is parameterized by a `ui-out' builder.</code></pre></td>
        <td class="diff"><pre><code>query interface.  Each function is parameterized by a `ui-out' builder.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>The result of the query is constructed using that builder before the</code></pre></td>
        <td class="diff"><pre><code>The result of the query is constructed using that builder before the</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>query function returns.</code></pre></td>
        <td class="diff"><pre><code>query function returns.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>File: gdbint.info,  Node: Symbol Handling,  Next: Language Support,  Prev: libgdb,  Up: Top</code></pre></td>
        <td class="diff"><pre><code>File: gdbint.info,  Node: Symbol Handling,  Next: Language Support,  Prev: libgdb,  Up: Top</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>6 Symbol Handling</code></pre></td>
        <td class="diff"><pre><code>6 Symbol Handling</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>*****************</code></pre></td>
        <td class="diff"><pre><code>*****************</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>Symbols are a key part of GDB's operation.  Symbols include variables,</code></pre></td>
        <td class="diff"><pre><code>Symbols are a key part of GDB's operation.  Symbols include variables,</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>functions, and types.</code></pre></td>
        <td class="diff"><pre><code>functions, and types.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>6.1 Symbol Reading</code></pre></td>
        <td class="diff"><pre><code>6.1 Symbol Reading</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>==================</code></pre></td>
        <td class="diff"><pre><code>==================</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>GDB reads symbols from "symbol files".  The usual symbol file is the</code></pre></td>
        <td class="diff"><pre><code>GDB reads symbols from "symbol files".  The usual symbol file is the</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>file containing the program which GDB is debugging.  GDB can be</code></pre></td>
        <td class="diff"><pre><code>file containing the program which GDB is debugging.  GDB can be</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>directed to use a different file for symbols (with the `symbol-file'</code></pre></td>
        <td class="diff"><pre><code>directed to use a different file for symbols (with the `symbol-file'</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>command), and it can also read more symbols via the `add-file' and</code></pre></td>
        <td class="diff"><pre><code>command), and it can also read more symbols via the `add-file' and</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>`load' commands, or while reading symbols from shared libraries.</code></pre></td>
        <td class="diff"><pre><code>`load' commands, or while reading symbols from shared libraries.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>   Symbol files are initially opened by code in `symfile.c' using the</code></pre></td>
        <td class="diff"><pre><code>   Symbol files are initially opened by code in `symfile.c' using the</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>BFD library (*note Support Libraries::).  BFD identifies the type of</code></pre></td>
        <td class="diff"><pre><code>BFD library (*note Support Libraries::).  BFD identifies the type of</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>the file by examining its header.  `find_sym_fns' then uses this</code></pre></td>
        <td class="diff"><pre><code>the file by examining its header.  `find_sym_fns' then uses this</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>identification to locate a set of symbol-reading functions.</code></pre></td>
        <td class="diff"><pre><code>identification to locate a set of symbol-reading functions.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>   Symbol-reading modules identify themselves to GDB by calling</code></pre></td>
        <td class="diff"><pre><code>   Symbol-reading modules identify themselves to GDB by calling</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>`add_symtab_fns' during their module initialization.  The argument to</code></pre></td>
        <td class="diff"><pre><code>`add_symtab_fns' during their module initialization.  The argument to</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>`add_symtab_fns' is a `struct sym_fns' which contains the name (or name</code></pre></td>
        <td class="diff"><pre><code>`add_symtab_fns' is a `struct sym_fns' which contains the name (or name</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>prefix) of the symbol format, the length of the prefix, and pointers to</code></pre></td>
        <td class="diff"><pre><code>prefix) of the symbol format, the length of the prefix, and pointers to</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>four functions.  These functions are called at various times to process</code></pre></td>
        <td class="diff"><pre><code>four functions.  These functions are called at various times to process</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>symbol files whose identification matches the specified prefix.</code></pre></td>
        <td class="diff"><pre><code>symbol files whose identification matches the specified prefix.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>   The functions supplied by each module are:</code></pre></td>
        <td class="diff"><pre><code>   The functions supplied by each module are:</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>`XYZ_symfile_init(struct sym_fns *sf)'</code></pre></td>
        <td class="diff"><pre><code>`XYZ_symfile_init(struct sym_fns *sf)'</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     Called from `symbol_file_add' when we are about to read a new</code></pre></td>
        <td class="diff"><pre><code>     Called from `symbol_file_add' when we are about to read a new</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     symbol file.  This function should clean up any internal state</code></pre></td>
        <td class="diff"><pre><code>     symbol file.  This function should clean up any internal state</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     (possibly resulting from half-read previous files, for example)</code></pre></td>
        <td class="diff"><pre><code>     (possibly resulting from half-read previous files, for example)</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     and prepare to read a new symbol file.  Note that the symbol file</code></pre></td>
        <td class="diff"><pre><code>     and prepare to read a new symbol file.  Note that the symbol file</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     which we are reading might be a new "main" symbol file, or might</code></pre></td>
        <td class="diff"><pre><code>     which we are reading might be a new "main" symbol file, or might</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     be a secondary symbol file whose symbols are being added to the</code></pre></td>
        <td class="diff"><pre><code>     be a secondary symbol file whose symbols are being added to the</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     existing symbol table.</code></pre></td>
        <td class="diff"><pre><code>     existing symbol table.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     The argument to `XYZ_symfile_init' is a newly allocated `struct</code></pre></td>
        <td class="diff"><pre><code>     The argument to `XYZ_symfile_init' is a newly allocated `struct</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     sym_fns' whose `bfd' field contains the BFD for the new symbol</code></pre></td>
        <td class="diff"><pre><code>     sym_fns' whose `bfd' field contains the BFD for the new symbol</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     file being read.  Its `private' field has been zeroed, and can be</code></pre></td>
        <td class="diff"><pre><code>     file being read.  Its `private' field has been zeroed, and can be</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     modified as desired.  Typically, a struct of private information</code></pre></td>
        <td class="diff"><pre><code>     modified as desired.  Typically, a struct of private information</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     will be `malloc''d, and a pointer to it will be placed in the</code></pre></td>
        <td class="diff"><pre><code>     will be `malloc''d, and a pointer to it will be placed in the</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     `private' field.</code></pre></td>
        <td class="diff"><pre><code>     `private' field.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     There is no result from `XYZ_symfile_init', but it can call</code></pre></td>
        <td class="diff"><pre><code>     There is no result from `XYZ_symfile_init', but it can call</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     `error' if it detects an unavoidable problem.</code></pre></td>
        <td class="diff"><pre><code>     `error' if it detects an unavoidable problem.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>`XYZ_new_init()'</code></pre></td>
        <td class="diff"><pre><code>`XYZ_new_init()'</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     Called from `symbol_file_add' when discarding existing symbols.</code></pre></td>
        <td class="diff"><pre><code>     Called from `symbol_file_add' when discarding existing symbols.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     This function needs only handle the symbol-reading module's</code></pre></td>
        <td class="diff"><pre><code>     This function needs only handle the symbol-reading module's</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     internal state; the symbol table data structures visible to the</code></pre></td>
        <td class="diff"><pre><code>     internal state; the symbol table data structures visible to the</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     rest of GDB will be discarded by `symbol_file_add'.  It has no</code></pre></td>
        <td class="diff"><pre><code>     rest of GDB will be discarded by `symbol_file_add'.  It has no</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     arguments and no result.  It may be called after</code></pre></td>
        <td class="diff"><pre><code>     arguments and no result.  It may be called after</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     `XYZ_symfile_init', if a new symbol table is being read, or may be</code></pre></td>
        <td class="diff"><pre><code>     `XYZ_symfile_init', if a new symbol table is being read, or may be</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     called alone if all symbols are simply being discarded.</code></pre></td>
        <td class="diff"><pre><code>     called alone if all symbols are simply being discarded.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>`XYZ_symfile_read(struct sym_fns *sf, CORE_ADDR addr, int mainline)'</code></pre></td>
        <td class="diff"><pre><code>`XYZ_symfile_read(struct sym_fns *sf, CORE_ADDR addr, int mainline)'</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     Called from `symbol_file_add' to actually read the symbols from a</code></pre></td>
        <td class="diff"><pre><code>     Called from `symbol_file_add' to actually read the symbols from a</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     symbol-file into a set of psymtabs or symtabs.</code></pre></td>
        <td class="diff"><pre><code>     symbol-file into a set of psymtabs or symtabs.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     `sf' points to the `struct sym_fns' originally passed to</code></pre></td>
        <td class="diff"><pre><code>     `sf' points to the `struct sym_fns' originally passed to</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     `XYZ_sym_init' for possible initialization.  `addr' is the offset</code></pre></td>
        <td class="diff"><pre><code>     `XYZ_sym_init' for possible initialization.  `addr' is the offset</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     between the file's specified start address and its true address in</code></pre></td>
        <td class="diff"><pre><code>     between the file's specified start address and its true address in</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     memory.  `mainline' is 1 if this is the main symbol table being</code></pre></td>
        <td class="diff"><pre><code>     memory.  `mainline' is 1 if this is the main symbol table being</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     read, and 0 if a secondary symbol file (e.g., shared library or</code></pre></td>
        <td class="diff"><pre><code>     read, and 0 if a secondary symbol file (e.g., shared library or</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     dynamically loaded file) is being read.</code></pre></td>
        <td class="diff"><pre><code>     dynamically loaded file) is being read.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>   In addition, if a symbol-reading module creates psymtabs when</code></pre></td>
        <td class="diff"><pre><code>   In addition, if a symbol-reading module creates psymtabs when</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>XYZ_symfile_read is called, these psymtabs will contain a pointer to a</code></pre></td>
        <td class="diff"><pre><code>XYZ_symfile_read is called, these psymtabs will contain a pointer to a</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>function `XYZ_psymtab_to_symtab', which can be called from any point in</code></pre></td>
        <td class="diff"><pre><code>function `XYZ_psymtab_to_symtab', which can be called from any point in</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>the GDB symbol-handling code.</code></pre></td>
        <td class="diff"><pre><code>the GDB symbol-handling code.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>`XYZ_psymtab_to_symtab (struct partial_symtab *pst)'</code></pre></td>
        <td class="diff"><pre><code>`XYZ_psymtab_to_symtab (struct partial_symtab *pst)'</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     Called from `psymtab_to_symtab' (or the `PSYMTAB_TO_SYMTAB' macro)</code></pre></td>
        <td class="diff"><pre><code>     Called from `psymtab_to_symtab' (or the `PSYMTAB_TO_SYMTAB' macro)</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     if the psymtab has not already been read in and had its</code></pre></td>
        <td class="diff"><pre><code>     if the psymtab has not already been read in and had its</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     `pst->symtab' pointer set.  The argument is the psymtab to be</code></pre></td>
        <td class="diff"><pre><code>     `pst->symtab' pointer set.  The argument is the psymtab to be</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     fleshed-out into a symtab.  Upon return, `pst->readin' should have</code></pre></td>
        <td class="diff"><pre><code>     fleshed-out into a symtab.  Upon return, `pst->readin' should have</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     been set to 1, and `pst->symtab' should contain a pointer to the</code></pre></td>
        <td class="diff"><pre><code>     been set to 1, and `pst->symtab' should contain a pointer to the</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     new corresponding symtab, or zero if there were no symbols in that</code></pre></td>
        <td class="diff"><pre><code>     new corresponding symtab, or zero if there were no symbols in that</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     part of the symbol file.</code></pre></td>
        <td class="diff"><pre><code>     part of the symbol file.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>6.2 Partial Symbol Tables</code></pre></td>
        <td class="diff"><pre><code>6.2 Partial Symbol Tables</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>=========================</code></pre></td>
        <td class="diff"><pre><code>=========================</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>GDB has three types of symbol tables:</code></pre></td>
        <td class="diff"><pre><code>GDB has three types of symbol tables:</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>   * Full symbol tables ("symtabs").  These contain the main</code></pre></td>
        <td class="diff"><pre><code>   * Full symbol tables ("symtabs").  These contain the main</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     information about symbols and addresses.</code></pre></td>
        <td class="diff"><pre><code>     information about symbols and addresses.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>   * Partial symbol tables ("psymtabs").  These contain enough</code></pre></td>
        <td class="diff"><pre><code>   * Partial symbol tables ("psymtabs").  These contain enough</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     information to know when to read the corresponding part of the full</code></pre></td>
        <td class="diff"><pre><code>     information to know when to read the corresponding part of the full</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     symbol table.</code></pre></td>
        <td class="diff"><pre><code>     symbol table.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>   * Minimal symbol tables ("msymtabs").  These contain information</code></pre></td>
        <td class="diff"><pre><code>   * Minimal symbol tables ("msymtabs").  These contain information</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     gleaned from non-debugging symbols.</code></pre></td>
        <td class="diff"><pre><code>     gleaned from non-debugging symbols.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>   This section describes partial symbol tables.</code></pre></td>
        <td class="diff"><pre><code>   This section describes partial symbol tables.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>   A psymtab is constructed by doing a very quick pass over an</code></pre></td>
        <td class="diff"><pre><code>   A psymtab is constructed by doing a very quick pass over an</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>executable file's debugging information.  Small amounts of information</code></pre></td>
        <td class="diff"><pre><code>executable file's debugging information.  Small amounts of information</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>are extracted--enough to identify which parts of the symbol table will</code></pre></td>
        <td class="diff"><pre><code>are extracted--enough to identify which parts of the symbol table will</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>need to be re-read and fully digested later, when the user needs the</code></pre></td>
        <td class="diff"><pre><code>need to be re-read and fully digested later, when the user needs the</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>information.  The speed of this pass causes GDB to start up very</code></pre></td>
        <td class="diff"><pre><code>information.  The speed of this pass causes GDB to start up very</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>quickly.  Later, as the detailed rereading occurs, it occurs in small</code></pre></td>
        <td class="diff"><pre><code>quickly.  Later, as the detailed rereading occurs, it occurs in small</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>pieces, at various times, and the delay therefrom is mostly invisible to</code></pre></td>
        <td class="diff"><pre><code>pieces, at various times, and the delay therefrom is mostly invisible to</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>the user.</code></pre></td>
        <td class="diff"><pre><code>the user.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>   The symbols that show up in a file's psymtab should be, roughly,</code></pre></td>
        <td class="diff"><pre><code>   The symbols that show up in a file's psymtab should be, roughly,</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>those visible to the debugger's user when the program is not running</code></pre></td>
        <td class="diff"><pre><code>those visible to the debugger's user when the program is not running</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>code from that file.  These include external symbols and types, static</code></pre></td>
        <td class="diff"><pre><code>code from that file.  These include external symbols and types, static</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>symbols and types, and `enum' values declared at file scope.</code></pre></td>
        <td class="diff"><pre><code>symbols and types, and `enum' values declared at file scope.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>   The psymtab also contains the range of instruction addresses that the</code></pre></td>
        <td class="diff"><pre><code>   The psymtab also contains the range of instruction addresses that the</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>full symbol table would represent.</code></pre></td>
        <td class="diff"><pre><code>full symbol table would represent.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>   The idea is that there are only two ways for the user (or much of the</code></pre></td>
        <td class="diff"><pre><code>   The idea is that there are only two ways for the user (or much of the</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>code in the debugger) to reference a symbol:</code></pre></td>
        <td class="diff"><pre><code>code in the debugger) to reference a symbol:</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>   * By its address (e.g., execution stops at some address which is</code></pre></td>
        <td class="diff"><pre><code>   * By its address (e.g., execution stops at some address which is</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     inside a function in this file).  The address will be noticed to</code></pre></td>
        <td class="diff"><pre><code>     inside a function in this file).  The address will be noticed to</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     be in the range of this psymtab, and the full symtab will be read</code></pre></td>
        <td class="diff"><pre><code>     be in the range of this psymtab, and the full symtab will be read</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     in.  `find_pc_function', `find_pc_line', and other `find_pc_...'</code></pre></td>
        <td class="diff"><pre><code>     in.  `find_pc_function', `find_pc_line', and other `find_pc_...'</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     functions handle this.</code></pre></td>
        <td class="diff"><pre><code>     functions handle this.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>   * By its name (e.g., the user asks to print a variable, or set a</code></pre></td>
        <td class="diff"><pre><code>   * By its name (e.g., the user asks to print a variable, or set a</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     breakpoint on a function).  Global names and file-scope names will</code></pre></td>
        <td class="diff"><pre><code>     breakpoint on a function).  Global names and file-scope names will</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     be found in the psymtab, which will cause the symtab to be pulled</code></pre></td>
        <td class="diff"><pre><code>     be found in the psymtab, which will cause the symtab to be pulled</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     in.  Local names will have to be qualified by a global name, or a</code></pre></td>
        <td class="diff"><pre><code>     in.  Local names will have to be qualified by a global name, or a</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     file-scope name, in which case we will have already read in the</code></pre></td>
        <td class="diff"><pre><code>     file-scope name, in which case we will have already read in the</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     symtab as we evaluated the qualifier.  Or, a local symbol can be</code></pre></td>
        <td class="diff"><pre><code>     symtab as we evaluated the qualifier.  Or, a local symbol can be</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     referenced when we are "in" a local scope, in which case the first</code></pre></td>
        <td class="diff"><pre><code>     referenced when we are "in" a local scope, in which case the first</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     case applies.  `lookup_symbol' does most of the work here.</code></pre></td>
        <td class="diff"><pre><code>     case applies.  `lookup_symbol' does most of the work here.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>   The only reason that psymtabs exist is to cause a symtab to be read</code></pre></td>
        <td class="diff"><pre><code>   The only reason that psymtabs exist is to cause a symtab to be read</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>in at the right moment.  Any symbol that can be elided from a psymtab,</code></pre></td>
        <td class="diff"><pre><code>in at the right moment.  Any symbol that can be elided from a psymtab,</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>while still causing that to happen, should not appear in it.  Since</code></pre></td>
        <td class="diff"><pre><code>while still causing that to happen, should not appear in it.  Since</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>psymtabs don't have the idea of scope, you can't put local symbols in</code></pre></td>
        <td class="diff"><pre><code>psymtabs don't have the idea of scope, you can't put local symbols in</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>them anyway.  Psymtabs don't have the idea of the type of a symbol,</code></pre></td>
        <td class="diff"><pre><code>them anyway.  Psymtabs don't have the idea of the type of a symbol,</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>either, so types need not appear, unless they will be referenced by</code></pre></td>
        <td class="diff"><pre><code>either, so types need not appear, unless they will be referenced by</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>name.</code></pre></td>
        <td class="diff"><pre><code>name.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>   It is a bug for GDB to behave one way when only a psymtab has been</code></pre></td>
        <td class="diff"><pre><code>   It is a bug for GDB to behave one way when only a psymtab has been</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>read, and another way if the corresponding symtab has been read in.</code></pre></td>
        <td class="diff"><pre><code>read, and another way if the corresponding symtab has been read in.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>Such bugs are typically caused by a psymtab that does not contain all</code></pre></td>
        <td class="diff"><pre><code>Such bugs are typically caused by a psymtab that does not contain all</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>the visible symbols, or which has the wrong instruction address ranges.</code></pre></td>
        <td class="diff"><pre><code>the visible symbols, or which has the wrong instruction address ranges.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>   The psymtab for a particular section of a symbol file (objfile)</code></pre></td>
        <td class="diff"><pre><code>   The psymtab for a particular section of a symbol file (objfile)</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>could be thrown away after the symtab has been read in.  The symtab</code></pre></td>
        <td class="diff"><pre><code>could be thrown away after the symtab has been read in.  The symtab</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>should always be searched before the psymtab, so the psymtab will never</code></pre></td>
        <td class="diff"><pre><code>should always be searched before the psymtab, so the psymtab will never</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>be used (in a bug-free environment).  Currently, psymtabs are allocated</code></pre></td>
        <td class="diff"><pre><code>be used (in a bug-free environment).  Currently, psymtabs are allocated</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>on an obstack, and all the psymbols themselves are allocated in a pair</code></pre></td>
        <td class="diff"><pre><code>on an obstack, and all the psymbols themselves are allocated in a pair</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>of large arrays on an obstack, so there is little to be gained by</code></pre></td>
        <td class="diff"><pre><code>of large arrays on an obstack, so there is little to be gained by</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>trying to free them unless you want to do a lot more work.</code></pre></td>
        <td class="diff"><pre><code>trying to free them unless you want to do a lot more work.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>6.3 Types</code></pre></td>
        <td class="diff"><pre><code>6.3 Types</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>=========</code></pre></td>
        <td class="diff"><pre><code>=========</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>Fundamental Types (e.g., `FT_VOID', `FT_BOOLEAN').</code></pre></td>
        <td class="diff"><pre><code>Fundamental Types (e.g., `FT_VOID', `FT_BOOLEAN').</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>--------------------------------------------------</code></pre></td>
        <td class="diff"><pre><code>--------------------------------------------------</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>These are the fundamental types that GDB uses internally.  Fundamental</code></pre></td>
        <td class="diff"><pre><code>These are the fundamental types that GDB uses internally.  Fundamental</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>types from the various debugging formats (stabs, ELF, etc) are mapped</code></pre></td>
        <td class="diff"><pre><code>types from the various debugging formats (stabs, ELF, etc) are mapped</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>into one of these.  They are basically a union of all fundamental types</code></pre></td>
        <td class="diff"><pre><code>into one of these.  They are basically a union of all fundamental types</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>that GDB knows about for all the languages that GDB knows about.</code></pre></td>
        <td class="diff"><pre><code>that GDB knows about for all the languages that GDB knows about.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>Type Codes (e.g., `TYPE_CODE_PTR', `TYPE_CODE_ARRAY').</code></pre></td>
        <td class="diff"><pre><code>Type Codes (e.g., `TYPE_CODE_PTR', `TYPE_CODE_ARRAY').</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>------------------------------------------------------</code></pre></td>
        <td class="diff"><pre><code>------------------------------------------------------</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>Each time GDB builds an internal type, it marks it with one of these</code></pre></td>
        <td class="diff"><pre><code>Each time GDB builds an internal type, it marks it with one of these</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>types.  The type may be a fundamental type, such as `TYPE_CODE_INT', or</code></pre></td>
        <td class="diff"><pre><code>types.  The type may be a fundamental type, such as `TYPE_CODE_INT', or</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>a derived type, such as `TYPE_CODE_PTR' which is a pointer to another</code></pre></td>
        <td class="diff"><pre><code>a derived type, such as `TYPE_CODE_PTR' which is a pointer to another</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>type.  Typically, several `FT_*' types map to one `TYPE_CODE_*' type,</code></pre></td>
        <td class="diff"><pre><code>type.  Typically, several `FT_*' types map to one `TYPE_CODE_*' type,</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>and are distinguished by other members of the type struct, such as</code></pre></td>
        <td class="diff"><pre><code>and are distinguished by other members of the type struct, such as</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>whether the type is signed or unsigned, and how many bits it uses.</code></pre></td>
        <td class="diff"><pre><code>whether the type is signed or unsigned, and how many bits it uses.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>Builtin Types (e.g., `builtin_type_void', `builtin_type_char').</code></pre></td>
        <td class="diff"><pre><code>Builtin Types (e.g., `builtin_type_void', `builtin_type_char').</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>---------------------------------------------------------------</code></pre></td>
        <td class="diff"><pre><code>---------------------------------------------------------------</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>These are instances of type structs that roughly correspond to</code></pre></td>
        <td class="diff"><pre><code>These are instances of type structs that roughly correspond to</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>fundamental types and are created as global types for GDB to use for</code></pre></td>
        <td class="diff"><pre><code>fundamental types and are created as global types for GDB to use for</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>various ugly historical reasons.  We eventually want to eliminate</code></pre></td>
        <td class="diff"><pre><code>various ugly historical reasons.  We eventually want to eliminate</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>these.  Note for example that `builtin_type_int' initialized in</code></pre></td>
        <td class="diff"><pre><code>these.  Note for example that `builtin_type_int' initialized in</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>`gdbtypes.c' is basically the same as a `TYPE_CODE_INT' type that is</code></pre></td>
        <td class="diff"><pre><code>`gdbtypes.c' is basically the same as a `TYPE_CODE_INT' type that is</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>initialized in `c-lang.c' for an `FT_INTEGER' fundamental type.  The</code></pre></td>
        <td class="diff"><pre><code>initialized in `c-lang.c' for an `FT_INTEGER' fundamental type.  The</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>difference is that the `builtin_type' is not associated with any</code></pre></td>
        <td class="diff"><pre><code>difference is that the `builtin_type' is not associated with any</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>particular objfile, and only one instance exists, while `c-lang.c'</code></pre></td>
        <td class="diff"><pre><code>particular objfile, and only one instance exists, while `c-lang.c'</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>builds as many `TYPE_CODE_INT' types as needed, with each one</code></pre></td>
        <td class="diff"><pre><code>builds as many `TYPE_CODE_INT' types as needed, with each one</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>associated with some particular objfile.</code></pre></td>
        <td class="diff"><pre><code>associated with some particular objfile.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>6.4 Object File Formats</code></pre></td>
        <td class="diff"><pre><code>6.4 Object File Formats</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>=======================</code></pre></td>
        <td class="diff"><pre><code>=======================</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>6.4.1 a.out</code></pre></td>
        <td class="diff"><pre><code>6.4.1 a.out</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>-----------</code></pre></td>
        <td class="diff"><pre><code>-----------</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>The `a.out' format is the original file format for Unix.  It consists</code></pre></td>
        <td class="diff"><pre><code>The `a.out' format is the original file format for Unix.  It consists</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>of three sections: `text', `data', and `bss', which are for program</code></pre></td>
        <td class="diff"><pre><code>of three sections: `text', `data', and `bss', which are for program</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>code, initialized data, and uninitialized data, respectively.</code></pre></td>
        <td class="diff"><pre><code>code, initialized data, and uninitialized data, respectively.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>   The `a.out' format is so simple that it doesn't have any reserved</code></pre></td>
        <td class="diff"><pre><code>   The `a.out' format is so simple that it doesn't have any reserved</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>place for debugging information.  (Hey, the original Unix hackers used</code></pre></td>
        <td class="diff"><pre><code>place for debugging information.  (Hey, the original Unix hackers used</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>`adb', which is a machine-language debugger!)  The only debugging</code></pre></td>
        <td class="diff"><pre><code>`adb', which is a machine-language debugger!)  The only debugging</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>format for `a.out' is stabs, which is encoded as a set of normal</code></pre></td>
        <td class="diff"><pre><code>format for `a.out' is stabs, which is encoded as a set of normal</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>symbols with distinctive attributes.</code></pre></td>
        <td class="diff"><pre><code>symbols with distinctive attributes.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>   The basic `a.out' reader is in `dbxread.c'.</code></pre></td>
        <td class="diff"><pre><code>   The basic `a.out' reader is in `dbxread.c'.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>6.4.2 COFF</code></pre></td>
        <td class="diff"><pre><code>6.4.2 COFF</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>----------</code></pre></td>
        <td class="diff"><pre><code>----------</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>The COFF format was introduced with System V Release 3 (SVR3) Unix.</code></pre></td>
        <td class="diff"><pre><code>The COFF format was introduced with System V Release 3 (SVR3) Unix.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>COFF files may have multiple sections, each prefixed by a header.  The</code></pre></td>
        <td class="diff"><pre><code>COFF files may have multiple sections, each prefixed by a header.  The</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>number of sections is limited.</code></pre></td>
        <td class="diff"><pre><code>number of sections is limited.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>   The COFF specification includes support for debugging.  Although this</code></pre></td>
        <td class="diff"><pre><code>   The COFF specification includes support for debugging.  Although this</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>was a step forward, the debugging information was woefully limited.  For</code></pre></td>
        <td class="diff"><pre><code>was a step forward, the debugging information was woefully limited.  For</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>instance, it was not possible to represent code that came from an</code></pre></td>
        <td class="diff"><pre><code>instance, it was not possible to represent code that came from an</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>included file.</code></pre></td>
        <td class="diff"><pre><code>included file.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>   The COFF reader is in `coffread.c'.</code></pre></td>
        <td class="diff"><pre><code>   The COFF reader is in `coffread.c'.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>6.4.3 ECOFF</code></pre></td>
        <td class="diff"><pre><code>6.4.3 ECOFF</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>-----------</code></pre></td>
        <td class="diff"><pre><code>-----------</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>ECOFF is an extended COFF originally introduced for Mips and Alpha</code></pre></td>
        <td class="diff"><pre><code>ECOFF is an extended COFF originally introduced for Mips and Alpha</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>workstations.</code></pre></td>
        <td class="diff"><pre><code>workstations.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>   The basic ECOFF reader is in `mipsread.c'.</code></pre></td>
        <td class="diff"><pre><code>   The basic ECOFF reader is in `mipsread.c'.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>6.4.4 XCOFF</code></pre></td>
        <td class="diff"><pre><code>6.4.4 XCOFF</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>-----------</code></pre></td>
        <td class="diff"><pre><code>-----------</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>The IBM RS/6000 running AIX uses an object file format called XCOFF.</code></pre></td>
        <td class="diff"><pre><code>The IBM RS/6000 running AIX uses an object file format called XCOFF.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>The COFF sections, symbols, and line numbers are used, but debugging</code></pre></td>
        <td class="diff"><pre><code>The COFF sections, symbols, and line numbers are used, but debugging</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>symbols are `dbx'-style stabs whose strings are located in the `.debug'</code></pre></td>
        <td class="diff"><pre><code>symbols are `dbx'-style stabs whose strings are located in the `.debug'</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>section (rather than the string table).  For more information, see</code></pre></td>
        <td class="diff"><pre><code>section (rather than the string table).  For more information, see</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>*Note Top: (stabs)Top.</code></pre></td>
        <td class="diff"><pre><code>*Note Top: (stabs)Top.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>   The shared library scheme has a clean interface for figuring out what</code></pre></td>
        <td class="diff"><pre><code>   The shared library scheme has a clean interface for figuring out what</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>shared libraries are in use, but the catch is that everything which</code></pre></td>
        <td class="diff"><pre><code>shared libraries are in use, but the catch is that everything which</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>refers to addresses (symbol tables and breakpoints at least) needs to be</code></pre></td>
        <td class="diff"><pre><code>refers to addresses (symbol tables and breakpoints at least) needs to be</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>relocated for both shared libraries and the main executable.  At least</code></pre></td>
        <td class="diff"><pre><code>relocated for both shared libraries and the main executable.  At least</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>using the standard mechanism this can only be done once the program has</code></pre></td>
        <td class="diff"><pre><code>using the standard mechanism this can only be done once the program has</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>been run (or the core file has been read).</code></pre></td>
        <td class="diff"><pre><code>been run (or the core file has been read).</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>6.4.5 PE</code></pre></td>
        <td class="diff"><pre><code>6.4.5 PE</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>--------</code></pre></td>
        <td class="diff"><pre><code>--------</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>Windows 95 and NT use the PE ("Portable Executable") format for their</code></pre></td>
        <td class="diff"><pre><code>Windows 95 and NT use the PE ("Portable Executable") format for their</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>executables.  PE is basically COFF with additional headers.</code></pre></td>
        <td class="diff"><pre><code>executables.  PE is basically COFF with additional headers.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>   While BFD includes special PE support, GDB needs only the basic COFF</code></pre></td>
        <td class="diff"><pre><code>   While BFD includes special PE support, GDB needs only the basic COFF</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>reader.</code></pre></td>
        <td class="diff"><pre><code>reader.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>6.4.6 ELF</code></pre></td>
        <td class="diff"><pre><code>6.4.6 ELF</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>---------</code></pre></td>
        <td class="diff"><pre><code>---------</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>The ELF format came with System V Release 4 (SVR4) Unix.  ELF is similar</code></pre></td>
        <td class="diff"><pre><code>The ELF format came with System V Release 4 (SVR4) Unix.  ELF is similar</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>to COFF in being organized into a number of sections, but it removes</code></pre></td>
        <td class="diff"><pre><code>to COFF in being organized into a number of sections, but it removes</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>many of COFF's limitations.</code></pre></td>
        <td class="diff"><pre><code>many of COFF's limitations.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>   The basic ELF reader is in `elfread.c'.</code></pre></td>
        <td class="diff"><pre><code>   The basic ELF reader is in `elfread.c'.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>6.4.7 SOM</code></pre></td>
        <td class="diff"><pre><code>6.4.7 SOM</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>---------</code></pre></td>
        <td class="diff"><pre><code>---------</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>SOM is HP's object file and debug format (not to be confused with IBM's</code></pre></td>
        <td class="diff"><pre><code>SOM is HP's object file and debug format (not to be confused with IBM's</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>SOM, which is a cross-language ABI).</code></pre></td>
        <td class="diff"><pre><code>SOM, which is a cross-language ABI).</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>   The SOM reader is in `somread.c'.</code></pre></td>
        <td class="diff"><pre><code>   The SOM reader is in `somread.c'.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>6.5 Debugging File Formats</code></pre></td>
        <td class="diff"><pre><code>6.5 Debugging File Formats</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>==========================</code></pre></td>
        <td class="diff"><pre><code>==========================</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>This section describes characteristics of debugging information that</code></pre></td>
        <td class="diff"><pre><code>This section describes characteristics of debugging information that</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>are independent of the object file format.</code></pre></td>
        <td class="diff"><pre><code>are independent of the object file format.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>6.5.1 stabs</code></pre></td>
        <td class="diff"><pre><code>6.5.1 stabs</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>-----------</code></pre></td>
        <td class="diff"><pre><code>-----------</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>`stabs' started out as special symbols within the `a.out' format.</code></pre></td>
        <td class="diff"><pre><code>`stabs' started out as special symbols within the `a.out' format.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>Since then, it has been encapsulated into other file formats, such as</code></pre></td>
        <td class="diff"><pre><code>Since then, it has been encapsulated into other file formats, such as</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>COFF and ELF.</code></pre></td>
        <td class="diff"><pre><code>COFF and ELF.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>   While `dbxread.c' does some of the basic stab processing, including</code></pre></td>
        <td class="diff"><pre><code>   While `dbxread.c' does some of the basic stab processing, including</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>for encapsulated versions, `stabsread.c' does the real work.</code></pre></td>
        <td class="diff"><pre><code>for encapsulated versions, `stabsread.c' does the real work.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>6.5.2 COFF</code></pre></td>
        <td class="diff"><pre><code>6.5.2 COFF</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>----------</code></pre></td>
        <td class="diff"><pre><code>----------</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>The basic COFF definition includes debugging information.  The level of</code></pre></td>
        <td class="diff"><pre><code>The basic COFF definition includes debugging information.  The level of</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>support is minimal and non-extensible, and is not often used.</code></pre></td>
        <td class="diff"><pre><code>support is minimal and non-extensible, and is not often used.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>6.5.3 Mips debug (Third Eye)</code></pre></td>
        <td class="diff"><pre><code>6.5.3 Mips debug (Third Eye)</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>----------------------------</code></pre></td>
        <td class="diff"><pre><code>----------------------------</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>ECOFF includes a definition of a special debug format.</code></pre></td>
        <td class="diff"><pre><code>ECOFF includes a definition of a special debug format.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>   The file `mdebugread.c' implements reading for this format.</code></pre></td>
        <td class="diff"><pre><code>   The file `mdebugread.c' implements reading for this format.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>6.5.4 DWARF 2</code></pre></td>
        <td class="diff"><pre><code>6.5.4 DWARF 2</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>-------------</code></pre></td>
        <td class="diff"><pre><code>-------------</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>DWARF 2 is an improved but incompatible version of DWARF 1.</code></pre></td>
        <td class="diff"><pre><code>DWARF 2 is an improved but incompatible version of DWARF 1.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>   The DWARF 2 reader is in `dwarf2read.c'.</code></pre></td>
        <td class="diff"><pre><code>   The DWARF 2 reader is in `dwarf2read.c'.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>6.5.5 SOM</code></pre></td>
        <td class="diff"><pre><code>6.5.5 SOM</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>---------</code></pre></td>
        <td class="diff"><pre><code>---------</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>Like COFF, the SOM definition includes debugging information.</code></pre></td>
        <td class="diff"><pre><code>Like COFF, the SOM definition includes debugging information.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>6.6 Adding a New Symbol Reader to GDB</code></pre></td>
        <td class="diff"><pre><code>6.6 Adding a New Symbol Reader to GDB</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>=====================================</code></pre></td>
        <td class="diff"><pre><code>=====================================</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>If you are using an existing object file format (`a.out', COFF, ELF,</code></pre></td>
        <td class="diff"><pre><code>If you are using an existing object file format (`a.out', COFF, ELF,</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>etc), there is probably little to be done.</code></pre></td>
        <td class="diff"><pre><code>etc), there is probably little to be done.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>   If you need to add a new object file format, you must first add it to</code></pre></td>
        <td class="diff"><pre><code>   If you need to add a new object file format, you must first add it to</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>BFD.  This is beyond the scope of this document.</code></pre></td>
        <td class="diff"><pre><code>BFD.  This is beyond the scope of this document.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>   You must then arrange for the BFD code to provide access to the</code></pre></td>
        <td class="diff"><pre><code>   You must then arrange for the BFD code to provide access to the</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>debugging symbols.  Generally GDB will have to call swapping routines</code></pre></td>
        <td class="diff"><pre><code>debugging symbols.  Generally GDB will have to call swapping routines</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>from BFD and a few other BFD internal routines to locate the debugging</code></pre></td>
        <td class="diff"><pre><code>from BFD and a few other BFD internal routines to locate the debugging</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>information.  As much as possible, GDB should not depend on the BFD</code></pre></td>
        <td class="diff"><pre><code>information.  As much as possible, GDB should not depend on the BFD</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>internal data structures.</code></pre></td>
        <td class="diff"><pre><code>internal data structures.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>   For some targets (e.g., COFF), there is a special transfer vector</code></pre></td>
        <td class="diff"><pre><code>   For some targets (e.g., COFF), there is a special transfer vector</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>used to call swapping routines, since the external data structures on</code></pre></td>
        <td class="diff"><pre><code>used to call swapping routines, since the external data structures on</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>various platforms have different sizes and layouts.  Specialized</code></pre></td>
        <td class="diff"><pre><code>various platforms have different sizes and layouts.  Specialized</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>routines that will only ever be implemented by one object file format</code></pre></td>
        <td class="diff"><pre><code>routines that will only ever be implemented by one object file format</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>may be called directly.  This interface should be described in a file</code></pre></td>
        <td class="diff"><pre><code>may be called directly.  This interface should be described in a file</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>`bfd/libXYZ.h', which is included by GDB.</code></pre></td>
        <td class="diff"><pre><code>`bfd/libXYZ.h', which is included by GDB.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>6.7 Memory Management for Symbol Files</code></pre></td>
        <td class="diff"><pre><code>6.7 Memory Management for Symbol Files</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>======================================</code></pre></td>
        <td class="diff"><pre><code>======================================</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>Most memory associated with a loaded symbol file is stored on its</code></pre></td>
        <td class="diff"><pre><code>Most memory associated with a loaded symbol file is stored on its</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>`objfile_obstack'.  This includes symbols, types, namespace data, and</code></pre></td>
        <td class="diff"><pre><code>`objfile_obstack'.  This includes symbols, types, namespace data, and</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>other information produced by the symbol readers.</code></pre></td>
        <td class="diff"><pre><code>other information produced by the symbol readers.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>   Because this data lives on the objfile's obstack, it is automatically</code></pre></td>
        <td class="diff"><pre><code>   Because this data lives on the objfile's obstack, it is automatically</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>released when the objfile is unloaded or reloaded.  Therefore one</code></pre></td>
        <td class="diff"><pre><code>released when the objfile is unloaded or reloaded.  Therefore one</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>objfile must not reference symbol or type data from another objfile;</code></pre></td>
        <td class="diff"><pre><code>objfile must not reference symbol or type data from another objfile;</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>they could be unloaded at different times.</code></pre></td>
        <td class="diff"><pre><code>they could be unloaded at different times.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>   User convenience variables, et cetera, have associated types.</code></pre></td>
        <td class="diff"><pre><code>   User convenience variables, et cetera, have associated types.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>Normally these types live in the associated objfile.  However, when the</code></pre></td>
        <td class="diff"><pre><code>Normally these types live in the associated objfile.  However, when the</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>objfile is unloaded, those types are deep copied to global memory, so</code></pre></td>
        <td class="diff"><pre><code>objfile is unloaded, those types are deep copied to global memory, so</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>that the values of the user variables and history items are not lost.</code></pre></td>
        <td class="diff"><pre><code>that the values of the user variables and history items are not lost.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>File: gdbint.info,  Node: Language Support,  Next: Host Definition,  Prev: Symbol Handling,  Up: Top</code></pre></td>
        <td class="diff"><pre><code>File: gdbint.info,  Node: Language Support,  Next: Host Definition,  Prev: Symbol Handling,  Up: Top</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>7 Language Support</code></pre></td>
        <td class="diff"><pre><code>7 Language Support</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>******************</code></pre></td>
        <td class="diff"><pre><code>******************</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>GDB's language support is mainly driven by the symbol reader, although</code></pre></td>
        <td class="diff"><pre><code>GDB's language support is mainly driven by the symbol reader, although</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>it is possible for the user to set the source language manually.</code></pre></td>
        <td class="diff"><pre><code>it is possible for the user to set the source language manually.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>   GDB chooses the source language by looking at the extension of the</code></pre></td>
        <td class="diff"><pre><code>   GDB chooses the source language by looking at the extension of the</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>file recorded in the debug info; `.c' means C, `.f' means Fortran, etc.</code></pre></td>
        <td class="diff"><pre><code>file recorded in the debug info; `.c' means C, `.f' means Fortran, etc.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>It may also use a special-purpose language identifier if the debug</code></pre></td>
        <td class="diff"><pre><code>It may also use a special-purpose language identifier if the debug</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>format supports it, like with DWARF.</code></pre></td>
        <td class="diff"><pre><code>format supports it, like with DWARF.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>7.1 Adding a Source Language to GDB</code></pre></td>
        <td class="diff"><pre><code>7.1 Adding a Source Language to GDB</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>===================================</code></pre></td>
        <td class="diff"><pre><code>===================================</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>To add other languages to GDB's expression parser, follow the following</code></pre></td>
        <td class="diff"><pre><code>To add other languages to GDB's expression parser, follow the following</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>steps:</code></pre></td>
        <td class="diff"><pre><code>steps:</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>_Create the expression parser._</code></pre></td>
        <td class="diff"><pre><code>_Create the expression parser._</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     This should reside in a file `LANG-exp.y'.  Routines for building</code></pre></td>
        <td class="diff"><pre><code>     This should reside in a file `LANG-exp.y'.  Routines for building</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     parsed expressions into a `union exp_element' list are in</code></pre></td>
        <td class="diff"><pre><code>     parsed expressions into a `union exp_element' list are in</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     `parse.c'.</code></pre></td>
        <td class="diff"><pre><code>     `parse.c'.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     Since we can't depend upon everyone having Bison, and YACC produces</code></pre></td>
        <td class="diff"><pre><code>     Since we can't depend upon everyone having Bison, and YACC produces</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     parsers that define a bunch of global names, the following lines</code></pre></td>
        <td class="diff"><pre><code>     parsers that define a bunch of global names, the following lines</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     *must* be included at the top of the YACC parser, to prevent the</code></pre></td>
        <td class="diff"><pre><code>     *must* be included at the top of the YACC parser, to prevent the</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     various parsers from defining the same global names:</code></pre></td>
        <td class="diff"><pre><code>     various parsers from defining the same global names:</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>          #define yyparse         LANG_parse</code></pre></td>
        <td class="diff"><pre><code>          #define yyparse         LANG_parse</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>          #define yylex           LANG_lex</code></pre></td>
        <td class="diff"><pre><code>          #define yylex           LANG_lex</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>          #define yyerror         LANG_error</code></pre></td>
        <td class="diff"><pre><code>          #define yyerror         LANG_error</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>          #define yylval          LANG_lval</code></pre></td>
        <td class="diff"><pre><code>          #define yylval          LANG_lval</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>          #define yychar          LANG_char</code></pre></td>
        <td class="diff"><pre><code>          #define yychar          LANG_char</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>          #define yydebug         LANG_debug</code></pre></td>
        <td class="diff"><pre><code>          #define yydebug         LANG_debug</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>          #define yypact          LANG_pact</code></pre></td>
        <td class="diff"><pre><code>          #define yypact          LANG_pact</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>          #define yyr1            LANG_r1</code></pre></td>
        <td class="diff"><pre><code>          #define yyr1            LANG_r1</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>          #define yyr2            LANG_r2</code></pre></td>
        <td class="diff"><pre><code>          #define yyr2            LANG_r2</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>          #define yydef           LANG_def</code></pre></td>
        <td class="diff"><pre><code>          #define yydef           LANG_def</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>          #define yychk           LANG_chk</code></pre></td>
        <td class="diff"><pre><code>          #define yychk           LANG_chk</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>          #define yypgo           LANG_pgo</code></pre></td>
        <td class="diff"><pre><code>          #define yypgo           LANG_pgo</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>          #define yyact           LANG_act</code></pre></td>
        <td class="diff"><pre><code>          #define yyact           LANG_act</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>          #define yyexca          LANG_exca</code></pre></td>
        <td class="diff"><pre><code>          #define yyexca          LANG_exca</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>          #define yyerrflag       LANG_errflag</code></pre></td>
        <td class="diff"><pre><code>          #define yyerrflag       LANG_errflag</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>          #define yynerrs         LANG_nerrs</code></pre></td>
        <td class="diff"><pre><code>          #define yynerrs         LANG_nerrs</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     At the bottom of your parser, define a `struct language_defn' and</code></pre></td>
        <td class="diff"><pre><code>     At the bottom of your parser, define a `struct language_defn' and</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     initialize it with the right values for your language.  Define an</code></pre></td>
        <td class="diff"><pre><code>     initialize it with the right values for your language.  Define an</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     `initialize_LANG' routine and have it call</code></pre></td>
        <td class="diff"><pre><code>     `initialize_LANG' routine and have it call</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     `add_language(LANG_language_defn)' to tell the rest of GDB that</code></pre></td>
        <td class="diff"><pre><code>     `add_language(LANG_language_defn)' to tell the rest of GDB that</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     your language exists.  You'll need some other supporting variables</code></pre></td>
        <td class="diff"><pre><code>     your language exists.  You'll need some other supporting variables</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     and functions, which will be used via pointers from your</code></pre></td>
        <td class="diff"><pre><code>     and functions, which will be used via pointers from your</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     `LANG_language_defn'.  See the declaration of `struct</code></pre></td>
        <td class="diff"><pre><code>     `LANG_language_defn'.  See the declaration of `struct</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     language_defn' in `language.h', and the other `*-exp.y' files, for</code></pre></td>
        <td class="diff"><pre><code>     language_defn' in `language.h', and the other `*-exp.y' files, for</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     more information.</code></pre></td>
        <td class="diff"><pre><code>     more information.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>_Add any evaluation routines, if necessary_</code></pre></td>
        <td class="diff"><pre><code>_Add any evaluation routines, if necessary_</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     If you need new opcodes (that represent the operations of the</code></pre></td>
        <td class="diff"><pre><code>     If you need new opcodes (that represent the operations of the</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     language), add them to the enumerated type in `expression.h'.  Add</code></pre></td>
        <td class="diff"><pre><code>     language), add them to the enumerated type in `expression.h'.  Add</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     support code for these operations in the `evaluate_subexp' function</code></pre></td>
        <td class="diff"><pre><code>     support code for these operations in the `evaluate_subexp' function</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     defined in the file `eval.c'.  Add cases for new opcodes in two</code></pre></td>
        <td class="diff"><pre><code>     defined in the file `eval.c'.  Add cases for new opcodes in two</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     functions from `parse.c': `prefixify_subexp' and</code></pre></td>
        <td class="diff"><pre><code>     functions from `parse.c': `prefixify_subexp' and</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     `length_of_subexp'.  These compute the number of `exp_element's</code></pre></td>
        <td class="diff"><pre><code>     `length_of_subexp'.  These compute the number of `exp_element's</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     that a given operation takes up.</code></pre></td>
        <td class="diff"><pre><code>     that a given operation takes up.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>_Update some existing code_</code></pre></td>
        <td class="diff"><pre><code>_Update some existing code_</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     Add an enumerated identifier for your language to the enumerated</code></pre></td>
        <td class="diff"><pre><code>     Add an enumerated identifier for your language to the enumerated</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     type `enum language' in `defs.h'.</code></pre></td>
        <td class="diff"><pre><code>     type `enum language' in `defs.h'.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     Update the routines in `language.c' so your language is included.</code></pre></td>
        <td class="diff"><pre><code>     Update the routines in `language.c' so your language is included.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     These routines include type predicates and such, which (in some</code></pre></td>
        <td class="diff"><pre><code>     These routines include type predicates and such, which (in some</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     cases) are language dependent.  If your language does not appear</code></pre></td>
        <td class="diff"><pre><code>     cases) are language dependent.  If your language does not appear</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     in the switch statement, an error is reported.</code></pre></td>
        <td class="diff"><pre><code>     in the switch statement, an error is reported.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     Also included in `language.c' is the code that updates the variable</code></pre></td>
        <td class="diff"><pre><code>     Also included in `language.c' is the code that updates the variable</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     `current_language', and the routines that translate the</code></pre></td>
        <td class="diff"><pre><code>     `current_language', and the routines that translate the</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     `language_LANG' enumerated identifier into a printable string.</code></pre></td>
        <td class="diff"><pre><code>     `language_LANG' enumerated identifier into a printable string.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     Update the function `_initialize_language' to include your</code></pre></td>
        <td class="diff"><pre><code>     Update the function `_initialize_language' to include your</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     language.  This function picks the default language upon startup,</code></pre></td>
        <td class="diff"><pre><code>     language.  This function picks the default language upon startup,</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     so is dependent upon which languages that GDB is built for.</code></pre></td>
        <td class="diff"><pre><code>     so is dependent upon which languages that GDB is built for.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     Update `allocate_symtab' in `symfile.c' and/or symbol-reading code</code></pre></td>
        <td class="diff"><pre><code>     Update `allocate_symtab' in `symfile.c' and/or symbol-reading code</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     so that the language of each symtab (source file) is set properly.</code></pre></td>
        <td class="diff"><pre><code>     so that the language of each symtab (source file) is set properly.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     This is used to determine the language to use at each stack frame</code></pre></td>
        <td class="diff"><pre><code>     This is used to determine the language to use at each stack frame</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     level.  Currently, the language is set based upon the extension of</code></pre></td>
        <td class="diff"><pre><code>     level.  Currently, the language is set based upon the extension of</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     the source file.  If the language can be better inferred from the</code></pre></td>
        <td class="diff"><pre><code>     the source file.  If the language can be better inferred from the</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     symbol information, please set the language of the symtab in the</code></pre></td>
        <td class="diff"><pre><code>     symbol information, please set the language of the symtab in the</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     symbol-reading code.</code></pre></td>
        <td class="diff"><pre><code>     symbol-reading code.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     Add helper code to `print_subexp' (in `expprint.c') to handle any</code></pre></td>
        <td class="diff"><pre><code>     Add helper code to `print_subexp' (in `expprint.c') to handle any</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     new expression opcodes you have added to `expression.h'.  Also,</code></pre></td>
        <td class="diff"><pre><code>     new expression opcodes you have added to `expression.h'.  Also,</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     add the printed representations of your operators to</code></pre></td>
        <td class="diff"><pre><code>     add the printed representations of your operators to</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     `op_print_tab'.</code></pre></td>
        <td class="diff"><pre><code>     `op_print_tab'.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>_Add a place of call_</code></pre></td>
        <td class="diff"><pre><code>_Add a place of call_</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     Add a call to `LANG_parse()' and `LANG_error' in `parse_exp_1'</code></pre></td>
        <td class="diff"><pre><code>     Add a call to `LANG_parse()' and `LANG_error' in `parse_exp_1'</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     (defined in `parse.c').</code></pre></td>
        <td class="diff"><pre><code>     (defined in `parse.c').</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>_Use macros to trim code_</code></pre></td>
        <td class="diff"><pre><code>_Use macros to trim code_</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     The user has the option of building GDB for some or all of the</code></pre></td>
        <td class="diff"><pre><code>     The user has the option of building GDB for some or all of the</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     languages.  If the user decides to build GDB for the language</code></pre></td>
        <td class="diff"><pre><code>     languages.  If the user decides to build GDB for the language</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     LANG, then every file dependent on `language.h' will have the</code></pre></td>
        <td class="diff"><pre><code>     LANG, then every file dependent on `language.h' will have the</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     macro `_LANG_LANG' defined in it.  Use `#ifdef's to leave out</code></pre></td>
        <td class="diff"><pre><code>     macro `_LANG_LANG' defined in it.  Use `#ifdef's to leave out</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     large routines that the user won't need if he or she is not using</code></pre></td>
        <td class="diff"><pre><code>     large routines that the user won't need if he or she is not using</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     your language.</code></pre></td>
        <td class="diff"><pre><code>     your language.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     Note that you do not need to do this in your YACC parser, since if</code></pre></td>
        <td class="diff"><pre><code>     Note that you do not need to do this in your YACC parser, since if</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     GDB is not build for LANG, then `LANG-exp.tab.o' (the compiled</code></pre></td>
        <td class="diff"><pre><code>     GDB is not build for LANG, then `LANG-exp.tab.o' (the compiled</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     form of your parser) is not linked into GDB at all.</code></pre></td>
        <td class="diff"><pre><code>     form of your parser) is not linked into GDB at all.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     See the file `configure.in' for how GDB is configured for</code></pre></td>
        <td class="diff"><pre><code>     See the file `configure.in' for how GDB is configured for</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     different languages.</code></pre></td>
        <td class="diff"><pre><code>     different languages.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>_Edit `Makefile.in'_</code></pre></td>
        <td class="diff"><pre><code>_Edit `Makefile.in'_</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     Add dependencies in `Makefile.in'.  Make sure you update the macro</code></pre></td>
        <td class="diff"><pre><code>     Add dependencies in `Makefile.in'.  Make sure you update the macro</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     variables such as `HFILES' and `OBJS', otherwise your code may not</code></pre></td>
        <td class="diff"><pre><code>     variables such as `HFILES' and `OBJS', otherwise your code may not</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     get linked in, or, worse yet, it may not get `tar'red into the</code></pre></td>
        <td class="diff"><pre><code>     get linked in, or, worse yet, it may not get `tar'red into the</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     distribution!</code></pre></td>
        <td class="diff"><pre><code>     distribution!</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>File: gdbint.info,  Node: Host Definition,  Next: Target Architecture Definition,  Prev: Language Support,  Up: Top</code></pre></td>
        <td class="diff"><pre><code>File: gdbint.info,  Node: Host Definition,  Next: Target Architecture Definition,  Prev: Language Support,  Up: Top</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>8 Host Definition</code></pre></td>
        <td class="diff"><pre><code>8 Host Definition</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>*****************</code></pre></td>
        <td class="diff"><pre><code>*****************</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>With the advent of Autoconf, it's rarely necessary to have host</code></pre></td>
        <td class="diff"><pre><code>With the advent of Autoconf, it's rarely necessary to have host</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>definition machinery anymore.  The following information is provided,</code></pre></td>
        <td class="diff"><pre><code>definition machinery anymore.  The following information is provided,</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>mainly, as an historical reference.</code></pre></td>
        <td class="diff"><pre><code>mainly, as an historical reference.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>8.1 Adding a New Host</code></pre></td>
        <td class="diff"><pre><code>8.1 Adding a New Host</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>=====================</code></pre></td>
        <td class="diff"><pre><code>=====================</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>GDB's host configuration support normally happens via Autoconf.  New</code></pre></td>
        <td class="diff"><pre><code>GDB's host configuration support normally happens via Autoconf.  New</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>host-specific definitions should not be needed.  Older hosts GDB still</code></pre></td>
        <td class="diff"><pre><code>host-specific definitions should not be needed.  Older hosts GDB still</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>use the host-specific definitions and files listed below, but these</code></pre></td>
        <td class="diff"><pre><code>use the host-specific definitions and files listed below, but these</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>mostly exist for historical reasons, and will eventually disappear.</code></pre></td>
        <td class="diff"><pre><code>mostly exist for historical reasons, and will eventually disappear.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>`gdb/config/ARCH/XYZ.mh'</code></pre></td>
        <td class="diff"><pre><code>`gdb/config/ARCH/XYZ.mh'</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     This file once contained both host and native configuration</code></pre></td>
        <td class="diff"><pre><code>     This file once contained both host and native configuration</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     information (*note Native Debugging::) for the machine XYZ.  The</code></pre></td>
        <td class="diff"><pre><code>     information (*note Native Debugging::) for the machine XYZ.  The</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     host configuration information is now handed by Autoconf.</code></pre></td>
        <td class="diff"><pre><code>     host configuration information is now handed by Autoconf.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     Host configuration information included a definition of</code></pre></td>
        <td class="diff"><pre><code>     Host configuration information included a definition of</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     `XM_FILE=xm-XYZ.h' and possibly definitions for `CC',</code></pre></td>
        <td class="diff"><pre><code>     `XM_FILE=xm-XYZ.h' and possibly definitions for `CC',</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     `SYSV_DEFINE', `XM_CFLAGS', `XM_ADD_FILES', `XM_CLIBS',</code></pre></td>
        <td class="diff"><pre><code>     `SYSV_DEFINE', `XM_CFLAGS', `XM_ADD_FILES', `XM_CLIBS',</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     `XM_CDEPS', etc.; see `Makefile.in'.</code></pre></td>
        <td class="diff"><pre><code>     `XM_CDEPS', etc.; see `Makefile.in'.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     New host only configurations do not need this file.</code></pre></td>
        <td class="diff"><pre><code>     New host only configurations do not need this file.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>`gdb/config/ARCH/xm-XYZ.h'</code></pre></td>
        <td class="diff"><pre><code>`gdb/config/ARCH/xm-XYZ.h'</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     This file once contained definitions and includes required when</code></pre></td>
        <td class="diff"><pre><code>     This file once contained definitions and includes required when</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     hosting gdb on machine XYZ.  Those definitions and includes are now</code></pre></td>
        <td class="diff"><pre><code>     hosting gdb on machine XYZ.  Those definitions and includes are now</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     handled by Autoconf.</code></pre></td>
        <td class="diff"><pre><code>     handled by Autoconf.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     New host and native configurations do not need this file.</code></pre></td>
        <td class="diff"><pre><code>     New host and native configurations do not need this file.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     _Maintainer's note: Some hosts continue to use the `xm-xyz.h' file</code></pre></td>
        <td class="diff"><pre><code>     _Maintainer's note: Some hosts continue to use the `xm-xyz.h' file</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     to define the macros HOST_FLOAT_FORMAT, HOST_DOUBLE_FORMAT and</code></pre></td>
        <td class="diff"><pre><code>     to define the macros HOST_FLOAT_FORMAT, HOST_DOUBLE_FORMAT and</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     HOST_LONG_DOUBLE_FORMAT.  That code also needs to be replaced with</code></pre></td>
        <td class="diff"><pre><code>     HOST_LONG_DOUBLE_FORMAT.  That code also needs to be replaced with</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     either an Autoconf or run-time test._</code></pre></td>
        <td class="diff"><pre><code>     either an Autoconf or run-time test._</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>Generic Host Support Files</code></pre></td>
        <td class="diff"><pre><code>Generic Host Support Files</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>--------------------------</code></pre></td>
        <td class="diff"><pre><code>--------------------------</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>There are some "generic" versions of routines that can be used by</code></pre></td>
        <td class="diff"><pre><code>There are some "generic" versions of routines that can be used by</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>various systems.  These can be customized in various ways by macros</code></pre></td>
        <td class="diff"><pre><code>various systems.  These can be customized in various ways by macros</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>defined in your `xm-XYZ.h' file.  If these routines work for the XYZ</code></pre></td>
        <td class="diff"><pre><code>defined in your `xm-XYZ.h' file.  If these routines work for the XYZ</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>host, you can just include the generic file's name (with `.o', not</code></pre></td>
        <td class="diff"><pre><code>host, you can just include the generic file's name (with `.o', not</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>`.c') in `XDEPFILES'.</code></pre></td>
        <td class="diff"><pre><code>`.c') in `XDEPFILES'.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>   Otherwise, if your machine needs custom support routines, you will</code></pre></td>
        <td class="diff"><pre><code>   Otherwise, if your machine needs custom support routines, you will</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>need to write routines that perform the same functions as the generic</code></pre></td>
        <td class="diff"><pre><code>need to write routines that perform the same functions as the generic</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>file.  Put them into `XYZ-xdep.c', and put `XYZ-xdep.o' into</code></pre></td>
        <td class="diff"><pre><code>file.  Put them into `XYZ-xdep.c', and put `XYZ-xdep.o' into</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>`XDEPFILES'.</code></pre></td>
        <td class="diff"><pre><code>`XDEPFILES'.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>`ser-unix.c'</code></pre></td>
        <td class="diff"><pre><code>`ser-unix.c'</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     This contains serial line support for Unix systems.  This is always</code></pre></td>
        <td class="diff"><pre><code>     This contains serial line support for Unix systems.  This is always</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     included, via the makefile variable `SER_HARDWIRE'; override this</code></pre></td>
        <td class="diff"><pre><code>     included, via the makefile variable `SER_HARDWIRE'; override this</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     variable in the `.mh' file to avoid it.</code></pre></td>
        <td class="diff"><pre><code>     variable in the `.mh' file to avoid it.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>`ser-go32.c'</code></pre></td>
        <td class="diff"><pre><code>`ser-go32.c'</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     This contains serial line support for 32-bit programs running</code></pre></td>
        <td class="diff"><pre><code>     This contains serial line support for 32-bit programs running</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     under DOS, using the DJGPP (a.k.a. GO32) execution environment.</code></pre></td>
        <td class="diff"><pre><code>     under DOS, using the DJGPP (a.k.a. GO32) execution environment.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>`ser-tcp.c'</code></pre></td>
        <td class="diff"><pre><code>`ser-tcp.c'</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     This contains generic TCP support using sockets.</code></pre></td>
        <td class="diff"><pre><code>     This contains generic TCP support using sockets.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>8.2 Host Conditionals</code></pre></td>
        <td class="diff"><pre><code>8.2 Host Conditionals</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>=====================</code></pre></td>
        <td class="diff"><pre><code>=====================</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>When GDB is configured and compiled, various macros are defined or left</code></pre></td>
        <td class="diff"><pre><code>When GDB is configured and compiled, various macros are defined or left</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>undefined, to control compilation based on the attributes of the host</code></pre></td>
        <td class="diff"><pre><code>undefined, to control compilation based on the attributes of the host</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>system.  These macros and their meanings (or if the meaning is not</code></pre></td>
        <td class="diff"><pre><code>system.  These macros and their meanings (or if the meaning is not</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>documented here, then one of the source files where they are used is</code></pre></td>
        <td class="diff"><pre><code>documented here, then one of the source files where they are used is</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>indicated) are:</code></pre></td>
        <td class="diff"><pre><code>indicated) are:</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>`GDBINIT_FILENAME'</code></pre></td>
        <td class="diff"><pre><code>`GDBINIT_FILENAME'</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     The default name of GDB's initialization file (normally</code></pre></td>
        <td class="diff"><pre><code>     The default name of GDB's initialization file (normally</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     `.gdbinit').</code></pre></td>
        <td class="diff"><pre><code>     `.gdbinit').</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>`NO_STD_REGS'</code></pre></td>
        <td class="diff"><pre><code>`NO_STD_REGS'</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     This macro is deprecated.</code></pre></td>
        <td class="diff"><pre><code>     This macro is deprecated.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>`SIGWINCH_HANDLER'</code></pre></td>
        <td class="diff"><pre><code>`SIGWINCH_HANDLER'</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     If your host defines `SIGWINCH', you can define this to be the name</code></pre></td>
        <td class="diff"><pre><code>     If your host defines `SIGWINCH', you can define this to be the name</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     of a function to be called if `SIGWINCH' is received.</code></pre></td>
        <td class="diff"><pre><code>     of a function to be called if `SIGWINCH' is received.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>`SIGWINCH_HANDLER_BODY'</code></pre></td>
        <td class="diff"><pre><code>`SIGWINCH_HANDLER_BODY'</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     Define this to expand into code that will define the function</code></pre></td>
        <td class="diff"><pre><code>     Define this to expand into code that will define the function</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     named by the expansion of `SIGWINCH_HANDLER'.</code></pre></td>
        <td class="diff"><pre><code>     named by the expansion of `SIGWINCH_HANDLER'.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>`CRLF_SOURCE_FILES'</code></pre></td>
        <td class="diff"><pre><code>`CRLF_SOURCE_FILES'</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     Define this if host files use `\r\n' rather than `\n' as a line</code></pre></td>
        <td class="diff"><pre><code>     Define this if host files use `\r\n' rather than `\n' as a line</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     terminator.  This will cause source file listings to omit `\r'</code></pre></td>
        <td class="diff"><pre><code>     terminator.  This will cause source file listings to omit `\r'</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     characters when printing and it will allow `\r\n' line endings of</code></pre></td>
        <td class="diff"><pre><code>     characters when printing and it will allow `\r\n' line endings of</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     files which are "sourced" by gdb.  It must be possible to open</code></pre></td>
        <td class="diff"><pre><code>     files which are "sourced" by gdb.  It must be possible to open</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     files in binary mode using `O_BINARY' or, for fopen, `"rb"'.</code></pre></td>
        <td class="diff"><pre><code>     files in binary mode using `O_BINARY' or, for fopen, `"rb"'.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>`DEFAULT_PROMPT'</code></pre></td>
        <td class="diff"><pre><code>`DEFAULT_PROMPT'</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     The default value of the prompt string (normally `"(gdb) "').</code></pre></td>
        <td class="diff"><pre><code>     The default value of the prompt string (normally `"(gdb) "').</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>`DEV_TTY'</code></pre></td>
        <td class="diff"><pre><code>`DEV_TTY'</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     The name of the generic TTY device, defaults to `"/dev/tty"'.</code></pre></td>
        <td class="diff"><pre><code>     The name of the generic TTY device, defaults to `"/dev/tty"'.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>`FOPEN_RB'</code></pre></td>
        <td class="diff"><pre><code>`FOPEN_RB'</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     Define this if binary files are opened the same way as text files.</code></pre></td>
        <td class="diff"><pre><code>     Define this if binary files are opened the same way as text files.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>`HAVE_MMAP'</code></pre></td>
        <td class="diff"><pre><code>`HAVE_MMAP'</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     In some cases, use the system call `mmap' for reading symbol</code></pre></td>
        <td class="diff"><pre><code>     In some cases, use the system call `mmap' for reading symbol</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     tables.  For some machines this allows for sharing and quick</code></pre></td>
        <td class="diff"><pre><code>     tables.  For some machines this allows for sharing and quick</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     updates.</code></pre></td>
        <td class="diff"><pre><code>     updates.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>`HAVE_TERMIO'</code></pre></td>
        <td class="diff"><pre><code>`HAVE_TERMIO'</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     Define this if the host system has `termio.h'.</code></pre></td>
        <td class="diff"><pre><code>     Define this if the host system has `termio.h'.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>`INT_MAX'</code></pre></td>
        <td class="diff"><pre><code>`INT_MAX'</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>`INT_MIN'</code></pre></td>
        <td class="diff"><pre><code>`INT_MIN'</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>`LONG_MAX'</code></pre></td>
        <td class="diff"><pre><code>`LONG_MAX'</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>`UINT_MAX'</code></pre></td>
        <td class="diff"><pre><code>`UINT_MAX'</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>`ULONG_MAX'</code></pre></td>
        <td class="diff"><pre><code>`ULONG_MAX'</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     Values for host-side constants.</code></pre></td>
        <td class="diff"><pre><code>     Values for host-side constants.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>`ISATTY'</code></pre></td>
        <td class="diff"><pre><code>`ISATTY'</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     Substitute for isatty, if not available.</code></pre></td>
        <td class="diff"><pre><code>     Substitute for isatty, if not available.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>`LONGEST'</code></pre></td>
        <td class="diff"><pre><code>`LONGEST'</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     This is the longest integer type available on the host.  If not</code></pre></td>
        <td class="diff"><pre><code>     This is the longest integer type available on the host.  If not</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     defined, it will default to `long long' or `long', depending on</code></pre></td>
        <td class="diff"><pre><code>     defined, it will default to `long long' or `long', depending on</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     `CC_HAS_LONG_LONG'.</code></pre></td>
        <td class="diff"><pre><code>     `CC_HAS_LONG_LONG'.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>`CC_HAS_LONG_LONG'</code></pre></td>
        <td class="diff"><pre><code>`CC_HAS_LONG_LONG'</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     Define this if the host C compiler supports `long long'.  This is</code></pre></td>
        <td class="diff"><pre><code>     Define this if the host C compiler supports `long long'.  This is</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     set by the `configure' script.</code></pre></td>
        <td class="diff"><pre><code>     set by the `configure' script.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>`PRINTF_HAS_LONG_LONG'</code></pre></td>
        <td class="diff"><pre><code>`PRINTF_HAS_LONG_LONG'</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     Define this if the host can handle printing of long long integers</code></pre></td>
        <td class="diff"><pre><code>     Define this if the host can handle printing of long long integers</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     via the printf format conversion specifier `ll'.  This is set by</code></pre></td>
        <td class="diff"><pre><code>     via the printf format conversion specifier `ll'.  This is set by</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     the `configure' script.</code></pre></td>
        <td class="diff"><pre><code>     the `configure' script.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>`HAVE_LONG_DOUBLE'</code></pre></td>
        <td class="diff"><pre><code>`HAVE_LONG_DOUBLE'</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     Define this if the host C compiler supports `long double'.  This is</code></pre></td>
        <td class="diff"><pre><code>     Define this if the host C compiler supports `long double'.  This is</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     set by the `configure' script.</code></pre></td>
        <td class="diff"><pre><code>     set by the `configure' script.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>`PRINTF_HAS_LONG_DOUBLE'</code></pre></td>
        <td class="diff"><pre><code>`PRINTF_HAS_LONG_DOUBLE'</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     Define this if the host can handle printing of long double</code></pre></td>
        <td class="diff"><pre><code>     Define this if the host can handle printing of long double</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     float-point numbers via the printf format conversion specifier</code></pre></td>
        <td class="diff"><pre><code>     float-point numbers via the printf format conversion specifier</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     `Lg'.  This is set by the `configure' script.</code></pre></td>
        <td class="diff"><pre><code>     `Lg'.  This is set by the `configure' script.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>`SCANF_HAS_LONG_DOUBLE'</code></pre></td>
        <td class="diff"><pre><code>`SCANF_HAS_LONG_DOUBLE'</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     Define this if the host can handle the parsing of long double</code></pre></td>
        <td class="diff"><pre><code>     Define this if the host can handle the parsing of long double</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     float-point numbers via the scanf format conversion specifier</code></pre></td>
        <td class="diff"><pre><code>     float-point numbers via the scanf format conversion specifier</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     `Lg'.  This is set by the `configure' script.</code></pre></td>
        <td class="diff"><pre><code>     `Lg'.  This is set by the `configure' script.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>`LSEEK_NOT_LINEAR'</code></pre></td>
        <td class="diff"><pre><code>`LSEEK_NOT_LINEAR'</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     Define this if `lseek (n)' does not necessarily move to byte number</code></pre></td>
        <td class="diff"><pre><code>     Define this if `lseek (n)' does not necessarily move to byte number</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     `n' in the file.  This is only used when reading source files.  It</code></pre></td>
        <td class="diff"><pre><code>     `n' in the file.  This is only used when reading source files.  It</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     is normally faster to define `CRLF_SOURCE_FILES' when possible.</code></pre></td>
        <td class="diff"><pre><code>     is normally faster to define `CRLF_SOURCE_FILES' when possible.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>`L_SET'</code></pre></td>
        <td class="diff"><pre><code>`L_SET'</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     This macro is used as the argument to `lseek' (or, most commonly,</code></pre></td>
        <td class="diff"><pre><code>     This macro is used as the argument to `lseek' (or, most commonly,</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     `bfd_seek').  FIXME, should be replaced by SEEK_SET instead, which</code></pre></td>
        <td class="diff"><pre><code>     `bfd_seek').  FIXME, should be replaced by SEEK_SET instead, which</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     is the POSIX equivalent.</code></pre></td>
        <td class="diff"><pre><code>     is the POSIX equivalent.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>`NORETURN'</code></pre></td>
        <td class="diff"><pre><code>`NORETURN'</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     If defined, this should be one or more tokens, such as `volatile',</code></pre></td>
        <td class="diff"><pre><code>     If defined, this should be one or more tokens, such as `volatile',</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     that can be used in both the declaration and definition of</code></pre></td>
        <td class="diff"><pre><code>     that can be used in both the declaration and definition of</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     functions to indicate that they never return.  The default is</code></pre></td>
        <td class="diff"><pre><code>     functions to indicate that they never return.  The default is</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     already set correctly if compiling with GCC.  This will almost</code></pre></td>
        <td class="diff"><pre><code>     already set correctly if compiling with GCC.  This will almost</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     never need to be defined.</code></pre></td>
        <td class="diff"><pre><code>     never need to be defined.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>`ATTR_NORETURN'</code></pre></td>
        <td class="diff"><pre><code>`ATTR_NORETURN'</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     If defined, this should be one or more tokens, such as</code></pre></td>
        <td class="diff"><pre><code>     If defined, this should be one or more tokens, such as</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     `__attribute__ ((noreturn))', that can be used in the declarations</code></pre></td>
        <td class="diff"><pre><code>     `__attribute__ ((noreturn))', that can be used in the declarations</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     of functions to indicate that they never return.  The default is</code></pre></td>
        <td class="diff"><pre><code>     of functions to indicate that they never return.  The default is</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     already set correctly if compiling with GCC.  This will almost</code></pre></td>
        <td class="diff"><pre><code>     already set correctly if compiling with GCC.  This will almost</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     never need to be defined.</code></pre></td>
        <td class="diff"><pre><code>     never need to be defined.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>`SEEK_CUR'</code></pre></td>
        <td class="diff"><pre><code>`SEEK_CUR'</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>`SEEK_SET'</code></pre></td>
        <td class="diff"><pre><code>`SEEK_SET'</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     Define these to appropriate value for the system `lseek', if not</code></pre></td>
        <td class="diff"><pre><code>     Define these to appropriate value for the system `lseek', if not</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     already defined.</code></pre></td>
        <td class="diff"><pre><code>     already defined.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>`STOP_SIGNAL'</code></pre></td>
        <td class="diff"><pre><code>`STOP_SIGNAL'</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     This is the signal for stopping GDB.  Defaults to `SIGTSTP'.</code></pre></td>
        <td class="diff"><pre><code>     This is the signal for stopping GDB.  Defaults to `SIGTSTP'.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     (Only redefined for the Convex.)</code></pre></td>
        <td class="diff"><pre><code>     (Only redefined for the Convex.)</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>`USG'</code></pre></td>
        <td class="diff"><pre><code>`USG'</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     Means that System V (prior to SVR4) include files are in use.</code></pre></td>
        <td class="diff"><pre><code>     Means that System V (prior to SVR4) include files are in use.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     (FIXME: This symbol is abused in `infrun.c', `regex.c', and</code></pre></td>
        <td class="diff"><pre><code>     (FIXME: This symbol is abused in `infrun.c', `regex.c', and</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     `utils.c' for other things, at the moment.)</code></pre></td>
        <td class="diff"><pre><code>     `utils.c' for other things, at the moment.)</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>`lint'</code></pre></td>
        <td class="diff"><pre><code>`lint'</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     Define this to help placate `lint' in some situations.</code></pre></td>
        <td class="diff"><pre><code>     Define this to help placate `lint' in some situations.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>`volatile'</code></pre></td>
        <td class="diff"><pre><code>`volatile'</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     Define this to override the defaults of `__volatile__' or `/**/'.</code></pre></td>
        <td class="diff"><pre><code>     Define this to override the defaults of `__volatile__' or `/**/'.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>File: gdbint.info,  Node: Target Architecture Definition,  Next: Target Descriptions,  Prev: Host Definition,  Up: Top</code></pre></td>
        <td class="diff"><pre><code>File: gdbint.info,  Node: Target Architecture Definition,  Next: Target Descriptions,  Prev: Host Definition,  Up: Top</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>9 Target Architecture Definition</code></pre></td>
        <td class="diff"><pre><code>9 Target Architecture Definition</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>********************************</code></pre></td>
        <td class="diff"><pre><code>********************************</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>GDB's target architecture defines what sort of machine-language</code></pre></td>
        <td class="diff"><pre><code>GDB's target architecture defines what sort of machine-language</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>programs GDB can work with, and how it works with them.</code></pre></td>
        <td class="diff"><pre><code>programs GDB can work with, and how it works with them.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>   The target architecture object is implemented as the C structure</code></pre></td>
        <td class="diff"><pre><code>   The target architecture object is implemented as the C structure</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>`struct gdbarch *'.  The structure, and its methods, are generated</code></pre></td>
        <td class="diff"><pre><code>`struct gdbarch *'.  The structure, and its methods, are generated</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>using the Bourne shell script `gdbarch.sh'.</code></pre></td>
        <td class="diff"><pre><code>using the Bourne shell script `gdbarch.sh'.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>* Menu:</code></pre></td>
        <td class="diff"><pre><code>* Menu:</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>* OS ABI Variant Handling::</code></pre></td>
        <td class="diff"><pre><code>* OS ABI Variant Handling::</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>* Initialize New Architecture::</code></pre></td>
        <td class="diff"><pre><code>* Initialize New Architecture::</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>* Registers and Memory::</code></pre></td>
        <td class="diff"><pre><code>* Registers and Memory::</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>* Pointers and Addresses::</code></pre></td>
        <td class="diff"><pre><code>* Pointers and Addresses::</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>* Address Classes::</code></pre></td>
        <td class="diff"><pre><code>* Address Classes::</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>* Raw and Virtual Registers::</code></pre></td>
        <td class="diff"><pre><code>* Raw and Virtual Registers::</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>* Register and Memory Data::</code></pre></td>
        <td class="diff"><pre><code>* Register and Memory Data::</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>* Frame Interpretation::</code></pre></td>
        <td class="diff"><pre><code>* Frame Interpretation::</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>* Inferior Call Setup::</code></pre></td>
        <td class="diff"><pre><code>* Inferior Call Setup::</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>* Compiler Characteristics::</code></pre></td>
        <td class="diff"><pre><code>* Compiler Characteristics::</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>* Target Conditionals::</code></pre></td>
        <td class="diff"><pre><code>* Target Conditionals::</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>* Adding a New Target::</code></pre></td>
        <td class="diff"><pre><code>* Adding a New Target::</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>File: gdbint.info,  Node: OS ABI Variant Handling,  Next: Initialize New Architecture,  Up: Target Architecture Definition</code></pre></td>
        <td class="diff"><pre><code>File: gdbint.info,  Node: OS ABI Variant Handling,  Next: Initialize New Architecture,  Up: Target Architecture Definition</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>9.1 Operating System ABI Variant Handling</code></pre></td>
        <td class="diff"><pre><code>9.1 Operating System ABI Variant Handling</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>=========================================</code></pre></td>
        <td class="diff"><pre><code>=========================================</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>GDB provides a mechanism for handling variations in OS ABIs.  An OS ABI</code></pre></td>
        <td class="diff"><pre><code>GDB provides a mechanism for handling variations in OS ABIs.  An OS ABI</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>variant may have influence over any number of variables in the target</code></pre></td>
        <td class="diff"><pre><code>variant may have influence over any number of variables in the target</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>architecture definition.  There are two major components in the OS ABI</code></pre></td>
        <td class="diff"><pre><code>architecture definition.  There are two major components in the OS ABI</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>mechanism: sniffers and handlers.</code></pre></td>
        <td class="diff"><pre><code>mechanism: sniffers and handlers.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>   A "sniffer" examines a file matching a BFD architecture/flavour pair</code></pre></td>
        <td class="diff"><pre><code>   A "sniffer" examines a file matching a BFD architecture/flavour pair</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>(the architecture may be wildcarded) in an attempt to determine the OS</code></pre></td>
        <td class="diff"><pre><code>(the architecture may be wildcarded) in an attempt to determine the OS</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>ABI of that file.  Sniffers with a wildcarded architecture are</code></pre></td>
        <td class="diff"><pre><code>ABI of that file.  Sniffers with a wildcarded architecture are</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>considered to be "generic", while sniffers for a specific architecture</code></pre></td>
        <td class="diff"><pre><code>considered to be "generic", while sniffers for a specific architecture</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>are considered to be "specific".  A match from a specific sniffer</code></pre></td>
        <td class="diff"><pre><code>are considered to be "specific".  A match from a specific sniffer</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>overrides a match from a generic sniffer.  Multiple sniffers for an</code></pre></td>
        <td class="diff"><pre><code>overrides a match from a generic sniffer.  Multiple sniffers for an</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>architecture/flavour may exist, in order to differentiate between two</code></pre></td>
        <td class="diff"><pre><code>architecture/flavour may exist, in order to differentiate between two</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>different operating systems which use the same basic file format.  The</code></pre></td>
        <td class="diff"><pre><code>different operating systems which use the same basic file format.  The</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>OS ABI framework provides a generic sniffer for ELF-format files which</code></pre></td>
        <td class="diff"><pre><code>OS ABI framework provides a generic sniffer for ELF-format files which</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>examines the `EI_OSABI' field of the ELF header, as well as note</code></pre></td>
        <td class="diff"><pre><code>examines the `EI_OSABI' field of the ELF header, as well as note</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>sections known to be used by several operating systems.</code></pre></td>
        <td class="diff"><pre><code>sections known to be used by several operating systems.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>   A "handler" is used to fine-tune the `gdbarch' structure for the</code></pre></td>
        <td class="diff"><pre><code>   A "handler" is used to fine-tune the `gdbarch' structure for the</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>selected OS ABI.  There may be only one handler for a given OS ABI for</code></pre></td>
        <td class="diff"><pre><code>selected OS ABI.  There may be only one handler for a given OS ABI for</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>each BFD architecture.</code></pre></td>
        <td class="diff"><pre><code>each BFD architecture.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>   The following OS ABI variants are defined in `defs.h':</code></pre></td>
        <td class="diff"><pre><code>   The following OS ABI variants are defined in `defs.h':</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>`GDB_OSABI_UNINITIALIZED'</code></pre></td>
        <td class="diff"><pre><code>`GDB_OSABI_UNINITIALIZED'</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     Used for struct gdbarch_info if ABI is still uninitialized.</code></pre></td>
        <td class="diff"><pre><code>     Used for struct gdbarch_info if ABI is still uninitialized.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>`GDB_OSABI_UNKNOWN'</code></pre></td>
        <td class="diff"><pre><code>`GDB_OSABI_UNKNOWN'</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     The ABI of the inferior is unknown.  The default `gdbarch'</code></pre></td>
        <td class="diff"><pre><code>     The ABI of the inferior is unknown.  The default `gdbarch'</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     settings for the architecture will be used.</code></pre></td>
        <td class="diff"><pre><code>     settings for the architecture will be used.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>`GDB_OSABI_SVR4'</code></pre></td>
        <td class="diff"><pre><code>`GDB_OSABI_SVR4'</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     UNIX System V Release 4.</code></pre></td>
        <td class="diff"><pre><code>     UNIX System V Release 4.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>`GDB_OSABI_HURD'</code></pre></td>
        <td class="diff"><pre><code>`GDB_OSABI_HURD'</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     GNU using the Hurd kernel.</code></pre></td>
        <td class="diff"><pre><code>     GNU using the Hurd kernel.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>`GDB_OSABI_SOLARIS'</code></pre></td>
        <td class="diff"><pre><code>`GDB_OSABI_SOLARIS'</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     Sun Solaris.</code></pre></td>
        <td class="diff"><pre><code>     Sun Solaris.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>`GDB_OSABI_OSF1'</code></pre></td>
        <td class="diff"><pre><code>`GDB_OSABI_OSF1'</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     OSF/1, including Digital UNIX and Compaq Tru64 UNIX.</code></pre></td>
        <td class="diff"><pre><code>     OSF/1, including Digital UNIX and Compaq Tru64 UNIX.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>`GDB_OSABI_LINUX'</code></pre></td>
        <td class="diff"><pre><code>`GDB_OSABI_LINUX'</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     GNU using the Linux kernel.</code></pre></td>
        <td class="diff"><pre><code>     GNU using the Linux kernel.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>`GDB_OSABI_FREEBSD_AOUT'</code></pre></td>
        <td class="diff"><pre><code>`GDB_OSABI_FREEBSD_AOUT'</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     FreeBSD using the `a.out' executable format.</code></pre></td>
        <td class="diff"><pre><code>     FreeBSD using the `a.out' executable format.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>`GDB_OSABI_FREEBSD_ELF'</code></pre></td>
        <td class="diff"><pre><code>`GDB_OSABI_FREEBSD_ELF'</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     FreeBSD using the ELF executable format.</code></pre></td>
        <td class="diff"><pre><code>     FreeBSD using the ELF executable format.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>`GDB_OSABI_NETBSD_AOUT'</code></pre></td>
        <td class="diff"><pre><code>`GDB_OSABI_NETBSD_AOUT'</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     NetBSD using the `a.out' executable format.</code></pre></td>
        <td class="diff"><pre><code>     NetBSD using the `a.out' executable format.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>`GDB_OSABI_NETBSD_ELF'</code></pre></td>
        <td class="diff"><pre><code>`GDB_OSABI_NETBSD_ELF'</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     NetBSD using the ELF executable format.</code></pre></td>
        <td class="diff"><pre><code>     NetBSD using the ELF executable format.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>`GDB_OSABI_OPENBSD_ELF'</code></pre></td>
        <td class="diff"><pre><code>`GDB_OSABI_OPENBSD_ELF'</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     OpenBSD using the ELF executable format.</code></pre></td>
        <td class="diff"><pre><code>     OpenBSD using the ELF executable format.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>`GDB_OSABI_WINCE'</code></pre></td>
        <td class="diff"><pre><code>`GDB_OSABI_WINCE'</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     Windows CE.</code></pre></td>
        <td class="diff"><pre><code>     Windows CE.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>`GDB_OSABI_GO32'</code></pre></td>
        <td class="diff"><pre><code>`GDB_OSABI_GO32'</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     DJGPP.</code></pre></td>
        <td class="diff"><pre><code>     DJGPP.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>`GDB_OSABI_IRIX'</code></pre></td>
        <td class="diff"><pre><code>`GDB_OSABI_IRIX'</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     Irix.</code></pre></td>
        <td class="diff"><pre><code>     Irix.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>`GDB_OSABI_INTERIX'</code></pre></td>
        <td class="diff"><pre><code>`GDB_OSABI_INTERIX'</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     Interix (Posix layer for MS-Windows systems).</code></pre></td>
        <td class="diff"><pre><code>     Interix (Posix layer for MS-Windows systems).</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>`GDB_OSABI_HPUX_ELF'</code></pre></td>
        <td class="diff"><pre><code>`GDB_OSABI_HPUX_ELF'</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     HP/UX using the ELF executable format.</code></pre></td>
        <td class="diff"><pre><code>     HP/UX using the ELF executable format.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>`GDB_OSABI_HPUX_SOM'</code></pre></td>
        <td class="diff"><pre><code>`GDB_OSABI_HPUX_SOM'</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     HP/UX using the SOM executable format.</code></pre></td>
        <td class="diff"><pre><code>     HP/UX using the SOM executable format.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>`GDB_OSABI_QNXNTO'</code></pre></td>
        <td class="diff"><pre><code>`GDB_OSABI_QNXNTO'</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     QNX Neutrino.</code></pre></td>
        <td class="diff"><pre><code>     QNX Neutrino.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>`GDB_OSABI_CYGWIN'</code></pre></td>
        <td class="diff"><pre><code>`GDB_OSABI_CYGWIN'</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     Cygwin.</code></pre></td>
        <td class="diff"><pre><code>     Cygwin.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>`GDB_OSABI_AIX'</code></pre></td>
        <td class="diff"><pre><code>`GDB_OSABI_AIX'</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     AIX.</code></pre></td>
        <td class="diff"><pre><code>     AIX.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>   Here are the functions that make up the OS ABI framework:</code></pre></td>
        <td class="diff"><pre><code>   Here are the functions that make up the OS ABI framework:</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code> -- Function: const char *gdbarch_osabi_name (enum gdb_osabi OSABI)</code></pre></td>
        <td class="diff"><pre><code> -- Function: const char *gdbarch_osabi_name (enum gdb_osabi OSABI)</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     Return the name of the OS ABI corresponding to OSABI.</code></pre></td>
        <td class="diff"><pre><code>     Return the name of the OS ABI corresponding to OSABI.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code> -- Function: void gdbarch_register_osabi (enum bfd_architecture ARCH,</code></pre></td>
        <td class="diff"><pre><code> -- Function: void gdbarch_register_osabi (enum bfd_architecture ARCH,</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>          unsigned long MACHINE, enum gdb_osabi OSABI, void</code></pre></td>
        <td class="diff"><pre><code>          unsigned long MACHINE, enum gdb_osabi OSABI, void</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>          (*INIT_OSABI)(struct gdbarch_info INFO, struct gdbarch</code></pre></td>
        <td class="diff"><pre><code>          (*INIT_OSABI)(struct gdbarch_info INFO, struct gdbarch</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>          *GDBARCH))</code></pre></td>
        <td class="diff"><pre><code>          *GDBARCH))</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     Register the OS ABI handler specified by INIT_OSABI for the</code></pre></td>
        <td class="diff"><pre><code>     Register the OS ABI handler specified by INIT_OSABI for the</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     architecture, machine type and OS ABI specified by ARCH, MACHINE</code></pre></td>
        <td class="diff"><pre><code>     architecture, machine type and OS ABI specified by ARCH, MACHINE</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     and OSABI.  In most cases, a value of zero for the machine type,</code></pre></td>
        <td class="diff"><pre><code>     and OSABI.  In most cases, a value of zero for the machine type,</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     which implies the architecture's default machine type, will</code></pre></td>
        <td class="diff"><pre><code>     which implies the architecture's default machine type, will</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     suffice.</code></pre></td>
        <td class="diff"><pre><code>     suffice.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code> -- Function: void gdbarch_register_osabi_sniffer (enum</code></pre></td>
        <td class="diff"><pre><code> -- Function: void gdbarch_register_osabi_sniffer (enum</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>          bfd_architecture ARCH, enum bfd_flavour FLAVOUR, enum</code></pre></td>
        <td class="diff"><pre><code>          bfd_architecture ARCH, enum bfd_flavour FLAVOUR, enum</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>          gdb_osabi (*SNIFFER)(bfd *ABFD))</code></pre></td>
        <td class="diff"><pre><code>          gdb_osabi (*SNIFFER)(bfd *ABFD))</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     Register the OS ABI file sniffer specified by SNIFFER for the BFD</code></pre></td>
        <td class="diff"><pre><code>     Register the OS ABI file sniffer specified by SNIFFER for the BFD</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     architecture/flavour pair specified by ARCH and FLAVOUR.  If ARCH</code></pre></td>
        <td class="diff"><pre><code>     architecture/flavour pair specified by ARCH and FLAVOUR.  If ARCH</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     is `bfd_arch_unknown', the sniffer is considered to be generic,</code></pre></td>
        <td class="diff"><pre><code>     is `bfd_arch_unknown', the sniffer is considered to be generic,</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     and is allowed to examine FLAVOUR-flavoured files for any</code></pre></td>
        <td class="diff"><pre><code>     and is allowed to examine FLAVOUR-flavoured files for any</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     architecture.</code></pre></td>
        <td class="diff"><pre><code>     architecture.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code> -- Function: enum gdb_osabi gdbarch_lookup_osabi (bfd *ABFD)</code></pre></td>
        <td class="diff"><pre><code> -- Function: enum gdb_osabi gdbarch_lookup_osabi (bfd *ABFD)</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     Examine the file described by ABFD to determine its OS ABI.  The</code></pre></td>
        <td class="diff"><pre><code>     Examine the file described by ABFD to determine its OS ABI.  The</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     value `GDB_OSABI_UNKNOWN' is returned if the OS ABI cannot be</code></pre></td>
        <td class="diff"><pre><code>     value `GDB_OSABI_UNKNOWN' is returned if the OS ABI cannot be</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     determined.</code></pre></td>
        <td class="diff"><pre><code>     determined.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code> -- Function: void gdbarch_init_osabi (struct gdbarch info INFO, struct</code></pre></td>
        <td class="diff"><pre><code> -- Function: void gdbarch_init_osabi (struct gdbarch info INFO, struct</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>          gdbarch *GDBARCH, enum gdb_osabi OSABI)</code></pre></td>
        <td class="diff"><pre><code>          gdbarch *GDBARCH, enum gdb_osabi OSABI)</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     Invoke the OS ABI handler corresponding to OSABI to fine-tune the</code></pre></td>
        <td class="diff"><pre><code>     Invoke the OS ABI handler corresponding to OSABI to fine-tune the</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     `gdbarch' structure specified by GDBARCH.  If a handler</code></pre></td>
        <td class="diff"><pre><code>     `gdbarch' structure specified by GDBARCH.  If a handler</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     corresponding to OSABI has not been registered for GDBARCH's</code></pre></td>
        <td class="diff"><pre><code>     corresponding to OSABI has not been registered for GDBARCH's</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     architecture, a warning will be issued and the debugging session</code></pre></td>
        <td class="diff"><pre><code>     architecture, a warning will be issued and the debugging session</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     will continue with the defaults already established for GDBARCH.</code></pre></td>
        <td class="diff"><pre><code>     will continue with the defaults already established for GDBARCH.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code> -- Function: void generic_elf_osabi_sniff_abi_tag_sections (bfd *ABFD,</code></pre></td>
        <td class="diff"><pre><code> -- Function: void generic_elf_osabi_sniff_abi_tag_sections (bfd *ABFD,</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>          asection *SECT, void *OBJ)</code></pre></td>
        <td class="diff"><pre><code>          asection *SECT, void *OBJ)</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     Helper routine for ELF file sniffers.  Examine the file described</code></pre></td>
        <td class="diff"><pre><code>     Helper routine for ELF file sniffers.  Examine the file described</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     by ABFD and look at ABI tag note sections to determine the OS ABI</code></pre></td>
        <td class="diff"><pre><code>     by ABFD and look at ABI tag note sections to determine the OS ABI</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     from the note.  This function should be called via</code></pre></td>
        <td class="diff"><pre><code>     from the note.  This function should be called via</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     `bfd_map_over_sections'.</code></pre></td>
        <td class="diff"><pre><code>     `bfd_map_over_sections'.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>File: gdbint.info,  Node: Initialize New Architecture,  Next: Registers and Memory,  Prev: OS ABI Variant Handling,  Up: Target Architecture Definition</code></pre></td>
        <td class="diff"><pre><code>File: gdbint.info,  Node: Initialize New Architecture,  Next: Registers and Memory,  Prev: OS ABI Variant Handling,  Up: Target Architecture Definition</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>9.2 Initializing a New Architecture</code></pre></td>
        <td class="diff"><pre><code>9.2 Initializing a New Architecture</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>===================================</code></pre></td>
        <td class="diff"><pre><code>===================================</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>Each `gdbarch' is associated with a single BFD architecture, via a</code></pre></td>
        <td class="diff"><pre><code>Each `gdbarch' is associated with a single BFD architecture, via a</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>`bfd_arch_ARCH' constant.  The `gdbarch' is registered by a call to</code></pre></td>
        <td class="diff"><pre><code>`bfd_arch_ARCH' constant.  The `gdbarch' is registered by a call to</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>`register_gdbarch_init', usually from the file's `_initialize_FILENAME'</code></pre></td>
        <td class="diff"><pre><code>`register_gdbarch_init', usually from the file's `_initialize_FILENAME'</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>routine, which will be automatically called during GDB startup.  The</code></pre></td>
        <td class="diff"><pre><code>routine, which will be automatically called during GDB startup.  The</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>arguments are a BFD architecture constant and an initialization</code></pre></td>
        <td class="diff"><pre><code>arguments are a BFD architecture constant and an initialization</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>function.</code></pre></td>
        <td class="diff"><pre><code>function.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>   The initialization function has this type:</code></pre></td>
        <td class="diff"><pre><code>   The initialization function has this type:</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     static struct gdbarch *</code></pre></td>
        <td class="diff"><pre><code>     static struct gdbarch *</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     ARCH_gdbarch_init (struct gdbarch_info INFO,</code></pre></td>
        <td class="diff"><pre><code>     ARCH_gdbarch_init (struct gdbarch_info INFO,</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>                              struct gdbarch_list *ARCHES)</code></pre></td>
        <td class="diff"><pre><code>                              struct gdbarch_list *ARCHES)</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>   The INFO argument contains parameters used to select the correct</code></pre></td>
        <td class="diff"><pre><code>   The INFO argument contains parameters used to select the correct</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>architecture, and ARCHES is a list of architectures which have already</code></pre></td>
        <td class="diff"><pre><code>architecture, and ARCHES is a list of architectures which have already</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>been created with the same `bfd_arch_ARCH' value.</code></pre></td>
        <td class="diff"><pre><code>been created with the same `bfd_arch_ARCH' value.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>   The initialization function should first make sure that INFO is</code></pre></td>
        <td class="diff"><pre><code>   The initialization function should first make sure that INFO is</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>acceptable, and return `NULL' if it is not.  Then, it should search</code></pre></td>
        <td class="diff"><pre><code>acceptable, and return `NULL' if it is not.  Then, it should search</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>through ARCHES for an exact match to INFO, and return one if found.</code></pre></td>
        <td class="diff"><pre><code>through ARCHES for an exact match to INFO, and return one if found.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>Lastly, if no exact match was found, it should create a new</code></pre></td>
        <td class="diff"><pre><code>Lastly, if no exact match was found, it should create a new</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>architecture based on INFO and return it.</code></pre></td>
        <td class="diff"><pre><code>architecture based on INFO and return it.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>   Only information in INFO should be used to choose the new</code></pre></td>
        <td class="diff"><pre><code>   Only information in INFO should be used to choose the new</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>architecture.  Historically, INFO could be sparse, and defaults would</code></pre></td>
        <td class="diff"><pre><code>architecture.  Historically, INFO could be sparse, and defaults would</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>be collected from the first element on ARCHES.  However, GDB now fills</code></pre></td>
        <td class="diff"><pre><code>be collected from the first element on ARCHES.  However, GDB now fills</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>in INFO more thoroughly, so new `gdbarch' initialization functions</code></pre></td>
        <td class="diff"><pre><code>in INFO more thoroughly, so new `gdbarch' initialization functions</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>should not take defaults from ARCHES.</code></pre></td>
        <td class="diff"><pre><code>should not take defaults from ARCHES.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>File: gdbint.info,  Node: Registers and Memory,  Next: Pointers and Addresses,  Prev: Initialize New Architecture,  Up: Target Architecture Definition</code></pre></td>
        <td class="diff"><pre><code>File: gdbint.info,  Node: Registers and Memory,  Next: Pointers and Addresses,  Prev: Initialize New Architecture,  Up: Target Architecture Definition</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>9.3 Registers and Memory</code></pre></td>
        <td class="diff"><pre><code>9.3 Registers and Memory</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>========================</code></pre></td>
        <td class="diff"><pre><code>========================</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>GDB's model of the target machine is rather simple.  GDB assumes the</code></pre></td>
        <td class="diff"><pre><code>GDB's model of the target machine is rather simple.  GDB assumes the</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>machine includes a bank of registers and a block of memory.  Each</code></pre></td>
        <td class="diff"><pre><code>machine includes a bank of registers and a block of memory.  Each</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>register may have a different size.</code></pre></td>
        <td class="diff"><pre><code>register may have a different size.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>   GDB does not have a magical way to match up with the compiler's idea</code></pre></td>
        <td class="diff"><pre><code>   GDB does not have a magical way to match up with the compiler's idea</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>of which registers are which; however, it is critical that they do</code></pre></td>
        <td class="diff"><pre><code>of which registers are which; however, it is critical that they do</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>match up accurately.  The only way to make this work is to get accurate</code></pre></td>
        <td class="diff"><pre><code>match up accurately.  The only way to make this work is to get accurate</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>information about the order that the compiler uses, and to reflect that</code></pre></td>
        <td class="diff"><pre><code>information about the order that the compiler uses, and to reflect that</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>in the `gdbarch_register_name' and related functions.</code></pre></td>
        <td class="diff"><pre><code>in the `gdbarch_register_name' and related functions.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>   GDB can handle big-endian, little-endian, and bi-endian</code></pre></td>
        <td class="diff"><pre><code>   GDB can handle big-endian, little-endian, and bi-endian</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>architectures.</code></pre></td>
        <td class="diff"><pre><code>architectures.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>File: gdbint.info,  Node: Pointers and Addresses,  Next: Address Classes,  Prev: Registers and Memory,  Up: Target Architecture Definition</code></pre></td>
        <td class="diff"><pre><code>File: gdbint.info,  Node: Pointers and Addresses,  Next: Address Classes,  Prev: Registers and Memory,  Up: Target Architecture Definition</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>9.4 Pointers Are Not Always Addresses</code></pre></td>
        <td class="diff"><pre><code>9.4 Pointers Are Not Always Addresses</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>=====================================</code></pre></td>
        <td class="diff"><pre><code>=====================================</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>On almost all 32-bit architectures, the representation of a pointer is</code></pre></td>
        <td class="diff"><pre><code>On almost all 32-bit architectures, the representation of a pointer is</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>indistinguishable from the representation of some fixed-length number</code></pre></td>
        <td class="diff"><pre><code>indistinguishable from the representation of some fixed-length number</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>whose value is the byte address of the object pointed to.  On such</code></pre></td>
        <td class="diff"><pre><code>whose value is the byte address of the object pointed to.  On such</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>machines, the words "pointer" and "address" can be used interchangeably.</code></pre></td>
        <td class="diff"><pre><code>machines, the words "pointer" and "address" can be used interchangeably.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>However, architectures with smaller word sizes are often cramped for</code></pre></td>
        <td class="diff"><pre><code>However, architectures with smaller word sizes are often cramped for</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>address space, so they may choose a pointer representation that breaks</code></pre></td>
        <td class="diff"><pre><code>address space, so they may choose a pointer representation that breaks</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>this identity, and allows a larger code address space.</code></pre></td>
        <td class="diff"><pre><code>this identity, and allows a larger code address space.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>   For example, the Renesas D10V is a 16-bit VLIW processor whose</code></pre></td>
        <td class="diff"><pre><code>   For example, the Renesas D10V is a 16-bit VLIW processor whose</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>instructions are 32 bits long(1).  If the D10V used ordinary byte</code></pre></td>
        <td class="diff"><pre><code>instructions are 32 bits long(1).  If the D10V used ordinary byte</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>addresses to refer to code locations, then the processor would only be</code></pre></td>
        <td class="diff"><pre><code>addresses to refer to code locations, then the processor would only be</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>able to address 64kb of instructions.  However, since instructions must</code></pre></td>
        <td class="diff"><pre><code>able to address 64kb of instructions.  However, since instructions must</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>be aligned on four-byte boundaries, the low two bits of any valid</code></pre></td>
        <td class="diff"><pre><code>be aligned on four-byte boundaries, the low two bits of any valid</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>instruction's byte address are always zero--byte addresses waste two</code></pre></td>
        <td class="diff"><pre><code>instruction's byte address are always zero--byte addresses waste two</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>bits.  So instead of byte addresses, the D10V uses word addresses--byte</code></pre></td>
        <td class="diff"><pre><code>bits.  So instead of byte addresses, the D10V uses word addresses--byte</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>addresses shifted right two bits--to refer to code.  Thus, the D10V can</code></pre></td>
        <td class="diff"><pre><code>addresses shifted right two bits--to refer to code.  Thus, the D10V can</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>use 16-bit words to address 256kb of code space.</code></pre></td>
        <td class="diff"><pre><code>use 16-bit words to address 256kb of code space.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>   However, this means that code pointers and data pointers have</code></pre></td>
        <td class="diff"><pre><code>   However, this means that code pointers and data pointers have</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>different forms on the D10V.  The 16-bit word `0xC020' refers to byte</code></pre></td>
        <td class="diff"><pre><code>different forms on the D10V.  The 16-bit word `0xC020' refers to byte</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>address `0xC020' when used as a data address, but refers to byte address</code></pre></td>
        <td class="diff"><pre><code>address `0xC020' when used as a data address, but refers to byte address</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>`0x30080' when used as a code address.</code></pre></td>
        <td class="diff"><pre><code>`0x30080' when used as a code address.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>   (The D10V also uses separate code and data address spaces, which also</code></pre></td>
        <td class="diff"><pre><code>   (The D10V also uses separate code and data address spaces, which also</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>affects the correspondence between pointers and addresses, but we're</code></pre></td>
        <td class="diff"><pre><code>affects the correspondence between pointers and addresses, but we're</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>going to ignore that here; this example is already too long.)</code></pre></td>
        <td class="diff"><pre><code>going to ignore that here; this example is already too long.)</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>   To cope with architectures like this--the D10V is not the only</code></pre></td>
        <td class="diff"><pre><code>   To cope with architectures like this--the D10V is not the only</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>one!--GDB tries to distinguish between "addresses", which are byte</code></pre></td>
        <td class="diff"><pre><code>one!--GDB tries to distinguish between "addresses", which are byte</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>numbers, and "pointers", which are the target's representation of an</code></pre></td>
        <td class="diff"><pre><code>numbers, and "pointers", which are the target's representation of an</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>address of a particular type of data.  In the example above, `0xC020'</code></pre></td>
        <td class="diff"><pre><code>address of a particular type of data.  In the example above, `0xC020'</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>is the pointer, which refers to one of the addresses `0xC020' or</code></pre></td>
        <td class="diff"><pre><code>is the pointer, which refers to one of the addresses `0xC020' or</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>`0x30080', depending on the type imposed upon it.  GDB provides</code></pre></td>
        <td class="diff"><pre><code>`0x30080', depending on the type imposed upon it.  GDB provides</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>functions for turning a pointer into an address and vice versa, in the</code></pre></td>
        <td class="diff"><pre><code>functions for turning a pointer into an address and vice versa, in the</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>appropriate way for the current architecture.</code></pre></td>
        <td class="diff"><pre><code>appropriate way for the current architecture.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>   Unfortunately, since addresses and pointers are identical on almost</code></pre></td>
        <td class="diff"><pre><code>   Unfortunately, since addresses and pointers are identical on almost</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>all processors, this distinction tends to bit-rot pretty quickly.  Thus,</code></pre></td>
        <td class="diff"><pre><code>all processors, this distinction tends to bit-rot pretty quickly.  Thus,</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>each time you port GDB to an architecture which does distinguish</code></pre></td>
        <td class="diff"><pre><code>each time you port GDB to an architecture which does distinguish</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>between pointers and addresses, you'll probably need to clean up some</code></pre></td>
        <td class="diff"><pre><code>between pointers and addresses, you'll probably need to clean up some</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>architecture-independent code.</code></pre></td>
        <td class="diff"><pre><code>architecture-independent code.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>   Here are functions which convert between pointers and addresses:</code></pre></td>
        <td class="diff"><pre><code>   Here are functions which convert between pointers and addresses:</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code> -- Function: CORE_ADDR extract_typed_address (void *BUF, struct type</code></pre></td>
        <td class="diff"><pre><code> -- Function: CORE_ADDR extract_typed_address (void *BUF, struct type</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>          *TYPE)</code></pre></td>
        <td class="diff"><pre><code>          *TYPE)</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     Treat the bytes at BUF as a pointer or reference of type TYPE, and</code></pre></td>
        <td class="diff"><pre><code>     Treat the bytes at BUF as a pointer or reference of type TYPE, and</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     return the address it represents, in a manner appropriate for the</code></pre></td>
        <td class="diff"><pre><code>     return the address it represents, in a manner appropriate for the</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     current architecture.  This yields an address GDB can use to read</code></pre></td>
        <td class="diff"><pre><code>     current architecture.  This yields an address GDB can use to read</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     target memory, disassemble, etc.  Note that BUF refers to a buffer</code></pre></td>
        <td class="diff"><pre><code>     target memory, disassemble, etc.  Note that BUF refers to a buffer</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     in GDB's memory, not the inferior's.</code></pre></td>
        <td class="diff"><pre><code>     in GDB's memory, not the inferior's.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     For example, if the current architecture is the Intel x86, this</code></pre></td>
        <td class="diff"><pre><code>     For example, if the current architecture is the Intel x86, this</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     function extracts a little-endian integer of the appropriate</code></pre></td>
        <td class="diff"><pre><code>     function extracts a little-endian integer of the appropriate</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     length from BUF and returns it.  However, if the current</code></pre></td>
        <td class="diff"><pre><code>     length from BUF and returns it.  However, if the current</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     architecture is the D10V, this function will return a 16-bit</code></pre></td>
        <td class="diff"><pre><code>     architecture is the D10V, this function will return a 16-bit</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     integer extracted from BUF, multiplied by four if TYPE is a</code></pre></td>
        <td class="diff"><pre><code>     integer extracted from BUF, multiplied by four if TYPE is a</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     pointer to a function.</code></pre></td>
        <td class="diff"><pre><code>     pointer to a function.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     If TYPE is not a pointer or reference type, then this function</code></pre></td>
        <td class="diff"><pre><code>     If TYPE is not a pointer or reference type, then this function</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     will signal an internal error.</code></pre></td>
        <td class="diff"><pre><code>     will signal an internal error.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code> -- Function: CORE_ADDR store_typed_address (void *BUF, struct type</code></pre></td>
        <td class="diff"><pre><code> -- Function: CORE_ADDR store_typed_address (void *BUF, struct type</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>          *TYPE, CORE_ADDR ADDR)</code></pre></td>
        <td class="diff"><pre><code>          *TYPE, CORE_ADDR ADDR)</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     Store the address ADDR in BUF, in the proper format for a pointer</code></pre></td>
        <td class="diff"><pre><code>     Store the address ADDR in BUF, in the proper format for a pointer</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     of type TYPE in the current architecture.  Note that BUF refers to</code></pre></td>
        <td class="diff"><pre><code>     of type TYPE in the current architecture.  Note that BUF refers to</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     a buffer in GDB's memory, not the inferior's.</code></pre></td>
        <td class="diff"><pre><code>     a buffer in GDB's memory, not the inferior's.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     For example, if the current architecture is the Intel x86, this</code></pre></td>
        <td class="diff"><pre><code>     For example, if the current architecture is the Intel x86, this</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     function stores ADDR unmodified as a little-endian integer of the</code></pre></td>
        <td class="diff"><pre><code>     function stores ADDR unmodified as a little-endian integer of the</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     appropriate length in BUF.  However, if the current architecture</code></pre></td>
        <td class="diff"><pre><code>     appropriate length in BUF.  However, if the current architecture</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     is the D10V, this function divides ADDR by four if TYPE is a</code></pre></td>
        <td class="diff"><pre><code>     is the D10V, this function divides ADDR by four if TYPE is a</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     pointer to a function, and then stores it in BUF.</code></pre></td>
        <td class="diff"><pre><code>     pointer to a function, and then stores it in BUF.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     If TYPE is not a pointer or reference type, then this function</code></pre></td>
        <td class="diff"><pre><code>     If TYPE is not a pointer or reference type, then this function</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     will signal an internal error.</code></pre></td>
        <td class="diff"><pre><code>     will signal an internal error.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code> -- Function: CORE_ADDR value_as_address (struct value *VAL)</code></pre></td>
        <td class="diff"><pre><code> -- Function: CORE_ADDR value_as_address (struct value *VAL)</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     Assuming that VAL is a pointer, return the address it represents,</code></pre></td>
        <td class="diff"><pre><code>     Assuming that VAL is a pointer, return the address it represents,</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     as appropriate for the current architecture.</code></pre></td>
        <td class="diff"><pre><code>     as appropriate for the current architecture.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     This function actually works on integral values, as well as</code></pre></td>
        <td class="diff"><pre><code>     This function actually works on integral values, as well as</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     pointers.  For pointers, it performs architecture-specific</code></pre></td>
        <td class="diff"><pre><code>     pointers.  For pointers, it performs architecture-specific</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     conversions as described above for `extract_typed_address'.</code></pre></td>
        <td class="diff"><pre><code>     conversions as described above for `extract_typed_address'.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code> -- Function: CORE_ADDR value_from_pointer (struct type *TYPE,</code></pre></td>
        <td class="diff"><pre><code> -- Function: CORE_ADDR value_from_pointer (struct type *TYPE,</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>          CORE_ADDR ADDR)</code></pre></td>
        <td class="diff"><pre><code>          CORE_ADDR ADDR)</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     Create and return a value representing a pointer of type TYPE to</code></pre></td>
        <td class="diff"><pre><code>     Create and return a value representing a pointer of type TYPE to</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     the address ADDR, as appropriate for the current architecture.</code></pre></td>
        <td class="diff"><pre><code>     the address ADDR, as appropriate for the current architecture.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     This function performs architecture-specific conversions as</code></pre></td>
        <td class="diff"><pre><code>     This function performs architecture-specific conversions as</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     described above for `store_typed_address'.</code></pre></td>
        <td class="diff"><pre><code>     described above for `store_typed_address'.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>   Here are two functions which architectures can define to indicate the</code></pre></td>
        <td class="diff"><pre><code>   Here are two functions which architectures can define to indicate the</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>relationship between pointers and addresses.  These have default</code></pre></td>
        <td class="diff"><pre><code>relationship between pointers and addresses.  These have default</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>definitions, appropriate for architectures on which all pointers are</code></pre></td>
        <td class="diff"><pre><code>definitions, appropriate for architectures on which all pointers are</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>simple unsigned byte addresses.</code></pre></td>
        <td class="diff"><pre><code>simple unsigned byte addresses.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code> -- Function: CORE_ADDR gdbarch_pointer_to_address (struct gdbarch</code></pre></td>
        <td class="diff"><pre><code> -- Function: CORE_ADDR gdbarch_pointer_to_address (struct gdbarch</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>          *CURRENT_GDBARCH, struct type *TYPE, char *BUF)</code></pre></td>
        <td class="diff"><pre><code>          *CURRENT_GDBARCH, struct type *TYPE, char *BUF)</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     Assume that BUF holds a pointer of type TYPE, in the appropriate</code></pre></td>
        <td class="diff"><pre><code>     Assume that BUF holds a pointer of type TYPE, in the appropriate</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     format for the current architecture.  Return the byte address the</code></pre></td>
        <td class="diff"><pre><code>     format for the current architecture.  Return the byte address the</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     pointer refers to.</code></pre></td>
        <td class="diff"><pre><code>     pointer refers to.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     This function may safely assume that TYPE is either a pointer or a</code></pre></td>
        <td class="diff"><pre><code>     This function may safely assume that TYPE is either a pointer or a</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     C++ reference type.</code></pre></td>
        <td class="diff"><pre><code>     C++ reference type.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code> -- Function: void gdbarch_address_to_pointer (struct gdbarch</code></pre></td>
        <td class="diff"><pre><code> -- Function: void gdbarch_address_to_pointer (struct gdbarch</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>          *CURRENT_GDBARCH, struct type *TYPE, char *BUF, CORE_ADDR</code></pre></td>
        <td class="diff"><pre><code>          *CURRENT_GDBARCH, struct type *TYPE, char *BUF, CORE_ADDR</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>          ADDR)</code></pre></td>
        <td class="diff"><pre><code>          ADDR)</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     Store in BUF a pointer of type TYPE representing the address ADDR,</code></pre></td>
        <td class="diff"><pre><code>     Store in BUF a pointer of type TYPE representing the address ADDR,</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     in the appropriate format for the current architecture.</code></pre></td>
        <td class="diff"><pre><code>     in the appropriate format for the current architecture.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     This function may safely assume that TYPE is either a pointer or a</code></pre></td>
        <td class="diff"><pre><code>     This function may safely assume that TYPE is either a pointer or a</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     C++ reference type.</code></pre></td>
        <td class="diff"><pre><code>     C++ reference type.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>   ---------- Footnotes ----------</code></pre></td>
        <td class="diff"><pre><code>   ---------- Footnotes ----------</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>   (1) Some D10V instructions are actually pairs of 16-bit</code></pre></td>
        <td class="diff"><pre><code>   (1) Some D10V instructions are actually pairs of 16-bit</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>sub-instructions.  However, since you can't jump into the middle of</code></pre></td>
        <td class="diff"><pre><code>sub-instructions.  However, since you can't jump into the middle of</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>such a pair, code addresses can only refer to full 32 bit instructions,</code></pre></td>
        <td class="diff"><pre><code>such a pair, code addresses can only refer to full 32 bit instructions,</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>which is what matters in this explanation.</code></pre></td>
        <td class="diff"><pre><code>which is what matters in this explanation.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>File: gdbint.info,  Node: Address Classes,  Next: Raw and Virtual Registers,  Prev: Pointers and Addresses,  Up: Target Architecture Definition</code></pre></td>
        <td class="diff"><pre><code>File: gdbint.info,  Node: Address Classes,  Next: Raw and Virtual Registers,  Prev: Pointers and Addresses,  Up: Target Architecture Definition</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>9.5 Address Classes</code></pre></td>
        <td class="diff"><pre><code>9.5 Address Classes</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>===================</code></pre></td>
        <td class="diff"><pre><code>===================</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>Sometimes information about different kinds of addresses is available</code></pre></td>
        <td class="diff"><pre><code>Sometimes information about different kinds of addresses is available</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>via the debug information.  For example, some programming environments</code></pre></td>
        <td class="diff"><pre><code>via the debug information.  For example, some programming environments</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>define addresses of several different sizes.  If the debug information</code></pre></td>
        <td class="diff"><pre><code>define addresses of several different sizes.  If the debug information</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>distinguishes these kinds of address classes through either the size</code></pre></td>
        <td class="diff"><pre><code>distinguishes these kinds of address classes through either the size</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>info (e.g, `DW_AT_byte_size' in DWARF 2) or through an explicit address</code></pre></td>
        <td class="diff"><pre><code>info (e.g, `DW_AT_byte_size' in DWARF 2) or through an explicit address</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>class attribute (e.g, `DW_AT_address_class' in DWARF 2), the following</code></pre></td>
        <td class="diff"><pre><code>class attribute (e.g, `DW_AT_address_class' in DWARF 2), the following</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>macros should be defined in order to disambiguate these types within</code></pre></td>
        <td class="diff"><pre><code>macros should be defined in order to disambiguate these types within</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>GDB as well as provide the added information to a GDB user when</code></pre></td>
        <td class="diff"><pre><code>GDB as well as provide the added information to a GDB user when</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>printing type expressions.</code></pre></td>
        <td class="diff"><pre><code>printing type expressions.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code> -- Function: int gdbarch_address_class_type_flags (struct gdbarch</code></pre></td>
        <td class="diff"><pre><code> -- Function: int gdbarch_address_class_type_flags (struct gdbarch</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>          *CURRENT_GDBARCH, int BYTE_SIZE, int DWARF2_ADDR_CLASS)</code></pre></td>
        <td class="diff"><pre><code>          *CURRENT_GDBARCH, int BYTE_SIZE, int DWARF2_ADDR_CLASS)</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     Returns the type flags needed to construct a pointer type whose</code></pre></td>
        <td class="diff"><pre><code>     Returns the type flags needed to construct a pointer type whose</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     size is BYTE_SIZE and whose address class is DWARF2_ADDR_CLASS.</code></pre></td>
        <td class="diff"><pre><code>     size is BYTE_SIZE and whose address class is DWARF2_ADDR_CLASS.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     This function is normally called from within a symbol reader.  See</code></pre></td>
        <td class="diff"><pre><code>     This function is normally called from within a symbol reader.  See</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     `dwarf2read.c'.</code></pre></td>
        <td class="diff"><pre><code>     `dwarf2read.c'.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code> -- Function: char *gdbarch_address_class_type_flags_to_name (struct</code></pre></td>
        <td class="diff"><pre><code> -- Function: char *gdbarch_address_class_type_flags_to_name (struct</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>          gdbarch *CURRENT_GDBARCH, int TYPE_FLAGS)</code></pre></td>
        <td class="diff"><pre><code>          gdbarch *CURRENT_GDBARCH, int TYPE_FLAGS)</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     Given the type flags representing an address class qualifier,</code></pre></td>
        <td class="diff"><pre><code>     Given the type flags representing an address class qualifier,</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     return its name.</code></pre></td>
        <td class="diff"><pre><code>     return its name.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code> -- Function: int gdbarch_address_class_name_to_type_flags (struct</code></pre></td>
        <td class="diff"><pre><code> -- Function: int gdbarch_address_class_name_to_type_flags (struct</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>          gdbarch *CURRENT_GDBARCH, int NAME, int *vartype_flags_ptr)</code></pre></td>
        <td class="diff"><pre><code>          gdbarch *CURRENT_GDBARCH, int NAME, int *vartype_flags_ptr)</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     Given an address qualifier name, set the `int' referenced by</code></pre></td>
        <td class="diff"><pre><code>     Given an address qualifier name, set the `int' referenced by</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     TYPE_FLAGS_PTR to the type flags for that address class qualifier.</code></pre></td>
        <td class="diff"><pre><code>     TYPE_FLAGS_PTR to the type flags for that address class qualifier.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>   Since the need for address classes is rather rare, none of the</code></pre></td>
        <td class="diff"><pre><code>   Since the need for address classes is rather rare, none of the</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>address class functions are defined by default.  Predicate functions</code></pre></td>
        <td class="diff"><pre><code>address class functions are defined by default.  Predicate functions</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>are provided to detect when they are defined.</code></pre></td>
        <td class="diff"><pre><code>are provided to detect when they are defined.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>   Consider a hypothetical architecture in which addresses are normally</code></pre></td>
        <td class="diff"><pre><code>   Consider a hypothetical architecture in which addresses are normally</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>32-bits wide, but 16-bit addresses are also supported.  Furthermore,</code></pre></td>
        <td class="diff"><pre><code>32-bits wide, but 16-bit addresses are also supported.  Furthermore,</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>suppose that the DWARF 2 information for this architecture simply uses</code></pre></td>
        <td class="diff"><pre><code>suppose that the DWARF 2 information for this architecture simply uses</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>a `DW_AT_byte_size' value of 2 to indicate the use of one of these</code></pre></td>
        <td class="diff"><pre><code>a `DW_AT_byte_size' value of 2 to indicate the use of one of these</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>"short" pointers.  The following functions could be defined to</code></pre></td>
        <td class="diff"><pre><code>"short" pointers.  The following functions could be defined to</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>implement the address class functions:</code></pre></td>
        <td class="diff"><pre><code>implement the address class functions:</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     somearch_address_class_type_flags (int byte_size,</code></pre></td>
        <td class="diff"><pre><code>     somearch_address_class_type_flags (int byte_size,</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>                                        int dwarf2_addr_class)</code></pre></td>
        <td class="diff"><pre><code>                                        int dwarf2_addr_class)</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     {</code></pre></td>
        <td class="diff"><pre><code>     {</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>       if (byte_size == 2)</code></pre></td>
        <td class="diff"><pre><code>       if (byte_size == 2)</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>         return TYPE_FLAG_ADDRESS_CLASS_1;</code></pre></td>
        <td class="diff"><pre><code>         return TYPE_FLAG_ADDRESS_CLASS_1;</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>       else</code></pre></td>
        <td class="diff"><pre><code>       else</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>         return 0;</code></pre></td>
        <td class="diff"><pre><code>         return 0;</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     }</code></pre></td>
        <td class="diff"><pre><code>     }</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     static char *</code></pre></td>
        <td class="diff"><pre><code>     static char *</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     somearch_address_class_type_flags_to_name (int type_flags)</code></pre></td>
        <td class="diff"><pre><code>     somearch_address_class_type_flags_to_name (int type_flags)</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     {</code></pre></td>
        <td class="diff"><pre><code>     {</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>       if (type_flags & TYPE_FLAG_ADDRESS_CLASS_1)</code></pre></td>
        <td class="diff"><pre><code>       if (type_flags & TYPE_FLAG_ADDRESS_CLASS_1)</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>         return "short";</code></pre></td>
        <td class="diff"><pre><code>         return "short";</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>       else</code></pre></td>
        <td class="diff"><pre><code>       else</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>         return NULL;</code></pre></td>
        <td class="diff"><pre><code>         return NULL;</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     }</code></pre></td>
        <td class="diff"><pre><code>     }</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     int</code></pre></td>
        <td class="diff"><pre><code>     int</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     somearch_address_class_name_to_type_flags (char *name,</code></pre></td>
        <td class="diff"><pre><code>     somearch_address_class_name_to_type_flags (char *name,</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>                                                int *type_flags_ptr)</code></pre></td>
        <td class="diff"><pre><code>                                                int *type_flags_ptr)</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     {</code></pre></td>
        <td class="diff"><pre><code>     {</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>       if (strcmp (name, "short") == 0)</code></pre></td>
        <td class="diff"><pre><code>       if (strcmp (name, "short") == 0)</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>         {</code></pre></td>
        <td class="diff"><pre><code>         {</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>           *type_flags_ptr = TYPE_FLAG_ADDRESS_CLASS_1;</code></pre></td>
        <td class="diff"><pre><code>           *type_flags_ptr = TYPE_FLAG_ADDRESS_CLASS_1;</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>           return 1;</code></pre></td>
        <td class="diff"><pre><code>           return 1;</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>         }</code></pre></td>
        <td class="diff"><pre><code>         }</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>       else</code></pre></td>
        <td class="diff"><pre><code>       else</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>         return 0;</code></pre></td>
        <td class="diff"><pre><code>         return 0;</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     }</code></pre></td>
        <td class="diff"><pre><code>     }</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>   The qualifier `@short' is used in GDB's type expressions to indicate</code></pre></td>
        <td class="diff"><pre><code>   The qualifier `@short' is used in GDB's type expressions to indicate</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>the presence of one of these "short" pointers.  E.g, if the debug</code></pre></td>
        <td class="diff"><pre><code>the presence of one of these "short" pointers.  E.g, if the debug</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>information indicates that `short_ptr_var' is one of these short</code></pre></td>
        <td class="diff"><pre><code>information indicates that `short_ptr_var' is one of these short</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>pointers, GDB might show the following behavior:</code></pre></td>
        <td class="diff"><pre><code>pointers, GDB might show the following behavior:</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     (gdb) ptype short_ptr_var</code></pre></td>
        <td class="diff"><pre><code>     (gdb) ptype short_ptr_var</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     type = int * @short</code></pre></td>
        <td class="diff"><pre><code>     type = int * @short</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>File: gdbint.info,  Node: Raw and Virtual Registers,  Next: Register and Memory Data,  Prev: Address Classes,  Up: Target Architecture Definition</code></pre></td>
        <td class="diff"><pre><code>File: gdbint.info,  Node: Raw and Virtual Registers,  Next: Register and Memory Data,  Prev: Address Classes,  Up: Target Architecture Definition</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>9.6 Raw and Virtual Register Representations</code></pre></td>
        <td class="diff"><pre><code>9.6 Raw and Virtual Register Representations</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>============================================</code></pre></td>
        <td class="diff"><pre><code>============================================</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>_Maintainer note: This section is pretty much obsolete.  The</code></pre></td>
        <td class="diff"><pre><code>_Maintainer note: This section is pretty much obsolete.  The</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>functionality described here has largely been replaced by</code></pre></td>
        <td class="diff"><pre><code>functionality described here has largely been replaced by</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>pseudo-registers and the mechanisms described in *Note Using Different</code></pre></td>
        <td class="diff"><pre><code>pseudo-registers and the mechanisms described in *Note Using Different</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>Register and Memory Data Representations: Target Architecture</code></pre></td>
        <td class="diff"><pre><code>Register and Memory Data Representations: Target Architecture</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>Definition.  See also Bug Tracking Database</code></pre></td>
        <td class="diff"><pre><code>Definition.  See also Bug Tracking Database</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>(http://www.gnu.org/software/gdb/bugs/) and ARI Index</code></pre></td>
        <td class="diff"><pre><code>(http://www.gnu.org/software/gdb/bugs/) and ARI Index</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>(http://sources.redhat.com/gdb/current/ari/) for more up-to-date</code></pre></td>
        <td class="diff"><pre><code>(http://sources.redhat.com/gdb/current/ari/) for more up-to-date</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>information._</code></pre></td>
        <td class="diff"><pre><code>information._</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>   Some architectures use one representation for a value when it lives</code></pre></td>
        <td class="diff"><pre><code>   Some architectures use one representation for a value when it lives</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>in a register, but use a different representation when it lives in</code></pre></td>
        <td class="diff"><pre><code>in a register, but use a different representation when it lives in</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>memory.  In GDB's terminology, the "raw" representation is the one used</code></pre></td>
        <td class="diff"><pre><code>memory.  In GDB's terminology, the "raw" representation is the one used</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>in the target registers, and the "virtual" representation is the one</code></pre></td>
        <td class="diff"><pre><code>in the target registers, and the "virtual" representation is the one</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>used in memory, and within GDB `struct value' objects.</code></pre></td>
        <td class="diff"><pre><code>used in memory, and within GDB `struct value' objects.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>   _Maintainer note: Notice that the same mechanism is being used to</code></pre></td>
        <td class="diff"><pre><code>   _Maintainer note: Notice that the same mechanism is being used to</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>both convert a register to a `struct value' and alternative register</code></pre></td>
        <td class="diff"><pre><code>both convert a register to a `struct value' and alternative register</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>forms._</code></pre></td>
        <td class="diff"><pre><code>forms._</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>   For almost all data types on almost all architectures, the virtual</code></pre></td>
        <td class="diff"><pre><code>   For almost all data types on almost all architectures, the virtual</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>and raw representations are identical, and no special handling is</code></pre></td>
        <td class="diff"><pre><code>and raw representations are identical, and no special handling is</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>needed.  However, they do occasionally differ.  For example:</code></pre></td>
        <td class="diff"><pre><code>needed.  However, they do occasionally differ.  For example:</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>   * The x86 architecture supports an 80-bit `long double' type.</code></pre></td>
        <td class="diff"><pre><code>   * The x86 architecture supports an 80-bit `long double' type.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     However, when we store those values in memory, they occupy twelve</code></pre></td>
        <td class="diff"><pre><code>     However, when we store those values in memory, they occupy twelve</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     bytes: the floating-point number occupies the first ten, and the</code></pre></td>
        <td class="diff"><pre><code>     bytes: the floating-point number occupies the first ten, and the</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     final two bytes are unused.  This keeps the values aligned on</code></pre></td>
        <td class="diff"><pre><code>     final two bytes are unused.  This keeps the values aligned on</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     four-byte boundaries, allowing more efficient access.  Thus, the</code></pre></td>
        <td class="diff"><pre><code>     four-byte boundaries, allowing more efficient access.  Thus, the</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     x86 80-bit floating-point type is the raw representation, and the</code></pre></td>
        <td class="diff"><pre><code>     x86 80-bit floating-point type is the raw representation, and the</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     twelve-byte loosely-packed arrangement is the virtual</code></pre></td>
        <td class="diff"><pre><code>     twelve-byte loosely-packed arrangement is the virtual</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     representation.</code></pre></td>
        <td class="diff"><pre><code>     representation.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>   * Some 64-bit MIPS targets present 32-bit registers to GDB as 64-bit</code></pre></td>
        <td class="diff"><pre><code>   * Some 64-bit MIPS targets present 32-bit registers to GDB as 64-bit</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     registers, with garbage in their upper bits.  GDB ignores the top</code></pre></td>
        <td class="diff"><pre><code>     registers, with garbage in their upper bits.  GDB ignores the top</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     32 bits.  Thus, the 64-bit form, with garbage in the upper 32</code></pre></td>
        <td class="diff"><pre><code>     32 bits.  Thus, the 64-bit form, with garbage in the upper 32</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     bits, is the raw representation, and the trimmed 32-bit</code></pre></td>
        <td class="diff"><pre><code>     bits, is the raw representation, and the trimmed 32-bit</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     representation is the virtual representation.</code></pre></td>
        <td class="diff"><pre><code>     representation is the virtual representation.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>   In general, the raw representation is determined by the</code></pre></td>
        <td class="diff"><pre><code>   In general, the raw representation is determined by the</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>architecture, or GDB's interface to the architecture, while the virtual</code></pre></td>
        <td class="diff"><pre><code>architecture, or GDB's interface to the architecture, while the virtual</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>representation can be chosen for GDB's convenience.  GDB's register</code></pre></td>
        <td class="diff"><pre><code>representation can be chosen for GDB's convenience.  GDB's register</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>file, `registers', holds the register contents in raw format, and the</code></pre></td>
        <td class="diff"><pre><code>file, `registers', holds the register contents in raw format, and the</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>GDB remote protocol transmits register values in raw format.</code></pre></td>
        <td class="diff"><pre><code>GDB remote protocol transmits register values in raw format.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>   Your architecture may define the following macros to request</code></pre></td>
        <td class="diff"><pre><code>   Your architecture may define the following macros to request</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>conversions between the raw and virtual format:</code></pre></td>
        <td class="diff"><pre><code>conversions between the raw and virtual format:</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code> -- Target Macro: int REGISTER_CONVERTIBLE (int REG)</code></pre></td>
        <td class="diff"><pre><code> -- Target Macro: int REGISTER_CONVERTIBLE (int REG)</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     Return non-zero if register number REG's value needs different raw</code></pre></td>
        <td class="diff"><pre><code>     Return non-zero if register number REG's value needs different raw</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     and virtual formats.</code></pre></td>
        <td class="diff"><pre><code>     and virtual formats.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     You should not use `REGISTER_CONVERT_TO_VIRTUAL' for a register</code></pre></td>
        <td class="diff"><pre><code>     You should not use `REGISTER_CONVERT_TO_VIRTUAL' for a register</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     unless this macro returns a non-zero value for that register.</code></pre></td>
        <td class="diff"><pre><code>     unless this macro returns a non-zero value for that register.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code> -- Target Macro: int DEPRECATED_REGISTER_RAW_SIZE (int REG)</code></pre></td>
        <td class="diff"><pre><code> -- Target Macro: int DEPRECATED_REGISTER_RAW_SIZE (int REG)</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     The size of register number REG's raw value.  This is the number</code></pre></td>
        <td class="diff"><pre><code>     The size of register number REG's raw value.  This is the number</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     of bytes the register will occupy in `registers', or in a GDB</code></pre></td>
        <td class="diff"><pre><code>     of bytes the register will occupy in `registers', or in a GDB</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     remote protocol packet.</code></pre></td>
        <td class="diff"><pre><code>     remote protocol packet.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code> -- Target Macro: int DEPRECATED_REGISTER_VIRTUAL_SIZE (int REG)</code></pre></td>
        <td class="diff"><pre><code> -- Target Macro: int DEPRECATED_REGISTER_VIRTUAL_SIZE (int REG)</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     The size of register number REG's value, in its virtual format.</code></pre></td>
        <td class="diff"><pre><code>     The size of register number REG's value, in its virtual format.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     This is the size a `struct value''s buffer will have, holding that</code></pre></td>
        <td class="diff"><pre><code>     This is the size a `struct value''s buffer will have, holding that</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     register's value.</code></pre></td>
        <td class="diff"><pre><code>     register's value.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code> -- Target Macro: struct type *DEPRECATED_REGISTER_VIRTUAL_TYPE (int</code></pre></td>
        <td class="diff"><pre><code> -- Target Macro: struct type *DEPRECATED_REGISTER_VIRTUAL_TYPE (int</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>          REG)</code></pre></td>
        <td class="diff"><pre><code>          REG)</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     This is the type of the virtual representation of register number</code></pre></td>
        <td class="diff"><pre><code>     This is the type of the virtual representation of register number</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     REG.  Note that there is no need for a macro giving a type for the</code></pre></td>
        <td class="diff"><pre><code>     REG.  Note that there is no need for a macro giving a type for the</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     register's raw form; once the register's value has been obtained,</code></pre></td>
        <td class="diff"><pre><code>     register's raw form; once the register's value has been obtained,</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     GDB always uses the virtual form.</code></pre></td>
        <td class="diff"><pre><code>     GDB always uses the virtual form.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code> -- Target Macro: void REGISTER_CONVERT_TO_VIRTUAL (int REG, struct</code></pre></td>
        <td class="diff"><pre><code> -- Target Macro: void REGISTER_CONVERT_TO_VIRTUAL (int REG, struct</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>          type *TYPE, char *FROM, char *TO)</code></pre></td>
        <td class="diff"><pre><code>          type *TYPE, char *FROM, char *TO)</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     Convert the value of register number REG to TYPE, which should</code></pre></td>
        <td class="diff"><pre><code>     Convert the value of register number REG to TYPE, which should</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     always be `DEPRECATED_REGISTER_VIRTUAL_TYPE (REG)'.  The buffer at</code></pre></td>
        <td class="diff"><pre><code>     always be `DEPRECATED_REGISTER_VIRTUAL_TYPE (REG)'.  The buffer at</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     FROM holds the register's value in raw format; the macro should</code></pre></td>
        <td class="diff"><pre><code>     FROM holds the register's value in raw format; the macro should</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     convert the value to virtual format, and place it at TO.</code></pre></td>
        <td class="diff"><pre><code>     convert the value to virtual format, and place it at TO.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     Note that `REGISTER_CONVERT_TO_VIRTUAL' and</code></pre></td>
        <td class="diff"><pre><code>     Note that `REGISTER_CONVERT_TO_VIRTUAL' and</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     `REGISTER_CONVERT_TO_RAW' take their REG and TYPE arguments in</code></pre></td>
        <td class="diff"><pre><code>     `REGISTER_CONVERT_TO_RAW' take their REG and TYPE arguments in</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     different orders.</code></pre></td>
        <td class="diff"><pre><code>     different orders.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     You should only use `REGISTER_CONVERT_TO_VIRTUAL' with registers</code></pre></td>
        <td class="diff"><pre><code>     You should only use `REGISTER_CONVERT_TO_VIRTUAL' with registers</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     for which the `REGISTER_CONVERTIBLE' macro returns a non-zero</code></pre></td>
        <td class="diff"><pre><code>     for which the `REGISTER_CONVERTIBLE' macro returns a non-zero</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     value.</code></pre></td>
        <td class="diff"><pre><code>     value.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code> -- Target Macro: void REGISTER_CONVERT_TO_RAW (struct type *TYPE, int</code></pre></td>
        <td class="diff"><pre><code> -- Target Macro: void REGISTER_CONVERT_TO_RAW (struct type *TYPE, int</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>          REG, char *FROM, char *TO)</code></pre></td>
        <td class="diff"><pre><code>          REG, char *FROM, char *TO)</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     Convert the value of register number REG to TYPE, which should</code></pre></td>
        <td class="diff"><pre><code>     Convert the value of register number REG to TYPE, which should</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     always be `DEPRECATED_REGISTER_VIRTUAL_TYPE (REG)'.  The buffer at</code></pre></td>
        <td class="diff"><pre><code>     always be `DEPRECATED_REGISTER_VIRTUAL_TYPE (REG)'.  The buffer at</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     FROM holds the register's value in raw format; the macro should</code></pre></td>
        <td class="diff"><pre><code>     FROM holds the register's value in raw format; the macro should</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     convert the value to virtual format, and place it at TO.</code></pre></td>
        <td class="diff"><pre><code>     convert the value to virtual format, and place it at TO.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     Note that REGISTER_CONVERT_TO_VIRTUAL and REGISTER_CONVERT_TO_RAW</code></pre></td>
        <td class="diff"><pre><code>     Note that REGISTER_CONVERT_TO_VIRTUAL and REGISTER_CONVERT_TO_RAW</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     take their REG and TYPE arguments in different orders.</code></pre></td>
        <td class="diff"><pre><code>     take their REG and TYPE arguments in different orders.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>File: gdbint.info,  Node: Register and Memory Data,  Next: Frame Interpretation,  Prev: Raw and Virtual Registers,  Up: Target Architecture Definition</code></pre></td>
        <td class="diff"><pre><code>File: gdbint.info,  Node: Register and Memory Data,  Next: Frame Interpretation,  Prev: Raw and Virtual Registers,  Up: Target Architecture Definition</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>9.7 Using Different Register and Memory Data Representations</code></pre></td>
        <td class="diff"><pre><code>9.7 Using Different Register and Memory Data Representations</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>============================================================</code></pre></td>
        <td class="diff"><pre><code>============================================================</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>_Maintainer's note: The way GDB manipulates registers is undergoing</code></pre></td>
        <td class="diff"><pre><code>_Maintainer's note: The way GDB manipulates registers is undergoing</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>significant change.  Many of the macros and functions referred to in</code></pre></td>
        <td class="diff"><pre><code>significant change.  Many of the macros and functions referred to in</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>this section are likely to be subject to further revision.  See A.R.</code></pre></td>
        <td class="diff"><pre><code>this section are likely to be subject to further revision.  See A.R.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>Index (http://sources.redhat.com/gdb/current/ari/) and Bug Tracking</code></pre></td>
        <td class="diff"><pre><code>Index (http://sources.redhat.com/gdb/current/ari/) and Bug Tracking</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>Database (http://www.gnu.org/software/gdb/bugs) for further</code></pre></td>
        <td class="diff"><pre><code>Database (http://www.gnu.org/software/gdb/bugs) for further</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>information.  cagney/2002-05-06._</code></pre></td>
        <td class="diff"><pre><code>information.  cagney/2002-05-06._</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>   Some architectures can represent a data object in a register using a</code></pre></td>
        <td class="diff"><pre><code>   Some architectures can represent a data object in a register using a</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>form that is different to the objects more normal memory representation.</code></pre></td>
        <td class="diff"><pre><code>form that is different to the objects more normal memory representation.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>For example:</code></pre></td>
        <td class="diff"><pre><code>For example:</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>   * The Alpha architecture can represent 32 bit integer values in</code></pre></td>
        <td class="diff"><pre><code>   * The Alpha architecture can represent 32 bit integer values in</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     floating-point registers.</code></pre></td>
        <td class="diff"><pre><code>     floating-point registers.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>   * The x86 architecture supports 80-bit floating-point registers.  The</code></pre></td>
        <td class="diff"><pre><code>   * The x86 architecture supports 80-bit floating-point registers.  The</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     `long double' data type occupies 96 bits in memory but only 80 bits</code></pre></td>
        <td class="diff"><pre><code>     `long double' data type occupies 96 bits in memory but only 80 bits</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     when stored in a register.</code></pre></td>
        <td class="diff"><pre><code>     when stored in a register.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>   In general, the register representation of a data type is determined</code></pre></td>
        <td class="diff"><pre><code>   In general, the register representation of a data type is determined</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>by the architecture, or GDB's interface to the architecture, while the</code></pre></td>
        <td class="diff"><pre><code>by the architecture, or GDB's interface to the architecture, while the</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>memory representation is determined by the Application Binary Interface.</code></pre></td>
        <td class="diff"><pre><code>memory representation is determined by the Application Binary Interface.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>   For almost all data types on almost all architectures, the two</code></pre></td>
        <td class="diff"><pre><code>   For almost all data types on almost all architectures, the two</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>representations are identical, and no special handling is needed.</code></pre></td>
        <td class="diff"><pre><code>representations are identical, and no special handling is needed.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>However, they do occasionally differ.  Your architecture may define the</code></pre></td>
        <td class="diff"><pre><code>However, they do occasionally differ.  Your architecture may define the</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>following macros to request conversions between the register and memory</code></pre></td>
        <td class="diff"><pre><code>following macros to request conversions between the register and memory</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>representations of a data type:</code></pre></td>
        <td class="diff"><pre><code>representations of a data type:</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code> -- Function: int gdbarch_convert_register_p (struct gdbarch *GDBARCH,</code></pre></td>
        <td class="diff"><pre><code> -- Function: int gdbarch_convert_register_p (struct gdbarch *GDBARCH,</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>          int REG)</code></pre></td>
        <td class="diff"><pre><code>          int REG)</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     Return non-zero if the representation of a data value stored in</code></pre></td>
        <td class="diff"><pre><code>     Return non-zero if the representation of a data value stored in</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     this register may be different to the representation of that same</code></pre></td>
        <td class="diff"><pre><code>     this register may be different to the representation of that same</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     data value when stored in memory.</code></pre></td>
        <td class="diff"><pre><code>     data value when stored in memory.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     When non-zero, the macros `gdbarch_register_to_value' and</code></pre></td>
        <td class="diff"><pre><code>     When non-zero, the macros `gdbarch_register_to_value' and</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     `value_to_register' are used to perform any necessary conversion.</code></pre></td>
        <td class="diff"><pre><code>     `value_to_register' are used to perform any necessary conversion.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     This function should return zero for the register's native type,</code></pre></td>
        <td class="diff"><pre><code>     This function should return zero for the register's native type,</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     when no conversion is necessary.</code></pre></td>
        <td class="diff"><pre><code>     when no conversion is necessary.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code> -- Function: void gdbarch_register_to_value (struct gdbarch *GDBARCH,</code></pre></td>
        <td class="diff"><pre><code> -- Function: void gdbarch_register_to_value (struct gdbarch *GDBARCH,</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>          int REG, struct type *TYPE, char *FROM, char *TO)</code></pre></td>
        <td class="diff"><pre><code>          int REG, struct type *TYPE, char *FROM, char *TO)</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     Convert the value of register number REG to a data object of type</code></pre></td>
        <td class="diff"><pre><code>     Convert the value of register number REG to a data object of type</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     TYPE.  The buffer at FROM holds the register's value in raw</code></pre></td>
        <td class="diff"><pre><code>     TYPE.  The buffer at FROM holds the register's value in raw</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     format; the converted value should be placed in the buffer at TO.</code></pre></td>
        <td class="diff"><pre><code>     format; the converted value should be placed in the buffer at TO.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     Note that `gdbarch_register_to_value' and</code></pre></td>
        <td class="diff"><pre><code>     Note that `gdbarch_register_to_value' and</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     `gdbarch_value_to_register' take their REG and TYPE arguments in</code></pre></td>
        <td class="diff"><pre><code>     `gdbarch_value_to_register' take their REG and TYPE arguments in</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     different orders.</code></pre></td>
        <td class="diff"><pre><code>     different orders.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     You should only use `gdbarch_register_to_value' with registers for</code></pre></td>
        <td class="diff"><pre><code>     You should only use `gdbarch_register_to_value' with registers for</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     which the `gdbarch_convert_register_p' function returns a non-zero</code></pre></td>
        <td class="diff"><pre><code>     which the `gdbarch_convert_register_p' function returns a non-zero</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     value.</code></pre></td>
        <td class="diff"><pre><code>     value.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code> -- Function: void gdbarch_value_to_register (struct gdbarch *GDBARCH,</code></pre></td>
        <td class="diff"><pre><code> -- Function: void gdbarch_value_to_register (struct gdbarch *GDBARCH,</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>          struct type *TYPE, int REG, char *FROM, char *TO)</code></pre></td>
        <td class="diff"><pre><code>          struct type *TYPE, int REG, char *FROM, char *TO)</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     Convert a data value of type TYPE to register number REG' raw</code></pre></td>
        <td class="diff"><pre><code>     Convert a data value of type TYPE to register number REG' raw</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     format.</code></pre></td>
        <td class="diff"><pre><code>     format.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     Note that `gdbarch_register_to_value' and</code></pre></td>
        <td class="diff"><pre><code>     Note that `gdbarch_register_to_value' and</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     `gdbarch_value_to_register' take their REG and TYPE arguments in</code></pre></td>
        <td class="diff"><pre><code>     `gdbarch_value_to_register' take their REG and TYPE arguments in</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     different orders.</code></pre></td>
        <td class="diff"><pre><code>     different orders.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     You should only use `gdbarch_value_to_register' with registers for</code></pre></td>
        <td class="diff"><pre><code>     You should only use `gdbarch_value_to_register' with registers for</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     which the `gdbarch_convert_register_p' function returns a non-zero</code></pre></td>
        <td class="diff"><pre><code>     which the `gdbarch_convert_register_p' function returns a non-zero</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     value.</code></pre></td>
        <td class="diff"><pre><code>     value.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code> -- Target Macro: void REGISTER_CONVERT_TO_TYPE (int REGNUM, struct</code></pre></td>
        <td class="diff"><pre><code> -- Target Macro: void REGISTER_CONVERT_TO_TYPE (int REGNUM, struct</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>          type *TYPE, char *BUF)</code></pre></td>
        <td class="diff"><pre><code>          type *TYPE, char *BUF)</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     See `mips-tdep.c'.  It does not do what you want.</code></pre></td>
        <td class="diff"><pre><code>     See `mips-tdep.c'.  It does not do what you want.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>File: gdbint.info,  Node: Frame Interpretation,  Next: Inferior Call Setup,  Prev: Register and Memory Data,  Up: Target Architecture Definition</code></pre></td>
        <td class="diff"><pre><code>File: gdbint.info,  Node: Frame Interpretation,  Next: Inferior Call Setup,  Prev: Register and Memory Data,  Up: Target Architecture Definition</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>9.8 Frame Interpretation</code></pre></td>
        <td class="diff"><pre><code>9.8 Frame Interpretation</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>========================</code></pre></td>
        <td class="diff"><pre><code>========================</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>File: gdbint.info,  Node: Inferior Call Setup,  Next: Compiler Characteristics,  Prev: Frame Interpretation,  Up: Target Architecture Definition</code></pre></td>
        <td class="diff"><pre><code>File: gdbint.info,  Node: Inferior Call Setup,  Next: Compiler Characteristics,  Prev: Frame Interpretation,  Up: Target Architecture Definition</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>9.9 Inferior Call Setup</code></pre></td>
        <td class="diff"><pre><code>9.9 Inferior Call Setup</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>=======================</code></pre></td>
        <td class="diff"><pre><code>=======================</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>File: gdbint.info,  Node: Compiler Characteristics,  Next: Target Conditionals,  Prev: Inferior Call Setup,  Up: Target Architecture Definition</code></pre></td>
        <td class="diff"><pre><code>File: gdbint.info,  Node: Compiler Characteristics,  Next: Target Conditionals,  Prev: Inferior Call Setup,  Up: Target Architecture Definition</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>9.10 Compiler Characteristics</code></pre></td>
        <td class="diff"><pre><code>9.10 Compiler Characteristics</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>=============================</code></pre></td>
        <td class="diff"><pre><code>=============================</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>File: gdbint.info,  Node: Target Conditionals,  Next: Adding a New Target,  Prev: Compiler Characteristics,  Up: Target Architecture Definition</code></pre></td>
        <td class="diff"><pre><code>File: gdbint.info,  Node: Target Conditionals,  Next: Adding a New Target,  Prev: Compiler Characteristics,  Up: Target Architecture Definition</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>9.11 Target Conditionals</code></pre></td>
        <td class="diff"><pre><code>9.11 Target Conditionals</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>========================</code></pre></td>
        <td class="diff"><pre><code>========================</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>This section describes the macros and functions that you can use to</code></pre></td>
        <td class="diff"><pre><code>This section describes the macros and functions that you can use to</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>define the target machine.</code></pre></td>
        <td class="diff"><pre><code>define the target machine.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>`CORE_ADDR gdbarch_addr_bits_remove (GDBARCH, ADDR)'</code></pre></td>
        <td class="diff"><pre><code>`CORE_ADDR gdbarch_addr_bits_remove (GDBARCH, ADDR)'</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     If a raw machine instruction address includes any bits that are not</code></pre></td>
        <td class="diff"><pre><code>     If a raw machine instruction address includes any bits that are not</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     really part of the address, then this function is used to zero</code></pre></td>
        <td class="diff"><pre><code>     really part of the address, then this function is used to zero</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     those bits in ADDR.  This is only used for addresses of</code></pre></td>
        <td class="diff"><pre><code>     those bits in ADDR.  This is only used for addresses of</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     instructions, and even then not in all contexts.</code></pre></td>
        <td class="diff"><pre><code>     instructions, and even then not in all contexts.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     For example, the two low-order bits of the PC on the</code></pre></td>
        <td class="diff"><pre><code>     For example, the two low-order bits of the PC on the</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     Hewlett-Packard PA 2.0 architecture contain the privilege level of</code></pre></td>
        <td class="diff"><pre><code>     Hewlett-Packard PA 2.0 architecture contain the privilege level of</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     the corresponding instruction.  Since instructions must always be</code></pre></td>
        <td class="diff"><pre><code>     the corresponding instruction.  Since instructions must always be</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     aligned on four-byte boundaries, the processor masks out these</code></pre></td>
        <td class="diff"><pre><code>     aligned on four-byte boundaries, the processor masks out these</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     bits to generate the actual address of the instruction.</code></pre></td>
        <td class="diff"><pre><code>     bits to generate the actual address of the instruction.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     `gdbarch_addr_bits_remove' would then for example look like that:</code></pre></td>
        <td class="diff"><pre><code>     `gdbarch_addr_bits_remove' would then for example look like that:</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>          arch_addr_bits_remove (CORE_ADDR addr)</code></pre></td>
        <td class="diff"><pre><code>          arch_addr_bits_remove (CORE_ADDR addr)</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>          {</code></pre></td>
        <td class="diff"><pre><code>          {</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>            return (addr &= ~0x3);</code></pre></td>
        <td class="diff"><pre><code>            return (addr &= ~0x3);</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>          }</code></pre></td>
        <td class="diff"><pre><code>          }</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>`int address_class_name_to_type_flags (GDBARCH, NAME, TYPE_FLAGS_PTR)'</code></pre></td>
        <td class="diff"><pre><code>`int address_class_name_to_type_flags (GDBARCH, NAME, TYPE_FLAGS_PTR)'</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     If NAME is a valid address class qualifier name, set the `int'</code></pre></td>
        <td class="diff"><pre><code>     If NAME is a valid address class qualifier name, set the `int'</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     referenced by TYPE_FLAGS_PTR to the mask representing the qualifier</code></pre></td>
        <td class="diff"><pre><code>     referenced by TYPE_FLAGS_PTR to the mask representing the qualifier</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     and return 1.  If NAME is not a valid address class qualifier name,</code></pre></td>
        <td class="diff"><pre><code>     and return 1.  If NAME is not a valid address class qualifier name,</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     return 0.</code></pre></td>
        <td class="diff"><pre><code>     return 0.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     The value for TYPE_FLAGS_PTR should be one of</code></pre></td>
        <td class="diff"><pre><code>     The value for TYPE_FLAGS_PTR should be one of</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     `TYPE_FLAG_ADDRESS_CLASS_1', `TYPE_FLAG_ADDRESS_CLASS_2', or</code></pre></td>
        <td class="diff"><pre><code>     `TYPE_FLAG_ADDRESS_CLASS_1', `TYPE_FLAG_ADDRESS_CLASS_2', or</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     possibly some combination of these values or'd together.  *Note</code></pre></td>
        <td class="diff"><pre><code>     possibly some combination of these values or'd together.  *Note</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     Address Classes: Target Architecture Definition.</code></pre></td>
        <td class="diff"><pre><code>     Address Classes: Target Architecture Definition.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>`int address_class_name_to_type_flags_p (GDBARCH)'</code></pre></td>
        <td class="diff"><pre><code>`int address_class_name_to_type_flags_p (GDBARCH)'</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     Predicate which indicates whether</code></pre></td>
        <td class="diff"><pre><code>     Predicate which indicates whether</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     `address_class_name_to_type_flags' has been defined.</code></pre></td>
        <td class="diff"><pre><code>     `address_class_name_to_type_flags' has been defined.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>`int gdbarch_address_class_type_flags (GDBARCH, BYTE_SIZE, DWARF2_ADDR_CLASS)'</code></pre></td>
        <td class="diff"><pre><code>`int gdbarch_address_class_type_flags (GDBARCH, BYTE_SIZE, DWARF2_ADDR_CLASS)'</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     Given a pointers byte size (as described by the debug information)</code></pre></td>
        <td class="diff"><pre><code>     Given a pointers byte size (as described by the debug information)</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     and the possible `DW_AT_address_class' value, return the type flags</code></pre></td>
        <td class="diff"><pre><code>     and the possible `DW_AT_address_class' value, return the type flags</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     used by GDB to represent this address class.  The value returned</code></pre></td>
        <td class="diff"><pre><code>     used by GDB to represent this address class.  The value returned</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     should be one of `TYPE_FLAG_ADDRESS_CLASS_1',</code></pre></td>
        <td class="diff"><pre><code>     should be one of `TYPE_FLAG_ADDRESS_CLASS_1',</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     `TYPE_FLAG_ADDRESS_CLASS_2', or possibly some combination of these</code></pre></td>
        <td class="diff"><pre><code>     `TYPE_FLAG_ADDRESS_CLASS_2', or possibly some combination of these</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     values or'd together.  *Note Address Classes: Target Architecture</code></pre></td>
        <td class="diff"><pre><code>     values or'd together.  *Note Address Classes: Target Architecture</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     Definition.</code></pre></td>
        <td class="diff"><pre><code>     Definition.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>`int gdbarch_address_class_type_flags_p (GDBARCH)'</code></pre></td>
        <td class="diff"><pre><code>`int gdbarch_address_class_type_flags_p (GDBARCH)'</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     Predicate which indicates whether</code></pre></td>
        <td class="diff"><pre><code>     Predicate which indicates whether</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     `gdbarch_address_class_type_flags_p' has been defined.</code></pre></td>
        <td class="diff"><pre><code>     `gdbarch_address_class_type_flags_p' has been defined.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>`const char *gdbarch_address_class_type_flags_to_name (GDBARCH, TYPE_FLAGS)'</code></pre></td>
        <td class="diff"><pre><code>`const char *gdbarch_address_class_type_flags_to_name (GDBARCH, TYPE_FLAGS)'</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     Return the name of the address class qualifier associated with the</code></pre></td>
        <td class="diff"><pre><code>     Return the name of the address class qualifier associated with the</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     type flags given by TYPE_FLAGS.</code></pre></td>
        <td class="diff"><pre><code>     type flags given by TYPE_FLAGS.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>`int gdbarch_address_class_type_flags_to_name_p (GDBARCH)'</code></pre></td>
        <td class="diff"><pre><code>`int gdbarch_address_class_type_flags_to_name_p (GDBARCH)'</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     Predicate which indicates whether</code></pre></td>
        <td class="diff"><pre><code>     Predicate which indicates whether</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     `gdbarch_address_class_type_flags_to_name' has been defined.</code></pre></td>
        <td class="diff"><pre><code>     `gdbarch_address_class_type_flags_to_name' has been defined.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     *Note Address Classes: Target Architecture Definition.</code></pre></td>
        <td class="diff"><pre><code>     *Note Address Classes: Target Architecture Definition.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>`void gdbarch_address_to_pointer (GDBARCH, TYPE, BUF, ADDR)'</code></pre></td>
        <td class="diff"><pre><code>`void gdbarch_address_to_pointer (GDBARCH, TYPE, BUF, ADDR)'</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     Store in BUF a pointer of type TYPE representing the address ADDR,</code></pre></td>
        <td class="diff"><pre><code>     Store in BUF a pointer of type TYPE representing the address ADDR,</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     in the appropriate format for the current architecture.  This</code></pre></td>
        <td class="diff"><pre><code>     in the appropriate format for the current architecture.  This</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     function may safely assume that TYPE is either a pointer or a C++</code></pre></td>
        <td class="diff"><pre><code>     function may safely assume that TYPE is either a pointer or a C++</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     reference type.  *Note Pointers Are Not Always Addresses: Target</code></pre></td>
        <td class="diff"><pre><code>     reference type.  *Note Pointers Are Not Always Addresses: Target</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     Architecture Definition.</code></pre></td>
        <td class="diff"><pre><code>     Architecture Definition.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>`int gdbarch_believe_pcc_promotion (GDBARCH)'</code></pre></td>
        <td class="diff"><pre><code>`int gdbarch_believe_pcc_promotion (GDBARCH)'</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     Used to notify if the compiler promotes a `short' or `char'</code></pre></td>
        <td class="diff"><pre><code>     Used to notify if the compiler promotes a `short' or `char'</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     parameter to an `int', but still reports the parameter as its</code></pre></td>
        <td class="diff"><pre><code>     parameter to an `int', but still reports the parameter as its</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     original type, rather than the promoted type.</code></pre></td>
        <td class="diff"><pre><code>     original type, rather than the promoted type.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>`gdbarch_bits_big_endian (GDBARCH)'</code></pre></td>
        <td class="diff"><pre><code>`gdbarch_bits_big_endian (GDBARCH)'</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     This is used if the numbering of bits in the targets does *not*</code></pre></td>
        <td class="diff"><pre><code>     This is used if the numbering of bits in the targets does *not*</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     match the endianness of the target byte order.  A value of 1 means</code></pre></td>
        <td class="diff"><pre><code>     match the endianness of the target byte order.  A value of 1 means</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     that the bits are numbered in a big-endian bit order, 0 means</code></pre></td>
        <td class="diff"><pre><code>     that the bits are numbered in a big-endian bit order, 0 means</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     little-endian.</code></pre></td>
        <td class="diff"><pre><code>     little-endian.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>`set_gdbarch_bits_big_endian (GDBARCH, BITS_BIG_ENDIAN)'</code></pre></td>
        <td class="diff"><pre><code>`set_gdbarch_bits_big_endian (GDBARCH, BITS_BIG_ENDIAN)'</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     Calling set_gdbarch_bits_big_endian with a value of 1 indicates</code></pre></td>
        <td class="diff"><pre><code>     Calling set_gdbarch_bits_big_endian with a value of 1 indicates</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     that the bits in the target are numbered in a big-endian bit</code></pre></td>
        <td class="diff"><pre><code>     that the bits in the target are numbered in a big-endian bit</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     order, 0 indicates little-endian.</code></pre></td>
        <td class="diff"><pre><code>     order, 0 indicates little-endian.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>`BREAKPOINT'</code></pre></td>
        <td class="diff"><pre><code>`BREAKPOINT'</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     This is the character array initializer for the bit pattern to put</code></pre></td>
        <td class="diff"><pre><code>     This is the character array initializer for the bit pattern to put</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     into memory where a breakpoint is set.  Although it's common to</code></pre></td>
        <td class="diff"><pre><code>     into memory where a breakpoint is set.  Although it's common to</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     use a trap instruction for a breakpoint, it's not required; for</code></pre></td>
        <td class="diff"><pre><code>     use a trap instruction for a breakpoint, it's not required; for</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     instance, the bit pattern could be an invalid instruction.  The</code></pre></td>
        <td class="diff"><pre><code>     instance, the bit pattern could be an invalid instruction.  The</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     breakpoint must be no longer than the shortest instruction of the</code></pre></td>
        <td class="diff"><pre><code>     breakpoint must be no longer than the shortest instruction of the</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     architecture.</code></pre></td>
        <td class="diff"><pre><code>     architecture.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     `BREAKPOINT' has been deprecated in favor of</code></pre></td>
        <td class="diff"><pre><code>     `BREAKPOINT' has been deprecated in favor of</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     `gdbarch_breakpoint_from_pc'.</code></pre></td>
        <td class="diff"><pre><code>     `gdbarch_breakpoint_from_pc'.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>`BIG_BREAKPOINT'</code></pre></td>
        <td class="diff"><pre><code>`BIG_BREAKPOINT'</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>`LITTLE_BREAKPOINT'</code></pre></td>
        <td class="diff"><pre><code>`LITTLE_BREAKPOINT'</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     Similar to BREAKPOINT, but used for bi-endian targets.</code></pre></td>
        <td class="diff"><pre><code>     Similar to BREAKPOINT, but used for bi-endian targets.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     `BIG_BREAKPOINT' and `LITTLE_BREAKPOINT' have been deprecated in</code></pre></td>
        <td class="diff"><pre><code>     `BIG_BREAKPOINT' and `LITTLE_BREAKPOINT' have been deprecated in</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     favor of `gdbarch_breakpoint_from_pc'.</code></pre></td>
        <td class="diff"><pre><code>     favor of `gdbarch_breakpoint_from_pc'.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>`const gdb_byte *gdbarch_breakpoint_from_pc (GDBARCH, PCPTR, LENPTR)'</code></pre></td>
        <td class="diff"><pre><code>`const gdb_byte *gdbarch_breakpoint_from_pc (GDBARCH, PCPTR, LENPTR)'</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     Use the program counter to determine the contents and size of a</code></pre></td>
        <td class="diff"><pre><code>     Use the program counter to determine the contents and size of a</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     breakpoint instruction.  It returns a pointer to a string of bytes</code></pre></td>
        <td class="diff"><pre><code>     breakpoint instruction.  It returns a pointer to a string of bytes</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     that encode a breakpoint instruction, stores the length of the</code></pre></td>
        <td class="diff"><pre><code>     that encode a breakpoint instruction, stores the length of the</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     string to `*LENPTR', and adjusts the program counter (if</code></pre></td>
        <td class="diff"><pre><code>     string to `*LENPTR', and adjusts the program counter (if</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     necessary) to point to the actual memory location where the</code></pre></td>
        <td class="diff"><pre><code>     necessary) to point to the actual memory location where the</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     breakpoint should be inserted.</code></pre></td>
        <td class="diff"><pre><code>     breakpoint should be inserted.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     Although it is common to use a trap instruction for a breakpoint,</code></pre></td>
        <td class="diff"><pre><code>     Although it is common to use a trap instruction for a breakpoint,</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     it's not required; for instance, the bit pattern could be an</code></pre></td>
        <td class="diff"><pre><code>     it's not required; for instance, the bit pattern could be an</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     invalid instruction.  The breakpoint must be no longer than the</code></pre></td>
        <td class="diff"><pre><code>     invalid instruction.  The breakpoint must be no longer than the</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     shortest instruction of the architecture.</code></pre></td>
        <td class="diff"><pre><code>     shortest instruction of the architecture.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     Replaces all the other BREAKPOINT macros.</code></pre></td>
        <td class="diff"><pre><code>     Replaces all the other BREAKPOINT macros.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>`int gdbarch_memory_insert_breakpoint (GDBARCH, BP_TGT)'</code></pre></td>
        <td class="diff"><pre><code>`int gdbarch_memory_insert_breakpoint (GDBARCH, BP_TGT)'</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>`gdbarch_memory_remove_breakpoint (GDBARCH, BP_TGT)'</code></pre></td>
        <td class="diff"><pre><code>`gdbarch_memory_remove_breakpoint (GDBARCH, BP_TGT)'</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     Insert or remove memory based breakpoints.  Reasonable defaults</code></pre></td>
        <td class="diff"><pre><code>     Insert or remove memory based breakpoints.  Reasonable defaults</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     (`default_memory_insert_breakpoint' and</code></pre></td>
        <td class="diff"><pre><code>     (`default_memory_insert_breakpoint' and</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     `default_memory_remove_breakpoint' respectively) have been</code></pre></td>
        <td class="diff"><pre><code>     `default_memory_remove_breakpoint' respectively) have been</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     provided so that it is not necessary to set these for most</code></pre></td>
        <td class="diff"><pre><code>     provided so that it is not necessary to set these for most</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     architectures.  Architectures which may want to set</code></pre></td>
        <td class="diff"><pre><code>     architectures.  Architectures which may want to set</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     `gdbarch_memory_insert_breakpoint' and</code></pre></td>
        <td class="diff"><pre><code>     `gdbarch_memory_insert_breakpoint' and</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     `gdbarch_memory_remove_breakpoint' will likely have instructions</code></pre></td>
        <td class="diff"><pre><code>     `gdbarch_memory_remove_breakpoint' will likely have instructions</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     that are oddly sized or are not stored in a conventional manner.</code></pre></td>
        <td class="diff"><pre><code>     that are oddly sized or are not stored in a conventional manner.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     It may also be desirable (from an efficiency standpoint) to define</code></pre></td>
        <td class="diff"><pre><code>     It may also be desirable (from an efficiency standpoint) to define</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     custom breakpoint insertion and removal routines if</code></pre></td>
        <td class="diff"><pre><code>     custom breakpoint insertion and removal routines if</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     `gdbarch_breakpoint_from_pc' needs to read the target's memory for</code></pre></td>
        <td class="diff"><pre><code>     `gdbarch_breakpoint_from_pc' needs to read the target's memory for</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     some reason.</code></pre></td>
        <td class="diff"><pre><code>     some reason.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>`CORE_ADDR gdbarch_adjust_breakpoint_address (GDBARCH, BPADDR)'</code></pre></td>
        <td class="diff"><pre><code>`CORE_ADDR gdbarch_adjust_breakpoint_address (GDBARCH, BPADDR)'</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     Given an address at which a breakpoint is desired, return a</code></pre></td>
        <td class="diff"><pre><code>     Given an address at which a breakpoint is desired, return a</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     breakpoint address adjusted to account for architectural</code></pre></td>
        <td class="diff"><pre><code>     breakpoint address adjusted to account for architectural</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     constraints on breakpoint placement.  This method is not needed by</code></pre></td>
        <td class="diff"><pre><code>     constraints on breakpoint placement.  This method is not needed by</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     most targets.</code></pre></td>
        <td class="diff"><pre><code>     most targets.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     The FR-V target (see `frv-tdep.c') requires this method.  The FR-V</code></pre></td>
        <td class="diff"><pre><code>     The FR-V target (see `frv-tdep.c') requires this method.  The FR-V</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     is a VLIW architecture in which a number of RISC-like instructions</code></pre></td>
        <td class="diff"><pre><code>     is a VLIW architecture in which a number of RISC-like instructions</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     are grouped (packed) together into an aggregate instruction or</code></pre></td>
        <td class="diff"><pre><code>     are grouped (packed) together into an aggregate instruction or</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     instruction bundle.  When the processor executes one of these</code></pre></td>
        <td class="diff"><pre><code>     instruction bundle.  When the processor executes one of these</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     bundles, the component instructions are executed in parallel.</code></pre></td>
        <td class="diff"><pre><code>     bundles, the component instructions are executed in parallel.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     In the course of optimization, the compiler may group instructions</code></pre></td>
        <td class="diff"><pre><code>     In the course of optimization, the compiler may group instructions</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     from distinct source statements into the same bundle.  The line</code></pre></td>
        <td class="diff"><pre><code>     from distinct source statements into the same bundle.  The line</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     number information associated with one of the latter statements</code></pre></td>
        <td class="diff"><pre><code>     number information associated with one of the latter statements</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     will likely refer to some instruction other than the first one in</code></pre></td>
        <td class="diff"><pre><code>     will likely refer to some instruction other than the first one in</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     the bundle.  So, if the user attempts to place a breakpoint on one</code></pre></td>
        <td class="diff"><pre><code>     the bundle.  So, if the user attempts to place a breakpoint on one</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     of these latter statements, GDB must be careful to _not_ place the</code></pre></td>
        <td class="diff"><pre><code>     of these latter statements, GDB must be careful to _not_ place the</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     break instruction on any instruction other than the first one in</code></pre></td>
        <td class="diff"><pre><code>     break instruction on any instruction other than the first one in</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     the bundle.  (Remember though that the instructions within a</code></pre></td>
        <td class="diff"><pre><code>     the bundle.  (Remember though that the instructions within a</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     bundle execute in parallel, so the _first_ instruction is the</code></pre></td>
        <td class="diff"><pre><code>     bundle execute in parallel, so the _first_ instruction is the</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     instruction at the lowest address and has nothing to do with</code></pre></td>
        <td class="diff"><pre><code>     instruction at the lowest address and has nothing to do with</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     execution order.)</code></pre></td>
        <td class="diff"><pre><code>     execution order.)</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     The FR-V's `gdbarch_adjust_breakpoint_address' method will adjust a</code></pre></td>
        <td class="diff"><pre><code>     The FR-V's `gdbarch_adjust_breakpoint_address' method will adjust a</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     breakpoint's address by scanning backwards for the beginning of</code></pre></td>
        <td class="diff"><pre><code>     breakpoint's address by scanning backwards for the beginning of</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     the bundle, returning the address of the bundle.</code></pre></td>
        <td class="diff"><pre><code>     the bundle, returning the address of the bundle.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     Since the adjustment of a breakpoint may significantly alter a</code></pre></td>
        <td class="diff"><pre><code>     Since the adjustment of a breakpoint may significantly alter a</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     user's expectation, GDB prints a warning when an adjusted</code></pre></td>
        <td class="diff"><pre><code>     user's expectation, GDB prints a warning when an adjusted</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     breakpoint is initially set and each time that that breakpoint is</code></pre></td>
        <td class="diff"><pre><code>     breakpoint is initially set and each time that that breakpoint is</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     hit.</code></pre></td>
        <td class="diff"><pre><code>     hit.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>`int gdbarch_call_dummy_location (GDBARCH)'</code></pre></td>
        <td class="diff"><pre><code>`int gdbarch_call_dummy_location (GDBARCH)'</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     See the file `inferior.h'.</code></pre></td>
        <td class="diff"><pre><code>     See the file `inferior.h'.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     This method has been replaced by `gdbarch_push_dummy_code' (*note</code></pre></td>
        <td class="diff"><pre><code>     This method has been replaced by `gdbarch_push_dummy_code' (*note</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     gdbarch_push_dummy_code::).</code></pre></td>
        <td class="diff"><pre><code>     gdbarch_push_dummy_code::).</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>`int gdbarch_cannot_fetch_register (GDBARCH, REGUM)'</code></pre></td>
        <td class="diff"><pre><code>`int gdbarch_cannot_fetch_register (GDBARCH, REGUM)'</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     This function should return nonzero if REGNO cannot be fetched</code></pre></td>
        <td class="diff"><pre><code>     This function should return nonzero if REGNO cannot be fetched</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     from an inferior process.  This is only relevant if</code></pre></td>
        <td class="diff"><pre><code>     from an inferior process.  This is only relevant if</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     `FETCH_INFERIOR_REGISTERS' is not defined.</code></pre></td>
        <td class="diff"><pre><code>     `FETCH_INFERIOR_REGISTERS' is not defined.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>`int gdbarch_cannot_store_register (GDBARCH, REGNUM)'</code></pre></td>
        <td class="diff"><pre><code>`int gdbarch_cannot_store_register (GDBARCH, REGNUM)'</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     This function should return nonzero if REGNO should not be written</code></pre></td>
        <td class="diff"><pre><code>     This function should return nonzero if REGNO should not be written</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     to the target.  This is often the case for program counters,</code></pre></td>
        <td class="diff"><pre><code>     to the target.  This is often the case for program counters,</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     status words, and other special registers.  This function returns</code></pre></td>
        <td class="diff"><pre><code>     status words, and other special registers.  This function returns</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     0 as default so that GDB will assume that all registers may be</code></pre></td>
        <td class="diff"><pre><code>     0 as default so that GDB will assume that all registers may be</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     written.</code></pre></td>
        <td class="diff"><pre><code>     written.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>`int gdbarch_convert_register_p (GDBARCH, REGNUM, struct type *TYPE)'</code></pre></td>
        <td class="diff"><pre><code>`int gdbarch_convert_register_p (GDBARCH, REGNUM, struct type *TYPE)'</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     Return non-zero if register REGNUM represents data values of type</code></pre></td>
        <td class="diff"><pre><code>     Return non-zero if register REGNUM represents data values of type</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     TYPE in a non-standard form.  *Note Using Different Register and</code></pre></td>
        <td class="diff"><pre><code>     TYPE in a non-standard form.  *Note Using Different Register and</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     Memory Data Representations: Target Architecture Definition.</code></pre></td>
        <td class="diff"><pre><code>     Memory Data Representations: Target Architecture Definition.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>`CORE_ADDR gdbarch_decr_pc_after_break (GDBARCH)'</code></pre></td>
        <td class="diff"><pre><code>`CORE_ADDR gdbarch_decr_pc_after_break (GDBARCH)'</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     This function shall return the amount by which to decrement the PC</code></pre></td>
        <td class="diff"><pre><code>     This function shall return the amount by which to decrement the PC</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     after the program encounters a breakpoint.  This is often the</code></pre></td>
        <td class="diff"><pre><code>     after the program encounters a breakpoint.  This is often the</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     number of bytes in `BREAKPOINT', though not always.  For most</code></pre></td>
        <td class="diff"><pre><code>     number of bytes in `BREAKPOINT', though not always.  For most</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     targets this value will be 0.</code></pre></td>
        <td class="diff"><pre><code>     targets this value will be 0.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>`DISABLE_UNSETTABLE_BREAK (ADDR)'</code></pre></td>
        <td class="diff"><pre><code>`DISABLE_UNSETTABLE_BREAK (ADDR)'</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     If defined, this should evaluate to 1 if ADDR is in a shared</code></pre></td>
        <td class="diff"><pre><code>     If defined, this should evaluate to 1 if ADDR is in a shared</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     library in which breakpoints cannot be set and so should be</code></pre></td>
        <td class="diff"><pre><code>     library in which breakpoints cannot be set and so should be</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     disabled.</code></pre></td>
        <td class="diff"><pre><code>     disabled.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>`void gdbarch_print_float_info (GDBARCH, FILE, FRAME, ARGS)'</code></pre></td>
        <td class="diff"><pre><code>`void gdbarch_print_float_info (GDBARCH, FILE, FRAME, ARGS)'</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     If defined, then the `info float' command will print information</code></pre></td>
        <td class="diff"><pre><code>     If defined, then the `info float' command will print information</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     about the processor's floating point unit.</code></pre></td>
        <td class="diff"><pre><code>     about the processor's floating point unit.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>`void gdbarch_print_registers_info (GDBARCH, FRAME, REGNUM, ALL)'</code></pre></td>
        <td class="diff"><pre><code>`void gdbarch_print_registers_info (GDBARCH, FRAME, REGNUM, ALL)'</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     If defined, pretty print the value of the register REGNUM for the</code></pre></td>
        <td class="diff"><pre><code>     If defined, pretty print the value of the register REGNUM for the</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     specified FRAME.  If the value of REGNUM is -1, pretty print</code></pre></td>
        <td class="diff"><pre><code>     specified FRAME.  If the value of REGNUM is -1, pretty print</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     either all registers (ALL is non zero) or a select subset of</code></pre></td>
        <td class="diff"><pre><code>     either all registers (ALL is non zero) or a select subset of</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     registers (ALL is zero).</code></pre></td>
        <td class="diff"><pre><code>     registers (ALL is zero).</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     The default method prints one register per line, and if ALL is</code></pre></td>
        <td class="diff"><pre><code>     The default method prints one register per line, and if ALL is</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     zero omits floating-point registers.</code></pre></td>
        <td class="diff"><pre><code>     zero omits floating-point registers.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>`int gdbarch_print_vector_info (GDBARCH, FILE, FRAME, ARGS)'</code></pre></td>
        <td class="diff"><pre><code>`int gdbarch_print_vector_info (GDBARCH, FILE, FRAME, ARGS)'</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     If defined, then the `info vector' command will call this function</code></pre></td>
        <td class="diff"><pre><code>     If defined, then the `info vector' command will call this function</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     to print information about the processor's vector unit.</code></pre></td>
        <td class="diff"><pre><code>     to print information about the processor's vector unit.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     By default, the `info vector' command will print all vector</code></pre></td>
        <td class="diff"><pre><code>     By default, the `info vector' command will print all vector</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     registers (the register's type having the vector attribute).</code></pre></td>
        <td class="diff"><pre><code>     registers (the register's type having the vector attribute).</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>`int gdbarch_dwarf_reg_to_regnum (GDBARCH, DWARF_REGNR)'</code></pre></td>
        <td class="diff"><pre><code>`int gdbarch_dwarf_reg_to_regnum (GDBARCH, DWARF_REGNR)'</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     Convert DWARF register number DWARF_REGNR into GDB regnum.  If not</code></pre></td>
        <td class="diff"><pre><code>     Convert DWARF register number DWARF_REGNR into GDB regnum.  If not</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     defined, no conversion will be performed.</code></pre></td>
        <td class="diff"><pre><code>     defined, no conversion will be performed.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>`int gdbarch_dwarf2_reg_to_regnum (GDBARCH, DWARF2_REGNR)'</code></pre></td>
        <td class="diff"><pre><code>`int gdbarch_dwarf2_reg_to_regnum (GDBARCH, DWARF2_REGNR)'</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     Convert DWARF2 register number DWARF2_REGNR into GDB regnum.  If</code></pre></td>
        <td class="diff"><pre><code>     Convert DWARF2 register number DWARF2_REGNR into GDB regnum.  If</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     not defined, no conversion will be performed.</code></pre></td>
        <td class="diff"><pre><code>     not defined, no conversion will be performed.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>`int gdbarch_ecoff_reg_to_regnum (GDBARCH, ECOFF_REGNR)'</code></pre></td>
        <td class="diff"><pre><code>`int gdbarch_ecoff_reg_to_regnum (GDBARCH, ECOFF_REGNR)'</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     Convert ECOFF register number  ECOFF_REGNR into GDB regnum.  If</code></pre></td>
        <td class="diff"><pre><code>     Convert ECOFF register number  ECOFF_REGNR into GDB regnum.  If</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     not defined, no conversion will be performed.</code></pre></td>
        <td class="diff"><pre><code>     not defined, no conversion will be performed.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>`DEPRECATED_FP_REGNUM'</code></pre></td>
        <td class="diff"><pre><code>`DEPRECATED_FP_REGNUM'</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     If the virtual frame pointer is kept in a register, then define</code></pre></td>
        <td class="diff"><pre><code>     If the virtual frame pointer is kept in a register, then define</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     this macro to be the number (greater than or equal to zero) of</code></pre></td>
        <td class="diff"><pre><code>     this macro to be the number (greater than or equal to zero) of</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     that register.</code></pre></td>
        <td class="diff"><pre><code>     that register.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     This should only need to be defined if `DEPRECATED_TARGET_READ_FP'</code></pre></td>
        <td class="diff"><pre><code>     This should only need to be defined if `DEPRECATED_TARGET_READ_FP'</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     is not defined.</code></pre></td>
        <td class="diff"><pre><code>     is not defined.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>`DEPRECATED_FRAMELESS_FUNCTION_INVOCATION(FI)'</code></pre></td>
        <td class="diff"><pre><code>`DEPRECATED_FRAMELESS_FUNCTION_INVOCATION(FI)'</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     Define this to an expression that returns 1 if the function</code></pre></td>
        <td class="diff"><pre><code>     Define this to an expression that returns 1 if the function</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     invocation represented by FI does not have a stack frame</code></pre></td>
        <td class="diff"><pre><code>     invocation represented by FI does not have a stack frame</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     associated with it.  Otherwise return 0.</code></pre></td>
        <td class="diff"><pre><code>     associated with it.  Otherwise return 0.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>`CORE_ADDR frame_align (GDBARCH, ADDRESS)'</code></pre></td>
        <td class="diff"><pre><code>`CORE_ADDR frame_align (GDBARCH, ADDRESS)'</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     Define this to adjust ADDRESS so that it meets the alignment</code></pre></td>
        <td class="diff"><pre><code>     Define this to adjust ADDRESS so that it meets the alignment</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     requirements for the start of a new stack frame.  A stack frame's</code></pre></td>
        <td class="diff"><pre><code>     requirements for the start of a new stack frame.  A stack frame's</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     alignment requirements are typically stronger than a target</code></pre></td>
        <td class="diff"><pre><code>     alignment requirements are typically stronger than a target</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     processors stack alignment requirements.</code></pre></td>
        <td class="diff"><pre><code>     processors stack alignment requirements.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     This function is used to ensure that, when creating a dummy frame,</code></pre></td>
        <td class="diff"><pre><code>     This function is used to ensure that, when creating a dummy frame,</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     both the initial stack pointer and (if needed) the address of the</code></pre></td>
        <td class="diff"><pre><code>     both the initial stack pointer and (if needed) the address of the</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     return value are correctly aligned.</code></pre></td>
        <td class="diff"><pre><code>     return value are correctly aligned.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     This function always adjusts the address in the direction of stack</code></pre></td>
        <td class="diff"><pre><code>     This function always adjusts the address in the direction of stack</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     growth.</code></pre></td>
        <td class="diff"><pre><code>     growth.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     By default, no frame based stack alignment is performed.</code></pre></td>
        <td class="diff"><pre><code>     By default, no frame based stack alignment is performed.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>`int gdbarch_frame_red_zone_size (GDBARCH)'</code></pre></td>
        <td class="diff"><pre><code>`int gdbarch_frame_red_zone_size (GDBARCH)'</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     The number of bytes, beyond the innermost-stack-address, reserved</code></pre></td>
        <td class="diff"><pre><code>     The number of bytes, beyond the innermost-stack-address, reserved</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     by the ABI.  A function is permitted to use this scratch area</code></pre></td>
        <td class="diff"><pre><code>     by the ABI.  A function is permitted to use this scratch area</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     (instead of allocating extra stack space).</code></pre></td>
        <td class="diff"><pre><code>     (instead of allocating extra stack space).</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     When performing an inferior function call, to ensure that it does</code></pre></td>
        <td class="diff"><pre><code>     When performing an inferior function call, to ensure that it does</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     not modify this area, GDB adjusts the innermost-stack-address by</code></pre></td>
        <td class="diff"><pre><code>     not modify this area, GDB adjusts the innermost-stack-address by</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     GDBARCH_FRAME_RED_ZONE_SIZE bytes before pushing parameters onto</code></pre></td>
        <td class="diff"><pre><code>     GDBARCH_FRAME_RED_ZONE_SIZE bytes before pushing parameters onto</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     the stack.</code></pre></td>
        <td class="diff"><pre><code>     the stack.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     By default, zero bytes are allocated.  The value must be aligned</code></pre></td>
        <td class="diff"><pre><code>     By default, zero bytes are allocated.  The value must be aligned</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     (*note frame_align::).</code></pre></td>
        <td class="diff"><pre><code>     (*note frame_align::).</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     The AMD64 (nee x86-64) ABI documentation refers to the _red zone_</code></pre></td>
        <td class="diff"><pre><code>     The AMD64 (nee x86-64) ABI documentation refers to the _red zone_</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     when describing this scratch area.</code></pre></td>
        <td class="diff"><pre><code>     when describing this scratch area.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>`DEPRECATED_FRAME_CHAIN(FRAME)'</code></pre></td>
        <td class="diff"><pre><code>`DEPRECATED_FRAME_CHAIN(FRAME)'</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     Given FRAME, return a pointer to the calling frame.</code></pre></td>
        <td class="diff"><pre><code>     Given FRAME, return a pointer to the calling frame.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>`DEPRECATED_FRAME_CHAIN_VALID(CHAIN, THISFRAME)'</code></pre></td>
        <td class="diff"><pre><code>`DEPRECATED_FRAME_CHAIN_VALID(CHAIN, THISFRAME)'</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     Define this to be an expression that returns zero if the given</code></pre></td>
        <td class="diff"><pre><code>     Define this to be an expression that returns zero if the given</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     frame is an outermost frame, with no caller, and nonzero</code></pre></td>
        <td class="diff"><pre><code>     frame is an outermost frame, with no caller, and nonzero</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     otherwise.  Most normal situations can be handled without defining</code></pre></td>
        <td class="diff"><pre><code>     otherwise.  Most normal situations can be handled without defining</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     this macro, including `NULL' chain pointers, dummy frames, and</code></pre></td>
        <td class="diff"><pre><code>     this macro, including `NULL' chain pointers, dummy frames, and</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     frames whose PC values are inside the startup file (e.g.</code></pre></td>
        <td class="diff"><pre><code>     frames whose PC values are inside the startup file (e.g.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     `crt0.o'), inside `main', or inside `_start'.</code></pre></td>
        <td class="diff"><pre><code>     `crt0.o'), inside `main', or inside `_start'.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>`DEPRECATED_FRAME_INIT_SAVED_REGS(FRAME)'</code></pre></td>
        <td class="diff"><pre><code>`DEPRECATED_FRAME_INIT_SAVED_REGS(FRAME)'</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     See `frame.h'.  Determines the address of all registers in the</code></pre></td>
        <td class="diff"><pre><code>     See `frame.h'.  Determines the address of all registers in the</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     current stack frame storing each in `frame->saved_regs'.  Space for</code></pre></td>
        <td class="diff"><pre><code>     current stack frame storing each in `frame->saved_regs'.  Space for</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     `frame->saved_regs' shall be allocated by</code></pre></td>
        <td class="diff"><pre><code>     `frame->saved_regs' shall be allocated by</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     `DEPRECATED_FRAME_INIT_SAVED_REGS' using `frame_saved_regs_zalloc'.</code></pre></td>
        <td class="diff"><pre><code>     `DEPRECATED_FRAME_INIT_SAVED_REGS' using `frame_saved_regs_zalloc'.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     `FRAME_FIND_SAVED_REGS' is deprecated.</code></pre></td>
        <td class="diff"><pre><code>     `FRAME_FIND_SAVED_REGS' is deprecated.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>`int gdbarch_frame_num_args (GDBARCH, FRAME)'</code></pre></td>
        <td class="diff"><pre><code>`int gdbarch_frame_num_args (GDBARCH, FRAME)'</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     For the frame described by FRAME return the number of arguments</code></pre></td>
        <td class="diff"><pre><code>     For the frame described by FRAME return the number of arguments</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     that are being passed.  If the number of arguments is not known,</code></pre></td>
        <td class="diff"><pre><code>     that are being passed.  If the number of arguments is not known,</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     return `-1'.</code></pre></td>
        <td class="diff"><pre><code>     return `-1'.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>`DEPRECATED_FRAME_SAVED_PC(FRAME)'</code></pre></td>
        <td class="diff"><pre><code>`DEPRECATED_FRAME_SAVED_PC(FRAME)'</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     Given FRAME, return the pc saved there.  This is the return</code></pre></td>
        <td class="diff"><pre><code>     Given FRAME, return the pc saved there.  This is the return</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     address.</code></pre></td>
        <td class="diff"><pre><code>     address.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     This method is deprecated. *Note gdbarch_unwind_pc::.</code></pre></td>
        <td class="diff"><pre><code>     This method is deprecated. *Note gdbarch_unwind_pc::.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>`CORE_ADDR gdbarch_unwind_pc (NEXT_FRAME)'</code></pre></td>
        <td class="diff"><pre><code>`CORE_ADDR gdbarch_unwind_pc (NEXT_FRAME)'</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     Return the instruction address, in NEXT_FRAME's caller, at which</code></pre></td>
        <td class="diff"><pre><code>     Return the instruction address, in NEXT_FRAME's caller, at which</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     execution will resume after NEXT_FRAME returns.  This is commonly</code></pre></td>
        <td class="diff"><pre><code>     execution will resume after NEXT_FRAME returns.  This is commonly</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     referred to as the return address.</code></pre></td>
        <td class="diff"><pre><code>     referred to as the return address.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     The implementation, which must be frame agnostic (work with any</code></pre></td>
        <td class="diff"><pre><code>     The implementation, which must be frame agnostic (work with any</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     frame), is typically no more than:</code></pre></td>
        <td class="diff"><pre><code>     frame), is typically no more than:</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>          ULONGEST pc;</code></pre></td>
        <td class="diff"><pre><code>          ULONGEST pc;</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>          pc = frame_unwind_register_unsigned (next_frame, S390_PC_REGNUM);</code></pre></td>
        <td class="diff"><pre><code>          pc = frame_unwind_register_unsigned (next_frame, S390_PC_REGNUM);</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>          return gdbarch_addr_bits_remove (gdbarch, pc);</code></pre></td>
        <td class="diff"><pre><code>          return gdbarch_addr_bits_remove (gdbarch, pc);</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     *Note DEPRECATED_FRAME_SAVED_PC::, which this method replaces.</code></pre></td>
        <td class="diff"><pre><code>     *Note DEPRECATED_FRAME_SAVED_PC::, which this method replaces.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>`CORE_ADDR gdbarch_unwind_sp (GDBARCH, NEXT_FRAME)'</code></pre></td>
        <td class="diff"><pre><code>`CORE_ADDR gdbarch_unwind_sp (GDBARCH, NEXT_FRAME)'</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     Return the frame's inner most stack address.  This is commonly</code></pre></td>
        <td class="diff"><pre><code>     Return the frame's inner most stack address.  This is commonly</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     referred to as the frame's "stack pointer".</code></pre></td>
        <td class="diff"><pre><code>     referred to as the frame's "stack pointer".</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     The implementation, which must be frame agnostic (work with any</code></pre></td>
        <td class="diff"><pre><code>     The implementation, which must be frame agnostic (work with any</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     frame), is typically no more than:</code></pre></td>
        <td class="diff"><pre><code>     frame), is typically no more than:</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>          ULONGEST sp;</code></pre></td>
        <td class="diff"><pre><code>          ULONGEST sp;</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>          sp = frame_unwind_register_unsigned (next_frame, S390_SP_REGNUM);</code></pre></td>
        <td class="diff"><pre><code>          sp = frame_unwind_register_unsigned (next_frame, S390_SP_REGNUM);</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>          return gdbarch_addr_bits_remove (gdbarch, sp);</code></pre></td>
        <td class="diff"><pre><code>          return gdbarch_addr_bits_remove (gdbarch, sp);</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     *Note TARGET_READ_SP::, which this method replaces.</code></pre></td>
        <td class="diff"><pre><code>     *Note TARGET_READ_SP::, which this method replaces.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>`FUNCTION_EPILOGUE_SIZE'</code></pre></td>
        <td class="diff"><pre><code>`FUNCTION_EPILOGUE_SIZE'</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     For some COFF targets, the `x_sym.x_misc.x_fsize' field of the</code></pre></td>
        <td class="diff"><pre><code>     For some COFF targets, the `x_sym.x_misc.x_fsize' field of the</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     function end symbol is 0.  For such targets, you must define</code></pre></td>
        <td class="diff"><pre><code>     function end symbol is 0.  For such targets, you must define</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     `FUNCTION_EPILOGUE_SIZE' to expand into the standard size of a</code></pre></td>
        <td class="diff"><pre><code>     `FUNCTION_EPILOGUE_SIZE' to expand into the standard size of a</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     function's epilogue.</code></pre></td>
        <td class="diff"><pre><code>     function's epilogue.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>`DEPRECATED_FUNCTION_START_OFFSET'</code></pre></td>
        <td class="diff"><pre><code>`DEPRECATED_FUNCTION_START_OFFSET'</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     An integer, giving the offset in bytes from a function's address</code></pre></td>
        <td class="diff"><pre><code>     An integer, giving the offset in bytes from a function's address</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     (as used in the values of symbols, function pointers, etc.), and</code></pre></td>
        <td class="diff"><pre><code>     (as used in the values of symbols, function pointers, etc.), and</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     the function's first genuine instruction.</code></pre></td>
        <td class="diff"><pre><code>     the function's first genuine instruction.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     This is zero on almost all machines: the function's address is</code></pre></td>
        <td class="diff"><pre><code>     This is zero on almost all machines: the function's address is</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     usually the address of its first instruction.  However, on the</code></pre></td>
        <td class="diff"><pre><code>     usually the address of its first instruction.  However, on the</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     VAX, for example, each function starts with two bytes containing a</code></pre></td>
        <td class="diff"><pre><code>     VAX, for example, each function starts with two bytes containing a</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     bitmask indicating which registers to save upon entry to the</code></pre></td>
        <td class="diff"><pre><code>     bitmask indicating which registers to save upon entry to the</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     function.  The VAX `call' instructions check this value, and save</code></pre></td>
        <td class="diff"><pre><code>     function.  The VAX `call' instructions check this value, and save</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     the appropriate registers automatically.  Thus, since the offset</code></pre></td>
        <td class="diff"><pre><code>     the appropriate registers automatically.  Thus, since the offset</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     from the function's address to its first instruction is two bytes,</code></pre></td>
        <td class="diff"><pre><code>     from the function's address to its first instruction is two bytes,</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     `DEPRECATED_FUNCTION_START_OFFSET' would be 2 on the VAX.</code></pre></td>
        <td class="diff"><pre><code>     `DEPRECATED_FUNCTION_START_OFFSET' would be 2 on the VAX.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>`GCC_COMPILED_FLAG_SYMBOL'</code></pre></td>
        <td class="diff"><pre><code>`GCC_COMPILED_FLAG_SYMBOL'</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>`GCC2_COMPILED_FLAG_SYMBOL'</code></pre></td>
        <td class="diff"><pre><code>`GCC2_COMPILED_FLAG_SYMBOL'</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     If defined, these are the names of the symbols that GDB will look</code></pre></td>
        <td class="diff"><pre><code>     If defined, these are the names of the symbols that GDB will look</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     for to detect that GCC compiled the file.  The default symbols are</code></pre></td>
        <td class="diff"><pre><code>     for to detect that GCC compiled the file.  The default symbols are</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     `gcc_compiled.' and `gcc2_compiled.', respectively.  (Currently</code></pre></td>
        <td class="diff"><pre><code>     `gcc_compiled.' and `gcc2_compiled.', respectively.  (Currently</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     only defined for the Delta 68.)</code></pre></td>
        <td class="diff"><pre><code>     only defined for the Delta 68.)</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>`gdbarch_get_longjmp_target'</code></pre></td>
        <td class="diff"><pre><code>`gdbarch_get_longjmp_target'</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     For most machines, this is a target-dependent parameter.  On the</code></pre></td>
        <td class="diff"><pre><code>     For most machines, this is a target-dependent parameter.  On the</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     DECstation and the Iris, this is a native-dependent parameter,</code></pre></td>
        <td class="diff"><pre><code>     DECstation and the Iris, this is a native-dependent parameter,</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     since the header file `setjmp.h' is needed to define it.</code></pre></td>
        <td class="diff"><pre><code>     since the header file `setjmp.h' is needed to define it.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     This macro determines the target PC address that `longjmp' will</code></pre></td>
        <td class="diff"><pre><code>     This macro determines the target PC address that `longjmp' will</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     jump to, assuming that we have just stopped at a `longjmp'</code></pre></td>
        <td class="diff"><pre><code>     jump to, assuming that we have just stopped at a `longjmp'</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     breakpoint.  It takes a `CORE_ADDR *' as argument, and stores the</code></pre></td>
        <td class="diff"><pre><code>     breakpoint.  It takes a `CORE_ADDR *' as argument, and stores the</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     target PC value through this pointer.  It examines the current</code></pre></td>
        <td class="diff"><pre><code>     target PC value through this pointer.  It examines the current</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     state of the machine as needed.</code></pre></td>
        <td class="diff"><pre><code>     state of the machine as needed.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>`DEPRECATED_IBM6000_TARGET'</code></pre></td>
        <td class="diff"><pre><code>`DEPRECATED_IBM6000_TARGET'</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     Shows that we are configured for an IBM RS/6000 system.  This</code></pre></td>
        <td class="diff"><pre><code>     Shows that we are configured for an IBM RS/6000 system.  This</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     conditional should be eliminated (FIXME) and replaced by</code></pre></td>
        <td class="diff"><pre><code>     conditional should be eliminated (FIXME) and replaced by</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     feature-specific macros.  It was introduced in a haste and we are</code></pre></td>
        <td class="diff"><pre><code>     feature-specific macros.  It was introduced in a haste and we are</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     repenting at leisure.</code></pre></td>
        <td class="diff"><pre><code>     repenting at leisure.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>`I386_USE_GENERIC_WATCHPOINTS'</code></pre></td>
        <td class="diff"><pre><code>`I386_USE_GENERIC_WATCHPOINTS'</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     An x86-based target can define this to use the generic x86</code></pre></td>
        <td class="diff"><pre><code>     An x86-based target can define this to use the generic x86</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     watchpoint support; see *Note I386_USE_GENERIC_WATCHPOINTS:</code></pre></td>
        <td class="diff"><pre><code>     watchpoint support; see *Note I386_USE_GENERIC_WATCHPOINTS:</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     Algorithms.</code></pre></td>
        <td class="diff"><pre><code>     Algorithms.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>`int gdbarch_inner_than (GDBARCH, LHS, RHS)'</code></pre></td>
        <td class="diff"><pre><code>`int gdbarch_inner_than (GDBARCH, LHS, RHS)'</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     Returns non-zero if stack address LHS is inner than (nearer to the</code></pre></td>
        <td class="diff"><pre><code>     Returns non-zero if stack address LHS is inner than (nearer to the</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     stack top) stack address RHS.  Let the function return `lhs < rhs'</code></pre></td>
        <td class="diff"><pre><code>     stack top) stack address RHS.  Let the function return `lhs < rhs'</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     if the target's stack grows downward in memory, or `lhs > rsh' if</code></pre></td>
        <td class="diff"><pre><code>     if the target's stack grows downward in memory, or `lhs > rsh' if</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     the stack grows upward.</code></pre></td>
        <td class="diff"><pre><code>     the stack grows upward.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>`gdbarch_in_function_epilogue_p (GDBARCH, ADDR)'</code></pre></td>
        <td class="diff"><pre><code>`gdbarch_in_function_epilogue_p (GDBARCH, ADDR)'</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     Returns non-zero if the given ADDR is in the epilogue of a</code></pre></td>
        <td class="diff"><pre><code>     Returns non-zero if the given ADDR is in the epilogue of a</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     function.  The epilogue of a function is defined as the part of a</code></pre></td>
        <td class="diff"><pre><code>     function.  The epilogue of a function is defined as the part of a</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     function where the stack frame of the function already has been</code></pre></td>
        <td class="diff"><pre><code>     function where the stack frame of the function already has been</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     destroyed up to the final `return from function call' instruction.</code></pre></td>
        <td class="diff"><pre><code>     destroyed up to the final `return from function call' instruction.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>`int gdbarch_in_solib_return_trampoline (GDBARCH, PC, NAME)'</code></pre></td>
        <td class="diff"><pre><code>`int gdbarch_in_solib_return_trampoline (GDBARCH, PC, NAME)'</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     Define this function to return nonzero if the program is stopped</code></pre></td>
        <td class="diff"><pre><code>     Define this function to return nonzero if the program is stopped</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     in the trampoline that returns from a shared library.</code></pre></td>
        <td class="diff"><pre><code>     in the trampoline that returns from a shared library.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>`IN_SOLIB_DYNSYM_RESOLVE_CODE (PC)'</code></pre></td>
        <td class="diff"><pre><code>`IN_SOLIB_DYNSYM_RESOLVE_CODE (PC)'</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     Define this to return nonzero if the program is stopped in the</code></pre></td>
        <td class="diff"><pre><code>     Define this to return nonzero if the program is stopped in the</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     dynamic linker.</code></pre></td>
        <td class="diff"><pre><code>     dynamic linker.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>`SKIP_SOLIB_RESOLVER (PC)'</code></pre></td>
        <td class="diff"><pre><code>`SKIP_SOLIB_RESOLVER (PC)'</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     Define this to evaluate to the (nonzero) address at which execution</code></pre></td>
        <td class="diff"><pre><code>     Define this to evaluate to the (nonzero) address at which execution</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     should continue to get past the dynamic linker's symbol resolution</code></pre></td>
        <td class="diff"><pre><code>     should continue to get past the dynamic linker's symbol resolution</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     function.  A zero value indicates that it is not important or</code></pre></td>
        <td class="diff"><pre><code>     function.  A zero value indicates that it is not important or</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     necessary to set a breakpoint to get through the dynamic linker</code></pre></td>
        <td class="diff"><pre><code>     necessary to set a breakpoint to get through the dynamic linker</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     and that single stepping will suffice.</code></pre></td>
        <td class="diff"><pre><code>     and that single stepping will suffice.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>`CORE_ADDR gdbarch_integer_to_address (GDBARCH, TYPE, BUF)'</code></pre></td>
        <td class="diff"><pre><code>`CORE_ADDR gdbarch_integer_to_address (GDBARCH, TYPE, BUF)'</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     Define this when the architecture needs to handle non-pointer to</code></pre></td>
        <td class="diff"><pre><code>     Define this when the architecture needs to handle non-pointer to</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     address conversions specially.  Converts that value to an address</code></pre></td>
        <td class="diff"><pre><code>     address conversions specially.  Converts that value to an address</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     according to the current architectures conventions.</code></pre></td>
        <td class="diff"><pre><code>     according to the current architectures conventions.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     _Pragmatics: When the user copies a well defined expression from</code></pre></td>
        <td class="diff"><pre><code>     _Pragmatics: When the user copies a well defined expression from</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     their source code and passes it, as a parameter, to GDB's `print'</code></pre></td>
        <td class="diff"><pre><code>     their source code and passes it, as a parameter, to GDB's `print'</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     command, they should get the same value as would have been</code></pre></td>
        <td class="diff"><pre><code>     command, they should get the same value as would have been</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     computed by the target program.  Any deviation from this rule can</code></pre></td>
        <td class="diff"><pre><code>     computed by the target program.  Any deviation from this rule can</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     cause major confusion and annoyance, and needs to be justified</code></pre></td>
        <td class="diff"><pre><code>     cause major confusion and annoyance, and needs to be justified</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     carefully.  In other words, GDB doesn't really have the freedom to</code></pre></td>
        <td class="diff"><pre><code>     carefully.  In other words, GDB doesn't really have the freedom to</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     do these conversions in clever and useful ways.  It has, however,</code></pre></td>
        <td class="diff"><pre><code>     do these conversions in clever and useful ways.  It has, however,</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     been pointed out that users aren't complaining about how GDB casts</code></pre></td>
        <td class="diff"><pre><code>     been pointed out that users aren't complaining about how GDB casts</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     integers to pointers; they are complaining that they can't take an</code></pre></td>
        <td class="diff"><pre><code>     integers to pointers; they are complaining that they can't take an</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     address from a disassembly listing and give it to `x/i'.  Adding</code></pre></td>
        <td class="diff"><pre><code>     address from a disassembly listing and give it to `x/i'.  Adding</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     an architecture method like `gdbarch_integer_to_address' certainly</code></pre></td>
        <td class="diff"><pre><code>     an architecture method like `gdbarch_integer_to_address' certainly</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     makes it possible for GDB to "get it right" in all circumstances._</code></pre></td>
        <td class="diff"><pre><code>     makes it possible for GDB to "get it right" in all circumstances._</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     *Note Pointers Are Not Always Addresses: Target Architecture</code></pre></td>
        <td class="diff"><pre><code>     *Note Pointers Are Not Always Addresses: Target Architecture</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     Definition.</code></pre></td>
        <td class="diff"><pre><code>     Definition.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>`CORE_ADDR gdbarch_pointer_to_address (GDBARCH, TYPE, BUF)'</code></pre></td>
        <td class="diff"><pre><code>`CORE_ADDR gdbarch_pointer_to_address (GDBARCH, TYPE, BUF)'</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     Assume that BUF holds a pointer of type TYPE, in the appropriate</code></pre></td>
        <td class="diff"><pre><code>     Assume that BUF holds a pointer of type TYPE, in the appropriate</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     format for the current architecture.  Return the byte address the</code></pre></td>
        <td class="diff"><pre><code>     format for the current architecture.  Return the byte address the</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     pointer refers to.  *Note Pointers Are Not Always Addresses:</code></pre></td>
        <td class="diff"><pre><code>     pointer refers to.  *Note Pointers Are Not Always Addresses:</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     Target Architecture Definition.</code></pre></td>
        <td class="diff"><pre><code>     Target Architecture Definition.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>`void gdbarch_register_to_value(GDBARCH, FRAME, REGNUM, TYPE, FUR)'</code></pre></td>
        <td class="diff"><pre><code>`void gdbarch_register_to_value(GDBARCH, FRAME, REGNUM, TYPE, FUR)'</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     Convert the raw contents of register REGNUM into a value of type</code></pre></td>
        <td class="diff"><pre><code>     Convert the raw contents of register REGNUM into a value of type</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     TYPE.  *Note Using Different Register and Memory Data</code></pre></td>
        <td class="diff"><pre><code>     TYPE.  *Note Using Different Register and Memory Data</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     Representations: Target Architecture Definition.</code></pre></td>
        <td class="diff"><pre><code>     Representations: Target Architecture Definition.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>`register_reggroup_p (GDBARCH, REGNUM, REGGROUP)'</code></pre></td>
        <td class="diff"><pre><code>`register_reggroup_p (GDBARCH, REGNUM, REGGROUP)'</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     Return non-zero if register REGNUM is a member of the register</code></pre></td>
        <td class="diff"><pre><code>     Return non-zero if register REGNUM is a member of the register</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     group REGGROUP.</code></pre></td>
        <td class="diff"><pre><code>     group REGGROUP.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     By default, registers are grouped as follows:</code></pre></td>
        <td class="diff"><pre><code>     By default, registers are grouped as follows:</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>    `float_reggroup'</code></pre></td>
        <td class="diff"><pre><code>    `float_reggroup'</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>          Any register with a valid name and a floating-point type.</code></pre></td>
        <td class="diff"><pre><code>          Any register with a valid name and a floating-point type.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>    `vector_reggroup'</code></pre></td>
        <td class="diff"><pre><code>    `vector_reggroup'</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>          Any register with a valid name and a vector type.</code></pre></td>
        <td class="diff"><pre><code>          Any register with a valid name and a vector type.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>    `general_reggroup'</code></pre></td>
        <td class="diff"><pre><code>    `general_reggroup'</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>          Any register with a valid name and a type other than vector or</code></pre></td>
        <td class="diff"><pre><code>          Any register with a valid name and a type other than vector or</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>          floating-point.  `float_reggroup'.</code></pre></td>
        <td class="diff"><pre><code>          floating-point.  `float_reggroup'.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>    `save_reggroup'</code></pre></td>
        <td class="diff"><pre><code>    `save_reggroup'</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>    `restore_reggroup'</code></pre></td>
        <td class="diff"><pre><code>    `restore_reggroup'</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>    `all_reggroup'</code></pre></td>
        <td class="diff"><pre><code>    `all_reggroup'</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>          Any register with a valid name.</code></pre></td>
        <td class="diff"><pre><code>          Any register with a valid name.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>`DEPRECATED_REGISTER_VIRTUAL_SIZE (REG)'</code></pre></td>
        <td class="diff"><pre><code>`DEPRECATED_REGISTER_VIRTUAL_SIZE (REG)'</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     Return the virtual size of REG; defaults to the size of the</code></pre></td>
        <td class="diff"><pre><code>     Return the virtual size of REG; defaults to the size of the</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     register's virtual type.  Return the virtual size of REG.  *Note</code></pre></td>
        <td class="diff"><pre><code>     register's virtual type.  Return the virtual size of REG.  *Note</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     Raw and Virtual Register Representations: Target Architecture</code></pre></td>
        <td class="diff"><pre><code>     Raw and Virtual Register Representations: Target Architecture</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     Definition.</code></pre></td>
        <td class="diff"><pre><code>     Definition.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>`DEPRECATED_REGISTER_VIRTUAL_TYPE (REG)'</code></pre></td>
        <td class="diff"><pre><code>`DEPRECATED_REGISTER_VIRTUAL_TYPE (REG)'</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     Return the virtual type of REG.  *Note Raw and Virtual Register</code></pre></td>
        <td class="diff"><pre><code>     Return the virtual type of REG.  *Note Raw and Virtual Register</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     Representations: Target Architecture Definition.</code></pre></td>
        <td class="diff"><pre><code>     Representations: Target Architecture Definition.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>`struct type *register_type (GDBARCH, REG)'</code></pre></td>
        <td class="diff"><pre><code>`struct type *register_type (GDBARCH, REG)'</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     If defined, return the type of register REG.  This function</code></pre></td>
        <td class="diff"><pre><code>     If defined, return the type of register REG.  This function</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     supersedes `DEPRECATED_REGISTER_VIRTUAL_TYPE'.  *Note Raw and</code></pre></td>
        <td class="diff"><pre><code>     supersedes `DEPRECATED_REGISTER_VIRTUAL_TYPE'.  *Note Raw and</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     Virtual Register Representations: Target Architecture Definition.</code></pre></td>
        <td class="diff"><pre><code>     Virtual Register Representations: Target Architecture Definition.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>`REGISTER_CONVERT_TO_VIRTUAL(REG, TYPE, FROM, TO)'</code></pre></td>
        <td class="diff"><pre><code>`REGISTER_CONVERT_TO_VIRTUAL(REG, TYPE, FROM, TO)'</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     Convert the value of register REG from its raw form to its virtual</code></pre></td>
        <td class="diff"><pre><code>     Convert the value of register REG from its raw form to its virtual</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     form.  *Note Raw and Virtual Register Representations: Target</code></pre></td>
        <td class="diff"><pre><code>     form.  *Note Raw and Virtual Register Representations: Target</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     Architecture Definition.</code></pre></td>
        <td class="diff"><pre><code>     Architecture Definition.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>`REGISTER_CONVERT_TO_RAW(TYPE, REG, FROM, TO)'</code></pre></td>
        <td class="diff"><pre><code>`REGISTER_CONVERT_TO_RAW(TYPE, REG, FROM, TO)'</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     Convert the value of register REG from its virtual form to its raw</code></pre></td>
        <td class="diff"><pre><code>     Convert the value of register REG from its virtual form to its raw</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     form.  *Note Raw and Virtual Register Representations: Target</code></pre></td>
        <td class="diff"><pre><code>     form.  *Note Raw and Virtual Register Representations: Target</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     Architecture Definition.</code></pre></td>
        <td class="diff"><pre><code>     Architecture Definition.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>`const struct regset *regset_from_core_section (struct gdbarch * GDBARCH, const char * SECT_NAME, size_t SECT_SIZE)'</code></pre></td>
        <td class="diff"><pre><code>`const struct regset *regset_from_core_section (struct gdbarch * GDBARCH, const char * SECT_NAME, size_t SECT_SIZE)'</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     Return the appropriate register set for a core file section with</code></pre></td>
        <td class="diff"><pre><code>     Return the appropriate register set for a core file section with</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     name SECT_NAME and size SECT_SIZE.</code></pre></td>
        <td class="diff"><pre><code>     name SECT_NAME and size SECT_SIZE.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>`SOFTWARE_SINGLE_STEP_P()'</code></pre></td>
        <td class="diff"><pre><code>`SOFTWARE_SINGLE_STEP_P()'</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     Define this as 1 if the target does not have a hardware single-step</code></pre></td>
        <td class="diff"><pre><code>     Define this as 1 if the target does not have a hardware single-step</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     mechanism.  The macro `SOFTWARE_SINGLE_STEP' must also be defined.</code></pre></td>
        <td class="diff"><pre><code>     mechanism.  The macro `SOFTWARE_SINGLE_STEP' must also be defined.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>`SOFTWARE_SINGLE_STEP(SIGNAL, INSERT_BREAKPOINTS_P)'</code></pre></td>
        <td class="diff"><pre><code>`SOFTWARE_SINGLE_STEP(SIGNAL, INSERT_BREAKPOINTS_P)'</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     A function that inserts or removes (depending on</code></pre></td>
        <td class="diff"><pre><code>     A function that inserts or removes (depending on</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     INSERT_BREAKPOINTS_P) breakpoints at each possible destinations of</code></pre></td>
        <td class="diff"><pre><code>     INSERT_BREAKPOINTS_P) breakpoints at each possible destinations of</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     the next instruction. See `sparc-tdep.c' and `rs6000-tdep.c' for</code></pre></td>
        <td class="diff"><pre><code>     the next instruction. See `sparc-tdep.c' and `rs6000-tdep.c' for</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     examples.</code></pre></td>
        <td class="diff"><pre><code>     examples.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>`set_gdbarch_sofun_address_maybe_missing (GDBARCH, SET)'</code></pre></td>
        <td class="diff"><pre><code>`set_gdbarch_sofun_address_maybe_missing (GDBARCH, SET)'</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     Somebody clever observed that, the more actual addresses you have</code></pre></td>
        <td class="diff"><pre><code>     Somebody clever observed that, the more actual addresses you have</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     in the debug information, the more time the linker has to spend</code></pre></td>
        <td class="diff"><pre><code>     in the debug information, the more time the linker has to spend</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     relocating them.  So whenever there's some other way the debugger</code></pre></td>
        <td class="diff"><pre><code>     relocating them.  So whenever there's some other way the debugger</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     could find the address it needs, you should omit it from the debug</code></pre></td>
        <td class="diff"><pre><code>     could find the address it needs, you should omit it from the debug</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     info, to make linking faster.</code></pre></td>
        <td class="diff"><pre><code>     info, to make linking faster.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     Calling `set_gdbarch_sofun_address_maybe_missing' with a non-zero</code></pre></td>
        <td class="diff"><pre><code>     Calling `set_gdbarch_sofun_address_maybe_missing' with a non-zero</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     argument SET indicates that a particular set of hacks of this sort</code></pre></td>
        <td class="diff"><pre><code>     argument SET indicates that a particular set of hacks of this sort</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     are in use, affecting `N_SO' and `N_FUN' entries in stabs-format</code></pre></td>
        <td class="diff"><pre><code>     are in use, affecting `N_SO' and `N_FUN' entries in stabs-format</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     debugging information.  `N_SO' stabs mark the beginning and ending</code></pre></td>
        <td class="diff"><pre><code>     debugging information.  `N_SO' stabs mark the beginning and ending</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     addresses of compilation units in the text segment.  `N_FUN' stabs</code></pre></td>
        <td class="diff"><pre><code>     addresses of compilation units in the text segment.  `N_FUN' stabs</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     mark the starts and ends of functions.</code></pre></td>
        <td class="diff"><pre><code>     mark the starts and ends of functions.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     In this case, GDB assumes two things:</code></pre></td>
        <td class="diff"><pre><code>     In this case, GDB assumes two things:</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>        * `N_FUN' stabs have an address of zero.  Instead of using those</code></pre></td>
        <td class="diff"><pre><code>        * `N_FUN' stabs have an address of zero.  Instead of using those</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>          addresses, you should find the address where the function</code></pre></td>
        <td class="diff"><pre><code>          addresses, you should find the address where the function</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>          starts by taking the function name from the stab, and then</code></pre></td>
        <td class="diff"><pre><code>          starts by taking the function name from the stab, and then</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>          looking that up in the minsyms (the linker/assembler symbol</code></pre></td>
        <td class="diff"><pre><code>          looking that up in the minsyms (the linker/assembler symbol</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>          table).  In other words, the stab has the name, and the</code></pre></td>
        <td class="diff"><pre><code>          table).  In other words, the stab has the name, and the</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>          linker/assembler symbol table is the only place that carries</code></pre></td>
        <td class="diff"><pre><code>          linker/assembler symbol table is the only place that carries</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>          the address.</code></pre></td>
        <td class="diff"><pre><code>          the address.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>        * `N_SO' stabs have an address of zero, too.  You just look at</code></pre></td>
        <td class="diff"><pre><code>        * `N_SO' stabs have an address of zero, too.  You just look at</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>          the `N_FUN' stabs that appear before and after the `N_SO'</code></pre></td>
        <td class="diff"><pre><code>          the `N_FUN' stabs that appear before and after the `N_SO'</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>          stab, and guess the starting and ending addresses of the</code></pre></td>
        <td class="diff"><pre><code>          stab, and guess the starting and ending addresses of the</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>          compilation unit from them.</code></pre></td>
        <td class="diff"><pre><code>          compilation unit from them.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>`int gdbarch_pc_regnum (GDBARCH)'</code></pre></td>
        <td class="diff"><pre><code>`int gdbarch_pc_regnum (GDBARCH)'</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     If the program counter is kept in a register, then let this</code></pre></td>
        <td class="diff"><pre><code>     If the program counter is kept in a register, then let this</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     function return the number (greater than or equal to zero) of that</code></pre></td>
        <td class="diff"><pre><code>     function return the number (greater than or equal to zero) of that</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     register.</code></pre></td>
        <td class="diff"><pre><code>     register.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     This should only need to be defined if `gdbarch_read_pc' and</code></pre></td>
        <td class="diff"><pre><code>     This should only need to be defined if `gdbarch_read_pc' and</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     `gdbarch_write_pc' are not defined.</code></pre></td>
        <td class="diff"><pre><code>     `gdbarch_write_pc' are not defined.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>`int gdbarch_stabs_argument_has_addr (GDBARCH, TYPE)'</code></pre></td>
        <td class="diff"><pre><code>`int gdbarch_stabs_argument_has_addr (GDBARCH, TYPE)'</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     Define this function to return nonzero if a function argument of</code></pre></td>
        <td class="diff"><pre><code>     Define this function to return nonzero if a function argument of</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     type TYPE is passed by reference instead of value.</code></pre></td>
        <td class="diff"><pre><code>     type TYPE is passed by reference instead of value.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>`PROCESS_LINENUMBER_HOOK'</code></pre></td>
        <td class="diff"><pre><code>`PROCESS_LINENUMBER_HOOK'</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     A hook defined for XCOFF reading.</code></pre></td>
        <td class="diff"><pre><code>     A hook defined for XCOFF reading.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>`gdbarch_ps_regnum (GDBARCH'</code></pre></td>
        <td class="diff"><pre><code>`gdbarch_ps_regnum (GDBARCH'</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     If defined, this function returns the number of the processor</code></pre></td>
        <td class="diff"><pre><code>     If defined, this function returns the number of the processor</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     status register.  (This definition is only used in generic code</code></pre></td>
        <td class="diff"><pre><code>     status register.  (This definition is only used in generic code</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     when parsing "$ps".)</code></pre></td>
        <td class="diff"><pre><code>     when parsing "$ps".)</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>`CORE_ADDR gdbarch_push_dummy_call (GDBARCH, FUNCTION, REGCACHE, BP_ADDR, NARGS, ARGS, SP, STRUCT_RETURN, STRUCT_ADDR)'</code></pre></td>
        <td class="diff"><pre><code>`CORE_ADDR gdbarch_push_dummy_call (GDBARCH, FUNCTION, REGCACHE, BP_ADDR, NARGS, ARGS, SP, STRUCT_RETURN, STRUCT_ADDR)'</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     Define this to push the dummy frame's call to the inferior</code></pre></td>
        <td class="diff"><pre><code>     Define this to push the dummy frame's call to the inferior</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     function onto the stack.  In addition to pushing NARGS, the code</code></pre></td>
        <td class="diff"><pre><code>     function onto the stack.  In addition to pushing NARGS, the code</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     should push STRUCT_ADDR (when STRUCT_RETURN is non-zero), and the</code></pre></td>
        <td class="diff"><pre><code>     should push STRUCT_ADDR (when STRUCT_RETURN is non-zero), and the</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     return address (BP_ADDR).</code></pre></td>
        <td class="diff"><pre><code>     return address (BP_ADDR).</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     FUNCTION is a pointer to a `struct value'; on architectures that</code></pre></td>
        <td class="diff"><pre><code>     FUNCTION is a pointer to a `struct value'; on architectures that</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     use function descriptors, this contains the function descriptor</code></pre></td>
        <td class="diff"><pre><code>     use function descriptors, this contains the function descriptor</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     value.</code></pre></td>
        <td class="diff"><pre><code>     value.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     Returns the updated top-of-stack pointer.</code></pre></td>
        <td class="diff"><pre><code>     Returns the updated top-of-stack pointer.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     This method replaces `DEPRECATED_PUSH_ARGUMENTS'.</code></pre></td>
        <td class="diff"><pre><code>     This method replaces `DEPRECATED_PUSH_ARGUMENTS'.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>`CORE_ADDR gdbarch_push_dummy_code (GDBARCH, SP, FUNADDR, USING_GCC, ARGS, NARGS, VALUE_TYPE, REAL_PC, BP_ADDR, REGCACHE)'</code></pre></td>
        <td class="diff"><pre><code>`CORE_ADDR gdbarch_push_dummy_code (GDBARCH, SP, FUNADDR, USING_GCC, ARGS, NARGS, VALUE_TYPE, REAL_PC, BP_ADDR, REGCACHE)'</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     Given a stack based call dummy, push the instruction sequence</code></pre></td>
        <td class="diff"><pre><code>     Given a stack based call dummy, push the instruction sequence</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     (including space for a breakpoint) to which the called function</code></pre></td>
        <td class="diff"><pre><code>     (including space for a breakpoint) to which the called function</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     should return.</code></pre></td>
        <td class="diff"><pre><code>     should return.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     Set BP_ADDR to the address at which the breakpoint instruction</code></pre></td>
        <td class="diff"><pre><code>     Set BP_ADDR to the address at which the breakpoint instruction</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     should be inserted, REAL_PC to the resume address when starting</code></pre></td>
        <td class="diff"><pre><code>     should be inserted, REAL_PC to the resume address when starting</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     the call sequence, and return the updated inner-most stack address.</code></pre></td>
        <td class="diff"><pre><code>     the call sequence, and return the updated inner-most stack address.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     By default, the stack is grown sufficient to hold a frame-aligned</code></pre></td>
        <td class="diff"><pre><code>     By default, the stack is grown sufficient to hold a frame-aligned</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     (*note frame_align::) breakpoint, BP_ADDR is set to the address</code></pre></td>
        <td class="diff"><pre><code>     (*note frame_align::) breakpoint, BP_ADDR is set to the address</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     reserved for that breakpoint, and REAL_PC set to FUNADDR.</code></pre></td>
        <td class="diff"><pre><code>     reserved for that breakpoint, and REAL_PC set to FUNADDR.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     This method replaces `gdbarch_call_dummy_location (GDBARCH)' and</code></pre></td>
        <td class="diff"><pre><code>     This method replaces `gdbarch_call_dummy_location (GDBARCH)' and</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     `DEPRECATED_REGISTER_SIZE'.</code></pre></td>
        <td class="diff"><pre><code>     `DEPRECATED_REGISTER_SIZE'.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>`const char *gdbarch_register_name (GDBARCH, REGNR)'</code></pre></td>
        <td class="diff"><pre><code>`const char *gdbarch_register_name (GDBARCH, REGNR)'</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     Return the name of register REGNR as a string.  May return `NULL'</code></pre></td>
        <td class="diff"><pre><code>     Return the name of register REGNR as a string.  May return `NULL'</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     to indicate that REGNR is not a valid register.</code></pre></td>
        <td class="diff"><pre><code>     to indicate that REGNR is not a valid register.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>`SAVE_DUMMY_FRAME_TOS (SP)'</code></pre></td>
        <td class="diff"><pre><code>`SAVE_DUMMY_FRAME_TOS (SP)'</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     Used in `call_function_by_hand' to notify the target dependent</code></pre></td>
        <td class="diff"><pre><code>     Used in `call_function_by_hand' to notify the target dependent</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     code of the top-of-stack value that will be passed to the inferior</code></pre></td>
        <td class="diff"><pre><code>     code of the top-of-stack value that will be passed to the inferior</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     code.  This is the value of the `SP' after both the dummy frame</code></pre></td>
        <td class="diff"><pre><code>     code.  This is the value of the `SP' after both the dummy frame</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     and space for parameters/results have been allocated on the stack.</code></pre></td>
        <td class="diff"><pre><code>     and space for parameters/results have been allocated on the stack.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     *Note gdbarch_unwind_dummy_id::.</code></pre></td>
        <td class="diff"><pre><code>     *Note gdbarch_unwind_dummy_id::.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>`int gdbarch_sdb_reg_to_regnum (GDBARCH, SDB_REGNR)'</code></pre></td>
        <td class="diff"><pre><code>`int gdbarch_sdb_reg_to_regnum (GDBARCH, SDB_REGNR)'</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     Use this function to convert sdb register SDB_REGNR into GDB</code></pre></td>
        <td class="diff"><pre><code>     Use this function to convert sdb register SDB_REGNR into GDB</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     regnum.  If not defined, no conversion will be done.</code></pre></td>
        <td class="diff"><pre><code>     regnum.  If not defined, no conversion will be done.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>`enum return_value_convention gdbarch_return_value (struct gdbarch *GDBARCH, struct type *VALTYPE, struct regcache *REGCACHE, void *READBUF, const void *WRITEBUF)'</code></pre></td>
        <td class="diff"><pre><code>`enum return_value_convention gdbarch_return_value (struct gdbarch *GDBARCH, struct type *VALTYPE, struct regcache *REGCACHE, void *READBUF, const void *WRITEBUF)'</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     Given a function with a return-value of type RETTYPE, return which</code></pre></td>
        <td class="diff"><pre><code>     Given a function with a return-value of type RETTYPE, return which</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     return-value convention that function would use.</code></pre></td>
        <td class="diff"><pre><code>     return-value convention that function would use.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     GDB currently recognizes two function return-value conventions:</code></pre></td>
        <td class="diff"><pre><code>     GDB currently recognizes two function return-value conventions:</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     `RETURN_VALUE_REGISTER_CONVENTION' where the return value is found</code></pre></td>
        <td class="diff"><pre><code>     `RETURN_VALUE_REGISTER_CONVENTION' where the return value is found</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     in registers; and `RETURN_VALUE_STRUCT_CONVENTION' where the return</code></pre></td>
        <td class="diff"><pre><code>     in registers; and `RETURN_VALUE_STRUCT_CONVENTION' where the return</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     value is found in memory and the address of that memory location is</code></pre></td>
        <td class="diff"><pre><code>     value is found in memory and the address of that memory location is</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     passed in as the function's first parameter.</code></pre></td>
        <td class="diff"><pre><code>     passed in as the function's first parameter.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     If the register convention is being used, and WRITEBUF is</code></pre></td>
        <td class="diff"><pre><code>     If the register convention is being used, and WRITEBUF is</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     non-`NULL', also copy the return-value in WRITEBUF into REGCACHE.</code></pre></td>
        <td class="diff"><pre><code>     non-`NULL', also copy the return-value in WRITEBUF into REGCACHE.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     If the register convention is being used, and READBUF is</code></pre></td>
        <td class="diff"><pre><code>     If the register convention is being used, and READBUF is</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     non-`NULL', also copy the return value from REGCACHE into READBUF</code></pre></td>
        <td class="diff"><pre><code>     non-`NULL', also copy the return value from REGCACHE into READBUF</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     (REGCACHE contains a copy of the registers from the just returned</code></pre></td>
        <td class="diff"><pre><code>     (REGCACHE contains a copy of the registers from the just returned</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     function).</code></pre></td>
        <td class="diff"><pre><code>     function).</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     _Maintainer note: This method replaces separate predicate, extract,</code></pre></td>
        <td class="diff"><pre><code>     _Maintainer note: This method replaces separate predicate, extract,</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     store methods.  By having only one method, the logic needed to</code></pre></td>
        <td class="diff"><pre><code>     store methods.  By having only one method, the logic needed to</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     determine the return-value convention need only be implemented in</code></pre></td>
        <td class="diff"><pre><code>     determine the return-value convention need only be implemented in</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     one place.  If GDB were written in an OO language, this method</code></pre></td>
        <td class="diff"><pre><code>     one place.  If GDB were written in an OO language, this method</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     would instead return an object that knew how to perform the</code></pre></td>
        <td class="diff"><pre><code>     would instead return an object that knew how to perform the</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     register return-value extract and store._</code></pre></td>
        <td class="diff"><pre><code>     register return-value extract and store._</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     _Maintainer note: This method does not take a GCC_P parameter, and</code></pre></td>
        <td class="diff"><pre><code>     _Maintainer note: This method does not take a GCC_P parameter, and</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     such a parameter should not be added.  If an architecture that</code></pre></td>
        <td class="diff"><pre><code>     such a parameter should not be added.  If an architecture that</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     requires per-compiler or per-function information be identified,</code></pre></td>
        <td class="diff"><pre><code>     requires per-compiler or per-function information be identified,</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     then the replacement of RETTYPE with `struct value' FUNCTION</code></pre></td>
        <td class="diff"><pre><code>     then the replacement of RETTYPE with `struct value' FUNCTION</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     should be pursued._</code></pre></td>
        <td class="diff"><pre><code>     should be pursued._</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     _Maintainer note: The REGCACHE parameter limits this methods to</code></pre></td>
        <td class="diff"><pre><code>     _Maintainer note: The REGCACHE parameter limits this methods to</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     the inner most frame.  While replacing REGCACHE with a `struct</code></pre></td>
        <td class="diff"><pre><code>     the inner most frame.  While replacing REGCACHE with a `struct</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     frame_info' FRAME parameter would remove that limitation there has</code></pre></td>
        <td class="diff"><pre><code>     frame_info' FRAME parameter would remove that limitation there has</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     yet to be a demonstrated need for such a change._</code></pre></td>
        <td class="diff"><pre><code>     yet to be a demonstrated need for such a change._</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>`void gdbarch_skip_permanent_breakpoint (GDBARCH, REGCACHE)'</code></pre></td>
        <td class="diff"><pre><code>`void gdbarch_skip_permanent_breakpoint (GDBARCH, REGCACHE)'</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     Advance the inferior's PC past a permanent breakpoint.  GDB</code></pre></td>
        <td class="diff"><pre><code>     Advance the inferior's PC past a permanent breakpoint.  GDB</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     normally steps over a breakpoint by removing it, stepping one</code></pre></td>
        <td class="diff"><pre><code>     normally steps over a breakpoint by removing it, stepping one</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     instruction, and re-inserting the breakpoint.  However, permanent</code></pre></td>
        <td class="diff"><pre><code>     instruction, and re-inserting the breakpoint.  However, permanent</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     breakpoints are hardwired into the inferior, and can't be removed,</code></pre></td>
        <td class="diff"><pre><code>     breakpoints are hardwired into the inferior, and can't be removed,</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     so this strategy doesn't work.  Calling</code></pre></td>
        <td class="diff"><pre><code>     so this strategy doesn't work.  Calling</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     `gdbarch_skip_permanent_breakpoint' adjusts the processor's state</code></pre></td>
        <td class="diff"><pre><code>     `gdbarch_skip_permanent_breakpoint' adjusts the processor's state</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     so that execution will resume just after the breakpoint.  This</code></pre></td>
        <td class="diff"><pre><code>     so that execution will resume just after the breakpoint.  This</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     function does the right thing even when the breakpoint is in the</code></pre></td>
        <td class="diff"><pre><code>     function does the right thing even when the breakpoint is in the</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     delay slot of a branch or jump.</code></pre></td>
        <td class="diff"><pre><code>     delay slot of a branch or jump.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>`CORE_ADDR gdbarch_skip_prologue (GDBARCH, IP)'</code></pre></td>
        <td class="diff"><pre><code>`CORE_ADDR gdbarch_skip_prologue (GDBARCH, IP)'</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     A function that returns the address of the "real" code beyond the</code></pre></td>
        <td class="diff"><pre><code>     A function that returns the address of the "real" code beyond the</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     function entry prologue found at IP.</code></pre></td>
        <td class="diff"><pre><code>     function entry prologue found at IP.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>`CORE_ADDR gdbarch_skip_trampoline_code (GDBARCH, FRAME, PC)'</code></pre></td>
        <td class="diff"><pre><code>`CORE_ADDR gdbarch_skip_trampoline_code (GDBARCH, FRAME, PC)'</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     If the target machine has trampoline code that sits between</code></pre></td>
        <td class="diff"><pre><code>     If the target machine has trampoline code that sits between</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     callers and the functions being called, then define this function</code></pre></td>
        <td class="diff"><pre><code>     callers and the functions being called, then define this function</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     to return a new PC that is at the start of the real function.</code></pre></td>
        <td class="diff"><pre><code>     to return a new PC that is at the start of the real function.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>`int gdbarch_sp_regnum (GDBARCH)'</code></pre></td>
        <td class="diff"><pre><code>`int gdbarch_sp_regnum (GDBARCH)'</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     If the stack-pointer is kept in a register, then use this function</code></pre></td>
        <td class="diff"><pre><code>     If the stack-pointer is kept in a register, then use this function</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     to return the number (greater than or equal to zero) of that</code></pre></td>
        <td class="diff"><pre><code>     to return the number (greater than or equal to zero) of that</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     register, or -1 if there is no such register.</code></pre></td>
        <td class="diff"><pre><code>     register, or -1 if there is no such register.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>`int gdbarch_stab_reg_to_regnum (GDBARCH, STAB_REGNR)'</code></pre></td>
        <td class="diff"><pre><code>`int gdbarch_stab_reg_to_regnum (GDBARCH, STAB_REGNR)'</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     Use this function to convert stab register STAB_REGNR into GDB</code></pre></td>
        <td class="diff"><pre><code>     Use this function to convert stab register STAB_REGNR into GDB</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     regnum.  If not defined, no conversion will be done.</code></pre></td>
        <td class="diff"><pre><code>     regnum.  If not defined, no conversion will be done.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>`SYMBOL_RELOADING_DEFAULT'</code></pre></td>
        <td class="diff"><pre><code>`SYMBOL_RELOADING_DEFAULT'</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     The default value of the "symbol-reloading" variable.  (Never</code></pre></td>
        <td class="diff"><pre><code>     The default value of the "symbol-reloading" variable.  (Never</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     defined in current sources.)</code></pre></td>
        <td class="diff"><pre><code>     defined in current sources.)</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>`TARGET_CHAR_BIT'</code></pre></td>
        <td class="diff"><pre><code>`TARGET_CHAR_BIT'</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     Number of bits in a char; defaults to 8.</code></pre></td>
        <td class="diff"><pre><code>     Number of bits in a char; defaults to 8.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>`int gdbarch_char_signed (GDBARCH)'</code></pre></td>
        <td class="diff"><pre><code>`int gdbarch_char_signed (GDBARCH)'</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     Non-zero if `char' is normally signed on this architecture; zero if</code></pre></td>
        <td class="diff"><pre><code>     Non-zero if `char' is normally signed on this architecture; zero if</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     it should be unsigned.</code></pre></td>
        <td class="diff"><pre><code>     it should be unsigned.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     The ISO C standard requires the compiler to treat `char' as</code></pre></td>
        <td class="diff"><pre><code>     The ISO C standard requires the compiler to treat `char' as</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     equivalent to either `signed char' or `unsigned char'; any</code></pre></td>
        <td class="diff"><pre><code>     equivalent to either `signed char' or `unsigned char'; any</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     character in the standard execution set is supposed to be positive.</code></pre></td>
        <td class="diff"><pre><code>     character in the standard execution set is supposed to be positive.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     Most compilers treat `char' as signed, but `char' is unsigned on</code></pre></td>
        <td class="diff"><pre><code>     Most compilers treat `char' as signed, but `char' is unsigned on</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     the IBM S/390, RS6000, and PowerPC targets.</code></pre></td>
        <td class="diff"><pre><code>     the IBM S/390, RS6000, and PowerPC targets.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>`int gdbarch_double_bit (GDBARCH)'</code></pre></td>
        <td class="diff"><pre><code>`int gdbarch_double_bit (GDBARCH)'</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     Number of bits in a double float; defaults to</code></pre></td>
        <td class="diff"><pre><code>     Number of bits in a double float; defaults to</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     `8 * TARGET_CHAR_BIT'.</code></pre></td>
        <td class="diff"><pre><code>     `8 * TARGET_CHAR_BIT'.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>`int gdbarch_float_bit (GDBARCH)'</code></pre></td>
        <td class="diff"><pre><code>`int gdbarch_float_bit (GDBARCH)'</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     Number of bits in a float; defaults to `4 * TARGET_CHAR_BIT'.</code></pre></td>
        <td class="diff"><pre><code>     Number of bits in a float; defaults to `4 * TARGET_CHAR_BIT'.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>`int gdbarch_int_bit (GDBARCH)'</code></pre></td>
        <td class="diff"><pre><code>`int gdbarch_int_bit (GDBARCH)'</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     Number of bits in an integer; defaults to `4 * TARGET_CHAR_BIT'.</code></pre></td>
        <td class="diff"><pre><code>     Number of bits in an integer; defaults to `4 * TARGET_CHAR_BIT'.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>`int gdbarch_long_bit (GDBARCH)'</code></pre></td>
        <td class="diff"><pre><code>`int gdbarch_long_bit (GDBARCH)'</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     Number of bits in a long integer; defaults to</code></pre></td>
        <td class="diff"><pre><code>     Number of bits in a long integer; defaults to</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     `4 * TARGET_CHAR_BIT'.</code></pre></td>
        <td class="diff"><pre><code>     `4 * TARGET_CHAR_BIT'.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>`int gdbarch_long_double_bit (GDBARCH)'</code></pre></td>
        <td class="diff"><pre><code>`int gdbarch_long_double_bit (GDBARCH)'</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     Number of bits in a long double float; defaults to</code></pre></td>
        <td class="diff"><pre><code>     Number of bits in a long double float; defaults to</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     `2 * gdbarch_double_bit (GDBARCH)'.</code></pre></td>
        <td class="diff"><pre><code>     `2 * gdbarch_double_bit (GDBARCH)'.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>`int gdbarch_long_long_bit (GDBARCH)'</code></pre></td>
        <td class="diff"><pre><code>`int gdbarch_long_long_bit (GDBARCH)'</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     Number of bits in a long long integer; defaults to</code></pre></td>
        <td class="diff"><pre><code>     Number of bits in a long long integer; defaults to</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     `2 * gdbarch_long_bit (GDBARCH)'.</code></pre></td>
        <td class="diff"><pre><code>     `2 * gdbarch_long_bit (GDBARCH)'.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>`int gdbarch_ptr_bit (GDBARCH)'</code></pre></td>
        <td class="diff"><pre><code>`int gdbarch_ptr_bit (GDBARCH)'</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     Number of bits in a pointer; defaults to</code></pre></td>
        <td class="diff"><pre><code>     Number of bits in a pointer; defaults to</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     `gdbarch_int_bit (GDBARCH)'.</code></pre></td>
        <td class="diff"><pre><code>     `gdbarch_int_bit (GDBARCH)'.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>`int gdbarch_short_bit (GDBARCH)'</code></pre></td>
        <td class="diff"><pre><code>`int gdbarch_short_bit (GDBARCH)'</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     Number of bits in a short integer; defaults to</code></pre></td>
        <td class="diff"><pre><code>     Number of bits in a short integer; defaults to</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     `2 * TARGET_CHAR_BIT'.</code></pre></td>
        <td class="diff"><pre><code>     `2 * TARGET_CHAR_BIT'.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>`CORE_ADDR gdbarch_read_pc (GDBARCH, REGCACHE)'</code></pre></td>
        <td class="diff"><pre><code>`CORE_ADDR gdbarch_read_pc (GDBARCH, REGCACHE)'</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>`gdbarch_write_pc (GDBARCH, REGCACHE, VAL)'</code></pre></td>
        <td class="diff"><pre><code>`gdbarch_write_pc (GDBARCH, REGCACHE, VAL)'</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>`TARGET_READ_SP'</code></pre></td>
        <td class="diff"><pre><code>`TARGET_READ_SP'</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>`TARGET_READ_FP'</code></pre></td>
        <td class="diff"><pre><code>`TARGET_READ_FP'</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     These change the behavior of `gdbarch_read_pc',</code></pre></td>
        <td class="diff"><pre><code>     These change the behavior of `gdbarch_read_pc',</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     `gdbarch_write_pc', and `read_sp'.  For most targets, these may be</code></pre></td>
        <td class="diff"><pre><code>     `gdbarch_write_pc', and `read_sp'.  For most targets, these may be</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     left undefined.  GDB will call the read and write register</code></pre></td>
        <td class="diff"><pre><code>     left undefined.  GDB will call the read and write register</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     functions with the relevant `_REGNUM' argument.</code></pre></td>
        <td class="diff"><pre><code>     functions with the relevant `_REGNUM' argument.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     These macros and functions are useful when a target keeps one of</code></pre></td>
        <td class="diff"><pre><code>     These macros and functions are useful when a target keeps one of</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     these registers in a hard to get at place; for example, part in a</code></pre></td>
        <td class="diff"><pre><code>     these registers in a hard to get at place; for example, part in a</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     segment register and part in an ordinary register.</code></pre></td>
        <td class="diff"><pre><code>     segment register and part in an ordinary register.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     *Note gdbarch_unwind_sp::, which replaces `TARGET_READ_SP'.</code></pre></td>
        <td class="diff"><pre><code>     *Note gdbarch_unwind_sp::, which replaces `TARGET_READ_SP'.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>`void gdbarch_virtual_frame_pointer (GDBARCH, PC, FRAME_REGNUM, FRAME_OFFSET)'</code></pre></td>
        <td class="diff"><pre><code>`void gdbarch_virtual_frame_pointer (GDBARCH, PC, FRAME_REGNUM, FRAME_OFFSET)'</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     Returns a `(register, offset)' pair representing the virtual frame</code></pre></td>
        <td class="diff"><pre><code>     Returns a `(register, offset)' pair representing the virtual frame</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     pointer in use at the code address PC.  If virtual frame pointers</code></pre></td>
        <td class="diff"><pre><code>     pointer in use at the code address PC.  If virtual frame pointers</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     are not used, a default definition simply returns</code></pre></td>
        <td class="diff"><pre><code>     are not used, a default definition simply returns</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     `DEPRECATED_FP_REGNUM', with an offset of zero.</code></pre></td>
        <td class="diff"><pre><code>     `DEPRECATED_FP_REGNUM', with an offset of zero.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>`TARGET_HAS_HARDWARE_WATCHPOINTS'</code></pre></td>
        <td class="diff"><pre><code>`TARGET_HAS_HARDWARE_WATCHPOINTS'</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     If non-zero, the target has support for hardware-assisted</code></pre></td>
        <td class="diff"><pre><code>     If non-zero, the target has support for hardware-assisted</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     watchpoints.  *Note watchpoints: Algorithms, for more details and</code></pre></td>
        <td class="diff"><pre><code>     watchpoints.  *Note watchpoints: Algorithms, for more details and</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     other related macros.</code></pre></td>
        <td class="diff"><pre><code>     other related macros.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>`int gdbarch_print_insn (GDBARCH, VMA, INFO)'</code></pre></td>
        <td class="diff"><pre><code>`int gdbarch_print_insn (GDBARCH, VMA, INFO)'</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     This is the function used by GDB to print an assembly instruction.</code></pre></td>
        <td class="diff"><pre><code>     This is the function used by GDB to print an assembly instruction.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     It prints the instruction at address VMA in debugged memory and</code></pre></td>
        <td class="diff"><pre><code>     It prints the instruction at address VMA in debugged memory and</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     returns the length of the instruction, in bytes.  If a target</code></pre></td>
        <td class="diff"><pre><code>     returns the length of the instruction, in bytes.  If a target</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     doesn't define its own printing routine, it defaults to an</code></pre></td>
        <td class="diff"><pre><code>     doesn't define its own printing routine, it defaults to an</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     accessor function for the global pointer</code></pre></td>
        <td class="diff"><pre><code>     accessor function for the global pointer</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     `deprecated_tm_print_insn'.  This usually points to a function in</code></pre></td>
        <td class="diff"><pre><code>     `deprecated_tm_print_insn'.  This usually points to a function in</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     the `opcodes' library (*note Opcodes: Support Libraries.).  INFO</code></pre></td>
        <td class="diff"><pre><code>     the `opcodes' library (*note Opcodes: Support Libraries.).  INFO</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     is a structure (of type `disassemble_info') defined in</code></pre></td>
        <td class="diff"><pre><code>     is a structure (of type `disassemble_info') defined in</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     `include/dis-asm.h' used to pass information to the instruction</code></pre></td>
        <td class="diff"><pre><code>     `include/dis-asm.h' used to pass information to the instruction</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     decoding routine.</code></pre></td>
        <td class="diff"><pre><code>     decoding routine.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>`frame_id gdbarch_unwind_dummy_id (GDBARCH, FRAME)'</code></pre></td>
        <td class="diff"><pre><code>`frame_id gdbarch_unwind_dummy_id (GDBARCH, FRAME)'</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     Given FRAME return a `struct frame_id' that uniquely identifies an</code></pre></td>
        <td class="diff"><pre><code>     Given FRAME return a `struct frame_id' that uniquely identifies an</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     inferior function call's dummy frame.  The value returned must</code></pre></td>
        <td class="diff"><pre><code>     inferior function call's dummy frame.  The value returned must</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     match the dummy frame stack value previously saved using</code></pre></td>
        <td class="diff"><pre><code>     match the dummy frame stack value previously saved using</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     `SAVE_DUMMY_FRAME_TOS'.  *Note SAVE_DUMMY_FRAME_TOS::.</code></pre></td>
        <td class="diff"><pre><code>     `SAVE_DUMMY_FRAME_TOS'.  *Note SAVE_DUMMY_FRAME_TOS::.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>`DEPRECATED_USE_STRUCT_CONVENTION (GCC_P, TYPE)'</code></pre></td>
        <td class="diff"><pre><code>`DEPRECATED_USE_STRUCT_CONVENTION (GCC_P, TYPE)'</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     If defined, this must be an expression that is nonzero if a value</code></pre></td>
        <td class="diff"><pre><code>     If defined, this must be an expression that is nonzero if a value</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     of the given TYPE being returned from a function must have space</code></pre></td>
        <td class="diff"><pre><code>     of the given TYPE being returned from a function must have space</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     allocated for it on the stack.  GCC_P is true if the function</code></pre></td>
        <td class="diff"><pre><code>     allocated for it on the stack.  GCC_P is true if the function</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     being considered is known to have been compiled by GCC; this is</code></pre></td>
        <td class="diff"><pre><code>     being considered is known to have been compiled by GCC; this is</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     helpful for systems where GCC is known to use different calling</code></pre></td>
        <td class="diff"><pre><code>     helpful for systems where GCC is known to use different calling</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     convention than other compilers.</code></pre></td>
        <td class="diff"><pre><code>     convention than other compilers.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     This method has been deprecated in favour of `gdbarch_return_value'</code></pre></td>
        <td class="diff"><pre><code>     This method has been deprecated in favour of `gdbarch_return_value'</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     (*note gdbarch_return_value::).</code></pre></td>
        <td class="diff"><pre><code>     (*note gdbarch_return_value::).</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>`void gdbarch_value_to_register (GDBARCH, FRAME, TYPE, BUF)'</code></pre></td>
        <td class="diff"><pre><code>`void gdbarch_value_to_register (GDBARCH, FRAME, TYPE, BUF)'</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     Convert a value of type TYPE into the raw contents of a register.</code></pre></td>
        <td class="diff"><pre><code>     Convert a value of type TYPE into the raw contents of a register.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     *Note Using Different Register and Memory Data Representations:</code></pre></td>
        <td class="diff"><pre><code>     *Note Using Different Register and Memory Data Representations:</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     Target Architecture Definition.</code></pre></td>
        <td class="diff"><pre><code>     Target Architecture Definition.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>   Motorola M68K target conditionals.</code></pre></td>
        <td class="diff"><pre><code>   Motorola M68K target conditionals.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>`BPT_VECTOR'</code></pre></td>
        <td class="diff"><pre><code>`BPT_VECTOR'</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     Define this to be the 4-bit location of the breakpoint trap</code></pre></td>
        <td class="diff"><pre><code>     Define this to be the 4-bit location of the breakpoint trap</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     vector.  If not defined, it will default to `0xf'.</code></pre></td>
        <td class="diff"><pre><code>     vector.  If not defined, it will default to `0xf'.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>`REMOTE_BPT_VECTOR'</code></pre></td>
        <td class="diff"><pre><code>`REMOTE_BPT_VECTOR'</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     Defaults to `1'.</code></pre></td>
        <td class="diff"><pre><code>     Defaults to `1'.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>`const char *gdbarch_name_of_malloc (GDBARCH)'</code></pre></td>
        <td class="diff"><pre><code>`const char *gdbarch_name_of_malloc (GDBARCH)'</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     A string containing the name of the function to call in order to</code></pre></td>
        <td class="diff"><pre><code>     A string containing the name of the function to call in order to</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     allocate some memory in the inferior. The default value is</code></pre></td>
        <td class="diff"><pre><code>     allocate some memory in the inferior. The default value is</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     "malloc".</code></pre></td>
        <td class="diff"><pre><code>     "malloc".</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>File: gdbint.info,  Node: Adding a New Target,  Prev: Target Conditionals,  Up: Target Architecture Definition</code></pre></td>
        <td class="diff"><pre><code>File: gdbint.info,  Node: Adding a New Target,  Prev: Target Conditionals,  Up: Target Architecture Definition</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>9.12 Adding a New Target</code></pre></td>
        <td class="diff"><pre><code>9.12 Adding a New Target</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>========================</code></pre></td>
        <td class="diff"><pre><code>========================</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>The following files add a target to GDB:</code></pre></td>
        <td class="diff"><pre><code>The following files add a target to GDB:</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>`gdb/config/ARCH/TTT.mt'</code></pre></td>
        <td class="diff"><pre><code>`gdb/config/ARCH/TTT.mt'</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     Contains a Makefile fragment specific to this target.  Specifies</code></pre></td>
        <td class="diff"><pre><code>     Contains a Makefile fragment specific to this target.  Specifies</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     what object files are needed for target TTT, by defining</code></pre></td>
        <td class="diff"><pre><code>     what object files are needed for target TTT, by defining</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     `TDEPFILES=...' and `TDEPLIBS=...'.  Also specifies the header</code></pre></td>
        <td class="diff"><pre><code>     `TDEPFILES=...' and `TDEPLIBS=...'.  Also specifies the header</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     file which describes TTT, by defining `TM_FILE= tm-TTT.h'.</code></pre></td>
        <td class="diff"><pre><code>     file which describes TTT, by defining `TM_FILE= tm-TTT.h'.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     You can also define `TM_CFLAGS', `TM_CLIBS', `TM_CDEPS', but these</code></pre></td>
        <td class="diff"><pre><code>     You can also define `TM_CFLAGS', `TM_CLIBS', `TM_CDEPS', but these</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     are now deprecated, replaced by autoconf, and may go away in</code></pre></td>
        <td class="diff"><pre><code>     are now deprecated, replaced by autoconf, and may go away in</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     future versions of GDB.</code></pre></td>
        <td class="diff"><pre><code>     future versions of GDB.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>`gdb/TTT-tdep.c'</code></pre></td>
        <td class="diff"><pre><code>`gdb/TTT-tdep.c'</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     Contains any miscellaneous code required for this target machine.</code></pre></td>
        <td class="diff"><pre><code>     Contains any miscellaneous code required for this target machine.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     On some machines it doesn't exist at all.  Sometimes the macros in</code></pre></td>
        <td class="diff"><pre><code>     On some machines it doesn't exist at all.  Sometimes the macros in</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     `tm-TTT.h' become very complicated, so they are implemented as</code></pre></td>
        <td class="diff"><pre><code>     `tm-TTT.h' become very complicated, so they are implemented as</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     functions here instead, and the macro is simply defined to call the</code></pre></td>
        <td class="diff"><pre><code>     functions here instead, and the macro is simply defined to call the</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     function.  This is vastly preferable, since it is easier to</code></pre></td>
        <td class="diff"><pre><code>     function.  This is vastly preferable, since it is easier to</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     understand and debug.</code></pre></td>
        <td class="diff"><pre><code>     understand and debug.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>`gdb/ARCH-tdep.c'</code></pre></td>
        <td class="diff"><pre><code>`gdb/ARCH-tdep.c'</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>`gdb/ARCH-tdep.h'</code></pre></td>
        <td class="diff"><pre><code>`gdb/ARCH-tdep.h'</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     This often exists to describe the basic layout of the target</code></pre></td>
        <td class="diff"><pre><code>     This often exists to describe the basic layout of the target</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     machine's processor chip (registers, stack, etc.).  If used, it is</code></pre></td>
        <td class="diff"><pre><code>     machine's processor chip (registers, stack, etc.).  If used, it is</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     included by `TTT-tdep.h'.  It can be shared among many targets</code></pre></td>
        <td class="diff"><pre><code>     included by `TTT-tdep.h'.  It can be shared among many targets</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     that use the same processor.</code></pre></td>
        <td class="diff"><pre><code>     that use the same processor.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>`gdb/config/ARCH/tm-TTT.h'</code></pre></td>
        <td class="diff"><pre><code>`gdb/config/ARCH/tm-TTT.h'</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     (`tm.h' is a link to this file, created by `configure').  Contains</code></pre></td>
        <td class="diff"><pre><code>     (`tm.h' is a link to this file, created by `configure').  Contains</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     macro definitions about the target machine's registers, stack frame</code></pre></td>
        <td class="diff"><pre><code>     macro definitions about the target machine's registers, stack frame</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     format and instructions.</code></pre></td>
        <td class="diff"><pre><code>     format and instructions.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     New targets do not need this file and should not create it.</code></pre></td>
        <td class="diff"><pre><code>     New targets do not need this file and should not create it.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>`gdb/config/ARCH/tm-ARCH.h'</code></pre></td>
        <td class="diff"><pre><code>`gdb/config/ARCH/tm-ARCH.h'</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     This often exists to describe the basic layout of the target</code></pre></td>
        <td class="diff"><pre><code>     This often exists to describe the basic layout of the target</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     machine's processor chip (registers, stack, etc.).  If used, it is</code></pre></td>
        <td class="diff"><pre><code>     machine's processor chip (registers, stack, etc.).  If used, it is</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     included by `tm-TTT.h'.  It can be shared among many targets that</code></pre></td>
        <td class="diff"><pre><code>     included by `tm-TTT.h'.  It can be shared among many targets that</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     use the same processor.</code></pre></td>
        <td class="diff"><pre><code>     use the same processor.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     New targets do not need this file and should not create it.</code></pre></td>
        <td class="diff"><pre><code>     New targets do not need this file and should not create it.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>   If you are adding a new operating system for an existing CPU chip,</code></pre></td>
        <td class="diff"><pre><code>   If you are adding a new operating system for an existing CPU chip,</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>add a `config/tm-OS.h' file that describes the operating system</code></pre></td>
        <td class="diff"><pre><code>add a `config/tm-OS.h' file that describes the operating system</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>facilities that are unusual (extra symbol table info; the breakpoint</code></pre></td>
        <td class="diff"><pre><code>facilities that are unusual (extra symbol table info; the breakpoint</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>instruction needed; etc.).  Then write a `ARCH/tm-OS.h' that just</code></pre></td>
        <td class="diff"><pre><code>instruction needed; etc.).  Then write a `ARCH/tm-OS.h' that just</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>`#include's `tm-ARCH.h' and `config/tm-OS.h'.</code></pre></td>
        <td class="diff"><pre><code>`#include's `tm-ARCH.h' and `config/tm-OS.h'.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>File: gdbint.info,  Node: Target Descriptions,  Next: Target Vector Definition,  Prev: Target Architecture Definition,  Up: Top</code></pre></td>
        <td class="diff"><pre><code>File: gdbint.info,  Node: Target Descriptions,  Next: Target Vector Definition,  Prev: Target Architecture Definition,  Up: Top</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>10 Target Descriptions</code></pre></td>
        <td class="diff"><pre><code>10 Target Descriptions</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>**********************</code></pre></td>
        <td class="diff"><pre><code>**********************</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>The target architecture definition (*note Target Architecture</code></pre></td>
        <td class="diff"><pre><code>The target architecture definition (*note Target Architecture</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>Definition::) contains GDB's hard-coded knowledge about an</code></pre></td>
        <td class="diff"><pre><code>Definition::) contains GDB's hard-coded knowledge about an</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>architecture.  For some platforms, it is handy to have more flexible</code></pre></td>
        <td class="diff"><pre><code>architecture.  For some platforms, it is handy to have more flexible</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>knowledge about a specific instance of the architecture--for instance,</code></pre></td>
        <td class="diff"><pre><code>knowledge about a specific instance of the architecture--for instance,</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>a processor or development board.  "Target descriptions" provide a</code></pre></td>
        <td class="diff"><pre><code>a processor or development board.  "Target descriptions" provide a</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>mechanism for the user to tell GDB more about what their target</code></pre></td>
        <td class="diff"><pre><code>mechanism for the user to tell GDB more about what their target</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>supports, or for the target to tell GDB directly.</code></pre></td>
        <td class="diff"><pre><code>supports, or for the target to tell GDB directly.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>   For details on writing, automatically supplying, and manually</code></pre></td>
        <td class="diff"><pre><code>   For details on writing, automatically supplying, and manually</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>selecting target descriptions, see *Note Target Descriptions:</code></pre></td>
        <td class="diff"><pre><code>selecting target descriptions, see *Note Target Descriptions:</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>(gdb)Target Descriptions.  This section will cover some related topics</code></pre></td>
        <td class="diff"><pre><code>(gdb)Target Descriptions.  This section will cover some related topics</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>about the GDB internals.</code></pre></td>
        <td class="diff"><pre><code>about the GDB internals.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>* Menu:</code></pre></td>
        <td class="diff"><pre><code>* Menu:</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>* Target Descriptions Implementation::</code></pre></td>
        <td class="diff"><pre><code>* Target Descriptions Implementation::</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>* Adding Target Described Register Support::</code></pre></td>
        <td class="diff"><pre><code>* Adding Target Described Register Support::</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>File: gdbint.info,  Node: Target Descriptions Implementation,  Next: Adding Target Described Register Support,  Up: Target Descriptions</code></pre></td>
        <td class="diff"><pre><code>File: gdbint.info,  Node: Target Descriptions Implementation,  Next: Adding Target Described Register Support,  Up: Target Descriptions</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>10.1 Target Descriptions Implementation</code></pre></td>
        <td class="diff"><pre><code>10.1 Target Descriptions Implementation</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>=======================================</code></pre></td>
        <td class="diff"><pre><code>=======================================</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>Before GDB connects to a new target, or runs a new program on an</code></pre></td>
        <td class="diff"><pre><code>Before GDB connects to a new target, or runs a new program on an</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>existing target, it discards any existing target description and</code></pre></td>
        <td class="diff"><pre><code>existing target, it discards any existing target description and</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>reverts to a default gdbarch.  Then, after connecting, it looks for a</code></pre></td>
        <td class="diff"><pre><code>reverts to a default gdbarch.  Then, after connecting, it looks for a</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>new target description by calling `target_find_description'.</code></pre></td>
        <td class="diff"><pre><code>new target description by calling `target_find_description'.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>   A description may come from a user specified file (XML), the remote</code></pre></td>
        <td class="diff"><pre><code>   A description may come from a user specified file (XML), the remote</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>`qXfer:features:read' packet (also XML), or from any custom</code></pre></td>
        <td class="diff"><pre><code>`qXfer:features:read' packet (also XML), or from any custom</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>`to_read_description' routine in the target vector.  For instance, the</code></pre></td>
        <td class="diff"><pre><code>`to_read_description' routine in the target vector.  For instance, the</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>remote target supports guessing whether a MIPS target is 32-bit or</code></pre></td>
        <td class="diff"><pre><code>remote target supports guessing whether a MIPS target is 32-bit or</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>64-bit based on the size of the `g' packet.</code></pre></td>
        <td class="diff"><pre><code>64-bit based on the size of the `g' packet.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>   If any target description is found, GDB creates a new gdbarch</code></pre></td>
        <td class="diff"><pre><code>   If any target description is found, GDB creates a new gdbarch</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>incorporating the description by calling `gdbarch_update_p'.  Any</code></pre></td>
        <td class="diff"><pre><code>incorporating the description by calling `gdbarch_update_p'.  Any</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>`<architecture>' element is handled first, to determine which</code></pre></td>
        <td class="diff"><pre><code>`<architecture>' element is handled first, to determine which</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>architecture's gdbarch initialization routine is called to create the</code></pre></td>
        <td class="diff"><pre><code>architecture's gdbarch initialization routine is called to create the</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>new architecture.  Then the initialization routine is called, and has a</code></pre></td>
        <td class="diff"><pre><code>new architecture.  Then the initialization routine is called, and has a</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>chance to adjust the constructed architecture based on the contents of</code></pre></td>
        <td class="diff"><pre><code>chance to adjust the constructed architecture based on the contents of</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>the target description.  For instance, it can recognize any properties</code></pre></td>
        <td class="diff"><pre><code>the target description.  For instance, it can recognize any properties</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>set by a `to_read_description' routine.  Also see *Note Adding Target</code></pre></td>
        <td class="diff"><pre><code>set by a `to_read_description' routine.  Also see *Note Adding Target</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>Described Register Support::.</code></pre></td>
        <td class="diff"><pre><code>Described Register Support::.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>File: gdbint.info,  Node: Adding Target Described Register Support,  Prev: Target Descriptions Implementation,  Up: Target Descriptions</code></pre></td>
        <td class="diff"><pre><code>File: gdbint.info,  Node: Adding Target Described Register Support,  Prev: Target Descriptions Implementation,  Up: Target Descriptions</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>10.2 Adding Target Described Register Support</code></pre></td>
        <td class="diff"><pre><code>10.2 Adding Target Described Register Support</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>=============================================</code></pre></td>
        <td class="diff"><pre><code>=============================================</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>Target descriptions can report additional registers specific to an</code></pre></td>
        <td class="diff"><pre><code>Target descriptions can report additional registers specific to an</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>instance of the target.  But it takes a little work in the architecture</code></pre></td>
        <td class="diff"><pre><code>instance of the target.  But it takes a little work in the architecture</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>specific routines to support this.</code></pre></td>
        <td class="diff"><pre><code>specific routines to support this.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>   A target description must either have no registers or a complete</code></pre></td>
        <td class="diff"><pre><code>   A target description must either have no registers or a complete</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>set--this avoids complexity in trying to merge standard registers with</code></pre></td>
        <td class="diff"><pre><code>set--this avoids complexity in trying to merge standard registers with</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>the target defined registers.  It is the architecture's responsibility</code></pre></td>
        <td class="diff"><pre><code>the target defined registers.  It is the architecture's responsibility</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>to validate that a description with registers has everything it needs.</code></pre></td>
        <td class="diff"><pre><code>to validate that a description with registers has everything it needs.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>To keep architecture code simple, the same mechanism is used to assign</code></pre></td>
        <td class="diff"><pre><code>To keep architecture code simple, the same mechanism is used to assign</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>fixed internal register numbers to standard registers.</code></pre></td>
        <td class="diff"><pre><code>fixed internal register numbers to standard registers.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>   If `tdesc_has_registers' returns 1, the description contains</code></pre></td>
        <td class="diff"><pre><code>   If `tdesc_has_registers' returns 1, the description contains</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>registers.  The architecture's `gdbarch_init' routine should:</code></pre></td>
        <td class="diff"><pre><code>registers.  The architecture's `gdbarch_init' routine should:</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>   * Call `tdesc_data_alloc' to allocate storage, early, before</code></pre></td>
        <td class="diff"><pre><code>   * Call `tdesc_data_alloc' to allocate storage, early, before</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     searching for a matching gdbarch or allocating a new one.</code></pre></td>
        <td class="diff"><pre><code>     searching for a matching gdbarch or allocating a new one.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>   * Use `tdesc_find_feature' to locate standard features by name.</code></pre></td>
        <td class="diff"><pre><code>   * Use `tdesc_find_feature' to locate standard features by name.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>   * Use `tdesc_numbered_register' and `tdesc_numbered_register_choices'</code></pre></td>
        <td class="diff"><pre><code>   * Use `tdesc_numbered_register' and `tdesc_numbered_register_choices'</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     to locate the expected registers in the standard features.</code></pre></td>
        <td class="diff"><pre><code>     to locate the expected registers in the standard features.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>   * Return `NULL' if a required feature is missing, or if any standard</code></pre></td>
        <td class="diff"><pre><code>   * Return `NULL' if a required feature is missing, or if any standard</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     feature is missing expected registers.  This will produce a</code></pre></td>
        <td class="diff"><pre><code>     feature is missing expected registers.  This will produce a</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     warning that the description was incomplete.</code></pre></td>
        <td class="diff"><pre><code>     warning that the description was incomplete.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>   * Free the allocated data before returning, unless</code></pre></td>
        <td class="diff"><pre><code>   * Free the allocated data before returning, unless</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     `tdesc_use_registers' is called.</code></pre></td>
        <td class="diff"><pre><code>     `tdesc_use_registers' is called.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>   * Call `set_gdbarch_num_regs' as usual, with a number higher than any</code></pre></td>
        <td class="diff"><pre><code>   * Call `set_gdbarch_num_regs' as usual, with a number higher than any</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     fixed number passed to `tdesc_numbered_register'.</code></pre></td>
        <td class="diff"><pre><code>     fixed number passed to `tdesc_numbered_register'.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>   * Call `tdesc_use_registers' after creating a new gdbarch, before</code></pre></td>
        <td class="diff"><pre><code>   * Call `tdesc_use_registers' after creating a new gdbarch, before</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     returning it.</code></pre></td>
        <td class="diff"><pre><code>     returning it.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>   After `tdesc_use_registers' has been called, the architecture's</code></pre></td>
        <td class="diff"><pre><code>   After `tdesc_use_registers' has been called, the architecture's</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>`register_name', `register_type', and `register_reggroup_p' routines</code></pre></td>
        <td class="diff"><pre><code>`register_name', `register_type', and `register_reggroup_p' routines</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>will not be called; that information will be taken from the target</code></pre></td>
        <td class="diff"><pre><code>will not be called; that information will be taken from the target</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>description.  `num_regs' may be increased to account for any additional</code></pre></td>
        <td class="diff"><pre><code>description.  `num_regs' may be increased to account for any additional</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>registers in the description.</code></pre></td>
        <td class="diff"><pre><code>registers in the description.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>   Pseudo-registers require some extra care:</code></pre></td>
        <td class="diff"><pre><code>   Pseudo-registers require some extra care:</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>   * Using `tdesc_numbered_register' allows the architecture to give</code></pre></td>
        <td class="diff"><pre><code>   * Using `tdesc_numbered_register' allows the architecture to give</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     constant register numbers to standard architectural registers, e.g.</code></pre></td>
        <td class="diff"><pre><code>     constant register numbers to standard architectural registers, e.g.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     as an `enum' in `ARCH-tdep.h'.  But because pseudo-registers are</code></pre></td>
        <td class="diff"><pre><code>     as an `enum' in `ARCH-tdep.h'.  But because pseudo-registers are</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     always numbered above `num_regs', which may be increased by the</code></pre></td>
        <td class="diff"><pre><code>     always numbered above `num_regs', which may be increased by the</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     description, constant numbers can not be used for pseudos.  They</code></pre></td>
        <td class="diff"><pre><code>     description, constant numbers can not be used for pseudos.  They</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     must be numbered relative to `num_regs' instead.</code></pre></td>
        <td class="diff"><pre><code>     must be numbered relative to `num_regs' instead.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>   * The description will not describe pseudo-registers, so the</code></pre></td>
        <td class="diff"><pre><code>   * The description will not describe pseudo-registers, so the</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     architecture must call `set_tdesc_pseudo_register_name',</code></pre></td>
        <td class="diff"><pre><code>     architecture must call `set_tdesc_pseudo_register_name',</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     `set_tdesc_pseudo_register_type', and</code></pre></td>
        <td class="diff"><pre><code>     `set_tdesc_pseudo_register_type', and</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     `set_tdesc_pseudo_register_reggroup_p' to supply routines</code></pre></td>
        <td class="diff"><pre><code>     `set_tdesc_pseudo_register_reggroup_p' to supply routines</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     describing pseudo registers.  These routines will be passed</code></pre></td>
        <td class="diff"><pre><code>     describing pseudo registers.  These routines will be passed</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     internal register numbers, so the same routines used for the</code></pre></td>
        <td class="diff"><pre><code>     internal register numbers, so the same routines used for the</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     gdbarch equivalents are usually suitable.</code></pre></td>
        <td class="diff"><pre><code>     gdbarch equivalents are usually suitable.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>File: gdbint.info,  Node: Target Vector Definition,  Next: Native Debugging,  Prev: Target Descriptions,  Up: Top</code></pre></td>
        <td class="diff"><pre><code>File: gdbint.info,  Node: Target Vector Definition,  Next: Native Debugging,  Prev: Target Descriptions,  Up: Top</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>11 Target Vector Definition</code></pre></td>
        <td class="diff"><pre><code>11 Target Vector Definition</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>***************************</code></pre></td>
        <td class="diff"><pre><code>***************************</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>The target vector defines the interface between GDB's abstract handling</code></pre></td>
        <td class="diff"><pre><code>The target vector defines the interface between GDB's abstract handling</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>of target systems, and the nitty-gritty code that actually exercises</code></pre></td>
        <td class="diff"><pre><code>of target systems, and the nitty-gritty code that actually exercises</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>control over a process or a serial port.  GDB includes some 30-40</code></pre></td>
        <td class="diff"><pre><code>control over a process or a serial port.  GDB includes some 30-40</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>different target vectors; however, each configuration of GDB includes</code></pre></td>
        <td class="diff"><pre><code>different target vectors; however, each configuration of GDB includes</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>only a few of them.</code></pre></td>
        <td class="diff"><pre><code>only a few of them.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>* Menu:</code></pre></td>
        <td class="diff"><pre><code>* Menu:</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>* Managing Execution State::</code></pre></td>
        <td class="diff"><pre><code>* Managing Execution State::</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>* Existing Targets::</code></pre></td>
        <td class="diff"><pre><code>* Existing Targets::</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>File: gdbint.info,  Node: Managing Execution State,  Next: Existing Targets,  Up: Target Vector Definition</code></pre></td>
        <td class="diff"><pre><code>File: gdbint.info,  Node: Managing Execution State,  Next: Existing Targets,  Up: Target Vector Definition</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>11.1 Managing Execution State</code></pre></td>
        <td class="diff"><pre><code>11.1 Managing Execution State</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>=============================</code></pre></td>
        <td class="diff"><pre><code>=============================</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>A target vector can be completely inactive (not pushed on the target</code></pre></td>
        <td class="diff"><pre><code>A target vector can be completely inactive (not pushed on the target</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>stack), active but not running (pushed, but not connected to a fully</code></pre></td>
        <td class="diff"><pre><code>stack), active but not running (pushed, but not connected to a fully</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>manifested inferior), or completely active (pushed, with an accessible</code></pre></td>
        <td class="diff"><pre><code>manifested inferior), or completely active (pushed, with an accessible</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>inferior).  Most targets are only completely inactive or completely</code></pre></td>
        <td class="diff"><pre><code>inferior).  Most targets are only completely inactive or completely</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>active, but some support persistent connections to a target even when</code></pre></td>
        <td class="diff"><pre><code>active, but some support persistent connections to a target even when</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>the target has exited or not yet started.</code></pre></td>
        <td class="diff"><pre><code>the target has exited or not yet started.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>   For example, connecting to the simulator using `target sim' does not</code></pre></td>
        <td class="diff"><pre><code>   For example, connecting to the simulator using `target sim' does not</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>create a running program.  Neither registers nor memory are accessible</code></pre></td>
        <td class="diff"><pre><code>create a running program.  Neither registers nor memory are accessible</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>until `run'.  Similarly, after `kill', the program can not continue</code></pre></td>
        <td class="diff"><pre><code>until `run'.  Similarly, after `kill', the program can not continue</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>executing.  But in both cases GDB remains connected to the simulator,</code></pre></td>
        <td class="diff"><pre><code>executing.  But in both cases GDB remains connected to the simulator,</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>and target-specific commands are directed to the simulator.</code></pre></td>
        <td class="diff"><pre><code>and target-specific commands are directed to the simulator.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>   A target which only supports complete activation should push itself</code></pre></td>
        <td class="diff"><pre><code>   A target which only supports complete activation should push itself</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>onto the stack in its `to_open' routine (by calling `push_target'), and</code></pre></td>
        <td class="diff"><pre><code>onto the stack in its `to_open' routine (by calling `push_target'), and</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>unpush itself from the stack in its `to_mourn_inferior' routine (by</code></pre></td>
        <td class="diff"><pre><code>unpush itself from the stack in its `to_mourn_inferior' routine (by</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>calling `unpush_target').</code></pre></td>
        <td class="diff"><pre><code>calling `unpush_target').</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>   A target which supports both partial and complete activation should</code></pre></td>
        <td class="diff"><pre><code>   A target which supports both partial and complete activation should</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>still call `push_target' in `to_open', but not call `unpush_target' in</code></pre></td>
        <td class="diff"><pre><code>still call `push_target' in `to_open', but not call `unpush_target' in</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>`to_mourn_inferior'.  Instead, it should call either</code></pre></td>
        <td class="diff"><pre><code>`to_mourn_inferior'.  Instead, it should call either</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>`target_mark_running' or `target_mark_exited' in its `to_open',</code></pre></td>
        <td class="diff"><pre><code>`target_mark_running' or `target_mark_exited' in its `to_open',</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>depending on whether the target is fully active after connection.  It</code></pre></td>
        <td class="diff"><pre><code>depending on whether the target is fully active after connection.  It</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>should also call `target_mark_running' any time the inferior becomes</code></pre></td>
        <td class="diff"><pre><code>should also call `target_mark_running' any time the inferior becomes</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>fully active (e.g. in `to_create_inferior' and `to_attach'), and</code></pre></td>
        <td class="diff"><pre><code>fully active (e.g. in `to_create_inferior' and `to_attach'), and</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>`target_mark_exited' when the inferior becomes inactive (in</code></pre></td>
        <td class="diff"><pre><code>`target_mark_exited' when the inferior becomes inactive (in</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>`to_mourn_inferior').  The target should also make sure to call</code></pre></td>
        <td class="diff"><pre><code>`to_mourn_inferior').  The target should also make sure to call</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>`target_mourn_inferior' from its `to_kill', to return the target to</code></pre></td>
        <td class="diff"><pre><code>`target_mourn_inferior' from its `to_kill', to return the target to</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>inactive state.</code></pre></td>
        <td class="diff"><pre><code>inactive state.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>File: gdbint.info,  Node: Existing Targets,  Prev: Managing Execution State,  Up: Target Vector Definition</code></pre></td>
        <td class="diff"><pre><code>File: gdbint.info,  Node: Existing Targets,  Prev: Managing Execution State,  Up: Target Vector Definition</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>11.2 Existing Targets</code></pre></td>
        <td class="diff"><pre><code>11.2 Existing Targets</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>=====================</code></pre></td>
        <td class="diff"><pre><code>=====================</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>11.2.1 File Targets</code></pre></td>
        <td class="diff"><pre><code>11.2.1 File Targets</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>-------------------</code></pre></td>
        <td class="diff"><pre><code>-------------------</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>Both executables and core files have target vectors.</code></pre></td>
        <td class="diff"><pre><code>Both executables and core files have target vectors.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>11.2.2 Standard Protocol and Remote Stubs</code></pre></td>
        <td class="diff"><pre><code>11.2.2 Standard Protocol and Remote Stubs</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>-----------------------------------------</code></pre></td>
        <td class="diff"><pre><code>-----------------------------------------</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>GDB's file `remote.c' talks a serial protocol to code that runs in the</code></pre></td>
        <td class="diff"><pre><code>GDB's file `remote.c' talks a serial protocol to code that runs in the</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>target system.  GDB provides several sample "stubs" that can be</code></pre></td>
        <td class="diff"><pre><code>target system.  GDB provides several sample "stubs" that can be</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>integrated into target programs or operating systems for this purpose;</code></pre></td>
        <td class="diff"><pre><code>integrated into target programs or operating systems for this purpose;</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>they are named `*-stub.c'.</code></pre></td>
        <td class="diff"><pre><code>they are named `*-stub.c'.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>   The GDB user's manual describes how to put such a stub into your</code></pre></td>
        <td class="diff"><pre><code>   The GDB user's manual describes how to put such a stub into your</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>target code.  What follows is a discussion of integrating the SPARC</code></pre></td>
        <td class="diff"><pre><code>target code.  What follows is a discussion of integrating the SPARC</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>stub into a complicated operating system (rather than a simple</code></pre></td>
        <td class="diff"><pre><code>stub into a complicated operating system (rather than a simple</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>program), by Stu Grossman, the author of this stub.</code></pre></td>
        <td class="diff"><pre><code>program), by Stu Grossman, the author of this stub.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>   The trap handling code in the stub assumes the following upon entry</code></pre></td>
        <td class="diff"><pre><code>   The trap handling code in the stub assumes the following upon entry</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>to `trap_low':</code></pre></td>
        <td class="diff"><pre><code>to `trap_low':</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>  1. %l1 and %l2 contain pc and npc respectively at the time of the</code></pre></td>
        <td class="diff"><pre><code>  1. %l1 and %l2 contain pc and npc respectively at the time of the</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     trap;</code></pre></td>
        <td class="diff"><pre><code>     trap;</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>  2. traps are disabled;</code></pre></td>
        <td class="diff"><pre><code>  2. traps are disabled;</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>  3. you are in the correct trap window.</code></pre></td>
        <td class="diff"><pre><code>  3. you are in the correct trap window.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>   As long as your trap handler can guarantee those conditions, then</code></pre></td>
        <td class="diff"><pre><code>   As long as your trap handler can guarantee those conditions, then</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>there is no reason why you shouldn't be able to "share" traps with the</code></pre></td>
        <td class="diff"><pre><code>there is no reason why you shouldn't be able to "share" traps with the</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>stub.  The stub has no requirement that it be jumped to directly from</code></pre></td>
        <td class="diff"><pre><code>stub.  The stub has no requirement that it be jumped to directly from</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>the hardware trap vector.  That is why it calls `exceptionHandler()',</code></pre></td>
        <td class="diff"><pre><code>the hardware trap vector.  That is why it calls `exceptionHandler()',</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>which is provided by the external environment.  For instance, this could</code></pre></td>
        <td class="diff"><pre><code>which is provided by the external environment.  For instance, this could</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>set up the hardware traps to actually execute code which calls the stub</code></pre></td>
        <td class="diff"><pre><code>set up the hardware traps to actually execute code which calls the stub</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>first, and then transfers to its own trap handler.</code></pre></td>
        <td class="diff"><pre><code>first, and then transfers to its own trap handler.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>   For the most point, there probably won't be much of an issue with</code></pre></td>
        <td class="diff"><pre><code>   For the most point, there probably won't be much of an issue with</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>"sharing" traps, as the traps we use are usually not used by the kernel,</code></pre></td>
        <td class="diff"><pre><code>"sharing" traps, as the traps we use are usually not used by the kernel,</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>and often indicate unrecoverable error conditions.  Anyway, this is all</code></pre></td>
        <td class="diff"><pre><code>and often indicate unrecoverable error conditions.  Anyway, this is all</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>controlled by a table, and is trivial to modify.  The most important</code></pre></td>
        <td class="diff"><pre><code>controlled by a table, and is trivial to modify.  The most important</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>trap for us is for `ta 1'.  Without that, we can't single step or do</code></pre></td>
        <td class="diff"><pre><code>trap for us is for `ta 1'.  Without that, we can't single step or do</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>breakpoints.  Everything else is unnecessary for the proper operation</code></pre></td>
        <td class="diff"><pre><code>breakpoints.  Everything else is unnecessary for the proper operation</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>of the debugger/stub.</code></pre></td>
        <td class="diff"><pre><code>of the debugger/stub.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>   From reading the stub, it's probably not obvious how breakpoints</code></pre></td>
        <td class="diff"><pre><code>   From reading the stub, it's probably not obvious how breakpoints</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>work.  They are simply done by deposit/examine operations from GDB.</code></pre></td>
        <td class="diff"><pre><code>work.  They are simply done by deposit/examine operations from GDB.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>11.2.3 ROM Monitor Interface</code></pre></td>
        <td class="diff"><pre><code>11.2.3 ROM Monitor Interface</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>----------------------------</code></pre></td>
        <td class="diff"><pre><code>----------------------------</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>11.2.4 Custom Protocols</code></pre></td>
        <td class="diff"><pre><code>11.2.4 Custom Protocols</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>-----------------------</code></pre></td>
        <td class="diff"><pre><code>-----------------------</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>11.2.5 Transport Layer</code></pre></td>
        <td class="diff"><pre><code>11.2.5 Transport Layer</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>----------------------</code></pre></td>
        <td class="diff"><pre><code>----------------------</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>11.2.6 Builtin Simulator</code></pre></td>
        <td class="diff"><pre><code>11.2.6 Builtin Simulator</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>------------------------</code></pre></td>
        <td class="diff"><pre><code>------------------------</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>File: gdbint.info,  Node: Native Debugging,  Next: Support Libraries,  Prev: Target Vector Definition,  Up: Top</code></pre></td>
        <td class="diff"><pre><code>File: gdbint.info,  Node: Native Debugging,  Next: Support Libraries,  Prev: Target Vector Definition,  Up: Top</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>12 Native Debugging</code></pre></td>
        <td class="diff"><pre><code>12 Native Debugging</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>*******************</code></pre></td>
        <td class="diff"><pre><code>*******************</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>Several files control GDB's configuration for native support:</code></pre></td>
        <td class="diff"><pre><code>Several files control GDB's configuration for native support:</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>`gdb/config/ARCH/XYZ.mh'</code></pre></td>
        <td class="diff"><pre><code>`gdb/config/ARCH/XYZ.mh'</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     Specifies Makefile fragments needed by a _native_ configuration on</code></pre></td>
        <td class="diff"><pre><code>     Specifies Makefile fragments needed by a _native_ configuration on</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     machine XYZ.  In particular, this lists the required</code></pre></td>
        <td class="diff"><pre><code>     machine XYZ.  In particular, this lists the required</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     native-dependent object files, by defining `NATDEPFILES=...'.</code></pre></td>
        <td class="diff"><pre><code>     native-dependent object files, by defining `NATDEPFILES=...'.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     Also specifies the header file which describes native support on</code></pre></td>
        <td class="diff"><pre><code>     Also specifies the header file which describes native support on</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     XYZ, by defining `NAT_FILE= nm-XYZ.h'.  You can also define</code></pre></td>
        <td class="diff"><pre><code>     XYZ, by defining `NAT_FILE= nm-XYZ.h'.  You can also define</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     `NAT_CFLAGS', `NAT_ADD_FILES', `NAT_CLIBS', `NAT_CDEPS', etc.; see</code></pre></td>
        <td class="diff"><pre><code>     `NAT_CFLAGS', `NAT_ADD_FILES', `NAT_CLIBS', `NAT_CDEPS', etc.; see</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     `Makefile.in'.</code></pre></td>
        <td class="diff"><pre><code>     `Makefile.in'.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     _Maintainer's note: The `.mh' suffix is because this file</code></pre></td>
        <td class="diff"><pre><code>     _Maintainer's note: The `.mh' suffix is because this file</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     originally contained `Makefile' fragments for hosting GDB on</code></pre></td>
        <td class="diff"><pre><code>     originally contained `Makefile' fragments for hosting GDB on</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     machine XYZ.  While the file is no longer used for this purpose,</code></pre></td>
        <td class="diff"><pre><code>     machine XYZ.  While the file is no longer used for this purpose,</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     the `.mh' suffix remains.  Perhaps someone will eventually rename</code></pre></td>
        <td class="diff"><pre><code>     the `.mh' suffix remains.  Perhaps someone will eventually rename</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     these fragments so that they have a `.mn' suffix._</code></pre></td>
        <td class="diff"><pre><code>     these fragments so that they have a `.mn' suffix._</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>`gdb/config/ARCH/nm-XYZ.h'</code></pre></td>
        <td class="diff"><pre><code>`gdb/config/ARCH/nm-XYZ.h'</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     (`nm.h' is a link to this file, created by `configure').  Contains</code></pre></td>
        <td class="diff"><pre><code>     (`nm.h' is a link to this file, created by `configure').  Contains</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     C macro definitions describing the native system environment, such</code></pre></td>
        <td class="diff"><pre><code>     C macro definitions describing the native system environment, such</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     as child process control and core file support.</code></pre></td>
        <td class="diff"><pre><code>     as child process control and core file support.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>`gdb/XYZ-nat.c'</code></pre></td>
        <td class="diff"><pre><code>`gdb/XYZ-nat.c'</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     Contains any miscellaneous C code required for this native support</code></pre></td>
        <td class="diff"><pre><code>     Contains any miscellaneous C code required for this native support</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     of this machine.  On some machines it doesn't exist at all.</code></pre></td>
        <td class="diff"><pre><code>     of this machine.  On some machines it doesn't exist at all.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>   There are some "generic" versions of routines that can be used by</code></pre></td>
        <td class="diff"><pre><code>   There are some "generic" versions of routines that can be used by</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>various systems.  These can be customized in various ways by macros</code></pre></td>
        <td class="diff"><pre><code>various systems.  These can be customized in various ways by macros</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>defined in your `nm-XYZ.h' file.  If these routines work for the XYZ</code></pre></td>
        <td class="diff"><pre><code>defined in your `nm-XYZ.h' file.  If these routines work for the XYZ</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>host, you can just include the generic file's name (with `.o', not</code></pre></td>
        <td class="diff"><pre><code>host, you can just include the generic file's name (with `.o', not</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>`.c') in `NATDEPFILES'.</code></pre></td>
        <td class="diff"><pre><code>`.c') in `NATDEPFILES'.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>   Otherwise, if your machine needs custom support routines, you will</code></pre></td>
        <td class="diff"><pre><code>   Otherwise, if your machine needs custom support routines, you will</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>need to write routines that perform the same functions as the generic</code></pre></td>
        <td class="diff"><pre><code>need to write routines that perform the same functions as the generic</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>file.  Put them into `XYZ-nat.c', and put `XYZ-nat.o' into</code></pre></td>
        <td class="diff"><pre><code>file.  Put them into `XYZ-nat.c', and put `XYZ-nat.o' into</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>`NATDEPFILES'.</code></pre></td>
        <td class="diff"><pre><code>`NATDEPFILES'.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>`inftarg.c'</code></pre></td>
        <td class="diff"><pre><code>`inftarg.c'</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     This contains the _target_ops vector_ that supports Unix child</code></pre></td>
        <td class="diff"><pre><code>     This contains the _target_ops vector_ that supports Unix child</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     processes on systems which use ptrace and wait to control the</code></pre></td>
        <td class="diff"><pre><code>     processes on systems which use ptrace and wait to control the</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     child.</code></pre></td>
        <td class="diff"><pre><code>     child.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>`procfs.c'</code></pre></td>
        <td class="diff"><pre><code>`procfs.c'</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     This contains the _target_ops vector_ that supports Unix child</code></pre></td>
        <td class="diff"><pre><code>     This contains the _target_ops vector_ that supports Unix child</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     processes on systems which use /proc to control the child.</code></pre></td>
        <td class="diff"><pre><code>     processes on systems which use /proc to control the child.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>`fork-child.c'</code></pre></td>
        <td class="diff"><pre><code>`fork-child.c'</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     This does the low-level grunge that uses Unix system calls to do a</code></pre></td>
        <td class="diff"><pre><code>     This does the low-level grunge that uses Unix system calls to do a</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     "fork and exec" to start up a child process.</code></pre></td>
        <td class="diff"><pre><code>     "fork and exec" to start up a child process.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>`infptrace.c'</code></pre></td>
        <td class="diff"><pre><code>`infptrace.c'</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     This is the low level interface to inferior processes for systems</code></pre></td>
        <td class="diff"><pre><code>     This is the low level interface to inferior processes for systems</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     using the Unix `ptrace' call in a vanilla way.</code></pre></td>
        <td class="diff"><pre><code>     using the Unix `ptrace' call in a vanilla way.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>12.1 Native core file Support</code></pre></td>
        <td class="diff"><pre><code>12.1 Native core file Support</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>=============================</code></pre></td>
        <td class="diff"><pre><code>=============================</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>`core-aout.c::fetch_core_registers()'</code></pre></td>
        <td class="diff"><pre><code>`core-aout.c::fetch_core_registers()'</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     Support for reading registers out of a core file.  This routine</code></pre></td>
        <td class="diff"><pre><code>     Support for reading registers out of a core file.  This routine</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     calls `register_addr()', see below.  Now that BFD is used to read</code></pre></td>
        <td class="diff"><pre><code>     calls `register_addr()', see below.  Now that BFD is used to read</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     core files, virtually all machines should use `core-aout.c', and</code></pre></td>
        <td class="diff"><pre><code>     core files, virtually all machines should use `core-aout.c', and</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     should just provide `fetch_core_registers' in `XYZ-nat.c' (or</code></pre></td>
        <td class="diff"><pre><code>     should just provide `fetch_core_registers' in `XYZ-nat.c' (or</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     `REGISTER_U_ADDR' in `nm-XYZ.h').</code></pre></td>
        <td class="diff"><pre><code>     `REGISTER_U_ADDR' in `nm-XYZ.h').</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>`core-aout.c::register_addr()'</code></pre></td>
        <td class="diff"><pre><code>`core-aout.c::register_addr()'</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     If your `nm-XYZ.h' file defines the macro `REGISTER_U_ADDR(addr,</code></pre></td>
        <td class="diff"><pre><code>     If your `nm-XYZ.h' file defines the macro `REGISTER_U_ADDR(addr,</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     blockend, regno)', it should be defined to set `addr' to the</code></pre></td>
        <td class="diff"><pre><code>     blockend, regno)', it should be defined to set `addr' to the</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     offset within the `user' struct of GDB register number `regno'.</code></pre></td>
        <td class="diff"><pre><code>     offset within the `user' struct of GDB register number `regno'.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     `blockend' is the offset within the "upage" of `u.u_ar0'.  If</code></pre></td>
        <td class="diff"><pre><code>     `blockend' is the offset within the "upage" of `u.u_ar0'.  If</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     `REGISTER_U_ADDR' is defined, `core-aout.c' will define the</code></pre></td>
        <td class="diff"><pre><code>     `REGISTER_U_ADDR' is defined, `core-aout.c' will define the</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     `register_addr()' function and use the macro in it.  If you do not</code></pre></td>
        <td class="diff"><pre><code>     `register_addr()' function and use the macro in it.  If you do not</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     define `REGISTER_U_ADDR', but you are using the standard</code></pre></td>
        <td class="diff"><pre><code>     define `REGISTER_U_ADDR', but you are using the standard</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     `fetch_core_registers()', you will need to define your own version</code></pre></td>
        <td class="diff"><pre><code>     `fetch_core_registers()', you will need to define your own version</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     of `register_addr()', put it into your `XYZ-nat.c' file, and be</code></pre></td>
        <td class="diff"><pre><code>     of `register_addr()', put it into your `XYZ-nat.c' file, and be</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     sure `XYZ-nat.o' is in the `NATDEPFILES' list.  If you have your</code></pre></td>
        <td class="diff"><pre><code>     sure `XYZ-nat.o' is in the `NATDEPFILES' list.  If you have your</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     own `fetch_core_registers()', you may not need a separate</code></pre></td>
        <td class="diff"><pre><code>     own `fetch_core_registers()', you may not need a separate</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     `register_addr()'.  Many custom `fetch_core_registers()'</code></pre></td>
        <td class="diff"><pre><code>     `register_addr()'.  Many custom `fetch_core_registers()'</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     implementations simply locate the registers themselves.</code></pre></td>
        <td class="diff"><pre><code>     implementations simply locate the registers themselves.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>   When making GDB run native on a new operating system, to make it</code></pre></td>
        <td class="diff"><pre><code>   When making GDB run native on a new operating system, to make it</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>possible to debug core files, you will need to either write specific</code></pre></td>
        <td class="diff"><pre><code>possible to debug core files, you will need to either write specific</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>code for parsing your OS's core files, or customize `bfd/trad-core.c'.</code></pre></td>
        <td class="diff"><pre><code>code for parsing your OS's core files, or customize `bfd/trad-core.c'.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>First, use whatever `#include' files your machine uses to define the</code></pre></td>
        <td class="diff"><pre><code>First, use whatever `#include' files your machine uses to define the</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>struct of registers that is accessible (possibly in the u-area) in a</code></pre></td>
        <td class="diff"><pre><code>struct of registers that is accessible (possibly in the u-area) in a</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>core file (rather than `machine/reg.h'), and an include file that</code></pre></td>
        <td class="diff"><pre><code>core file (rather than `machine/reg.h'), and an include file that</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>defines whatever header exists on a core file (e.g., the u-area or a</code></pre></td>
        <td class="diff"><pre><code>defines whatever header exists on a core file (e.g., the u-area or a</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>`struct core').  Then modify `trad_unix_core_file_p' to use these</code></pre></td>
        <td class="diff"><pre><code>`struct core').  Then modify `trad_unix_core_file_p' to use these</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>values to set up the section information for the data segment, stack</code></pre></td>
        <td class="diff"><pre><code>values to set up the section information for the data segment, stack</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>segment, any other segments in the core file (perhaps shared library</code></pre></td>
        <td class="diff"><pre><code>segment, any other segments in the core file (perhaps shared library</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>contents or control information), "registers" segment, and if there are</code></pre></td>
        <td class="diff"><pre><code>contents or control information), "registers" segment, and if there are</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>two discontiguous sets of registers (e.g., integer and float), the</code></pre></td>
        <td class="diff"><pre><code>two discontiguous sets of registers (e.g., integer and float), the</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>"reg2" segment.  This section information basically delimits areas in</code></pre></td>
        <td class="diff"><pre><code>"reg2" segment.  This section information basically delimits areas in</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>the core file in a standard way, which the section-reading routines in</code></pre></td>
        <td class="diff"><pre><code>the core file in a standard way, which the section-reading routines in</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>BFD know how to seek around in.</code></pre></td>
        <td class="diff"><pre><code>BFD know how to seek around in.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>   Then back in GDB, you need a matching routine called</code></pre></td>
        <td class="diff"><pre><code>   Then back in GDB, you need a matching routine called</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>`fetch_core_registers'.  If you can use the generic one, it's in</code></pre></td>
        <td class="diff"><pre><code>`fetch_core_registers'.  If you can use the generic one, it's in</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>`core-aout.c'; if not, it's in your `XYZ-nat.c' file.  It will be</code></pre></td>
        <td class="diff"><pre><code>`core-aout.c'; if not, it's in your `XYZ-nat.c' file.  It will be</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>passed a char pointer to the entire "registers" segment, its length,</code></pre></td>
        <td class="diff"><pre><code>passed a char pointer to the entire "registers" segment, its length,</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>and a zero; or a char pointer to the entire "regs2" segment, its</code></pre></td>
        <td class="diff"><pre><code>and a zero; or a char pointer to the entire "regs2" segment, its</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>length, and a 2.  The routine should suck out the supplied register</code></pre></td>
        <td class="diff"><pre><code>length, and a 2.  The routine should suck out the supplied register</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>values and install them into GDB's "registers" array.</code></pre></td>
        <td class="diff"><pre><code>values and install them into GDB's "registers" array.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>   If your system uses `/proc' to control processes, and uses ELF</code></pre></td>
        <td class="diff"><pre><code>   If your system uses `/proc' to control processes, and uses ELF</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>format core files, then you may be able to use the same routines for</code></pre></td>
        <td class="diff"><pre><code>format core files, then you may be able to use the same routines for</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>reading the registers out of processes and out of core files.</code></pre></td>
        <td class="diff"><pre><code>reading the registers out of processes and out of core files.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>12.2 ptrace</code></pre></td>
        <td class="diff"><pre><code>12.2 ptrace</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>===========</code></pre></td>
        <td class="diff"><pre><code>===========</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>12.3 /proc</code></pre></td>
        <td class="diff"><pre><code>12.3 /proc</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>==========</code></pre></td>
        <td class="diff"><pre><code>==========</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>12.4 win32</code></pre></td>
        <td class="diff"><pre><code>12.4 win32</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>==========</code></pre></td>
        <td class="diff"><pre><code>==========</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>12.5 shared libraries</code></pre></td>
        <td class="diff"><pre><code>12.5 shared libraries</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>=====================</code></pre></td>
        <td class="diff"><pre><code>=====================</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>12.6 Native Conditionals</code></pre></td>
        <td class="diff"><pre><code>12.6 Native Conditionals</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>========================</code></pre></td>
        <td class="diff"><pre><code>========================</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>When GDB is configured and compiled, various macros are defined or left</code></pre></td>
        <td class="diff"><pre><code>When GDB is configured and compiled, various macros are defined or left</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>undefined, to control compilation when the host and target systems are</code></pre></td>
        <td class="diff"><pre><code>undefined, to control compilation when the host and target systems are</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>the same.  These macros should be defined (or left undefined) in</code></pre></td>
        <td class="diff"><pre><code>the same.  These macros should be defined (or left undefined) in</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>`nm-SYSTEM.h'.</code></pre></td>
        <td class="diff"><pre><code>`nm-SYSTEM.h'.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>`CHILD_PREPARE_TO_STORE'</code></pre></td>
        <td class="diff"><pre><code>`CHILD_PREPARE_TO_STORE'</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     If the machine stores all registers at once in the child process,</code></pre></td>
        <td class="diff"><pre><code>     If the machine stores all registers at once in the child process,</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     then define this to ensure that all values are correct.  This</code></pre></td>
        <td class="diff"><pre><code>     then define this to ensure that all values are correct.  This</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     usually entails a read from the child.</code></pre></td>
        <td class="diff"><pre><code>     usually entails a read from the child.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     [Note that this is incorrectly defined in `xm-SYSTEM.h' files</code></pre></td>
        <td class="diff"><pre><code>     [Note that this is incorrectly defined in `xm-SYSTEM.h' files</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     currently.]</code></pre></td>
        <td class="diff"><pre><code>     currently.]</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>`FETCH_INFERIOR_REGISTERS'</code></pre></td>
        <td class="diff"><pre><code>`FETCH_INFERIOR_REGISTERS'</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     Define this if the native-dependent code will provide its own</code></pre></td>
        <td class="diff"><pre><code>     Define this if the native-dependent code will provide its own</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     routines `fetch_inferior_registers' and `store_inferior_registers'</code></pre></td>
        <td class="diff"><pre><code>     routines `fetch_inferior_registers' and `store_inferior_registers'</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     in `HOST-nat.c'.  If this symbol is _not_ defined, and</code></pre></td>
        <td class="diff"><pre><code>     in `HOST-nat.c'.  If this symbol is _not_ defined, and</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     `infptrace.c' is included in this configuration, the default</code></pre></td>
        <td class="diff"><pre><code>     `infptrace.c' is included in this configuration, the default</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     routines in `infptrace.c' are used for these functions.</code></pre></td>
        <td class="diff"><pre><code>     routines in `infptrace.c' are used for these functions.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>`int gdbarch_fp0_regnum (GDBARCH)'</code></pre></td>
        <td class="diff"><pre><code>`int gdbarch_fp0_regnum (GDBARCH)'</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     This functions normally returns the number of the first floating</code></pre></td>
        <td class="diff"><pre><code>     This functions normally returns the number of the first floating</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     point register, if the machine has such registers.  As such, it</code></pre></td>
        <td class="diff"><pre><code>     point register, if the machine has such registers.  As such, it</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     would appear only in target-specific code.  However, `/proc'</code></pre></td>
        <td class="diff"><pre><code>     would appear only in target-specific code.  However, `/proc'</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     support uses this to decide whether floats are in use on this</code></pre></td>
        <td class="diff"><pre><code>     support uses this to decide whether floats are in use on this</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     target.</code></pre></td>
        <td class="diff"><pre><code>     target.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>`int gdbarch_get_longjmp_target (GDBARCH)'</code></pre></td>
        <td class="diff"><pre><code>`int gdbarch_get_longjmp_target (GDBARCH)'</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     For most machines, this is a target-dependent parameter.  On the</code></pre></td>
        <td class="diff"><pre><code>     For most machines, this is a target-dependent parameter.  On the</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     DECstation and the Iris, this is a native-dependent parameter,</code></pre></td>
        <td class="diff"><pre><code>     DECstation and the Iris, this is a native-dependent parameter,</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     since `setjmp.h' is needed to define it.</code></pre></td>
        <td class="diff"><pre><code>     since `setjmp.h' is needed to define it.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     This function determines the target PC address that `longjmp' will</code></pre></td>
        <td class="diff"><pre><code>     This function determines the target PC address that `longjmp' will</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     jump to, assuming that we have just stopped at a longjmp</code></pre></td>
        <td class="diff"><pre><code>     jump to, assuming that we have just stopped at a longjmp</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     breakpoint.  It takes a `CORE_ADDR *' as argument, and stores the</code></pre></td>
        <td class="diff"><pre><code>     breakpoint.  It takes a `CORE_ADDR *' as argument, and stores the</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     target PC value through this pointer.  It examines the current</code></pre></td>
        <td class="diff"><pre><code>     target PC value through this pointer.  It examines the current</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     state of the machine as needed.</code></pre></td>
        <td class="diff"><pre><code>     state of the machine as needed.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>`I386_USE_GENERIC_WATCHPOINTS'</code></pre></td>
        <td class="diff"><pre><code>`I386_USE_GENERIC_WATCHPOINTS'</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     An x86-based machine can define this to use the generic x86</code></pre></td>
        <td class="diff"><pre><code>     An x86-based machine can define this to use the generic x86</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     watchpoint support; see *Note I386_USE_GENERIC_WATCHPOINTS:</code></pre></td>
        <td class="diff"><pre><code>     watchpoint support; see *Note I386_USE_GENERIC_WATCHPOINTS:</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     Algorithms.</code></pre></td>
        <td class="diff"><pre><code>     Algorithms.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>`ONE_PROCESS_WRITETEXT'</code></pre></td>
        <td class="diff"><pre><code>`ONE_PROCESS_WRITETEXT'</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     Define this to be able to, when a breakpoint insertion fails, warn</code></pre></td>
        <td class="diff"><pre><code>     Define this to be able to, when a breakpoint insertion fails, warn</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     the user that another process may be running with the same</code></pre></td>
        <td class="diff"><pre><code>     the user that another process may be running with the same</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     executable.</code></pre></td>
        <td class="diff"><pre><code>     executable.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>`PROC_NAME_FMT'</code></pre></td>
        <td class="diff"><pre><code>`PROC_NAME_FMT'</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     Defines the format for the name of a `/proc' device.  Should be</code></pre></td>
        <td class="diff"><pre><code>     Defines the format for the name of a `/proc' device.  Should be</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     defined in `nm.h' _only_ in order to override the default</code></pre></td>
        <td class="diff"><pre><code>     defined in `nm.h' _only_ in order to override the default</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     definition in `procfs.c'.</code></pre></td>
        <td class="diff"><pre><code>     definition in `procfs.c'.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>`SOLIB_ADD (FILENAME, FROM_TTY, TARG, READSYMS)'</code></pre></td>
        <td class="diff"><pre><code>`SOLIB_ADD (FILENAME, FROM_TTY, TARG, READSYMS)'</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     Define this to expand into an expression that will cause the</code></pre></td>
        <td class="diff"><pre><code>     Define this to expand into an expression that will cause the</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     symbols in FILENAME to be added to GDB's symbol table. If READSYMS</code></pre></td>
        <td class="diff"><pre><code>     symbols in FILENAME to be added to GDB's symbol table. If READSYMS</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     is zero symbols are not read but any necessary low level</code></pre></td>
        <td class="diff"><pre><code>     is zero symbols are not read but any necessary low level</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     processing for FILENAME is still done.</code></pre></td>
        <td class="diff"><pre><code>     processing for FILENAME is still done.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>`SOLIB_CREATE_INFERIOR_HOOK'</code></pre></td>
        <td class="diff"><pre><code>`SOLIB_CREATE_INFERIOR_HOOK'</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     Define this to expand into any shared-library-relocation code that</code></pre></td>
        <td class="diff"><pre><code>     Define this to expand into any shared-library-relocation code that</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     you want to be run just after the child process has been forked.</code></pre></td>
        <td class="diff"><pre><code>     you want to be run just after the child process has been forked.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>`START_INFERIOR_TRAPS_EXPECTED'</code></pre></td>
        <td class="diff"><pre><code>`START_INFERIOR_TRAPS_EXPECTED'</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     When starting an inferior, GDB normally expects to trap twice;</code></pre></td>
        <td class="diff"><pre><code>     When starting an inferior, GDB normally expects to trap twice;</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     once when the shell execs, and once when the program itself execs.</code></pre></td>
        <td class="diff"><pre><code>     once when the shell execs, and once when the program itself execs.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     If the actual number of traps is something other than 2, then</code></pre></td>
        <td class="diff"><pre><code>     If the actual number of traps is something other than 2, then</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     define this macro to expand into the number expected.</code></pre></td>
        <td class="diff"><pre><code>     define this macro to expand into the number expected.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>File: gdbint.info,  Node: Support Libraries,  Next: Coding,  Prev: Native Debugging,  Up: Top</code></pre></td>
        <td class="diff"><pre><code>File: gdbint.info,  Node: Support Libraries,  Next: Coding,  Prev: Native Debugging,  Up: Top</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>13 Support Libraries</code></pre></td>
        <td class="diff"><pre><code>13 Support Libraries</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>********************</code></pre></td>
        <td class="diff"><pre><code>********************</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>13.1 BFD</code></pre></td>
        <td class="diff"><pre><code>13.1 BFD</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>========</code></pre></td>
        <td class="diff"><pre><code>========</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>BFD provides support for GDB in several ways:</code></pre></td>
        <td class="diff"><pre><code>BFD provides support for GDB in several ways:</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>_identifying executable and core files_</code></pre></td>
        <td class="diff"><pre><code>_identifying executable and core files_</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     BFD will identify a variety of file types, including a.out, coff,</code></pre></td>
        <td class="diff"><pre><code>     BFD will identify a variety of file types, including a.out, coff,</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     and several variants thereof, as well as several kinds of core</code></pre></td>
        <td class="diff"><pre><code>     and several variants thereof, as well as several kinds of core</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     files.</code></pre></td>
        <td class="diff"><pre><code>     files.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>_access to sections of files_</code></pre></td>
        <td class="diff"><pre><code>_access to sections of files_</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     BFD parses the file headers to determine the names, virtual</code></pre></td>
        <td class="diff"><pre><code>     BFD parses the file headers to determine the names, virtual</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     addresses, sizes, and file locations of all the various named</code></pre></td>
        <td class="diff"><pre><code>     addresses, sizes, and file locations of all the various named</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     sections in files (such as the text section or the data section).</code></pre></td>
        <td class="diff"><pre><code>     sections in files (such as the text section or the data section).</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     GDB simply calls BFD to read or write section X at byte offset Y</code></pre></td>
        <td class="diff"><pre><code>     GDB simply calls BFD to read or write section X at byte offset Y</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     for length Z.</code></pre></td>
        <td class="diff"><pre><code>     for length Z.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>_specialized core file support_</code></pre></td>
        <td class="diff"><pre><code>_specialized core file support_</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     BFD provides routines to determine the failing command name stored</code></pre></td>
        <td class="diff"><pre><code>     BFD provides routines to determine the failing command name stored</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     in a core file, the signal with which the program failed, and</code></pre></td>
        <td class="diff"><pre><code>     in a core file, the signal with which the program failed, and</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     whether a core file matches (i.e. could be a core dump of) a</code></pre></td>
        <td class="diff"><pre><code>     whether a core file matches (i.e. could be a core dump of) a</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     particular executable file.</code></pre></td>
        <td class="diff"><pre><code>     particular executable file.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>_locating the symbol information_</code></pre></td>
        <td class="diff"><pre><code>_locating the symbol information_</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     GDB uses an internal interface of BFD to determine where to find</code></pre></td>
        <td class="diff"><pre><code>     GDB uses an internal interface of BFD to determine where to find</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     the symbol information in an executable file or symbol-file.  GDB</code></pre></td>
        <td class="diff"><pre><code>     the symbol information in an executable file or symbol-file.  GDB</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     itself handles the reading of symbols, since BFD does not</code></pre></td>
        <td class="diff"><pre><code>     itself handles the reading of symbols, since BFD does not</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     "understand" debug symbols, but GDB uses BFD's cached information</code></pre></td>
        <td class="diff"><pre><code>     "understand" debug symbols, but GDB uses BFD's cached information</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     to find the symbols, string table, etc.</code></pre></td>
        <td class="diff"><pre><code>     to find the symbols, string table, etc.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>13.2 opcodes</code></pre></td>
        <td class="diff"><pre><code>13.2 opcodes</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>============</code></pre></td>
        <td class="diff"><pre><code>============</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>The opcodes library provides GDB's disassembler.  (It's a separate</code></pre></td>
        <td class="diff"><pre><code>The opcodes library provides GDB's disassembler.  (It's a separate</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>library because it's also used in binutils, for `objdump').</code></pre></td>
        <td class="diff"><pre><code>library because it's also used in binutils, for `objdump').</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>13.3 readline</code></pre></td>
        <td class="diff"><pre><code>13.3 readline</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>=============</code></pre></td>
        <td class="diff"><pre><code>=============</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>The `readline' library provides a set of functions for use by</code></pre></td>
        <td class="diff"><pre><code>The `readline' library provides a set of functions for use by</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>applications that allow users to edit command lines as they are typed</code></pre></td>
        <td class="diff"><pre><code>applications that allow users to edit command lines as they are typed</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>in.</code></pre></td>
        <td class="diff"><pre><code>in.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>13.4 libiberty</code></pre></td>
        <td class="diff"><pre><code>13.4 libiberty</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>==============</code></pre></td>
        <td class="diff"><pre><code>==============</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>The `libiberty' library provides a set of functions and features that</code></pre></td>
        <td class="diff"><pre><code>The `libiberty' library provides a set of functions and features that</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>integrate and improve on functionality found in modern operating</code></pre></td>
        <td class="diff"><pre><code>integrate and improve on functionality found in modern operating</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>systems.  Broadly speaking, such features can be divided into three</code></pre></td>
        <td class="diff"><pre><code>systems.  Broadly speaking, such features can be divided into three</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>groups: supplemental functions (functions that may be missing in some</code></pre></td>
        <td class="diff"><pre><code>groups: supplemental functions (functions that may be missing in some</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>environments and operating systems), replacement functions (providing a</code></pre></td>
        <td class="diff"><pre><code>environments and operating systems), replacement functions (providing a</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>uniform and easier to use interface for commonly used standard</code></pre></td>
        <td class="diff"><pre><code>uniform and easier to use interface for commonly used standard</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>functions), and extensions (which provide additional functionality</code></pre></td>
        <td class="diff"><pre><code>functions), and extensions (which provide additional functionality</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>beyond standard functions).</code></pre></td>
        <td class="diff"><pre><code>beyond standard functions).</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>   GDB uses various features provided by the `libiberty' library, for</code></pre></td>
        <td class="diff"><pre><code>   GDB uses various features provided by the `libiberty' library, for</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>instance the C++ demangler, the IEEE floating format support functions,</code></pre></td>
        <td class="diff"><pre><code>instance the C++ demangler, the IEEE floating format support functions,</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>the input options parser `getopt', the `obstack' extension, and other</code></pre></td>
        <td class="diff"><pre><code>the input options parser `getopt', the `obstack' extension, and other</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>functions.</code></pre></td>
        <td class="diff"><pre><code>functions.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>13.4.1 `obstacks' in GDB</code></pre></td>
        <td class="diff"><pre><code>13.4.1 `obstacks' in GDB</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>------------------------</code></pre></td>
        <td class="diff"><pre><code>------------------------</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>The obstack mechanism provides a convenient way to allocate and free</code></pre></td>
        <td class="diff"><pre><code>The obstack mechanism provides a convenient way to allocate and free</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>chunks of memory.  Each obstack is a pool of memory that is managed</code></pre></td>
        <td class="diff"><pre><code>chunks of memory.  Each obstack is a pool of memory that is managed</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>like a stack.  Objects (of any nature, size and alignment) are</code></pre></td>
        <td class="diff"><pre><code>like a stack.  Objects (of any nature, size and alignment) are</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>allocated and freed in a LIFO fashion on an obstack (see `libiberty''s</code></pre></td>
        <td class="diff"><pre><code>allocated and freed in a LIFO fashion on an obstack (see `libiberty''s</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>documentation for a more detailed explanation of `obstacks').</code></pre></td>
        <td class="diff"><pre><code>documentation for a more detailed explanation of `obstacks').</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>   The most noticeable use of the `obstacks' in GDB is in object files.</code></pre></td>
        <td class="diff"><pre><code>   The most noticeable use of the `obstacks' in GDB is in object files.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>There is an obstack associated with each internal representation of an</code></pre></td>
        <td class="diff"><pre><code>There is an obstack associated with each internal representation of an</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>object file.  Lots of things get allocated on these `obstacks':</code></pre></td>
        <td class="diff"><pre><code>object file.  Lots of things get allocated on these `obstacks':</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>dictionary entries, blocks, blockvectors, symbols, minimal symbols,</code></pre></td>
        <td class="diff"><pre><code>dictionary entries, blocks, blockvectors, symbols, minimal symbols,</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>types, vectors of fundamental types, class fields of types, object</code></pre></td>
        <td class="diff"><pre><code>types, vectors of fundamental types, class fields of types, object</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>files section lists, object files section offset lists, line tables,</code></pre></td>
        <td class="diff"><pre><code>files section lists, object files section offset lists, line tables,</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>symbol tables, partial symbol tables, string tables, symbol table</code></pre></td>
        <td class="diff"><pre><code>symbol tables, partial symbol tables, string tables, symbol table</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>private data, macros tables, debug information sections and entries,</code></pre></td>
        <td class="diff"><pre><code>private data, macros tables, debug information sections and entries,</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>import and export lists (som), unwind information (hppa), dwarf2</code></pre></td>
        <td class="diff"><pre><code>import and export lists (som), unwind information (hppa), dwarf2</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>location expressions data.  Plus various strings such as directory</code></pre></td>
        <td class="diff"><pre><code>location expressions data.  Plus various strings such as directory</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>names strings, debug format strings, names of types.</code></pre></td>
        <td class="diff"><pre><code>names strings, debug format strings, names of types.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>   An essential and convenient property of all data on `obstacks' is</code></pre></td>
        <td class="diff"><pre><code>   An essential and convenient property of all data on `obstacks' is</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>that memory for it gets allocated (with `obstack_alloc') at various</code></pre></td>
        <td class="diff"><pre><code>that memory for it gets allocated (with `obstack_alloc') at various</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>times during a debugging session, but it is released all at once using</code></pre></td>
        <td class="diff"><pre><code>times during a debugging session, but it is released all at once using</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>the `obstack_free' function.  The `obstack_free' function takes a</code></pre></td>
        <td class="diff"><pre><code>the `obstack_free' function.  The `obstack_free' function takes a</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>pointer to where in the stack it must start the deletion from (much</code></pre></td>
        <td class="diff"><pre><code>pointer to where in the stack it must start the deletion from (much</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>like the cleanup chains have a pointer to where to start the cleanups).</code></pre></td>
        <td class="diff"><pre><code>like the cleanup chains have a pointer to where to start the cleanups).</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>Because of the stack like structure of the `obstacks', this allows to</code></pre></td>
        <td class="diff"><pre><code>Because of the stack like structure of the `obstacks', this allows to</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>free only a top portion of the obstack.  There are a few instances in</code></pre></td>
        <td class="diff"><pre><code>free only a top portion of the obstack.  There are a few instances in</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>GDB where such thing happens.  Calls to `obstack_free' are done after</code></pre></td>
        <td class="diff"><pre><code>GDB where such thing happens.  Calls to `obstack_free' are done after</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>some local data is allocated to the obstack.  Only the local data is</code></pre></td>
        <td class="diff"><pre><code>some local data is allocated to the obstack.  Only the local data is</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>deleted from the obstack.  Of course this assumes that nothing between</code></pre></td>
        <td class="diff"><pre><code>deleted from the obstack.  Of course this assumes that nothing between</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>the `obstack_alloc' and the `obstack_free' allocates anything else on</code></pre></td>
        <td class="diff"><pre><code>the `obstack_alloc' and the `obstack_free' allocates anything else on</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>the same obstack.  For this reason it is best and safest to use</code></pre></td>
        <td class="diff"><pre><code>the same obstack.  For this reason it is best and safest to use</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>temporary `obstacks'.</code></pre></td>
        <td class="diff"><pre><code>temporary `obstacks'.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>   Releasing the whole obstack is also not safe per se.  It is safe only</code></pre></td>
        <td class="diff"><pre><code>   Releasing the whole obstack is also not safe per se.  It is safe only</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>under the condition that we know the `obstacks' memory is no longer</code></pre></td>
        <td class="diff"><pre><code>under the condition that we know the `obstacks' memory is no longer</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>needed.  In GDB we get rid of the `obstacks' only when we get rid of</code></pre></td>
        <td class="diff"><pre><code>needed.  In GDB we get rid of the `obstacks' only when we get rid of</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>the whole objfile(s), for instance upon reading a new symbol file.</code></pre></td>
        <td class="diff"><pre><code>the whole objfile(s), for instance upon reading a new symbol file.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>13.5 gnu-regex</code></pre></td>
        <td class="diff"><pre><code>13.5 gnu-regex</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>==============</code></pre></td>
        <td class="diff"><pre><code>==============</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>Regex conditionals.</code></pre></td>
        <td class="diff"><pre><code>Regex conditionals.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>`C_ALLOCA'</code></pre></td>
        <td class="diff"><pre><code>`C_ALLOCA'</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>`NFAILURES'</code></pre></td>
        <td class="diff"><pre><code>`NFAILURES'</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>`RE_NREGS'</code></pre></td>
        <td class="diff"><pre><code>`RE_NREGS'</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>`SIGN_EXTEND_CHAR'</code></pre></td>
        <td class="diff"><pre><code>`SIGN_EXTEND_CHAR'</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>`SWITCH_ENUM_BUG'</code></pre></td>
        <td class="diff"><pre><code>`SWITCH_ENUM_BUG'</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>`SYNTAX_TABLE'</code></pre></td>
        <td class="diff"><pre><code>`SYNTAX_TABLE'</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>`Sword'</code></pre></td>
        <td class="diff"><pre><code>`Sword'</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>`sparc'</code></pre></td>
        <td class="diff"><pre><code>`sparc'</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>13.6 Array Containers</code></pre></td>
        <td class="diff"><pre><code>13.6 Array Containers</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>=====================</code></pre></td>
        <td class="diff"><pre><code>=====================</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>Often it is necessary to manipulate a dynamic array of a set of</code></pre></td>
        <td class="diff"><pre><code>Often it is necessary to manipulate a dynamic array of a set of</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>objects.  C forces some bookkeeping on this, which can get cumbersome</code></pre></td>
        <td class="diff"><pre><code>objects.  C forces some bookkeeping on this, which can get cumbersome</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>and repetitive.  The `vec.h' file contains macros for defining and</code></pre></td>
        <td class="diff"><pre><code>and repetitive.  The `vec.h' file contains macros for defining and</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>using a typesafe vector type.  The functions defined will be inlined</code></pre></td>
        <td class="diff"><pre><code>using a typesafe vector type.  The functions defined will be inlined</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>when compiling, and so the abstraction cost should be zero.  Domain</code></pre></td>
        <td class="diff"><pre><code>when compiling, and so the abstraction cost should be zero.  Domain</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>checks are added to detect programming errors.</code></pre></td>
        <td class="diff"><pre><code>checks are added to detect programming errors.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>   An example use would be an array of symbols or section information.</code></pre></td>
        <td class="diff"><pre><code>   An example use would be an array of symbols or section information.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>The array can be grown as symbols are read in (or preallocated), and</code></pre></td>
        <td class="diff"><pre><code>The array can be grown as symbols are read in (or preallocated), and</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>the accessor macros provided keep care of all the necessary</code></pre></td>
        <td class="diff"><pre><code>the accessor macros provided keep care of all the necessary</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>bookkeeping.  Because the arrays are type safe, there is no danger of</code></pre></td>
        <td class="diff"><pre><code>bookkeeping.  Because the arrays are type safe, there is no danger of</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>accidentally mixing up the contents.  Think of these as C++ templates,</code></pre></td>
        <td class="diff"><pre><code>accidentally mixing up the contents.  Think of these as C++ templates,</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>but implemented in C.</code></pre></td>
        <td class="diff"><pre><code>but implemented in C.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>   Because of the different behavior of structure objects, scalar</code></pre></td>
        <td class="diff"><pre><code>   Because of the different behavior of structure objects, scalar</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>objects and of pointers, there are three flavors of vector, one for</code></pre></td>
        <td class="diff"><pre><code>objects and of pointers, there are three flavors of vector, one for</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>each of these variants.  Both the structure object and pointer variants</code></pre></td>
        <td class="diff"><pre><code>each of these variants.  Both the structure object and pointer variants</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>pass pointers to objects around -- in the former case the pointers are</code></pre></td>
        <td class="diff"><pre><code>pass pointers to objects around -- in the former case the pointers are</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>stored into the vector and in the latter case the pointers are</code></pre></td>
        <td class="diff"><pre><code>stored into the vector and in the latter case the pointers are</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>dereferenced and the objects copied into the vector.  The scalar object</code></pre></td>
        <td class="diff"><pre><code>dereferenced and the objects copied into the vector.  The scalar object</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>variant is suitable for `int'-like objects, and the vector elements are</code></pre></td>
        <td class="diff"><pre><code>variant is suitable for `int'-like objects, and the vector elements are</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>returned by value.</code></pre></td>
        <td class="diff"><pre><code>returned by value.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>   There are both `index' and `iterate' accessors.  The iterator</code></pre></td>
        <td class="diff"><pre><code>   There are both `index' and `iterate' accessors.  The iterator</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>returns a boolean iteration condition and updates the iteration</code></pre></td>
        <td class="diff"><pre><code>returns a boolean iteration condition and updates the iteration</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>variable passed by reference.  Because the iterator will be inlined,</code></pre></td>
        <td class="diff"><pre><code>variable passed by reference.  Because the iterator will be inlined,</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>the address-of can be optimized away.</code></pre></td>
        <td class="diff"><pre><code>the address-of can be optimized away.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>   The vectors are implemented using the trailing array idiom, thus they</code></pre></td>
        <td class="diff"><pre><code>   The vectors are implemented using the trailing array idiom, thus they</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>are not resizeable without changing the address of the vector object</code></pre></td>
        <td class="diff"><pre><code>are not resizeable without changing the address of the vector object</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>itself.  This means you cannot have variables or fields of vector type</code></pre></td>
        <td class="diff"><pre><code>itself.  This means you cannot have variables or fields of vector type</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>-- always use a pointer to a vector.  The one exception is the final</code></pre></td>
        <td class="diff"><pre><code>-- always use a pointer to a vector.  The one exception is the final</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>field of a structure, which could be a vector type.  You will have to</code></pre></td>
        <td class="diff"><pre><code>field of a structure, which could be a vector type.  You will have to</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>use the `embedded_size' & `embedded_init' calls to create such objects,</code></pre></td>
        <td class="diff"><pre><code>use the `embedded_size' & `embedded_init' calls to create such objects,</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>and they will probably not be resizeable (so don't use the "safe"</code></pre></td>
        <td class="diff"><pre><code>and they will probably not be resizeable (so don't use the "safe"</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>allocation variants).  The trailing array idiom is used (rather than a</code></pre></td>
        <td class="diff"><pre><code>allocation variants).  The trailing array idiom is used (rather than a</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>pointer to an array of data), because, if we allow `NULL' to also</code></pre></td>
        <td class="diff"><pre><code>pointer to an array of data), because, if we allow `NULL' to also</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>represent an empty vector, empty vectors occupy minimal space in the</code></pre></td>
        <td class="diff"><pre><code>represent an empty vector, empty vectors occupy minimal space in the</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>structure containing them.</code></pre></td>
        <td class="diff"><pre><code>structure containing them.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>   Each operation that increases the number of active elements is</code></pre></td>
        <td class="diff"><pre><code>   Each operation that increases the number of active elements is</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>available in "quick" and "safe" variants.  The former presumes that</code></pre></td>
        <td class="diff"><pre><code>available in "quick" and "safe" variants.  The former presumes that</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>there is sufficient allocated space for the operation to succeed (it</code></pre></td>
        <td class="diff"><pre><code>there is sufficient allocated space for the operation to succeed (it</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>dies if there is not).  The latter will reallocate the vector, if</code></pre></td>
        <td class="diff"><pre><code>dies if there is not).  The latter will reallocate the vector, if</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>needed.  Reallocation causes an exponential increase in vector size.</code></pre></td>
        <td class="diff"><pre><code>needed.  Reallocation causes an exponential increase in vector size.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>If you know you will be adding N elements, it would be more efficient</code></pre></td>
        <td class="diff"><pre><code>If you know you will be adding N elements, it would be more efficient</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>to use the reserve operation before adding the elements with the</code></pre></td>
        <td class="diff"><pre><code>to use the reserve operation before adding the elements with the</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>"quick" operation.  This will ensure there are at least as many</code></pre></td>
        <td class="diff"><pre><code>"quick" operation.  This will ensure there are at least as many</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>elements as you ask for, it will exponentially increase if there are</code></pre></td>
        <td class="diff"><pre><code>elements as you ask for, it will exponentially increase if there are</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>too few spare slots.  If you want reserve a specific number of slots,</code></pre></td>
        <td class="diff"><pre><code>too few spare slots.  If you want reserve a specific number of slots,</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>but do not want the exponential increase (for instance, you know this</code></pre></td>
        <td class="diff"><pre><code>but do not want the exponential increase (for instance, you know this</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>is the last allocation), use a negative number for reservation.  You</code></pre></td>
        <td class="diff"><pre><code>is the last allocation), use a negative number for reservation.  You</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>can also create a vector of a specific size from the get go.</code></pre></td>
        <td class="diff"><pre><code>can also create a vector of a specific size from the get go.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>   You should prefer the push and pop operations, as they append and</code></pre></td>
        <td class="diff"><pre><code>   You should prefer the push and pop operations, as they append and</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>remove from the end of the vector. If you need to remove several items</code></pre></td>
        <td class="diff"><pre><code>remove from the end of the vector. If you need to remove several items</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>in one go, use the truncate operation.  The insert and remove</code></pre></td>
        <td class="diff"><pre><code>in one go, use the truncate operation.  The insert and remove</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>operations allow you to change elements in the middle of the vector.</code></pre></td>
        <td class="diff"><pre><code>operations allow you to change elements in the middle of the vector.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>There are two remove operations, one which preserves the element</code></pre></td>
        <td class="diff"><pre><code>There are two remove operations, one which preserves the element</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>ordering `ordered_remove', and one which does not `unordered_remove'.</code></pre></td>
        <td class="diff"><pre><code>ordering `ordered_remove', and one which does not `unordered_remove'.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>The latter function copies the end element into the removed slot,</code></pre></td>
        <td class="diff"><pre><code>The latter function copies the end element into the removed slot,</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>rather than invoke a memmove operation.  The `lower_bound' function</code></pre></td>
        <td class="diff"><pre><code>rather than invoke a memmove operation.  The `lower_bound' function</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>will determine where to place an item in the array using insert that</code></pre></td>
        <td class="diff"><pre><code>will determine where to place an item in the array using insert that</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>will maintain sorted order.</code></pre></td>
        <td class="diff"><pre><code>will maintain sorted order.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>   If you need to directly manipulate a vector, then the `address'</code></pre></td>
        <td class="diff"><pre><code>   If you need to directly manipulate a vector, then the `address'</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>accessor will return the address of the start of the vector.  Also the</code></pre></td>
        <td class="diff"><pre><code>accessor will return the address of the start of the vector.  Also the</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>`space' predicate will tell you whether there is spare capacity in the</code></pre></td>
        <td class="diff"><pre><code>`space' predicate will tell you whether there is spare capacity in the</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>vector.  You will not normally need to use these two functions.</code></pre></td>
        <td class="diff"><pre><code>vector.  You will not normally need to use these two functions.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>   Vector types are defined using a `DEF_VEC_{O,P,I}(TYPENAME)' macro.</code></pre></td>
        <td class="diff"><pre><code>   Vector types are defined using a `DEF_VEC_{O,P,I}(TYPENAME)' macro.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>Variables of vector type are declared using a `VEC(TYPENAME)' macro.</code></pre></td>
        <td class="diff"><pre><code>Variables of vector type are declared using a `VEC(TYPENAME)' macro.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>The characters `O', `P' and `I' indicate whether TYPENAME is an object</code></pre></td>
        <td class="diff"><pre><code>The characters `O', `P' and `I' indicate whether TYPENAME is an object</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>(`O'), pointer (`P') or integral (`I') type.  Be careful to pick the</code></pre></td>
        <td class="diff"><pre><code>(`O'), pointer (`P') or integral (`I') type.  Be careful to pick the</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>correct one, as you'll get an awkward and inefficient API if you use</code></pre></td>
        <td class="diff"><pre><code>correct one, as you'll get an awkward and inefficient API if you use</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>the wrong one.  There is a check, which results in a compile-time</code></pre></td>
        <td class="diff"><pre><code>the wrong one.  There is a check, which results in a compile-time</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>warning, for the `P' and `I' versions, but there is no check for the</code></pre></td>
        <td class="diff"><pre><code>warning, for the `P' and `I' versions, but there is no check for the</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>`O' versions, as that is not possible in plain C.</code></pre></td>
        <td class="diff"><pre><code>`O' versions, as that is not possible in plain C.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>   An example of their use would be,</code></pre></td>
        <td class="diff"><pre><code>   An example of their use would be,</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     DEF_VEC_P(tree);   // non-managed tree vector.</code></pre></td>
        <td class="diff"><pre><code>     DEF_VEC_P(tree);   // non-managed tree vector.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     struct my_struct {</code></pre></td>
        <td class="diff"><pre><code>     struct my_struct {</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>       VEC(tree) *v;      // A (pointer to) a vector of tree pointers.</code></pre></td>
        <td class="diff"><pre><code>       VEC(tree) *v;      // A (pointer to) a vector of tree pointers.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     };</code></pre></td>
        <td class="diff"><pre><code>     };</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     struct my_struct *s;</code></pre></td>
        <td class="diff"><pre><code>     struct my_struct *s;</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     if (VEC_length(tree, s->v)) { we have some contents }</code></pre></td>
        <td class="diff"><pre><code>     if (VEC_length(tree, s->v)) { we have some contents }</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     VEC_safe_push(tree, s->v, decl); // append some decl onto the end</code></pre></td>
        <td class="diff"><pre><code>     VEC_safe_push(tree, s->v, decl); // append some decl onto the end</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     for (ix = 0; VEC_iterate(tree, s->v, ix, elt); ix++)</code></pre></td>
        <td class="diff"><pre><code>     for (ix = 0; VEC_iterate(tree, s->v, ix, elt); ix++)</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>       { do something with elt }</code></pre></td>
        <td class="diff"><pre><code>       { do something with elt }</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>   The `vec.h' file provides details on how to invoke the various</code></pre></td>
        <td class="diff"><pre><code>   The `vec.h' file provides details on how to invoke the various</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>accessors provided.  They are enumerated here:</code></pre></td>
        <td class="diff"><pre><code>accessors provided.  They are enumerated here:</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>`VEC_length'</code></pre></td>
        <td class="diff"><pre><code>`VEC_length'</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     Return the number of items in the array,</code></pre></td>
        <td class="diff"><pre><code>     Return the number of items in the array,</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>`VEC_empty'</code></pre></td>
        <td class="diff"><pre><code>`VEC_empty'</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     Return true if the array has no elements.</code></pre></td>
        <td class="diff"><pre><code>     Return true if the array has no elements.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>`VEC_last'</code></pre></td>
        <td class="diff"><pre><code>`VEC_last'</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>`VEC_index'</code></pre></td>
        <td class="diff"><pre><code>`VEC_index'</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     Return the last or arbitrary item in the array.</code></pre></td>
        <td class="diff"><pre><code>     Return the last or arbitrary item in the array.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>`VEC_iterate'</code></pre></td>
        <td class="diff"><pre><code>`VEC_iterate'</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     Access an array element and indicate whether the array has been</code></pre></td>
        <td class="diff"><pre><code>     Access an array element and indicate whether the array has been</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     traversed.</code></pre></td>
        <td class="diff"><pre><code>     traversed.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>`VEC_alloc'</code></pre></td>
        <td class="diff"><pre><code>`VEC_alloc'</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>`VEC_free'</code></pre></td>
        <td class="diff"><pre><code>`VEC_free'</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     Create and destroy an array.</code></pre></td>
        <td class="diff"><pre><code>     Create and destroy an array.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>`VEC_embedded_size'</code></pre></td>
        <td class="diff"><pre><code>`VEC_embedded_size'</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>`VEC_embedded_init'</code></pre></td>
        <td class="diff"><pre><code>`VEC_embedded_init'</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     Helpers for embedding an array as the final element of another</code></pre></td>
        <td class="diff"><pre><code>     Helpers for embedding an array as the final element of another</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     struct.</code></pre></td>
        <td class="diff"><pre><code>     struct.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>`VEC_copy'</code></pre></td>
        <td class="diff"><pre><code>`VEC_copy'</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     Duplicate an array.</code></pre></td>
        <td class="diff"><pre><code>     Duplicate an array.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>`VEC_space'</code></pre></td>
        <td class="diff"><pre><code>`VEC_space'</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     Return the amount of free space in an array.</code></pre></td>
        <td class="diff"><pre><code>     Return the amount of free space in an array.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>`VEC_reserve'</code></pre></td>
        <td class="diff"><pre><code>`VEC_reserve'</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     Ensure a certain amount of free space.</code></pre></td>
        <td class="diff"><pre><code>     Ensure a certain amount of free space.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>`VEC_quick_push'</code></pre></td>
        <td class="diff"><pre><code>`VEC_quick_push'</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>`VEC_safe_push'</code></pre></td>
        <td class="diff"><pre><code>`VEC_safe_push'</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     Append to an array, either assuming the space is available, or</code></pre></td>
        <td class="diff"><pre><code>     Append to an array, either assuming the space is available, or</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     making sure that it is.</code></pre></td>
        <td class="diff"><pre><code>     making sure that it is.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>`VEC_pop'</code></pre></td>
        <td class="diff"><pre><code>`VEC_pop'</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     Remove the last item from an array.</code></pre></td>
        <td class="diff"><pre><code>     Remove the last item from an array.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>`VEC_truncate'</code></pre></td>
        <td class="diff"><pre><code>`VEC_truncate'</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     Remove several items from the end of an array.</code></pre></td>
        <td class="diff"><pre><code>     Remove several items from the end of an array.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>`VEC_safe_grow'</code></pre></td>
        <td class="diff"><pre><code>`VEC_safe_grow'</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     Add several items to the end of an array.</code></pre></td>
        <td class="diff"><pre><code>     Add several items to the end of an array.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>`VEC_replace'</code></pre></td>
        <td class="diff"><pre><code>`VEC_replace'</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     Overwrite an item in the array.</code></pre></td>
        <td class="diff"><pre><code>     Overwrite an item in the array.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>`VEC_quick_insert'</code></pre></td>
        <td class="diff"><pre><code>`VEC_quick_insert'</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>`VEC_safe_insert'</code></pre></td>
        <td class="diff"><pre><code>`VEC_safe_insert'</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     Insert an item into the middle of the array.  Either the space must</code></pre></td>
        <td class="diff"><pre><code>     Insert an item into the middle of the array.  Either the space must</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     already exist, or the space is created.</code></pre></td>
        <td class="diff"><pre><code>     already exist, or the space is created.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>`VEC_ordered_remove'</code></pre></td>
        <td class="diff"><pre><code>`VEC_ordered_remove'</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>`VEC_unordered_remove'</code></pre></td>
        <td class="diff"><pre><code>`VEC_unordered_remove'</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     Remove an item from the array, preserving order or not.</code></pre></td>
        <td class="diff"><pre><code>     Remove an item from the array, preserving order or not.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>`VEC_block_remove'</code></pre></td>
        <td class="diff"><pre><code>`VEC_block_remove'</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     Remove a set of items from the array.</code></pre></td>
        <td class="diff"><pre><code>     Remove a set of items from the array.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>`VEC_address'</code></pre></td>
        <td class="diff"><pre><code>`VEC_address'</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     Provide the address of the first element.</code></pre></td>
        <td class="diff"><pre><code>     Provide the address of the first element.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>`VEC_lower_bound'</code></pre></td>
        <td class="diff"><pre><code>`VEC_lower_bound'</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     Binary search the array.</code></pre></td>
        <td class="diff"><pre><code>     Binary search the array.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>13.7 include</code></pre></td>
        <td class="diff"><pre><code>13.7 include</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>============</code></pre></td>
        <td class="diff"><pre><code>============</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>File: gdbint.info,  Node: Coding,  Next: Porting GDB,  Prev: Support Libraries,  Up: Top</code></pre></td>
        <td class="diff"><pre><code>File: gdbint.info,  Node: Coding,  Next: Porting GDB,  Prev: Support Libraries,  Up: Top</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>14 Coding</code></pre></td>
        <td class="diff"><pre><code>14 Coding</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>*********</code></pre></td>
        <td class="diff"><pre><code>*********</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>This chapter covers topics that are lower-level than the major</code></pre></td>
        <td class="diff"><pre><code>This chapter covers topics that are lower-level than the major</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>algorithms of GDB.</code></pre></td>
        <td class="diff"><pre><code>algorithms of GDB.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>14.1 Cleanups</code></pre></td>
        <td class="diff"><pre><code>14.1 Cleanups</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>=============</code></pre></td>
        <td class="diff"><pre><code>=============</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>Cleanups are a structured way to deal with things that need to be done</code></pre></td>
        <td class="diff"><pre><code>Cleanups are a structured way to deal with things that need to be done</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>later.</code></pre></td>
        <td class="diff"><pre><code>later.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>   When your code does something (e.g., `xmalloc' some memory, or</code></pre></td>
        <td class="diff"><pre><code>   When your code does something (e.g., `xmalloc' some memory, or</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>`open' a file) that needs to be undone later (e.g., `xfree' the memory</code></pre></td>
        <td class="diff"><pre><code>`open' a file) that needs to be undone later (e.g., `xfree' the memory</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>or `close' the file), it can make a cleanup.  The cleanup will be done</code></pre></td>
        <td class="diff"><pre><code>or `close' the file), it can make a cleanup.  The cleanup will be done</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>at some future point: when the command is finished and control returns</code></pre></td>
        <td class="diff"><pre><code>at some future point: when the command is finished and control returns</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>to the top level; when an error occurs and the stack is unwound; or</code></pre></td>
        <td class="diff"><pre><code>to the top level; when an error occurs and the stack is unwound; or</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>when your code decides it's time to explicitly perform cleanups.</code></pre></td>
        <td class="diff"><pre><code>when your code decides it's time to explicitly perform cleanups.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>Alternatively you can elect to discard the cleanups you created.</code></pre></td>
        <td class="diff"><pre><code>Alternatively you can elect to discard the cleanups you created.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>   Syntax:</code></pre></td>
        <td class="diff"><pre><code>   Syntax:</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>`struct cleanup *OLD_CHAIN;'</code></pre></td>
        <td class="diff"><pre><code>`struct cleanup *OLD_CHAIN;'</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     Declare a variable which will hold a cleanup chain handle.</code></pre></td>
        <td class="diff"><pre><code>     Declare a variable which will hold a cleanup chain handle.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>`OLD_CHAIN = make_cleanup (FUNCTION, ARG);'</code></pre></td>
        <td class="diff"><pre><code>`OLD_CHAIN = make_cleanup (FUNCTION, ARG);'</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     Make a cleanup which will cause FUNCTION to be called with ARG (a</code></pre></td>
        <td class="diff"><pre><code>     Make a cleanup which will cause FUNCTION to be called with ARG (a</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     `char *') later.  The result, OLD_CHAIN, is a handle that can</code></pre></td>
        <td class="diff"><pre><code>     `char *') later.  The result, OLD_CHAIN, is a handle that can</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     later be passed to `do_cleanups' or `discard_cleanups'.  Unless</code></pre></td>
        <td class="diff"><pre><code>     later be passed to `do_cleanups' or `discard_cleanups'.  Unless</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     you are going to call `do_cleanups' or `discard_cleanups', you can</code></pre></td>
        <td class="diff"><pre><code>     you are going to call `do_cleanups' or `discard_cleanups', you can</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     ignore the result from `make_cleanup'.</code></pre></td>
        <td class="diff"><pre><code>     ignore the result from `make_cleanup'.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>`do_cleanups (OLD_CHAIN);'</code></pre></td>
        <td class="diff"><pre><code>`do_cleanups (OLD_CHAIN);'</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     Do all cleanups added to the chain since the corresponding</code></pre></td>
        <td class="diff"><pre><code>     Do all cleanups added to the chain since the corresponding</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     `make_cleanup' call was made.</code></pre></td>
        <td class="diff"><pre><code>     `make_cleanup' call was made.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>`discard_cleanups (OLD_CHAIN);'</code></pre></td>
        <td class="diff"><pre><code>`discard_cleanups (OLD_CHAIN);'</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     Same as `do_cleanups' except that it just removes the cleanups from</code></pre></td>
        <td class="diff"><pre><code>     Same as `do_cleanups' except that it just removes the cleanups from</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     the chain and does not call the specified functions.</code></pre></td>
        <td class="diff"><pre><code>     the chain and does not call the specified functions.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>   Cleanups are implemented as a chain.  The handle returned by</code></pre></td>
        <td class="diff"><pre><code>   Cleanups are implemented as a chain.  The handle returned by</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>`make_cleanups' includes the cleanup passed to the call and any later</code></pre></td>
        <td class="diff"><pre><code>`make_cleanups' includes the cleanup passed to the call and any later</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>cleanups appended to the chain (but not yet discarded or performed).</code></pre></td>
        <td class="diff"><pre><code>cleanups appended to the chain (but not yet discarded or performed).</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>E.g.:</code></pre></td>
        <td class="diff"><pre><code>E.g.:</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     make_cleanup (a, 0);</code></pre></td>
        <td class="diff"><pre><code>     make_cleanup (a, 0);</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     {</code></pre></td>
        <td class="diff"><pre><code>     {</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>       struct cleanup *old = make_cleanup (b, 0);</code></pre></td>
        <td class="diff"><pre><code>       struct cleanup *old = make_cleanup (b, 0);</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>       make_cleanup (c, 0)</code></pre></td>
        <td class="diff"><pre><code>       make_cleanup (c, 0)</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>       ...</code></pre></td>
        <td class="diff"><pre><code>       ...</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>       do_cleanups (old);</code></pre></td>
        <td class="diff"><pre><code>       do_cleanups (old);</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     }</code></pre></td>
        <td class="diff"><pre><code>     }</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>will call `c()' and `b()' but will not call `a()'.  The cleanup that</code></pre></td>
        <td class="diff"><pre><code>will call `c()' and `b()' but will not call `a()'.  The cleanup that</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>calls `a()' will remain in the cleanup chain, and will be done later</code></pre></td>
        <td class="diff"><pre><code>calls `a()' will remain in the cleanup chain, and will be done later</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>unless otherwise discarded.</code></pre></td>
        <td class="diff"><pre><code>unless otherwise discarded.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>   Your function should explicitly do or discard the cleanups it</code></pre></td>
        <td class="diff"><pre><code>   Your function should explicitly do or discard the cleanups it</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>creates.  Failing to do this leads to non-deterministic behavior since</code></pre></td>
        <td class="diff"><pre><code>creates.  Failing to do this leads to non-deterministic behavior since</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>the caller will arbitrarily do or discard your functions cleanups.</code></pre></td>
        <td class="diff"><pre><code>the caller will arbitrarily do or discard your functions cleanups.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>This need leads to two common cleanup styles.</code></pre></td>
        <td class="diff"><pre><code>This need leads to two common cleanup styles.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>   The first style is try/finally.  Before it exits, your code-block</code></pre></td>
        <td class="diff"><pre><code>   The first style is try/finally.  Before it exits, your code-block</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>calls `do_cleanups' with the old cleanup chain and thus ensures that</code></pre></td>
        <td class="diff"><pre><code>calls `do_cleanups' with the old cleanup chain and thus ensures that</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>your code-block's cleanups are always performed.  For instance, the</code></pre></td>
        <td class="diff"><pre><code>your code-block's cleanups are always performed.  For instance, the</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>following code-segment avoids a memory leak problem (even when `error'</code></pre></td>
        <td class="diff"><pre><code>following code-segment avoids a memory leak problem (even when `error'</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>is called and a forced stack unwind occurs) by ensuring that the</code></pre></td>
        <td class="diff"><pre><code>is called and a forced stack unwind occurs) by ensuring that the</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>`xfree' will always be called:</code></pre></td>
        <td class="diff"><pre><code>`xfree' will always be called:</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     struct cleanup *old = make_cleanup (null_cleanup, 0);</code></pre></td>
        <td class="diff"><pre><code>     struct cleanup *old = make_cleanup (null_cleanup, 0);</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     data = xmalloc (sizeof blah);</code></pre></td>
        <td class="diff"><pre><code>     data = xmalloc (sizeof blah);</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     make_cleanup (xfree, data);</code></pre></td>
        <td class="diff"><pre><code>     make_cleanup (xfree, data);</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     ... blah blah ...</code></pre></td>
        <td class="diff"><pre><code>     ... blah blah ...</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     do_cleanups (old);</code></pre></td>
        <td class="diff"><pre><code>     do_cleanups (old);</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>   The second style is try/except.  Before it exits, your code-block</code></pre></td>
        <td class="diff"><pre><code>   The second style is try/except.  Before it exits, your code-block</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>calls `discard_cleanups' with the old cleanup chain and thus ensures</code></pre></td>
        <td class="diff"><pre><code>calls `discard_cleanups' with the old cleanup chain and thus ensures</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>that any created cleanups are not performed.  For instance, the</code></pre></td>
        <td class="diff"><pre><code>that any created cleanups are not performed.  For instance, the</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>following code segment, ensures that the file will be closed but only</code></pre></td>
        <td class="diff"><pre><code>following code segment, ensures that the file will be closed but only</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>if there is an error:</code></pre></td>
        <td class="diff"><pre><code>if there is an error:</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     FILE *file = fopen ("afile", "r");</code></pre></td>
        <td class="diff"><pre><code>     FILE *file = fopen ("afile", "r");</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     struct cleanup *old = make_cleanup (close_file, file);</code></pre></td>
        <td class="diff"><pre><code>     struct cleanup *old = make_cleanup (close_file, file);</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     ... blah blah ...</code></pre></td>
        <td class="diff"><pre><code>     ... blah blah ...</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     discard_cleanups (old);</code></pre></td>
        <td class="diff"><pre><code>     discard_cleanups (old);</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     return file;</code></pre></td>
        <td class="diff"><pre><code>     return file;</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>   Some functions, e.g., `fputs_filtered()' or `error()', specify that</code></pre></td>
        <td class="diff"><pre><code>   Some functions, e.g., `fputs_filtered()' or `error()', specify that</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>they "should not be called when cleanups are not in place".  This means</code></pre></td>
        <td class="diff"><pre><code>they "should not be called when cleanups are not in place".  This means</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>that any actions you need to reverse in the case of an error or</code></pre></td>
        <td class="diff"><pre><code>that any actions you need to reverse in the case of an error or</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>interruption must be on the cleanup chain before you call these</code></pre></td>
        <td class="diff"><pre><code>interruption must be on the cleanup chain before you call these</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>functions, since they might never return to your code (they `longjmp'</code></pre></td>
        <td class="diff"><pre><code>functions, since they might never return to your code (they `longjmp'</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>instead).</code></pre></td>
        <td class="diff"><pre><code>instead).</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>14.2 Per-architecture module data</code></pre></td>
        <td class="diff"><pre><code>14.2 Per-architecture module data</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>=================================</code></pre></td>
        <td class="diff"><pre><code>=================================</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>The multi-arch framework includes a mechanism for adding module</code></pre></td>
        <td class="diff"><pre><code>The multi-arch framework includes a mechanism for adding module</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>specific per-architecture data-pointers to the `struct gdbarch'</code></pre></td>
        <td class="diff"><pre><code>specific per-architecture data-pointers to the `struct gdbarch'</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>architecture object.</code></pre></td>
        <td class="diff"><pre><code>architecture object.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>   A module registers one or more per-architecture data-pointers using:</code></pre></td>
        <td class="diff"><pre><code>   A module registers one or more per-architecture data-pointers using:</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code> -- Function: struct gdbarch_data *gdbarch_data_register_pre_init</code></pre></td>
        <td class="diff"><pre><code> -- Function: struct gdbarch_data *gdbarch_data_register_pre_init</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>          (gdbarch_data_pre_init_ftype *PRE_INIT)</code></pre></td>
        <td class="diff"><pre><code>          (gdbarch_data_pre_init_ftype *PRE_INIT)</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     PRE_INIT is used to, on-demand, allocate an initial value for a</code></pre></td>
        <td class="diff"><pre><code>     PRE_INIT is used to, on-demand, allocate an initial value for a</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     per-architecture data-pointer using the architecture's obstack</code></pre></td>
        <td class="diff"><pre><code>     per-architecture data-pointer using the architecture's obstack</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     (passed in as a parameter).  Since PRE_INIT can be called during</code></pre></td>
        <td class="diff"><pre><code>     (passed in as a parameter).  Since PRE_INIT can be called during</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     architecture creation, it is not parameterized with the</code></pre></td>
        <td class="diff"><pre><code>     architecture creation, it is not parameterized with the</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     architecture.  and must not call modules that use per-architecture</code></pre></td>
        <td class="diff"><pre><code>     architecture.  and must not call modules that use per-architecture</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     data.</code></pre></td>
        <td class="diff"><pre><code>     data.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code> -- Function: struct gdbarch_data *gdbarch_data_register_post_init</code></pre></td>
        <td class="diff"><pre><code> -- Function: struct gdbarch_data *gdbarch_data_register_post_init</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>          (gdbarch_data_post_init_ftype *POST_INIT)</code></pre></td>
        <td class="diff"><pre><code>          (gdbarch_data_post_init_ftype *POST_INIT)</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     POST_INIT is used to obtain an initial value for a</code></pre></td>
        <td class="diff"><pre><code>     POST_INIT is used to obtain an initial value for a</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     per-architecture data-pointer _after_.  Since POST_INIT is always</code></pre></td>
        <td class="diff"><pre><code>     per-architecture data-pointer _after_.  Since POST_INIT is always</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     called after architecture creation, it both receives the fully</code></pre></td>
        <td class="diff"><pre><code>     called after architecture creation, it both receives the fully</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     initialized architecture and is free to call modules that use</code></pre></td>
        <td class="diff"><pre><code>     initialized architecture and is free to call modules that use</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     per-architecture data (care needs to be taken to ensure that those</code></pre></td>
        <td class="diff"><pre><code>     per-architecture data (care needs to be taken to ensure that those</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     other modules do not try to call back to this module as that will</code></pre></td>
        <td class="diff"><pre><code>     other modules do not try to call back to this module as that will</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     create in cycles in the initialization call graph).</code></pre></td>
        <td class="diff"><pre><code>     create in cycles in the initialization call graph).</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>   These functions return a `struct gdbarch_data' that is used to</code></pre></td>
        <td class="diff"><pre><code>   These functions return a `struct gdbarch_data' that is used to</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>identify the per-architecture data-pointer added for that module.</code></pre></td>
        <td class="diff"><pre><code>identify the per-architecture data-pointer added for that module.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>   The per-architecture data-pointer is accessed using the function:</code></pre></td>
        <td class="diff"><pre><code>   The per-architecture data-pointer is accessed using the function:</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code> -- Function: void *gdbarch_data (struct gdbarch *GDBARCH, struct</code></pre></td>
        <td class="diff"><pre><code> -- Function: void *gdbarch_data (struct gdbarch *GDBARCH, struct</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>          gdbarch_data *DATA_HANDLE)</code></pre></td>
        <td class="diff"><pre><code>          gdbarch_data *DATA_HANDLE)</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     Given the architecture ARCH and module data handle DATA_HANDLE</code></pre></td>
        <td class="diff"><pre><code>     Given the architecture ARCH and module data handle DATA_HANDLE</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     (returned by `gdbarch_data_register_pre_init' or</code></pre></td>
        <td class="diff"><pre><code>     (returned by `gdbarch_data_register_pre_init' or</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     `gdbarch_data_register_post_init'), this function returns the</code></pre></td>
        <td class="diff"><pre><code>     `gdbarch_data_register_post_init'), this function returns the</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     current value of the per-architecture data-pointer.  If the data</code></pre></td>
        <td class="diff"><pre><code>     current value of the per-architecture data-pointer.  If the data</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     pointer is `NULL', it is first initialized by calling the</code></pre></td>
        <td class="diff"><pre><code>     pointer is `NULL', it is first initialized by calling the</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     corresponding PRE_INIT or POST_INIT method.</code></pre></td>
        <td class="diff"><pre><code>     corresponding PRE_INIT or POST_INIT method.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>   The examples below assume the following definitions:</code></pre></td>
        <td class="diff"><pre><code>   The examples below assume the following definitions:</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     struct nozel { int total; };</code></pre></td>
        <td class="diff"><pre><code>     struct nozel { int total; };</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     static struct gdbarch_data *nozel_handle;</code></pre></td>
        <td class="diff"><pre><code>     static struct gdbarch_data *nozel_handle;</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>   A module can extend the architecture vector, adding additional</code></pre></td>
        <td class="diff"><pre><code>   A module can extend the architecture vector, adding additional</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>per-architecture data, using the PRE_INIT method.  The module's</code></pre></td>
        <td class="diff"><pre><code>per-architecture data, using the PRE_INIT method.  The module's</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>per-architecture data is then initialized during architecture creation.</code></pre></td>
        <td class="diff"><pre><code>per-architecture data is then initialized during architecture creation.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>   In the below, the module's per-architecture _nozel_ is added.  An</code></pre></td>
        <td class="diff"><pre><code>   In the below, the module's per-architecture _nozel_ is added.  An</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>architecture can specify its nozel by calling `set_gdbarch_nozel' from</code></pre></td>
        <td class="diff"><pre><code>architecture can specify its nozel by calling `set_gdbarch_nozel' from</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>`gdbarch_init'.</code></pre></td>
        <td class="diff"><pre><code>`gdbarch_init'.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     static void *</code></pre></td>
        <td class="diff"><pre><code>     static void *</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     nozel_pre_init (struct obstack *obstack)</code></pre></td>
        <td class="diff"><pre><code>     nozel_pre_init (struct obstack *obstack)</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     {</code></pre></td>
        <td class="diff"><pre><code>     {</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>       struct nozel *data = OBSTACK_ZALLOC (obstack, struct nozel);</code></pre></td>
        <td class="diff"><pre><code>       struct nozel *data = OBSTACK_ZALLOC (obstack, struct nozel);</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>       return data;</code></pre></td>
        <td class="diff"><pre><code>       return data;</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     }</code></pre></td>
        <td class="diff"><pre><code>     }</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     extern void</code></pre></td>
        <td class="diff"><pre><code>     extern void</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     set_gdbarch_nozel (struct gdbarch *gdbarch, int total)</code></pre></td>
        <td class="diff"><pre><code>     set_gdbarch_nozel (struct gdbarch *gdbarch, int total)</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     {</code></pre></td>
        <td class="diff"><pre><code>     {</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>       struct nozel *data = gdbarch_data (gdbarch, nozel_handle);</code></pre></td>
        <td class="diff"><pre><code>       struct nozel *data = gdbarch_data (gdbarch, nozel_handle);</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>       data->total = nozel;</code></pre></td>
        <td class="diff"><pre><code>       data->total = nozel;</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     }</code></pre></td>
        <td class="diff"><pre><code>     }</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>   A module can on-demand create architecture dependant data structures</code></pre></td>
        <td class="diff"><pre><code>   A module can on-demand create architecture dependant data structures</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>using `post_init'.</code></pre></td>
        <td class="diff"><pre><code>using `post_init'.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>   In the below, the nozel's total is computed on-demand by</code></pre></td>
        <td class="diff"><pre><code>   In the below, the nozel's total is computed on-demand by</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>`nozel_post_init' using information obtained from the architecture.</code></pre></td>
        <td class="diff"><pre><code>`nozel_post_init' using information obtained from the architecture.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     static void *</code></pre></td>
        <td class="diff"><pre><code>     static void *</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     nozel_post_init (struct gdbarch *gdbarch)</code></pre></td>
        <td class="diff"><pre><code>     nozel_post_init (struct gdbarch *gdbarch)</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     {</code></pre></td>
        <td class="diff"><pre><code>     {</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>       struct nozel *data = GDBARCH_OBSTACK_ZALLOC (gdbarch, struct nozel);</code></pre></td>
        <td class="diff"><pre><code>       struct nozel *data = GDBARCH_OBSTACK_ZALLOC (gdbarch, struct nozel);</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>       nozel->total = gdbarch... (gdbarch);</code></pre></td>
        <td class="diff"><pre><code>       nozel->total = gdbarch... (gdbarch);</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>       return data;</code></pre></td>
        <td class="diff"><pre><code>       return data;</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     }</code></pre></td>
        <td class="diff"><pre><code>     }</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     extern int</code></pre></td>
        <td class="diff"><pre><code>     extern int</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     nozel_total (struct gdbarch *gdbarch)</code></pre></td>
        <td class="diff"><pre><code>     nozel_total (struct gdbarch *gdbarch)</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     {</code></pre></td>
        <td class="diff"><pre><code>     {</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>       struct nozel *data = gdbarch_data (gdbarch, nozel_handle);</code></pre></td>
        <td class="diff"><pre><code>       struct nozel *data = gdbarch_data (gdbarch, nozel_handle);</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>       return data->total;</code></pre></td>
        <td class="diff"><pre><code>       return data->total;</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     }</code></pre></td>
        <td class="diff"><pre><code>     }</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>14.3 Wrapping Output Lines</code></pre></td>
        <td class="diff"><pre><code>14.3 Wrapping Output Lines</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>==========================</code></pre></td>
        <td class="diff"><pre><code>==========================</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>Output that goes through `printf_filtered' or `fputs_filtered' or</code></pre></td>
        <td class="diff"><pre><code>Output that goes through `printf_filtered' or `fputs_filtered' or</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>`fputs_demangled' needs only to have calls to `wrap_here' added in</code></pre></td>
        <td class="diff"><pre><code>`fputs_demangled' needs only to have calls to `wrap_here' added in</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>places that would be good breaking points.  The utility routines will</code></pre></td>
        <td class="diff"><pre><code>places that would be good breaking points.  The utility routines will</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>take care of actually wrapping if the line width is exceeded.</code></pre></td>
        <td class="diff"><pre><code>take care of actually wrapping if the line width is exceeded.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>   The argument to `wrap_here' is an indentation string which is</code></pre></td>
        <td class="diff"><pre><code>   The argument to `wrap_here' is an indentation string which is</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>printed _only_ if the line breaks there.  This argument is saved away</code></pre></td>
        <td class="diff"><pre><code>printed _only_ if the line breaks there.  This argument is saved away</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>and used later.  It must remain valid until the next call to</code></pre></td>
        <td class="diff"><pre><code>and used later.  It must remain valid until the next call to</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>`wrap_here' or until a newline has been printed through the</code></pre></td>
        <td class="diff"><pre><code>`wrap_here' or until a newline has been printed through the</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>`*_filtered' functions.  Don't pass in a local variable and then return!</code></pre></td>
        <td class="diff"><pre><code>`*_filtered' functions.  Don't pass in a local variable and then return!</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>   It is usually best to call `wrap_here' after printing a comma or</code></pre></td>
        <td class="diff"><pre><code>   It is usually best to call `wrap_here' after printing a comma or</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>space.  If you call it before printing a space, make sure that your</code></pre></td>
        <td class="diff"><pre><code>space.  If you call it before printing a space, make sure that your</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>indentation properly accounts for the leading space that will print if</code></pre></td>
        <td class="diff"><pre><code>indentation properly accounts for the leading space that will print if</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>the line wraps there.</code></pre></td>
        <td class="diff"><pre><code>the line wraps there.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>   Any function or set of functions that produce filtered output must</code></pre></td>
        <td class="diff"><pre><code>   Any function or set of functions that produce filtered output must</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>finish by printing a newline, to flush the wrap buffer, before switching</code></pre></td>
        <td class="diff"><pre><code>finish by printing a newline, to flush the wrap buffer, before switching</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>to unfiltered (`printf') output.  Symbol reading routines that print</code></pre></td>
        <td class="diff"><pre><code>to unfiltered (`printf') output.  Symbol reading routines that print</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>warnings are a good example.</code></pre></td>
        <td class="diff"><pre><code>warnings are a good example.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>14.4 GDB Coding Standards</code></pre></td>
        <td class="diff"><pre><code>14.4 GDB Coding Standards</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>=========================</code></pre></td>
        <td class="diff"><pre><code>=========================</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>GDB follows the GNU coding standards, as described in</code></pre></td>
        <td class="diff"><pre><code>GDB follows the GNU coding standards, as described in</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>`etc/standards.texi'.  This file is also available for anonymous FTP</code></pre></td>
        <td class="diff"><pre><code>`etc/standards.texi'.  This file is also available for anonymous FTP</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>from GNU archive sites.  GDB takes a strict interpretation of the</code></pre></td>
        <td class="diff"><pre><code>from GNU archive sites.  GDB takes a strict interpretation of the</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>standard; in general, when the GNU standard recommends a practice but</code></pre></td>
        <td class="diff"><pre><code>standard; in general, when the GNU standard recommends a practice but</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>does not require it, GDB requires it.</code></pre></td>
        <td class="diff"><pre><code>does not require it, GDB requires it.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>   GDB follows an additional set of coding standards specific to GDB,</code></pre></td>
        <td class="diff"><pre><code>   GDB follows an additional set of coding standards specific to GDB,</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>as described in the following sections.</code></pre></td>
        <td class="diff"><pre><code>as described in the following sections.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>14.4.1 ISO C</code></pre></td>
        <td class="diff"><pre><code>14.4.1 ISO C</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>------------</code></pre></td>
        <td class="diff"><pre><code>------------</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>GDB assumes an ISO/IEC 9899:1990 (a.k.a. ISO C90) compliant compiler.</code></pre></td>
        <td class="diff"><pre><code>GDB assumes an ISO/IEC 9899:1990 (a.k.a. ISO C90) compliant compiler.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>   GDB does not assume an ISO C or POSIX compliant C library.</code></pre></td>
        <td class="diff"><pre><code>   GDB does not assume an ISO C or POSIX compliant C library.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>14.4.2 Memory Management</code></pre></td>
        <td class="diff"><pre><code>14.4.2 Memory Management</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>------------------------</code></pre></td>
        <td class="diff"><pre><code>------------------------</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>GDB does not use the functions `malloc', `realloc', `calloc', `free'</code></pre></td>
        <td class="diff"><pre><code>GDB does not use the functions `malloc', `realloc', `calloc', `free'</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>and `asprintf'.</code></pre></td>
        <td class="diff"><pre><code>and `asprintf'.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>   GDB uses the functions `xmalloc', `xrealloc' and `xcalloc' when</code></pre></td>
        <td class="diff"><pre><code>   GDB uses the functions `xmalloc', `xrealloc' and `xcalloc' when</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>allocating memory.  Unlike `malloc' et.al.  these functions do not</code></pre></td>
        <td class="diff"><pre><code>allocating memory.  Unlike `malloc' et.al.  these functions do not</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>return when the memory pool is empty.  Instead, they unwind the stack</code></pre></td>
        <td class="diff"><pre><code>return when the memory pool is empty.  Instead, they unwind the stack</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>using cleanups.  These functions return `NULL' when requested to</code></pre></td>
        <td class="diff"><pre><code>using cleanups.  These functions return `NULL' when requested to</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>allocate a chunk of memory of size zero.</code></pre></td>
        <td class="diff"><pre><code>allocate a chunk of memory of size zero.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>   _Pragmatics: By using these functions, the need to check every</code></pre></td>
        <td class="diff"><pre><code>   _Pragmatics: By using these functions, the need to check every</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>memory allocation is removed.  These functions provide portable</code></pre></td>
        <td class="diff"><pre><code>memory allocation is removed.  These functions provide portable</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>behavior._</code></pre></td>
        <td class="diff"><pre><code>behavior._</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>   GDB does not use the function `free'.</code></pre></td>
        <td class="diff"><pre><code>   GDB does not use the function `free'.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>   GDB uses the function `xfree' to return memory to the memory pool.</code></pre></td>
        <td class="diff"><pre><code>   GDB uses the function `xfree' to return memory to the memory pool.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>Consistent with ISO-C, this function ignores a request to free a `NULL'</code></pre></td>
        <td class="diff"><pre><code>Consistent with ISO-C, this function ignores a request to free a `NULL'</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>pointer.</code></pre></td>
        <td class="diff"><pre><code>pointer.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>   _Pragmatics: On some systems `free' fails when passed a `NULL'</code></pre></td>
        <td class="diff"><pre><code>   _Pragmatics: On some systems `free' fails when passed a `NULL'</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>pointer._</code></pre></td>
        <td class="diff"><pre><code>pointer._</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>   GDB can use the non-portable function `alloca' for the allocation of</code></pre></td>
        <td class="diff"><pre><code>   GDB can use the non-portable function `alloca' for the allocation of</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>small temporary values (such as strings).</code></pre></td>
        <td class="diff"><pre><code>small temporary values (such as strings).</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>   _Pragmatics: This function is very non-portable.  Some systems</code></pre></td>
        <td class="diff"><pre><code>   _Pragmatics: This function is very non-portable.  Some systems</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>restrict the memory being allocated to no more than a few kilobytes._</code></pre></td>
        <td class="diff"><pre><code>restrict the memory being allocated to no more than a few kilobytes._</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>   GDB uses the string function `xstrdup' and the print function</code></pre></td>
        <td class="diff"><pre><code>   GDB uses the string function `xstrdup' and the print function</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>`xstrprintf'.</code></pre></td>
        <td class="diff"><pre><code>`xstrprintf'.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>   _Pragmatics: `asprintf' and `strdup' can fail.  Print functions such</code></pre></td>
        <td class="diff"><pre><code>   _Pragmatics: `asprintf' and `strdup' can fail.  Print functions such</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>as `sprintf' are very prone to buffer overflow errors._</code></pre></td>
        <td class="diff"><pre><code>as `sprintf' are very prone to buffer overflow errors._</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>14.4.3 Compiler Warnings</code></pre></td>
        <td class="diff"><pre><code>14.4.3 Compiler Warnings</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>------------------------</code></pre></td>
        <td class="diff"><pre><code>------------------------</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>With few exceptions, developers should avoid the configuration option</code></pre></td>
        <td class="diff"><pre><code>With few exceptions, developers should avoid the configuration option</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>`--disable-werror' when building GDB.  The exceptions are listed in the</code></pre></td>
        <td class="diff"><pre><code>`--disable-werror' when building GDB.  The exceptions are listed in the</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>file `gdb/MAINTAINERS'.  The default, when building with GCC, is</code></pre></td>
        <td class="diff"><pre><code>file `gdb/MAINTAINERS'.  The default, when building with GCC, is</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>`--enable-werror'.</code></pre></td>
        <td class="diff"><pre><code>`--enable-werror'.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>   This option causes GDB (when built using GCC) to be compiled with a</code></pre></td>
        <td class="diff"><pre><code>   This option causes GDB (when built using GCC) to be compiled with a</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>carefully selected list of compiler warning flags.  Any warnings from</code></pre></td>
        <td class="diff"><pre><code>carefully selected list of compiler warning flags.  Any warnings from</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>those flags are treated as errors.</code></pre></td>
        <td class="diff"><pre><code>those flags are treated as errors.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>   The current list of warning flags includes:</code></pre></td>
        <td class="diff"><pre><code>   The current list of warning flags includes:</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>`-Wall'</code></pre></td>
        <td class="diff"><pre><code>`-Wall'</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     Recommended GCC warnings.</code></pre></td>
        <td class="diff"><pre><code>     Recommended GCC warnings.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>`-Wdeclaration-after-statement'</code></pre></td>
        <td class="diff"><pre><code>`-Wdeclaration-after-statement'</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     GCC 3.x (and later) and C99 allow declarations mixed with code,</code></pre></td>
        <td class="diff"><pre><code>     GCC 3.x (and later) and C99 allow declarations mixed with code,</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     but GCC 2.x and C89 do not.</code></pre></td>
        <td class="diff"><pre><code>     but GCC 2.x and C89 do not.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>`-Wpointer-arith'</code></pre></td>
        <td class="diff"><pre><code>`-Wpointer-arith'</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>`-Wformat-nonliteral'</code></pre></td>
        <td class="diff"><pre><code>`-Wformat-nonliteral'</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     Non-literal format strings, with a few exceptions, are bugs - they</code></pre></td>
        <td class="diff"><pre><code>     Non-literal format strings, with a few exceptions, are bugs - they</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     might contain unintended user-supplied format specifiers.  Since</code></pre></td>
        <td class="diff"><pre><code>     might contain unintended user-supplied format specifiers.  Since</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     GDB uses the `format printf' attribute on all `printf' like</code></pre></td>
        <td class="diff"><pre><code>     GDB uses the `format printf' attribute on all `printf' like</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     functions this checks not just `printf' calls but also calls to</code></pre></td>
        <td class="diff"><pre><code>     functions this checks not just `printf' calls but also calls to</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     functions such as `fprintf_unfiltered'.</code></pre></td>
        <td class="diff"><pre><code>     functions such as `fprintf_unfiltered'.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>`-Wno-pointer-sign'</code></pre></td>
        <td class="diff"><pre><code>`-Wno-pointer-sign'</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     In version 4.0, GCC began warning about pointer argument passing or</code></pre></td>
        <td class="diff"><pre><code>     In version 4.0, GCC began warning about pointer argument passing or</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     assignment even when the source and destination differed only in</code></pre></td>
        <td class="diff"><pre><code>     assignment even when the source and destination differed only in</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     signedness.  However, most GDB code doesn't distinguish carefully</code></pre></td>
        <td class="diff"><pre><code>     signedness.  However, most GDB code doesn't distinguish carefully</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     between `char' and `unsigned char'.  In early 2006 the GDB</code></pre></td>
        <td class="diff"><pre><code>     between `char' and `unsigned char'.  In early 2006 the GDB</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     developers decided correcting these warnings wasn't worth the time</code></pre></td>
        <td class="diff"><pre><code>     developers decided correcting these warnings wasn't worth the time</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     it would take.</code></pre></td>
        <td class="diff"><pre><code>     it would take.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>`-Wno-unused-parameter'</code></pre></td>
        <td class="diff"><pre><code>`-Wno-unused-parameter'</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     Due to the way that GDB is implemented many functions have unused</code></pre></td>
        <td class="diff"><pre><code>     Due to the way that GDB is implemented many functions have unused</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     parameters.  Consequently this warning is avoided.  The macro</code></pre></td>
        <td class="diff"><pre><code>     parameters.  Consequently this warning is avoided.  The macro</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     `ATTRIBUTE_UNUSED' is not used as it leads to false negatives --</code></pre></td>
        <td class="diff"><pre><code>     `ATTRIBUTE_UNUSED' is not used as it leads to false negatives --</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     it is not an error to have `ATTRIBUTE_UNUSED' on a parameter that</code></pre></td>
        <td class="diff"><pre><code>     it is not an error to have `ATTRIBUTE_UNUSED' on a parameter that</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     is being used.</code></pre></td>
        <td class="diff"><pre><code>     is being used.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>`-Wno-unused'</code></pre></td>
        <td class="diff"><pre><code>`-Wno-unused'</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>`-Wno-switch'</code></pre></td>
        <td class="diff"><pre><code>`-Wno-switch'</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>`-Wno-char-subscripts'</code></pre></td>
        <td class="diff"><pre><code>`-Wno-char-subscripts'</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     These are warnings which might be useful for GDB, but are</code></pre></td>
        <td class="diff"><pre><code>     These are warnings which might be useful for GDB, but are</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     currently too noisy to enable with `-Werror'.</code></pre></td>
        <td class="diff"><pre><code>     currently too noisy to enable with `-Werror'.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>14.4.4 Formatting</code></pre></td>
        <td class="diff"><pre><code>14.4.4 Formatting</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>-----------------</code></pre></td>
        <td class="diff"><pre><code>-----------------</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>The standard GNU recommendations for formatting must be followed</code></pre></td>
        <td class="diff"><pre><code>The standard GNU recommendations for formatting must be followed</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>strictly.</code></pre></td>
        <td class="diff"><pre><code>strictly.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>   A function declaration should not have its name in column zero.  A</code></pre></td>
        <td class="diff"><pre><code>   A function declaration should not have its name in column zero.  A</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>function definition should have its name in column zero.</code></pre></td>
        <td class="diff"><pre><code>function definition should have its name in column zero.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     /* Declaration */</code></pre></td>
        <td class="diff"><pre><code>     /* Declaration */</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     static void foo (void);</code></pre></td>
        <td class="diff"><pre><code>     static void foo (void);</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     /* Definition */</code></pre></td>
        <td class="diff"><pre><code>     /* Definition */</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     void</code></pre></td>
        <td class="diff"><pre><code>     void</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     foo (void)</code></pre></td>
        <td class="diff"><pre><code>     foo (void)</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     {</code></pre></td>
        <td class="diff"><pre><code>     {</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     }</code></pre></td>
        <td class="diff"><pre><code>     }</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>   _Pragmatics: This simplifies scripting.  Function definitions can be</code></pre></td>
        <td class="diff"><pre><code>   _Pragmatics: This simplifies scripting.  Function definitions can be</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>found using `^function-name'._</code></pre></td>
        <td class="diff"><pre><code>found using `^function-name'._</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>   There must be a space between a function or macro name and the</code></pre></td>
        <td class="diff"><pre><code>   There must be a space between a function or macro name and the</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>opening parenthesis of its argument list (except for macro definitions,</code></pre></td>
        <td class="diff"><pre><code>opening parenthesis of its argument list (except for macro definitions,</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>as required by C).  There must not be a space after an open</code></pre></td>
        <td class="diff"><pre><code>as required by C).  There must not be a space after an open</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>paren/bracket or before a close paren/bracket.</code></pre></td>
        <td class="diff"><pre><code>paren/bracket or before a close paren/bracket.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>   While additional whitespace is generally helpful for reading, do not</code></pre></td>
        <td class="diff"><pre><code>   While additional whitespace is generally helpful for reading, do not</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>use more than one blank line to separate blocks, and avoid adding</code></pre></td>
        <td class="diff"><pre><code>use more than one blank line to separate blocks, and avoid adding</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>whitespace after the end of a program line (as of 1/99, some 600 lines</code></pre></td>
        <td class="diff"><pre><code>whitespace after the end of a program line (as of 1/99, some 600 lines</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>had whitespace after the semicolon).  Excess whitespace causes</code></pre></td>
        <td class="diff"><pre><code>had whitespace after the semicolon).  Excess whitespace causes</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>difficulties for `diff' and `patch' utilities.</code></pre></td>
        <td class="diff"><pre><code>difficulties for `diff' and `patch' utilities.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>   Pointers are declared using the traditional K&R C style:</code></pre></td>
        <td class="diff"><pre><code>   Pointers are declared using the traditional K&R C style:</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     void *foo;</code></pre></td>
        <td class="diff"><pre><code>     void *foo;</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>and not:</code></pre></td>
        <td class="diff"><pre><code>and not:</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     void * foo;</code></pre></td>
        <td class="diff"><pre><code>     void * foo;</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     void* foo;</code></pre></td>
        <td class="diff"><pre><code>     void* foo;</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>14.4.5 Comments</code></pre></td>
        <td class="diff"><pre><code>14.4.5 Comments</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>---------------</code></pre></td>
        <td class="diff"><pre><code>---------------</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>The standard GNU requirements on comments must be followed strictly.</code></pre></td>
        <td class="diff"><pre><code>The standard GNU requirements on comments must be followed strictly.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>   Block comments must appear in the following form, with no `/*'- or</code></pre></td>
        <td class="diff"><pre><code>   Block comments must appear in the following form, with no `/*'- or</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>`*/'-only lines, and no leading `*':</code></pre></td>
        <td class="diff"><pre><code>`*/'-only lines, and no leading `*':</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     /* Wait for control to return from inferior to debugger.  If inferior</code></pre></td>
        <td class="diff"><pre><code>     /* Wait for control to return from inferior to debugger.  If inferior</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>        gets a signal, we may decide to start it up again instead of</code></pre></td>
        <td class="diff"><pre><code>        gets a signal, we may decide to start it up again instead of</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>        returning.  That is why there is a loop in this function.  When</code></pre></td>
        <td class="diff"><pre><code>        returning.  That is why there is a loop in this function.  When</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>        this function actually returns it means the inferior should be left</code></pre></td>
        <td class="diff"><pre><code>        this function actually returns it means the inferior should be left</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>        stopped and GDB should read more commands.  */</code></pre></td>
        <td class="diff"><pre><code>        stopped and GDB should read more commands.  */</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>   (Note that this format is encouraged by Emacs; tabbing for a</code></pre></td>
        <td class="diff"><pre><code>   (Note that this format is encouraged by Emacs; tabbing for a</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>multi-line comment works correctly, and `M-q' fills the block</code></pre></td>
        <td class="diff"><pre><code>multi-line comment works correctly, and `M-q' fills the block</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>consistently.)</code></pre></td>
        <td class="diff"><pre><code>consistently.)</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>   Put a blank line between the block comments preceding function or</code></pre></td>
        <td class="diff"><pre><code>   Put a blank line between the block comments preceding function or</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>variable definitions, and the definition itself.</code></pre></td>
        <td class="diff"><pre><code>variable definitions, and the definition itself.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>   In general, put function-body comments on lines by themselves, rather</code></pre></td>
        <td class="diff"><pre><code>   In general, put function-body comments on lines by themselves, rather</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>than trying to fit them into the 20 characters left at the end of a</code></pre></td>
        <td class="diff"><pre><code>than trying to fit them into the 20 characters left at the end of a</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>line, since either the comment or the code will inevitably get longer</code></pre></td>
        <td class="diff"><pre><code>line, since either the comment or the code will inevitably get longer</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>than will fit, and then somebody will have to move it anyhow.</code></pre></td>
        <td class="diff"><pre><code>than will fit, and then somebody will have to move it anyhow.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>14.4.6 C Usage</code></pre></td>
        <td class="diff"><pre><code>14.4.6 C Usage</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>--------------</code></pre></td>
        <td class="diff"><pre><code>--------------</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>Code must not depend on the sizes of C data types, the format of the</code></pre></td>
        <td class="diff"><pre><code>Code must not depend on the sizes of C data types, the format of the</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>host's floating point numbers, the alignment of anything, or the order</code></pre></td>
        <td class="diff"><pre><code>host's floating point numbers, the alignment of anything, or the order</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>of evaluation of expressions.</code></pre></td>
        <td class="diff"><pre><code>of evaluation of expressions.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>   Use functions freely.  There are only a handful of compute-bound</code></pre></td>
        <td class="diff"><pre><code>   Use functions freely.  There are only a handful of compute-bound</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>areas in GDB that might be affected by the overhead of a function call,</code></pre></td>
        <td class="diff"><pre><code>areas in GDB that might be affected by the overhead of a function call,</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>mainly in symbol reading.  Most of GDB's performance is limited by the</code></pre></td>
        <td class="diff"><pre><code>mainly in symbol reading.  Most of GDB's performance is limited by the</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>target interface (whether serial line or system call).</code></pre></td>
        <td class="diff"><pre><code>target interface (whether serial line or system call).</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>   However, use functions with moderation.  A thousand one-line</code></pre></td>
        <td class="diff"><pre><code>   However, use functions with moderation.  A thousand one-line</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>functions are just as hard to understand as a single thousand-line</code></pre></td>
        <td class="diff"><pre><code>functions are just as hard to understand as a single thousand-line</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>function.</code></pre></td>
        <td class="diff"><pre><code>function.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>   _Macros are bad, M'kay._ (But if you have to use a macro, make sure</code></pre></td>
        <td class="diff"><pre><code>   _Macros are bad, M'kay._ (But if you have to use a macro, make sure</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>that the macro arguments are protected with parentheses.)</code></pre></td>
        <td class="diff"><pre><code>that the macro arguments are protected with parentheses.)</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>   Declarations like `struct foo *' should be used in preference to</code></pre></td>
        <td class="diff"><pre><code>   Declarations like `struct foo *' should be used in preference to</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>declarations like `typedef struct foo { ... } *foo_ptr'.</code></pre></td>
        <td class="diff"><pre><code>declarations like `typedef struct foo { ... } *foo_ptr'.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>14.4.7 Function Prototypes</code></pre></td>
        <td class="diff"><pre><code>14.4.7 Function Prototypes</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>--------------------------</code></pre></td>
        <td class="diff"><pre><code>--------------------------</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>Prototypes must be used when both _declaring_ and _defining_ a</code></pre></td>
        <td class="diff"><pre><code>Prototypes must be used when both _declaring_ and _defining_ a</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>function.  Prototypes for GDB functions must include both the argument</code></pre></td>
        <td class="diff"><pre><code>function.  Prototypes for GDB functions must include both the argument</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>type and name, with the name matching that used in the actual function</code></pre></td>
        <td class="diff"><pre><code>type and name, with the name matching that used in the actual function</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>definition.</code></pre></td>
        <td class="diff"><pre><code>definition.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>   All external functions should have a declaration in a header file</code></pre></td>
        <td class="diff"><pre><code>   All external functions should have a declaration in a header file</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>that callers include, except for `_initialize_*' functions, which must</code></pre></td>
        <td class="diff"><pre><code>that callers include, except for `_initialize_*' functions, which must</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>be external so that `init.c' construction works, but shouldn't be</code></pre></td>
        <td class="diff"><pre><code>be external so that `init.c' construction works, but shouldn't be</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>visible to random source files.</code></pre></td>
        <td class="diff"><pre><code>visible to random source files.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>   Where a source file needs a forward declaration of a static function,</code></pre></td>
        <td class="diff"><pre><code>   Where a source file needs a forward declaration of a static function,</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>that declaration must appear in a block near the top of the source file.</code></pre></td>
        <td class="diff"><pre><code>that declaration must appear in a block near the top of the source file.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>14.4.8 Internal Error Recovery</code></pre></td>
        <td class="diff"><pre><code>14.4.8 Internal Error Recovery</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>------------------------------</code></pre></td>
        <td class="diff"><pre><code>------------------------------</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>During its execution, GDB can encounter two types of errors.  User</code></pre></td>
        <td class="diff"><pre><code>During its execution, GDB can encounter two types of errors.  User</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>errors and internal errors.  User errors include not only a user</code></pre></td>
        <td class="diff"><pre><code>errors and internal errors.  User errors include not only a user</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>entering an incorrect command but also problems arising from corrupt</code></pre></td>
        <td class="diff"><pre><code>entering an incorrect command but also problems arising from corrupt</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>object files and system errors when interacting with the target.</code></pre></td>
        <td class="diff"><pre><code>object files and system errors when interacting with the target.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>Internal errors include situations where GDB has detected, at run time,</code></pre></td>
        <td class="diff"><pre><code>Internal errors include situations where GDB has detected, at run time,</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>a corrupt or erroneous situation.</code></pre></td>
        <td class="diff"><pre><code>a corrupt or erroneous situation.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>   When reporting an internal error, GDB uses `internal_error' and</code></pre></td>
        <td class="diff"><pre><code>   When reporting an internal error, GDB uses `internal_error' and</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>`gdb_assert'.</code></pre></td>
        <td class="diff"><pre><code>`gdb_assert'.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>   GDB must not call `abort' or `assert'.</code></pre></td>
        <td class="diff"><pre><code>   GDB must not call `abort' or `assert'.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>   _Pragmatics: There is no `internal_warning' function.  Either the</code></pre></td>
        <td class="diff"><pre><code>   _Pragmatics: There is no `internal_warning' function.  Either the</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>code detected a user error, recovered from it and issued a `warning' or</code></pre></td>
        <td class="diff"><pre><code>code detected a user error, recovered from it and issued a `warning' or</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>the code failed to correctly recover from the user error and issued an</code></pre></td>
        <td class="diff"><pre><code>the code failed to correctly recover from the user error and issued an</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>`internal_error'._</code></pre></td>
        <td class="diff"><pre><code>`internal_error'._</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>14.4.9 File Names</code></pre></td>
        <td class="diff"><pre><code>14.4.9 File Names</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>-----------------</code></pre></td>
        <td class="diff"><pre><code>-----------------</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>Any file used when building the core of GDB must be in lower case. Any</code></pre></td>
        <td class="diff"><pre><code>Any file used when building the core of GDB must be in lower case. Any</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>file used when building the core of GDB must be 8.3 unique.  These</code></pre></td>
        <td class="diff"><pre><code>file used when building the core of GDB must be 8.3 unique.  These</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>requirements apply to both source and generated files.</code></pre></td>
        <td class="diff"><pre><code>requirements apply to both source and generated files.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>   _Pragmatics: The core of GDB must be buildable on many platforms</code></pre></td>
        <td class="diff"><pre><code>   _Pragmatics: The core of GDB must be buildable on many platforms</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>including DJGPP and MacOS/HFS.  Every time an unfriendly file is</code></pre></td>
        <td class="diff"><pre><code>including DJGPP and MacOS/HFS.  Every time an unfriendly file is</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>introduced to the build process both `Makefile.in' and `configure.in'</code></pre></td>
        <td class="diff"><pre><code>introduced to the build process both `Makefile.in' and `configure.in'</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>need to be modified accordingly.  Compare the convoluted conversion</code></pre></td>
        <td class="diff"><pre><code>need to be modified accordingly.  Compare the convoluted conversion</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>process needed to transform `COPYING' into `copying.c' with the</code></pre></td>
        <td class="diff"><pre><code>process needed to transform `COPYING' into `copying.c' with the</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>conversion needed to transform `version.in' into `version.c'._</code></pre></td>
        <td class="diff"><pre><code>conversion needed to transform `version.in' into `version.c'._</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>   Any file non 8.3 compliant file (that is not used when building the</code></pre></td>
        <td class="diff"><pre><code>   Any file non 8.3 compliant file (that is not used when building the</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>core of GDB) must be added to `gdb/config/djgpp/fnchange.lst'.</code></pre></td>
        <td class="diff"><pre><code>core of GDB) must be added to `gdb/config/djgpp/fnchange.lst'.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>   _Pragmatics: This is clearly a compromise._</code></pre></td>
        <td class="diff"><pre><code>   _Pragmatics: This is clearly a compromise._</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>   When GDB has a local version of a system header file (ex `string.h')</code></pre></td>
        <td class="diff"><pre><code>   When GDB has a local version of a system header file (ex `string.h')</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>the file name based on the POSIX header prefixed with `gdb_'</code></pre></td>
        <td class="diff"><pre><code>the file name based on the POSIX header prefixed with `gdb_'</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>(`gdb_string.h').  These headers should be relatively independent: they</code></pre></td>
        <td class="diff"><pre><code>(`gdb_string.h').  These headers should be relatively independent: they</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>should use only macros defined by `configure', the compiler, or the</code></pre></td>
        <td class="diff"><pre><code>should use only macros defined by `configure', the compiler, or the</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>host; they should include only system headers; they should refer only</code></pre></td>
        <td class="diff"><pre><code>host; they should include only system headers; they should refer only</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>to system types.  They may be shared between multiple programs, e.g.</code></pre></td>
        <td class="diff"><pre><code>to system types.  They may be shared between multiple programs, e.g.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>GDB and GDBSERVER.</code></pre></td>
        <td class="diff"><pre><code>GDB and GDBSERVER.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>   For other files `-' is used as the separator.</code></pre></td>
        <td class="diff"><pre><code>   For other files `-' is used as the separator.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>14.4.10 Include Files</code></pre></td>
        <td class="diff"><pre><code>14.4.10 Include Files</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>---------------------</code></pre></td>
        <td class="diff"><pre><code>---------------------</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>A `.c' file should include `defs.h' first.</code></pre></td>
        <td class="diff"><pre><code>A `.c' file should include `defs.h' first.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>   A `.c' file should directly include the `.h' file of every</code></pre></td>
        <td class="diff"><pre><code>   A `.c' file should directly include the `.h' file of every</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>declaration and/or definition it directly refers to.  It cannot rely on</code></pre></td>
        <td class="diff"><pre><code>declaration and/or definition it directly refers to.  It cannot rely on</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>indirect inclusion.</code></pre></td>
        <td class="diff"><pre><code>indirect inclusion.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>   A `.h' file should directly include the `.h' file of every</code></pre></td>
        <td class="diff"><pre><code>   A `.h' file should directly include the `.h' file of every</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>declaration and/or definition it directly refers to.  It cannot rely on</code></pre></td>
        <td class="diff"><pre><code>declaration and/or definition it directly refers to.  It cannot rely on</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>indirect inclusion.  Exception: The file `defs.h' does not need to be</code></pre></td>
        <td class="diff"><pre><code>indirect inclusion.  Exception: The file `defs.h' does not need to be</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>directly included.</code></pre></td>
        <td class="diff"><pre><code>directly included.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>   An external declaration should only appear in one include file.</code></pre></td>
        <td class="diff"><pre><code>   An external declaration should only appear in one include file.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>   An external declaration should never appear in a `.c' file.</code></pre></td>
        <td class="diff"><pre><code>   An external declaration should never appear in a `.c' file.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>Exception: a declaration for the `_initialize' function that pacifies</code></pre></td>
        <td class="diff"><pre><code>Exception: a declaration for the `_initialize' function that pacifies</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>`-Wmissing-declaration'.</code></pre></td>
        <td class="diff"><pre><code>`-Wmissing-declaration'.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>   A `typedef' definition should only appear in one include file.</code></pre></td>
        <td class="diff"><pre><code>   A `typedef' definition should only appear in one include file.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>   An opaque `struct' declaration can appear in multiple `.h' files.</code></pre></td>
        <td class="diff"><pre><code>   An opaque `struct' declaration can appear in multiple `.h' files.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>Where possible, a `.h' file should use an opaque `struct' declaration</code></pre></td>
        <td class="diff"><pre><code>Where possible, a `.h' file should use an opaque `struct' declaration</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>instead of an include.</code></pre></td>
        <td class="diff"><pre><code>instead of an include.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>   All `.h' files should be wrapped in:</code></pre></td>
        <td class="diff"><pre><code>   All `.h' files should be wrapped in:</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     #ifndef INCLUDE_FILE_NAME_H</code></pre></td>
        <td class="diff"><pre><code>     #ifndef INCLUDE_FILE_NAME_H</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     #define INCLUDE_FILE_NAME_H</code></pre></td>
        <td class="diff"><pre><code>     #define INCLUDE_FILE_NAME_H</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     header body</code></pre></td>
        <td class="diff"><pre><code>     header body</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     #endif</code></pre></td>
        <td class="diff"><pre><code>     #endif</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>14.4.11 Clean Design and Portable Implementation</code></pre></td>
        <td class="diff"><pre><code>14.4.11 Clean Design and Portable Implementation</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>------------------------------------------------</code></pre></td>
        <td class="diff"><pre><code>------------------------------------------------</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>In addition to getting the syntax right, there's the little question of</code></pre></td>
        <td class="diff"><pre><code>In addition to getting the syntax right, there's the little question of</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>semantics.  Some things are done in certain ways in GDB because long</code></pre></td>
        <td class="diff"><pre><code>semantics.  Some things are done in certain ways in GDB because long</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>experience has shown that the more obvious ways caused various kinds of</code></pre></td>
        <td class="diff"><pre><code>experience has shown that the more obvious ways caused various kinds of</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>trouble.</code></pre></td>
        <td class="diff"><pre><code>trouble.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>   You can't assume the byte order of anything that comes from a target</code></pre></td>
        <td class="diff"><pre><code>   You can't assume the byte order of anything that comes from a target</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>(including VALUEs, object files, and instructions).  Such things must</code></pre></td>
        <td class="diff"><pre><code>(including VALUEs, object files, and instructions).  Such things must</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>be byte-swapped using `SWAP_TARGET_AND_HOST' in GDB, or one of the swap</code></pre></td>
        <td class="diff"><pre><code>be byte-swapped using `SWAP_TARGET_AND_HOST' in GDB, or one of the swap</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>routines defined in `bfd.h', such as `bfd_get_32'.</code></pre></td>
        <td class="diff"><pre><code>routines defined in `bfd.h', such as `bfd_get_32'.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>   You can't assume that you know what interface is being used to talk</code></pre></td>
        <td class="diff"><pre><code>   You can't assume that you know what interface is being used to talk</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>to the target system.  All references to the target must go through the</code></pre></td>
        <td class="diff"><pre><code>to the target system.  All references to the target must go through the</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>current `target_ops' vector.</code></pre></td>
        <td class="diff"><pre><code>current `target_ops' vector.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>   You can't assume that the host and target machines are the same</code></pre></td>
        <td class="diff"><pre><code>   You can't assume that the host and target machines are the same</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>machine (except in the "native" support modules).  In particular, you</code></pre></td>
        <td class="diff"><pre><code>machine (except in the "native" support modules).  In particular, you</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>can't assume that the target machine's header files will be available</code></pre></td>
        <td class="diff"><pre><code>can't assume that the target machine's header files will be available</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>on the host machine.  Target code must bring along its own header files</code></pre></td>
        <td class="diff"><pre><code>on the host machine.  Target code must bring along its own header files</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>- written from scratch or explicitly donated by their owner, to avoid</code></pre></td>
        <td class="diff"><pre><code>- written from scratch or explicitly donated by their owner, to avoid</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>copyright problems.</code></pre></td>
        <td class="diff"><pre><code>copyright problems.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>   Insertion of new `#ifdef''s will be frowned upon.  It's much better</code></pre></td>
        <td class="diff"><pre><code>   Insertion of new `#ifdef''s will be frowned upon.  It's much better</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>to write the code portably than to conditionalize it for various</code></pre></td>
        <td class="diff"><pre><code>to write the code portably than to conditionalize it for various</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>systems.</code></pre></td>
        <td class="diff"><pre><code>systems.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>   New `#ifdef''s which test for specific compilers or manufacturers or</code></pre></td>
        <td class="diff"><pre><code>   New `#ifdef''s which test for specific compilers or manufacturers or</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>operating systems are unacceptable.  All `#ifdef''s should test for</code></pre></td>
        <td class="diff"><pre><code>operating systems are unacceptable.  All `#ifdef''s should test for</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>features.  The information about which configurations contain which</code></pre></td>
        <td class="diff"><pre><code>features.  The information about which configurations contain which</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>features should be segregated into the configuration files.  Experience</code></pre></td>
        <td class="diff"><pre><code>features should be segregated into the configuration files.  Experience</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>has proven far too often that a feature unique to one particular system</code></pre></td>
        <td class="diff"><pre><code>has proven far too often that a feature unique to one particular system</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>often creeps into other systems; and that a conditional based on some</code></pre></td>
        <td class="diff"><pre><code>often creeps into other systems; and that a conditional based on some</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>predefined macro for your current system will become worthless over</code></pre></td>
        <td class="diff"><pre><code>predefined macro for your current system will become worthless over</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>time, as new versions of your system come out that behave differently</code></pre></td>
        <td class="diff"><pre><code>time, as new versions of your system come out that behave differently</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>with regard to this feature.</code></pre></td>
        <td class="diff"><pre><code>with regard to this feature.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>   Adding code that handles specific architectures, operating systems,</code></pre></td>
        <td class="diff"><pre><code>   Adding code that handles specific architectures, operating systems,</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>target interfaces, or hosts, is not acceptable in generic code.</code></pre></td>
        <td class="diff"><pre><code>target interfaces, or hosts, is not acceptable in generic code.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>   One particularly notorious area where system dependencies tend to</code></pre></td>
        <td class="diff"><pre><code>   One particularly notorious area where system dependencies tend to</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>creep in is handling of file names.  The mainline GDB code assumes</code></pre></td>
        <td class="diff"><pre><code>creep in is handling of file names.  The mainline GDB code assumes</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>Posix semantics of file names: absolute file names begin with a forward</code></pre></td>
        <td class="diff"><pre><code>Posix semantics of file names: absolute file names begin with a forward</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>slash `/', slashes are used to separate leading directories,</code></pre></td>
        <td class="diff"><pre><code>slash `/', slashes are used to separate leading directories,</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>case-sensitive file names.  These assumptions are not necessarily true</code></pre></td>
        <td class="diff"><pre><code>case-sensitive file names.  These assumptions are not necessarily true</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>on non-Posix systems such as MS-Windows.  To avoid system-dependent</code></pre></td>
        <td class="diff"><pre><code>on non-Posix systems such as MS-Windows.  To avoid system-dependent</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>code where you need to take apart or construct a file name, use the</code></pre></td>
        <td class="diff"><pre><code>code where you need to take apart or construct a file name, use the</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>following portable macros:</code></pre></td>
        <td class="diff"><pre><code>following portable macros:</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>`HAVE_DOS_BASED_FILE_SYSTEM'</code></pre></td>
        <td class="diff"><pre><code>`HAVE_DOS_BASED_FILE_SYSTEM'</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     This preprocessing symbol is defined to a non-zero value on hosts</code></pre></td>
        <td class="diff"><pre><code>     This preprocessing symbol is defined to a non-zero value on hosts</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     whose filesystems belong to the MS-DOS/MS-Windows family.  Use this</code></pre></td>
        <td class="diff"><pre><code>     whose filesystems belong to the MS-DOS/MS-Windows family.  Use this</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     symbol to write conditional code which should only be compiled for</code></pre></td>
        <td class="diff"><pre><code>     symbol to write conditional code which should only be compiled for</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     such hosts.</code></pre></td>
        <td class="diff"><pre><code>     such hosts.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>`IS_DIR_SEPARATOR (C)'</code></pre></td>
        <td class="diff"><pre><code>`IS_DIR_SEPARATOR (C)'</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     Evaluates to a non-zero value if C is a directory separator</code></pre></td>
        <td class="diff"><pre><code>     Evaluates to a non-zero value if C is a directory separator</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     character.  On Unix and GNU/Linux systems, only a slash `/' is</code></pre></td>
        <td class="diff"><pre><code>     character.  On Unix and GNU/Linux systems, only a slash `/' is</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     such a character, but on Windows, both `/' and `\' will pass.</code></pre></td>
        <td class="diff"><pre><code>     such a character, but on Windows, both `/' and `\' will pass.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>`IS_ABSOLUTE_PATH (FILE)'</code></pre></td>
        <td class="diff"><pre><code>`IS_ABSOLUTE_PATH (FILE)'</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     Evaluates to a non-zero value if FILE is an absolute file name.</code></pre></td>
        <td class="diff"><pre><code>     Evaluates to a non-zero value if FILE is an absolute file name.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     For Unix and GNU/Linux hosts, a name which begins with a slash `/'</code></pre></td>
        <td class="diff"><pre><code>     For Unix and GNU/Linux hosts, a name which begins with a slash `/'</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     is absolute.  On DOS and Windows, `d:/foo' and `x:\bar' are also</code></pre></td>
        <td class="diff"><pre><code>     is absolute.  On DOS and Windows, `d:/foo' and `x:\bar' are also</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     absolute file names.</code></pre></td>
        <td class="diff"><pre><code>     absolute file names.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>`FILENAME_CMP (F1, F2)'</code></pre></td>
        <td class="diff"><pre><code>`FILENAME_CMP (F1, F2)'</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     Calls a function which compares file names F1 and F2 as</code></pre></td>
        <td class="diff"><pre><code>     Calls a function which compares file names F1 and F2 as</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     appropriate for the underlying host filesystem.  For Posix systems,</code></pre></td>
        <td class="diff"><pre><code>     appropriate for the underlying host filesystem.  For Posix systems,</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     this simply calls `strcmp'; on case-insensitive filesystems it</code></pre></td>
        <td class="diff"><pre><code>     this simply calls `strcmp'; on case-insensitive filesystems it</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     will call `strcasecmp' instead.</code></pre></td>
        <td class="diff"><pre><code>     will call `strcasecmp' instead.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>`DIRNAME_SEPARATOR'</code></pre></td>
        <td class="diff"><pre><code>`DIRNAME_SEPARATOR'</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     Evaluates to a character which separates directories in</code></pre></td>
        <td class="diff"><pre><code>     Evaluates to a character which separates directories in</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     `PATH'-style lists, typically held in environment variables.  This</code></pre></td>
        <td class="diff"><pre><code>     `PATH'-style lists, typically held in environment variables.  This</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     character is `:' on Unix, `;' on DOS and Windows.</code></pre></td>
        <td class="diff"><pre><code>     character is `:' on Unix, `;' on DOS and Windows.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>`SLASH_STRING'</code></pre></td>
        <td class="diff"><pre><code>`SLASH_STRING'</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     This evaluates to a constant string you should use to produce an</code></pre></td>
        <td class="diff"><pre><code>     This evaluates to a constant string you should use to produce an</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     absolute filename from leading directories and the file's basename.</code></pre></td>
        <td class="diff"><pre><code>     absolute filename from leading directories and the file's basename.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     `SLASH_STRING' is `"/"' on most systems, but might be `"\\"' for</code></pre></td>
        <td class="diff"><pre><code>     `SLASH_STRING' is `"/"' on most systems, but might be `"\\"' for</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     some Windows-based ports.</code></pre></td>
        <td class="diff"><pre><code>     some Windows-based ports.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>   In addition to using these macros, be sure to use portable library</code></pre></td>
        <td class="diff"><pre><code>   In addition to using these macros, be sure to use portable library</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>functions whenever possible.  For example, to extract a directory or a</code></pre></td>
        <td class="diff"><pre><code>functions whenever possible.  For example, to extract a directory or a</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>basename part from a file name, use the `dirname' and `basename'</code></pre></td>
        <td class="diff"><pre><code>basename part from a file name, use the `dirname' and `basename'</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>library functions (available in `libiberty' for platforms which don't</code></pre></td>
        <td class="diff"><pre><code>library functions (available in `libiberty' for platforms which don't</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>provide them), instead of searching for a slash with `strrchr'.</code></pre></td>
        <td class="diff"><pre><code>provide them), instead of searching for a slash with `strrchr'.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>   Another way to generalize GDB along a particular interface is with an</code></pre></td>
        <td class="diff"><pre><code>   Another way to generalize GDB along a particular interface is with an</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>attribute struct.  For example, GDB has been generalized to handle</code></pre></td>
        <td class="diff"><pre><code>attribute struct.  For example, GDB has been generalized to handle</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>multiple kinds of remote interfaces--not by `#ifdef's everywhere, but</code></pre></td>
        <td class="diff"><pre><code>multiple kinds of remote interfaces--not by `#ifdef's everywhere, but</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>by defining the `target_ops' structure and having a current target (as</code></pre></td>
        <td class="diff"><pre><code>by defining the `target_ops' structure and having a current target (as</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>well as a stack of targets below it, for memory references).  Whenever</code></pre></td>
        <td class="diff"><pre><code>well as a stack of targets below it, for memory references).  Whenever</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>something needs to be done that depends on which remote interface we are</code></pre></td>
        <td class="diff"><pre><code>something needs to be done that depends on which remote interface we are</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>using, a flag in the current target_ops structure is tested (e.g.,</code></pre></td>
        <td class="diff"><pre><code>using, a flag in the current target_ops structure is tested (e.g.,</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>`target_has_stack'), or a function is called through a pointer in the</code></pre></td>
        <td class="diff"><pre><code>`target_has_stack'), or a function is called through a pointer in the</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>current target_ops structure.  In this way, when a new remote interface</code></pre></td>
        <td class="diff"><pre><code>current target_ops structure.  In this way, when a new remote interface</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>is added, only one module needs to be touched--the one that actually</code></pre></td>
        <td class="diff"><pre><code>is added, only one module needs to be touched--the one that actually</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>implements the new remote interface.  Other examples of</code></pre></td>
        <td class="diff"><pre><code>implements the new remote interface.  Other examples of</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>attribute-structs are BFD access to multiple kinds of object file</code></pre></td>
        <td class="diff"><pre><code>attribute-structs are BFD access to multiple kinds of object file</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>formats, or GDB's access to multiple source languages.</code></pre></td>
        <td class="diff"><pre><code>formats, or GDB's access to multiple source languages.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>   Please avoid duplicating code.  For example, in GDB 3.x all the code</code></pre></td>
        <td class="diff"><pre><code>   Please avoid duplicating code.  For example, in GDB 3.x all the code</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>interfacing between `ptrace' and the rest of GDB was duplicated in</code></pre></td>
        <td class="diff"><pre><code>interfacing between `ptrace' and the rest of GDB was duplicated in</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>`*-dep.c', and so changing something was very painful.  In GDB 4.x,</code></pre></td>
        <td class="diff"><pre><code>`*-dep.c', and so changing something was very painful.  In GDB 4.x,</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>these have all been consolidated into `infptrace.c'.  `infptrace.c' can</code></pre></td>
        <td class="diff"><pre><code>these have all been consolidated into `infptrace.c'.  `infptrace.c' can</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>deal with variations between systems the same way any system-independent</code></pre></td>
        <td class="diff"><pre><code>deal with variations between systems the same way any system-independent</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>file would (hooks, `#if defined', etc.), and machines which are</code></pre></td>
        <td class="diff"><pre><code>file would (hooks, `#if defined', etc.), and machines which are</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>radically different don't need to use `infptrace.c' at all.</code></pre></td>
        <td class="diff"><pre><code>radically different don't need to use `infptrace.c' at all.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>   All debugging code must be controllable using the `set debug MODULE'</code></pre></td>
        <td class="diff"><pre><code>   All debugging code must be controllable using the `set debug MODULE'</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>command.  Do not use `printf' to print trace messages.  Use</code></pre></td>
        <td class="diff"><pre><code>command.  Do not use `printf' to print trace messages.  Use</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>`fprintf_unfiltered(gdb_stdlog, ...'.  Do not use `#ifdef DEBUG'.</code></pre></td>
        <td class="diff"><pre><code>`fprintf_unfiltered(gdb_stdlog, ...'.  Do not use `#ifdef DEBUG'.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>File: gdbint.info,  Node: Porting GDB,  Next: Versions and Branches,  Prev: Coding,  Up: Top</code></pre></td>
        <td class="diff"><pre><code>File: gdbint.info,  Node: Porting GDB,  Next: Versions and Branches,  Prev: Coding,  Up: Top</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>15 Porting GDB</code></pre></td>
        <td class="diff"><pre><code>15 Porting GDB</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>**************</code></pre></td>
        <td class="diff"><pre><code>**************</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>Most of the work in making GDB compile on a new machine is in</code></pre></td>
        <td class="diff"><pre><code>Most of the work in making GDB compile on a new machine is in</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>specifying the configuration of the machine.  This is done in a</code></pre></td>
        <td class="diff"><pre><code>specifying the configuration of the machine.  This is done in a</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>dizzying variety of header files and configuration scripts, which we</code></pre></td>
        <td class="diff"><pre><code>dizzying variety of header files and configuration scripts, which we</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>hope to make more sensible soon.  Let's say your new host is called an</code></pre></td>
        <td class="diff"><pre><code>hope to make more sensible soon.  Let's say your new host is called an</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>XYZ (e.g.,  `sun4'), and its full three-part configuration name is</code></pre></td>
        <td class="diff"><pre><code>XYZ (e.g.,  `sun4'), and its full three-part configuration name is</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>`ARCH-XVEND-XOS' (e.g., `sparc-sun-sunos4').  In particular:</code></pre></td>
        <td class="diff"><pre><code>`ARCH-XVEND-XOS' (e.g., `sparc-sun-sunos4').  In particular:</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>   * In the top level directory, edit `config.sub' and add ARCH, XVEND,</code></pre></td>
        <td class="diff"><pre><code>   * In the top level directory, edit `config.sub' and add ARCH, XVEND,</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     and XOS to the lists of supported architectures, vendors, and</code></pre></td>
        <td class="diff"><pre><code>     and XOS to the lists of supported architectures, vendors, and</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     operating systems near the bottom of the file.  Also, add XYZ as</code></pre></td>
        <td class="diff"><pre><code>     operating systems near the bottom of the file.  Also, add XYZ as</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     an alias that maps to `ARCH-XVEND-XOS'.  You can test your changes</code></pre></td>
        <td class="diff"><pre><code>     an alias that maps to `ARCH-XVEND-XOS'.  You can test your changes</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     by running</code></pre></td>
        <td class="diff"><pre><code>     by running</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>          ./config.sub XYZ</code></pre></td>
        <td class="diff"><pre><code>          ./config.sub XYZ</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     and</code></pre></td>
        <td class="diff"><pre><code>     and</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>          ./config.sub `ARCH-XVEND-XOS'</code></pre></td>
        <td class="diff"><pre><code>          ./config.sub `ARCH-XVEND-XOS'</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     which should both respond with `ARCH-XVEND-XOS' and no error</code></pre></td>
        <td class="diff"><pre><code>     which should both respond with `ARCH-XVEND-XOS' and no error</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     messages.</code></pre></td>
        <td class="diff"><pre><code>     messages.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     You need to port BFD, if that hasn't been done already.  Porting</code></pre></td>
        <td class="diff"><pre><code>     You need to port BFD, if that hasn't been done already.  Porting</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     BFD is beyond the scope of this manual.</code></pre></td>
        <td class="diff"><pre><code>     BFD is beyond the scope of this manual.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>   * To configure GDB itself, edit `gdb/configure.host' to recognize</code></pre></td>
        <td class="diff"><pre><code>   * To configure GDB itself, edit `gdb/configure.host' to recognize</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     your system and set `gdb_host' to XYZ, and (unless your desired</code></pre></td>
        <td class="diff"><pre><code>     your system and set `gdb_host' to XYZ, and (unless your desired</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     target is already available) also edit `gdb/configure.tgt',</code></pre></td>
        <td class="diff"><pre><code>     target is already available) also edit `gdb/configure.tgt',</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     setting `gdb_target' to something appropriate (for instance, XYZ).</code></pre></td>
        <td class="diff"><pre><code>     setting `gdb_target' to something appropriate (for instance, XYZ).</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     _Maintainer's note: Work in progress.  The file</code></pre></td>
        <td class="diff"><pre><code>     _Maintainer's note: Work in progress.  The file</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     `gdb/configure.host' originally needed to be modified when either a</code></pre></td>
        <td class="diff"><pre><code>     `gdb/configure.host' originally needed to be modified when either a</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     new native target or a new host machine was being added to GDB.</code></pre></td>
        <td class="diff"><pre><code>     new native target or a new host machine was being added to GDB.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     Recent changes have removed this requirement.  The file now only</code></pre></td>
        <td class="diff"><pre><code>     Recent changes have removed this requirement.  The file now only</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     needs to be modified when adding a new native configuration.  This</code></pre></td>
        <td class="diff"><pre><code>     needs to be modified when adding a new native configuration.  This</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     will likely changed again in the future._</code></pre></td>
        <td class="diff"><pre><code>     will likely changed again in the future._</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>   * Finally, you'll need to specify and define GDB's host-, native-,</code></pre></td>
        <td class="diff"><pre><code>   * Finally, you'll need to specify and define GDB's host-, native-,</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     and target-dependent `.h' and `.c' files used for your</code></pre></td>
        <td class="diff"><pre><code>     and target-dependent `.h' and `.c' files used for your</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     configuration.</code></pre></td>
        <td class="diff"><pre><code>     configuration.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>File: gdbint.info,  Node: Versions and Branches,  Next: Start of New Year Procedure,  Prev: Porting GDB,  Up: Top</code></pre></td>
        <td class="diff"><pre><code>File: gdbint.info,  Node: Versions and Branches,  Next: Start of New Year Procedure,  Prev: Porting GDB,  Up: Top</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>16 Versions and Branches</code></pre></td>
        <td class="diff"><pre><code>16 Versions and Branches</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>************************</code></pre></td>
        <td class="diff"><pre><code>************************</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>16.1 Versions</code></pre></td>
        <td class="diff"><pre><code>16.1 Versions</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>=============</code></pre></td>
        <td class="diff"><pre><code>=============</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>GDB's version is determined by the file `gdb/version.in' and takes one</code></pre></td>
        <td class="diff"><pre><code>GDB's version is determined by the file `gdb/version.in' and takes one</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>of the following forms:</code></pre></td>
        <td class="diff"><pre><code>of the following forms:</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>MAJOR.MINOR</code></pre></td>
        <td class="diff"><pre><code>MAJOR.MINOR</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>MAJOR.MINOR.PATCHLEVEL</code></pre></td>
        <td class="diff"><pre><code>MAJOR.MINOR.PATCHLEVEL</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     an official release (e.g., 6.2 or 6.2.1)</code></pre></td>
        <td class="diff"><pre><code>     an official release (e.g., 6.2 or 6.2.1)</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>MAJOR.MINOR.PATCHLEVEL.YYYYMMDD</code></pre></td>
        <td class="diff"><pre><code>MAJOR.MINOR.PATCHLEVEL.YYYYMMDD</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     a snapshot taken at YYYY-MM-DD-gmt (e.g., 6.1.50.20020302,</code></pre></td>
        <td class="diff"><pre><code>     a snapshot taken at YYYY-MM-DD-gmt (e.g., 6.1.50.20020302,</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     6.1.90.20020304, or 6.1.0.20020308)</code></pre></td>
        <td class="diff"><pre><code>     6.1.90.20020304, or 6.1.0.20020308)</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>MAJOR.MINOR.PATCHLEVEL.YYYYMMDD-cvs</code></pre></td>
        <td class="diff"><pre><code>MAJOR.MINOR.PATCHLEVEL.YYYYMMDD-cvs</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     a CVS check out drawn on YYYY-MM-DD (e.g., 6.1.50.20020302-cvs,</code></pre></td>
        <td class="diff"><pre><code>     a CVS check out drawn on YYYY-MM-DD (e.g., 6.1.50.20020302-cvs,</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     6.1.90.20020304-cvs, or 6.1.0.20020308-cvs)</code></pre></td>
        <td class="diff"><pre><code>     6.1.90.20020304-cvs, or 6.1.0.20020308-cvs)</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>MAJOR.MINOR.PATCHLEVEL.YYYYMMDD (VENDOR)</code></pre></td>
        <td class="diff"><pre><code>MAJOR.MINOR.PATCHLEVEL.YYYYMMDD (VENDOR)</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     a vendor specific release of GDB, that while based on</code></pre></td>
        <td class="diff"><pre><code>     a vendor specific release of GDB, that while based on</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     MAJOR.MINOR.PATCHLEVEL.YYYYMMDD, may include additional changes</code></pre></td>
        <td class="diff"><pre><code>     MAJOR.MINOR.PATCHLEVEL.YYYYMMDD, may include additional changes</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>   GDB's mainline uses the MAJOR and MINOR version numbers from the</code></pre></td>
        <td class="diff"><pre><code>   GDB's mainline uses the MAJOR and MINOR version numbers from the</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>most recent release branch, with a PATCHLEVEL of 50.  At the time each</code></pre></td>
        <td class="diff"><pre><code>most recent release branch, with a PATCHLEVEL of 50.  At the time each</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>new release branch is created, the mainline's MAJOR and MINOR version</code></pre></td>
        <td class="diff"><pre><code>new release branch is created, the mainline's MAJOR and MINOR version</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>numbers are updated.</code></pre></td>
        <td class="diff"><pre><code>numbers are updated.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>   GDB's release branch is similar.  When the branch is cut, the</code></pre></td>
        <td class="diff"><pre><code>   GDB's release branch is similar.  When the branch is cut, the</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>PATCHLEVEL is changed from 50 to 90.  As draft releases are drawn from</code></pre></td>
        <td class="diff"><pre><code>PATCHLEVEL is changed from 50 to 90.  As draft releases are drawn from</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>the branch, the PATCHLEVEL is incremented.  Once the first release</code></pre></td>
        <td class="diff"><pre><code>the branch, the PATCHLEVEL is incremented.  Once the first release</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>(MAJOR.MINOR) has been made, the PATCHLEVEL is set to 0 and updates</code></pre></td>
        <td class="diff"><pre><code>(MAJOR.MINOR) has been made, the PATCHLEVEL is set to 0 and updates</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>have an incremented PATCHLEVEL.</code></pre></td>
        <td class="diff"><pre><code>have an incremented PATCHLEVEL.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>   For snapshots, and CVS check outs, it is also possible to identify</code></pre></td>
        <td class="diff"><pre><code>   For snapshots, and CVS check outs, it is also possible to identify</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>the CVS origin:</code></pre></td>
        <td class="diff"><pre><code>the CVS origin:</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>MAJOR.MINOR.50.YYYYMMDD</code></pre></td>
        <td class="diff"><pre><code>MAJOR.MINOR.50.YYYYMMDD</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     drawn from the HEAD of mainline CVS (e.g., 6.1.50.20020302)</code></pre></td>
        <td class="diff"><pre><code>     drawn from the HEAD of mainline CVS (e.g., 6.1.50.20020302)</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>MAJOR.MINOR.90.YYYYMMDD</code></pre></td>
        <td class="diff"><pre><code>MAJOR.MINOR.90.YYYYMMDD</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>MAJOR.MINOR.91.YYYYMMDD ...</code></pre></td>
        <td class="diff"><pre><code>MAJOR.MINOR.91.YYYYMMDD ...</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     drawn from a release branch prior to the release (e.g.,</code></pre></td>
        <td class="diff"><pre><code>     drawn from a release branch prior to the release (e.g.,</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     6.1.90.20020304)</code></pre></td>
        <td class="diff"><pre><code>     6.1.90.20020304)</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>MAJOR.MINOR.0.YYYYMMDD</code></pre></td>
        <td class="diff"><pre><code>MAJOR.MINOR.0.YYYYMMDD</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>MAJOR.MINOR.1.YYYYMMDD ...</code></pre></td>
        <td class="diff"><pre><code>MAJOR.MINOR.1.YYYYMMDD ...</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     drawn from a release branch after the release (e.g.,</code></pre></td>
        <td class="diff"><pre><code>     drawn from a release branch after the release (e.g.,</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     6.2.0.20020308)</code></pre></td>
        <td class="diff"><pre><code>     6.2.0.20020308)</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>   If the previous GDB version is 6.1 and the current version is 6.2,</code></pre></td>
        <td class="diff"><pre><code>   If the previous GDB version is 6.1 and the current version is 6.2,</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>then, substituting 6 for MAJOR and 1 or 2 for MINOR, here's an</code></pre></td>
        <td class="diff"><pre><code>then, substituting 6 for MAJOR and 1 or 2 for MINOR, here's an</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>illustration of a typical sequence:</code></pre></td>
        <td class="diff"><pre><code>illustration of a typical sequence:</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>          <HEAD></code></pre></td>
        <td class="diff"><pre><code>          <HEAD></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>             |</code></pre></td>
        <td class="diff"><pre><code>             |</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     6.1.50.20020302-cvs</code></pre></td>
        <td class="diff"><pre><code>     6.1.50.20020302-cvs</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>             |</code></pre></td>
        <td class="diff"><pre><code>             |</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>             +--------------------------.</code></pre></td>
        <td class="diff"><pre><code>             +--------------------------.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>             |                    <gdb_6_2-branch></code></pre></td>
        <td class="diff"><pre><code>             |                    <gdb_6_2-branch></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>             |                          |</code></pre></td>
        <td class="diff"><pre><code>             |                          |</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     6.2.50.20020303-cvs        6.1.90 (draft #1)</code></pre></td>
        <td class="diff"><pre><code>     6.2.50.20020303-cvs        6.1.90 (draft #1)</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>             |                          |</code></pre></td>
        <td class="diff"><pre><code>             |                          |</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     6.2.50.20020304-cvs        6.1.90.20020304-cvs</code></pre></td>
        <td class="diff"><pre><code>     6.2.50.20020304-cvs        6.1.90.20020304-cvs</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>             |                          |</code></pre></td>
        <td class="diff"><pre><code>             |                          |</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     6.2.50.20020305-cvs        6.1.91 (draft #2)</code></pre></td>
        <td class="diff"><pre><code>     6.2.50.20020305-cvs        6.1.91 (draft #2)</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>             |                          |</code></pre></td>
        <td class="diff"><pre><code>             |                          |</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     6.2.50.20020306-cvs        6.1.91.20020306-cvs</code></pre></td>
        <td class="diff"><pre><code>     6.2.50.20020306-cvs        6.1.91.20020306-cvs</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>             |                          |</code></pre></td>
        <td class="diff"><pre><code>             |                          |</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     6.2.50.20020307-cvs        6.2 (release)</code></pre></td>
        <td class="diff"><pre><code>     6.2.50.20020307-cvs        6.2 (release)</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>             |                          |</code></pre></td>
        <td class="diff"><pre><code>             |                          |</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     6.2.50.20020308-cvs        6.2.0.20020308-cvs</code></pre></td>
        <td class="diff"><pre><code>     6.2.50.20020308-cvs        6.2.0.20020308-cvs</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>             |                          |</code></pre></td>
        <td class="diff"><pre><code>             |                          |</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     6.2.50.20020309-cvs        6.2.1 (update)</code></pre></td>
        <td class="diff"><pre><code>     6.2.50.20020309-cvs        6.2.1 (update)</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>             |                          |</code></pre></td>
        <td class="diff"><pre><code>             |                          |</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     6.2.50.20020310-cvs         <branch closed></code></pre></td>
        <td class="diff"><pre><code>     6.2.50.20020310-cvs         <branch closed></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>             |</code></pre></td>
        <td class="diff"><pre><code>             |</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     6.2.50.20020311-cvs</code></pre></td>
        <td class="diff"><pre><code>     6.2.50.20020311-cvs</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>             |</code></pre></td>
        <td class="diff"><pre><code>             |</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>             +--------------------------.</code></pre></td>
        <td class="diff"><pre><code>             +--------------------------.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>             |                     <gdb_6_3-branch></code></pre></td>
        <td class="diff"><pre><code>             |                     <gdb_6_3-branch></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>             |                          |</code></pre></td>
        <td class="diff"><pre><code>             |                          |</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     6.3.50.20020312-cvs        6.2.90 (draft #1)</code></pre></td>
        <td class="diff"><pre><code>     6.3.50.20020312-cvs        6.2.90 (draft #1)</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>             |                          |</code></pre></td>
        <td class="diff"><pre><code>             |                          |</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>16.2 Release Branches</code></pre></td>
        <td class="diff"><pre><code>16.2 Release Branches</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>=====================</code></pre></td>
        <td class="diff"><pre><code>=====================</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>GDB draws a release series (6.2, 6.2.1, ...) from a single release</code></pre></td>
        <td class="diff"><pre><code>GDB draws a release series (6.2, 6.2.1, ...) from a single release</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>branch, and identifies that branch using the CVS branch tags:</code></pre></td>
        <td class="diff"><pre><code>branch, and identifies that branch using the CVS branch tags:</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     gdb_MAJOR_MINOR-YYYYMMDD-branchpoint</code></pre></td>
        <td class="diff"><pre><code>     gdb_MAJOR_MINOR-YYYYMMDD-branchpoint</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     gdb_MAJOR_MINOR-branch</code></pre></td>
        <td class="diff"><pre><code>     gdb_MAJOR_MINOR-branch</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     gdb_MAJOR_MINOR-YYYYMMDD-release</code></pre></td>
        <td class="diff"><pre><code>     gdb_MAJOR_MINOR-YYYYMMDD-release</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>   _Pragmatics: To help identify the date at which a branch or release</code></pre></td>
        <td class="diff"><pre><code>   _Pragmatics: To help identify the date at which a branch or release</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>is made, both the branchpoint and release tags include the date that</code></pre></td>
        <td class="diff"><pre><code>is made, both the branchpoint and release tags include the date that</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>they are cut (YYYYMMDD) in the tag.  The branch tag, denoting the head</code></pre></td>
        <td class="diff"><pre><code>they are cut (YYYYMMDD) in the tag.  The branch tag, denoting the head</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>of the branch, does not need this._</code></pre></td>
        <td class="diff"><pre><code>of the branch, does not need this._</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>16.3 Vendor Branches</code></pre></td>
        <td class="diff"><pre><code>16.3 Vendor Branches</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>====================</code></pre></td>
        <td class="diff"><pre><code>====================</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>To avoid version conflicts, vendors are expected to modify the file</code></pre></td>
        <td class="diff"><pre><code>To avoid version conflicts, vendors are expected to modify the file</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>`gdb/version.in' to include a vendor unique alphabetic identifier (an</code></pre></td>
        <td class="diff"><pre><code>`gdb/version.in' to include a vendor unique alphabetic identifier (an</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>official GDB release never uses alphabetic characters in its version</code></pre></td>
        <td class="diff"><pre><code>official GDB release never uses alphabetic characters in its version</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>identifier).  E.g., `6.2widgit2', or `6.2 (Widgit Inc Patch 2)'.</code></pre></td>
        <td class="diff"><pre><code>identifier).  E.g., `6.2widgit2', or `6.2 (Widgit Inc Patch 2)'.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>16.4 Experimental Branches</code></pre></td>
        <td class="diff"><pre><code>16.4 Experimental Branches</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>==========================</code></pre></td>
        <td class="diff"><pre><code>==========================</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>16.4.1 Guidelines</code></pre></td>
        <td class="diff"><pre><code>16.4.1 Guidelines</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>-----------------</code></pre></td>
        <td class="diff"><pre><code>-----------------</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>GDB permits the creation of branches, cut from the CVS repository, for</code></pre></td>
        <td class="diff"><pre><code>GDB permits the creation of branches, cut from the CVS repository, for</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>experimental development.  Branches make it possible for developers to</code></pre></td>
        <td class="diff"><pre><code>experimental development.  Branches make it possible for developers to</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>share preliminary work, and maintainers to examine significant new</code></pre></td>
        <td class="diff"><pre><code>share preliminary work, and maintainers to examine significant new</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>developments.</code></pre></td>
        <td class="diff"><pre><code>developments.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>   The following are a set of guidelines for creating such branches:</code></pre></td>
        <td class="diff"><pre><code>   The following are a set of guidelines for creating such branches:</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>_a branch has an owner_</code></pre></td>
        <td class="diff"><pre><code>_a branch has an owner_</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     The owner can set further policy for a branch, but may not change</code></pre></td>
        <td class="diff"><pre><code>     The owner can set further policy for a branch, but may not change</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     the ground rules.  In particular, they can set a policy for</code></pre></td>
        <td class="diff"><pre><code>     the ground rules.  In particular, they can set a policy for</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     commits (be it adding more reviewers or deciding who can commit).</code></pre></td>
        <td class="diff"><pre><code>     commits (be it adding more reviewers or deciding who can commit).</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>_all commits are posted_</code></pre></td>
        <td class="diff"><pre><code>_all commits are posted_</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     All changes committed to a branch shall also be posted to the GDB</code></pre></td>
        <td class="diff"><pre><code>     All changes committed to a branch shall also be posted to the GDB</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     patches mailing list <gdb-patches@sources.redhat.com>.  While</code></pre></td>
        <td class="diff"><pre><code>     patches mailing list <gdb-patches@sources.redhat.com>.  While</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     commentary on such changes are encouraged, people should remember</code></pre></td>
        <td class="diff"><pre><code>     commentary on such changes are encouraged, people should remember</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     that the changes only apply to a branch.</code></pre></td>
        <td class="diff"><pre><code>     that the changes only apply to a branch.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>_all commits are covered by an assignment_</code></pre></td>
        <td class="diff"><pre><code>_all commits are covered by an assignment_</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     This ensures that all changes belong to the Free Software</code></pre></td>
        <td class="diff"><pre><code>     This ensures that all changes belong to the Free Software</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     Foundation, and avoids the possibility that the branch may become</code></pre></td>
        <td class="diff"><pre><code>     Foundation, and avoids the possibility that the branch may become</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     contaminated.</code></pre></td>
        <td class="diff"><pre><code>     contaminated.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>_a branch is focused_</code></pre></td>
        <td class="diff"><pre><code>_a branch is focused_</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     A focused branch has a single objective or goal, and does not</code></pre></td>
        <td class="diff"><pre><code>     A focused branch has a single objective or goal, and does not</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     contain unnecessary or irrelevant changes.  Cleanups, where</code></pre></td>
        <td class="diff"><pre><code>     contain unnecessary or irrelevant changes.  Cleanups, where</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     identified, being be pushed into the mainline as soon as possible.</code></pre></td>
        <td class="diff"><pre><code>     identified, being be pushed into the mainline as soon as possible.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>_a branch tracks mainline_</code></pre></td>
        <td class="diff"><pre><code>_a branch tracks mainline_</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     This keeps the level of divergence under control.  It also keeps</code></pre></td>
        <td class="diff"><pre><code>     This keeps the level of divergence under control.  It also keeps</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     the pressure on developers to push cleanups and other stuff into</code></pre></td>
        <td class="diff"><pre><code>     the pressure on developers to push cleanups and other stuff into</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     the mainline.</code></pre></td>
        <td class="diff"><pre><code>     the mainline.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>_a branch shall contain the entire GDB module_</code></pre></td>
        <td class="diff"><pre><code>_a branch shall contain the entire GDB module_</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     The GDB module `gdb' should be specified when creating a branch</code></pre></td>
        <td class="diff"><pre><code>     The GDB module `gdb' should be specified when creating a branch</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     (branches of individual files should be avoided).  *Note Tags::.</code></pre></td>
        <td class="diff"><pre><code>     (branches of individual files should be avoided).  *Note Tags::.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>_a branch shall be branded using `version.in'_</code></pre></td>
        <td class="diff"><pre><code>_a branch shall be branded using `version.in'_</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     The file `gdb/version.in' shall be modified so that it identifies</code></pre></td>
        <td class="diff"><pre><code>     The file `gdb/version.in' shall be modified so that it identifies</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     the branch OWNER and branch NAME, e.g.,</code></pre></td>
        <td class="diff"><pre><code>     the branch OWNER and branch NAME, e.g.,</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     `6.2.50.20030303_owner_name' or `6.2 (Owner Name)'.</code></pre></td>
        <td class="diff"><pre><code>     `6.2.50.20030303_owner_name' or `6.2 (Owner Name)'.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>16.4.2 Tags</code></pre></td>
        <td class="diff"><pre><code>16.4.2 Tags</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>-----------</code></pre></td>
        <td class="diff"><pre><code>-----------</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>To simplify the identification of GDB branches, the following branch</code></pre></td>
        <td class="diff"><pre><code>To simplify the identification of GDB branches, the following branch</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>tagging convention is strongly recommended:</code></pre></td>
        <td class="diff"><pre><code>tagging convention is strongly recommended:</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>`OWNER_NAME-YYYYMMDD-branchpoint'</code></pre></td>
        <td class="diff"><pre><code>`OWNER_NAME-YYYYMMDD-branchpoint'</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>`OWNER_NAME-YYYYMMDD-branch'</code></pre></td>
        <td class="diff"><pre><code>`OWNER_NAME-YYYYMMDD-branch'</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     The branch point and corresponding branch tag.  YYYYMMDD is the</code></pre></td>
        <td class="diff"><pre><code>     The branch point and corresponding branch tag.  YYYYMMDD is the</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     date that the branch was created.  A branch is created using the</code></pre></td>
        <td class="diff"><pre><code>     date that the branch was created.  A branch is created using the</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     sequence:</code></pre></td>
        <td class="diff"><pre><code>     sequence:</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>          cvs rtag OWNER_NAME-YYYYMMDD-branchpoint gdb</code></pre></td>
        <td class="diff"><pre><code>          cvs rtag OWNER_NAME-YYYYMMDD-branchpoint gdb</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>          cvs rtag -b -r OWNER_NAME-YYYYMMDD-branchpoint \</code></pre></td>
        <td class="diff"><pre><code>          cvs rtag -b -r OWNER_NAME-YYYYMMDD-branchpoint \</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>             OWNER_NAME-YYYYMMDD-branch gdb</code></pre></td>
        <td class="diff"><pre><code>             OWNER_NAME-YYYYMMDD-branch gdb</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>`OWNER_NAME-YYYYMMDD-mergepoint'</code></pre></td>
        <td class="diff"><pre><code>`OWNER_NAME-YYYYMMDD-mergepoint'</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     The tagged point, on the mainline, that was used when merging the</code></pre></td>
        <td class="diff"><pre><code>     The tagged point, on the mainline, that was used when merging the</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     branch on YYYYMMDD.  To merge in all changes since the branch was</code></pre></td>
        <td class="diff"><pre><code>     branch on YYYYMMDD.  To merge in all changes since the branch was</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     cut, use a command sequence like:</code></pre></td>
        <td class="diff"><pre><code>     cut, use a command sequence like:</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>          cvs rtag OWNER_NAME-YYYYMMDD-mergepoint gdb</code></pre></td>
        <td class="diff"><pre><code>          cvs rtag OWNER_NAME-YYYYMMDD-mergepoint gdb</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>          cvs update \</code></pre></td>
        <td class="diff"><pre><code>          cvs update \</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>             -jOWNER_NAME-YYYYMMDD-branchpoint</code></pre></td>
        <td class="diff"><pre><code>             -jOWNER_NAME-YYYYMMDD-branchpoint</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>             -jOWNER_NAME-YYYYMMDD-mergepoint</code></pre></td>
        <td class="diff"><pre><code>             -jOWNER_NAME-YYYYMMDD-mergepoint</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     Similar sequences can be used to just merge in changes since the</code></pre></td>
        <td class="diff"><pre><code>     Similar sequences can be used to just merge in changes since the</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     last merge.</code></pre></td>
        <td class="diff"><pre><code>     last merge.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>For further information on CVS, see Concurrent Versions System</code></pre></td>
        <td class="diff"><pre><code>For further information on CVS, see Concurrent Versions System</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>(http://www.gnu.org/software/cvs/).</code></pre></td>
        <td class="diff"><pre><code>(http://www.gnu.org/software/cvs/).</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>File: gdbint.info,  Node: Start of New Year Procedure,  Next: Releasing GDB,  Prev: Versions and Branches,  Up: Top</code></pre></td>
        <td class="diff"><pre><code>File: gdbint.info,  Node: Start of New Year Procedure,  Next: Releasing GDB,  Prev: Versions and Branches,  Up: Top</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>17 Start of New Year Procedure</code></pre></td>
        <td class="diff"><pre><code>17 Start of New Year Procedure</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>******************************</code></pre></td>
        <td class="diff"><pre><code>******************************</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>At the start of each new year, the following actions should be</code></pre></td>
        <td class="diff"><pre><code>At the start of each new year, the following actions should be</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>performed:</code></pre></td>
        <td class="diff"><pre><code>performed:</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>   * Rotate the ChangeLog file</code></pre></td>
        <td class="diff"><pre><code>   * Rotate the ChangeLog file</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     The current `ChangeLog' file should be renamed into</code></pre></td>
        <td class="diff"><pre><code>     The current `ChangeLog' file should be renamed into</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     `ChangeLog-YYYY' where YYYY is the year that has just passed.  A</code></pre></td>
        <td class="diff"><pre><code>     `ChangeLog-YYYY' where YYYY is the year that has just passed.  A</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     new `ChangeLog' file should be created, and its contents should</code></pre></td>
        <td class="diff"><pre><code>     new `ChangeLog' file should be created, and its contents should</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     contain a reference to the previous ChangeLog.  The following</code></pre></td>
        <td class="diff"><pre><code>     contain a reference to the previous ChangeLog.  The following</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     should also be preserved at the end of the new ChangeLog, in order</code></pre></td>
        <td class="diff"><pre><code>     should also be preserved at the end of the new ChangeLog, in order</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     to provide the appropriate settings when editing this file with</code></pre></td>
        <td class="diff"><pre><code>     to provide the appropriate settings when editing this file with</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     Emacs:</code></pre></td>
        <td class="diff"><pre><code>     Emacs:</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>          Local Variables:</code></pre></td>
        <td class="diff"><pre><code>          Local Variables:</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>          mode: change-log</code></pre></td>
        <td class="diff"><pre><code>          mode: change-log</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>          left-margin: 8</code></pre></td>
        <td class="diff"><pre><code>          left-margin: 8</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>          fill-column: 74</code></pre></td>
        <td class="diff"><pre><code>          fill-column: 74</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>          version-control: never</code></pre></td>
        <td class="diff"><pre><code>          version-control: never</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>          End:</code></pre></td>
        <td class="diff"><pre><code>          End:</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>   * Add an entry for the newly created ChangeLog file</code></pre></td>
        <td class="diff"><pre><code>   * Add an entry for the newly created ChangeLog file</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     (`ChangeLog-YYYY') in `gdb/config/djgpp/fnchange.lst'.</code></pre></td>
        <td class="diff"><pre><code>     (`ChangeLog-YYYY') in `gdb/config/djgpp/fnchange.lst'.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>   * Update the copyright year in the startup message</code></pre></td>
        <td class="diff"><pre><code>   * Update the copyright year in the startup message</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     Update the copyright year in file `top.c', function</code></pre></td>
        <td class="diff"><pre><code>     Update the copyright year in file `top.c', function</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     `print_gdb_version'.</code></pre></td>
        <td class="diff"><pre><code>     `print_gdb_version'.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>   * Add the new year in the copyright notices of all source and</code></pre></td>
        <td class="diff"><pre><code>   * Add the new year in the copyright notices of all source and</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     documentation files.  This can be done semi-automatically by</code></pre></td>
        <td class="diff"><pre><code>     documentation files.  This can be done semi-automatically by</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     running the `copyright.sh' script.  This script requires Emacs 22</code></pre></td>
        <td class="diff"><pre><code>     running the `copyright.sh' script.  This script requires Emacs 22</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     or later to be installed.</code></pre></td>
        <td class="diff"><pre><code>     or later to be installed.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>File: gdbint.info,  Node: Releasing GDB,  Next: Testsuite,  Prev: Start of New Year Procedure,  Up: Top</code></pre></td>
        <td class="diff"><pre><code>File: gdbint.info,  Node: Releasing GDB,  Next: Testsuite,  Prev: Start of New Year Procedure,  Up: Top</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>18 Releasing GDB</code></pre></td>
        <td class="diff"><pre><code>18 Releasing GDB</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>****************</code></pre></td>
        <td class="diff"><pre><code>****************</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>18.1 Branch Commit Policy</code></pre></td>
        <td class="diff"><pre><code>18.1 Branch Commit Policy</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>=========================</code></pre></td>
        <td class="diff"><pre><code>=========================</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>The branch commit policy is pretty slack.  GDB releases 5.0, 5.1 and</code></pre></td>
        <td class="diff"><pre><code>The branch commit policy is pretty slack.  GDB releases 5.0, 5.1 and</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>5.2 all used the below:</code></pre></td>
        <td class="diff"><pre><code>5.2 all used the below:</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>   * The `gdb/MAINTAINERS' file still holds.</code></pre></td>
        <td class="diff"><pre><code>   * The `gdb/MAINTAINERS' file still holds.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>   * Don't fix something on the branch unless/until it is also fixed in</code></pre></td>
        <td class="diff"><pre><code>   * Don't fix something on the branch unless/until it is also fixed in</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     the trunk.  If this isn't possible, mentioning it in the</code></pre></td>
        <td class="diff"><pre><code>     the trunk.  If this isn't possible, mentioning it in the</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     `gdb/PROBLEMS' file is better than committing a hack.</code></pre></td>
        <td class="diff"><pre><code>     `gdb/PROBLEMS' file is better than committing a hack.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>   * When considering a patch for the branch, suggested criteria</code></pre></td>
        <td class="diff"><pre><code>   * When considering a patch for the branch, suggested criteria</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     include: Does it fix a build?  Does it fix the sequence `break</code></pre></td>
        <td class="diff"><pre><code>     include: Does it fix a build?  Does it fix the sequence `break</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     main; run' when debugging a static binary?</code></pre></td>
        <td class="diff"><pre><code>     main; run' when debugging a static binary?</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>   * The further a change is from the core of GDB, the less likely the</code></pre></td>
        <td class="diff"><pre><code>   * The further a change is from the core of GDB, the less likely the</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     change will worry anyone (e.g., target specific code).</code></pre></td>
        <td class="diff"><pre><code>     change will worry anyone (e.g., target specific code).</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>   * Only post a proposal to change the core of GDB after you've sent</code></pre></td>
        <td class="diff"><pre><code>   * Only post a proposal to change the core of GDB after you've sent</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     individual bribes to all the people listed in the `MAINTAINERS'</code></pre></td>
        <td class="diff"><pre><code>     individual bribes to all the people listed in the `MAINTAINERS'</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     file ;-)</code></pre></td>
        <td class="diff"><pre><code>     file ;-)</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>   _Pragmatics: Provided updates are restricted to non-core</code></pre></td>
        <td class="diff"><pre><code>   _Pragmatics: Provided updates are restricted to non-core</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>functionality there is little chance that a broken change will be fatal.</code></pre></td>
        <td class="diff"><pre><code>functionality there is little chance that a broken change will be fatal.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>This means that changes such as adding a new architectures or (within</code></pre></td>
        <td class="diff"><pre><code>This means that changes such as adding a new architectures or (within</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>reason) support for a new host are considered acceptable._</code></pre></td>
        <td class="diff"><pre><code>reason) support for a new host are considered acceptable._</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>18.2 Obsoleting code</code></pre></td>
        <td class="diff"><pre><code>18.2 Obsoleting code</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>====================</code></pre></td>
        <td class="diff"><pre><code>====================</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>Before anything else, poke the other developers (and around the source</code></pre></td>
        <td class="diff"><pre><code>Before anything else, poke the other developers (and around the source</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>code) to see if there is anything that can be removed from GDB (an old</code></pre></td>
        <td class="diff"><pre><code>code) to see if there is anything that can be removed from GDB (an old</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>target, an unused file).</code></pre></td>
        <td class="diff"><pre><code>target, an unused file).</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>   Obsolete code is identified by adding an `OBSOLETE' prefix to every</code></pre></td>
        <td class="diff"><pre><code>   Obsolete code is identified by adding an `OBSOLETE' prefix to every</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>line.  Doing this means that it is easy to identify something that has</code></pre></td>
        <td class="diff"><pre><code>line.  Doing this means that it is easy to identify something that has</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>been obsoleted when greping through the sources.</code></pre></td>
        <td class="diff"><pre><code>been obsoleted when greping through the sources.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>   The process is done in stages -- this is mainly to ensure that the</code></pre></td>
        <td class="diff"><pre><code>   The process is done in stages -- this is mainly to ensure that the</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>wider GDB community has a reasonable opportunity to respond.  Remember,</code></pre></td>
        <td class="diff"><pre><code>wider GDB community has a reasonable opportunity to respond.  Remember,</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>everything on the Internet takes a week.</code></pre></td>
        <td class="diff"><pre><code>everything on the Internet takes a week.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>  1. Post the proposal on the GDB mailing list <gdb@sources.redhat.com></code></pre></td>
        <td class="diff"><pre><code>  1. Post the proposal on the GDB mailing list <gdb@sources.redhat.com></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     Creating a bug report to track the task's state, is also highly</code></pre></td>
        <td class="diff"><pre><code>     Creating a bug report to track the task's state, is also highly</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     recommended.</code></pre></td>
        <td class="diff"><pre><code>     recommended.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>  2. Wait a week or so.</code></pre></td>
        <td class="diff"><pre><code>  2. Wait a week or so.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>  3. Post the proposal on the GDB Announcement mailing list</code></pre></td>
        <td class="diff"><pre><code>  3. Post the proposal on the GDB Announcement mailing list</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     <gdb-announce@sources.redhat.com>.</code></pre></td>
        <td class="diff"><pre><code>     <gdb-announce@sources.redhat.com>.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>  4. Wait a week or so.</code></pre></td>
        <td class="diff"><pre><code>  4. Wait a week or so.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>  5. Go through and edit all relevant files and lines so that they are</code></pre></td>
        <td class="diff"><pre><code>  5. Go through and edit all relevant files and lines so that they are</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     prefixed with the word `OBSOLETE'.</code></pre></td>
        <td class="diff"><pre><code>     prefixed with the word `OBSOLETE'.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>  6. Wait until the next GDB version, containing this obsolete code,</code></pre></td>
        <td class="diff"><pre><code>  6. Wait until the next GDB version, containing this obsolete code,</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     has been released.</code></pre></td>
        <td class="diff"><pre><code>     has been released.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>  7. Remove the obsolete code.</code></pre></td>
        <td class="diff"><pre><code>  7. Remove the obsolete code.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>_Maintainer note: While removing old code is regrettable it is</code></pre></td>
        <td class="diff"><pre><code>_Maintainer note: While removing old code is regrettable it is</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>hopefully better for GDB's long term development.  Firstly it helps the</code></pre></td>
        <td class="diff"><pre><code>hopefully better for GDB's long term development.  Firstly it helps the</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>developers by removing code that is either no longer relevant or simply</code></pre></td>
        <td class="diff"><pre><code>developers by removing code that is either no longer relevant or simply</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>wrong.  Secondly since it removes any history associated with the file</code></pre></td>
        <td class="diff"><pre><code>wrong.  Secondly since it removes any history associated with the file</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>(effectively clearing the slate) the developer has a much freer hand</code></pre></td>
        <td class="diff"><pre><code>(effectively clearing the slate) the developer has a much freer hand</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>when it comes to fixing broken files._</code></pre></td>
        <td class="diff"><pre><code>when it comes to fixing broken files._</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>18.3 Before the Branch</code></pre></td>
        <td class="diff"><pre><code>18.3 Before the Branch</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>======================</code></pre></td>
        <td class="diff"><pre><code>======================</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>The most important objective at this stage is to find and fix simple</code></pre></td>
        <td class="diff"><pre><code>The most important objective at this stage is to find and fix simple</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>changes that become a pain to track once the branch is created.  For</code></pre></td>
        <td class="diff"><pre><code>changes that become a pain to track once the branch is created.  For</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>instance, configuration problems that stop GDB from even building.  If</code></pre></td>
        <td class="diff"><pre><code>instance, configuration problems that stop GDB from even building.  If</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>you can't get the problem fixed, document it in the `gdb/PROBLEMS' file.</code></pre></td>
        <td class="diff"><pre><code>you can't get the problem fixed, document it in the `gdb/PROBLEMS' file.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>Prompt for `gdb/NEWS'</code></pre></td>
        <td class="diff"><pre><code>Prompt for `gdb/NEWS'</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>---------------------</code></pre></td>
        <td class="diff"><pre><code>---------------------</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>People always forget.  Send a post reminding them but also if you know</code></pre></td>
        <td class="diff"><pre><code>People always forget.  Send a post reminding them but also if you know</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>something interesting happened add it yourself.  The `schedule' script</code></pre></td>
        <td class="diff"><pre><code>something interesting happened add it yourself.  The `schedule' script</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>will mention this in its e-mail.</code></pre></td>
        <td class="diff"><pre><code>will mention this in its e-mail.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>Review `gdb/README'</code></pre></td>
        <td class="diff"><pre><code>Review `gdb/README'</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>-------------------</code></pre></td>
        <td class="diff"><pre><code>-------------------</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>Grab one of the nightly snapshots and then walk through the</code></pre></td>
        <td class="diff"><pre><code>Grab one of the nightly snapshots and then walk through the</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>`gdb/README' looking for anything that can be improved.  The `schedule'</code></pre></td>
        <td class="diff"><pre><code>`gdb/README' looking for anything that can be improved.  The `schedule'</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>script will mention this in its e-mail.</code></pre></td>
        <td class="diff"><pre><code>script will mention this in its e-mail.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>Refresh any imported files.</code></pre></td>
        <td class="diff"><pre><code>Refresh any imported files.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>---------------------------</code></pre></td>
        <td class="diff"><pre><code>---------------------------</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>A number of files are taken from external repositories.  They include:</code></pre></td>
        <td class="diff"><pre><code>A number of files are taken from external repositories.  They include:</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>   * `texinfo/texinfo.tex'</code></pre></td>
        <td class="diff"><pre><code>   * `texinfo/texinfo.tex'</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>   * `config.guess' et. al. (see the top-level `MAINTAINERS' file)</code></pre></td>
        <td class="diff"><pre><code>   * `config.guess' et. al. (see the top-level `MAINTAINERS' file)</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>   * `etc/standards.texi', `etc/make-stds.texi'</code></pre></td>
        <td class="diff"><pre><code>   * `etc/standards.texi', `etc/make-stds.texi'</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>Check the ARI</code></pre></td>
        <td class="diff"><pre><code>Check the ARI</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>-------------</code></pre></td>
        <td class="diff"><pre><code>-------------</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>A.R.I. is an `awk' script (Awk Regression Index ;-) that checks for a</code></pre></td>
        <td class="diff"><pre><code>A.R.I. is an `awk' script (Awk Regression Index ;-) that checks for a</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>number of errors and coding conventions.  The checks include things</code></pre></td>
        <td class="diff"><pre><code>number of errors and coding conventions.  The checks include things</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>like using `malloc' instead of `xmalloc' and file naming problems.</code></pre></td>
        <td class="diff"><pre><code>like using `malloc' instead of `xmalloc' and file naming problems.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>There shouldn't be any regressions.</code></pre></td>
        <td class="diff"><pre><code>There shouldn't be any regressions.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>18.3.1 Review the bug data base</code></pre></td>
        <td class="diff"><pre><code>18.3.1 Review the bug data base</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>-------------------------------</code></pre></td>
        <td class="diff"><pre><code>-------------------------------</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>Close anything obviously fixed.</code></pre></td>
        <td class="diff"><pre><code>Close anything obviously fixed.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>18.3.2 Check all cross targets build</code></pre></td>
        <td class="diff"><pre><code>18.3.2 Check all cross targets build</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>------------------------------------</code></pre></td>
        <td class="diff"><pre><code>------------------------------------</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>The targets are listed in `gdb/MAINTAINERS'.</code></pre></td>
        <td class="diff"><pre><code>The targets are listed in `gdb/MAINTAINERS'.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>18.4 Cut the Branch</code></pre></td>
        <td class="diff"><pre><code>18.4 Cut the Branch</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>===================</code></pre></td>
        <td class="diff"><pre><code>===================</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>Create the branch</code></pre></td>
        <td class="diff"><pre><code>Create the branch</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>-----------------</code></pre></td>
        <td class="diff"><pre><code>-----------------</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     $  u=5.1</code></pre></td>
        <td class="diff"><pre><code>     $  u=5.1</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     $  v=5.2</code></pre></td>
        <td class="diff"><pre><code>     $  v=5.2</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     $  V=`echo $v | sed 's/\./_/g'`</code></pre></td>
        <td class="diff"><pre><code>     $  V=`echo $v | sed 's/\./_/g'`</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     $  D=`date -u +%Y-%m-%d`</code></pre></td>
        <td class="diff"><pre><code>     $  D=`date -u +%Y-%m-%d`</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     $  echo $u $V $D</code></pre></td>
        <td class="diff"><pre><code>     $  echo $u $V $D</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     5.1 5_2 2002-03-03</code></pre></td>
        <td class="diff"><pre><code>     5.1 5_2 2002-03-03</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     $  echo cvs -f -d :ext:sources.redhat.com:/cvs/src rtag \</code></pre></td>
        <td class="diff"><pre><code>     $  echo cvs -f -d :ext:sources.redhat.com:/cvs/src rtag \</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     -D $D-gmt gdb_$V-$D-branchpoint insight</code></pre></td>
        <td class="diff"><pre><code>     -D $D-gmt gdb_$V-$D-branchpoint insight</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     cvs -f -d :ext:sources.redhat.com:/cvs/src rtag</code></pre></td>
        <td class="diff"><pre><code>     cvs -f -d :ext:sources.redhat.com:/cvs/src rtag</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     -D 2002-03-03-gmt gdb_5_2-2002-03-03-branchpoint insight</code></pre></td>
        <td class="diff"><pre><code>     -D 2002-03-03-gmt gdb_5_2-2002-03-03-branchpoint insight</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     $  ^echo ^^</code></pre></td>
        <td class="diff"><pre><code>     $  ^echo ^^</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     ...</code></pre></td>
        <td class="diff"><pre><code>     ...</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     $  echo cvs -f -d :ext:sources.redhat.com:/cvs/src rtag \</code></pre></td>
        <td class="diff"><pre><code>     $  echo cvs -f -d :ext:sources.redhat.com:/cvs/src rtag \</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     -b -r gdb_$V-$D-branchpoint gdb_$V-branch insight</code></pre></td>
        <td class="diff"><pre><code>     -b -r gdb_$V-$D-branchpoint gdb_$V-branch insight</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     cvs -f -d :ext:sources.redhat.com:/cvs/src rtag \</code></pre></td>
        <td class="diff"><pre><code>     cvs -f -d :ext:sources.redhat.com:/cvs/src rtag \</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     -b -r gdb_5_2-2002-03-03-branchpoint gdb_5_2-branch insight</code></pre></td>
        <td class="diff"><pre><code>     -b -r gdb_5_2-2002-03-03-branchpoint gdb_5_2-branch insight</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     $  ^echo ^^</code></pre></td>
        <td class="diff"><pre><code>     $  ^echo ^^</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     ...</code></pre></td>
        <td class="diff"><pre><code>     ...</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     $</code></pre></td>
        <td class="diff"><pre><code>     $</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>   * By using `-D YYYY-MM-DD-gmt', the branch is forced to an exact</code></pre></td>
        <td class="diff"><pre><code>   * By using `-D YYYY-MM-DD-gmt', the branch is forced to an exact</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     date/time.</code></pre></td>
        <td class="diff"><pre><code>     date/time.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>   * The trunk is first tagged so that the branch point can easily be</code></pre></td>
        <td class="diff"><pre><code>   * The trunk is first tagged so that the branch point can easily be</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     found.</code></pre></td>
        <td class="diff"><pre><code>     found.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>   * Insight, which includes GDB, is tagged at the same time.</code></pre></td>
        <td class="diff"><pre><code>   * Insight, which includes GDB, is tagged at the same time.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>   * `version.in' gets bumped to avoid version number conflicts.</code></pre></td>
        <td class="diff"><pre><code>   * `version.in' gets bumped to avoid version number conflicts.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>   * The reading of `.cvsrc' is disabled using `-f'.</code></pre></td>
        <td class="diff"><pre><code>   * The reading of `.cvsrc' is disabled using `-f'.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>Update `version.in'</code></pre></td>
        <td class="diff"><pre><code>Update `version.in'</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>-------------------</code></pre></td>
        <td class="diff"><pre><code>-------------------</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     $  u=5.1</code></pre></td>
        <td class="diff"><pre><code>     $  u=5.1</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     $  v=5.2</code></pre></td>
        <td class="diff"><pre><code>     $  v=5.2</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     $  V=`echo $v | sed 's/\./_/g'`</code></pre></td>
        <td class="diff"><pre><code>     $  V=`echo $v | sed 's/\./_/g'`</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     $  echo $u $v$V</code></pre></td>
        <td class="diff"><pre><code>     $  echo $u $v$V</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     5.1 5_2</code></pre></td>
        <td class="diff"><pre><code>     5.1 5_2</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     $  cd /tmp</code></pre></td>
        <td class="diff"><pre><code>     $  cd /tmp</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     $  echo cvs -f -d :ext:sources.redhat.com:/cvs/src co \</code></pre></td>
        <td class="diff"><pre><code>     $  echo cvs -f -d :ext:sources.redhat.com:/cvs/src co \</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     -r gdb_$V-branch src/gdb/version.in</code></pre></td>
        <td class="diff"><pre><code>     -r gdb_$V-branch src/gdb/version.in</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     cvs -f -d :ext:sources.redhat.com:/cvs/src co</code></pre></td>
        <td class="diff"><pre><code>     cvs -f -d :ext:sources.redhat.com:/cvs/src co</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>      -r gdb_5_2-branch src/gdb/version.in</code></pre></td>
        <td class="diff"><pre><code>      -r gdb_5_2-branch src/gdb/version.in</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     $  ^echo ^^</code></pre></td>
        <td class="diff"><pre><code>     $  ^echo ^^</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     U src/gdb/version.in</code></pre></td>
        <td class="diff"><pre><code>     U src/gdb/version.in</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     $  cd src/gdb</code></pre></td>
        <td class="diff"><pre><code>     $  cd src/gdb</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     $  echo $u.90-0000-00-00-cvs > version.in</code></pre></td>
        <td class="diff"><pre><code>     $  echo $u.90-0000-00-00-cvs > version.in</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     $  cat version.in</code></pre></td>
        <td class="diff"><pre><code>     $  cat version.in</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     5.1.90-0000-00-00-cvs</code></pre></td>
        <td class="diff"><pre><code>     5.1.90-0000-00-00-cvs</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     $  cvs -f commit version.in</code></pre></td>
        <td class="diff"><pre><code>     $  cvs -f commit version.in</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>   * `0000-00-00' is used as a date to pump prime the version.in update</code></pre></td>
        <td class="diff"><pre><code>   * `0000-00-00' is used as a date to pump prime the version.in update</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     mechanism.</code></pre></td>
        <td class="diff"><pre><code>     mechanism.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>   * `.90' and the previous branch version are used as fairly arbitrary</code></pre></td>
        <td class="diff"><pre><code>   * `.90' and the previous branch version are used as fairly arbitrary</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     initial branch version number.</code></pre></td>
        <td class="diff"><pre><code>     initial branch version number.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>Update the web and news pages</code></pre></td>
        <td class="diff"><pre><code>Update the web and news pages</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>-----------------------------</code></pre></td>
        <td class="diff"><pre><code>-----------------------------</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>Something?</code></pre></td>
        <td class="diff"><pre><code>Something?</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>Tweak cron to track the new branch</code></pre></td>
        <td class="diff"><pre><code>Tweak cron to track the new branch</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>----------------------------------</code></pre></td>
        <td class="diff"><pre><code>----------------------------------</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>The file `gdbadmin/cron/crontab' contains gdbadmin's cron table.  This</code></pre></td>
        <td class="diff"><pre><code>The file `gdbadmin/cron/crontab' contains gdbadmin's cron table.  This</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>file needs to be updated so that:</code></pre></td>
        <td class="diff"><pre><code>file needs to be updated so that:</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>   * A daily timestamp is added to the file `version.in'.</code></pre></td>
        <td class="diff"><pre><code>   * A daily timestamp is added to the file `version.in'.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>   * The new branch is included in the snapshot process.</code></pre></td>
        <td class="diff"><pre><code>   * The new branch is included in the snapshot process.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>See the file `gdbadmin/cron/README' for how to install the updated cron</code></pre></td>
        <td class="diff"><pre><code>See the file `gdbadmin/cron/README' for how to install the updated cron</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>table.</code></pre></td>
        <td class="diff"><pre><code>table.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>   The file `gdbadmin/ss/README' should also be reviewed to reflect any</code></pre></td>
        <td class="diff"><pre><code>   The file `gdbadmin/ss/README' should also be reviewed to reflect any</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>changes.  That file is copied to both the branch/ and current/ snapshot</code></pre></td>
        <td class="diff"><pre><code>changes.  That file is copied to both the branch/ and current/ snapshot</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>directories.</code></pre></td>
        <td class="diff"><pre><code>directories.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>Update the NEWS and README files</code></pre></td>
        <td class="diff"><pre><code>Update the NEWS and README files</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>--------------------------------</code></pre></td>
        <td class="diff"><pre><code>--------------------------------</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>The `NEWS' file needs to be updated so that on the branch it refers to</code></pre></td>
        <td class="diff"><pre><code>The `NEWS' file needs to be updated so that on the branch it refers to</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>_changes in the current release_ while on the trunk it also refers to</code></pre></td>
        <td class="diff"><pre><code>_changes in the current release_ while on the trunk it also refers to</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>_changes since the current release_.</code></pre></td>
        <td class="diff"><pre><code>_changes since the current release_.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>   The `README' file needs to be updated so that it refers to the</code></pre></td>
        <td class="diff"><pre><code>   The `README' file needs to be updated so that it refers to the</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>current release.</code></pre></td>
        <td class="diff"><pre><code>current release.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>Post the branch info</code></pre></td>
        <td class="diff"><pre><code>Post the branch info</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>--------------------</code></pre></td>
        <td class="diff"><pre><code>--------------------</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>Send an announcement to the mailing lists:</code></pre></td>
        <td class="diff"><pre><code>Send an announcement to the mailing lists:</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>   * GDB Announcement mailing list <gdb-announce@sources.redhat.com></code></pre></td>
        <td class="diff"><pre><code>   * GDB Announcement mailing list <gdb-announce@sources.redhat.com></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>   * GDB Discussion mailing list <gdb@sources.redhat.com> and GDB</code></pre></td>
        <td class="diff"><pre><code>   * GDB Discussion mailing list <gdb@sources.redhat.com> and GDB</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     Testers mailing list <gdb-testers@sources.redhat.com></code></pre></td>
        <td class="diff"><pre><code>     Testers mailing list <gdb-testers@sources.redhat.com></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>   _Pragmatics: The branch creation is sent to the announce list to</code></pre></td>
        <td class="diff"><pre><code>   _Pragmatics: The branch creation is sent to the announce list to</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>ensure that people people not subscribed to the higher volume discussion</code></pre></td>
        <td class="diff"><pre><code>ensure that people people not subscribed to the higher volume discussion</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>list are alerted._</code></pre></td>
        <td class="diff"><pre><code>list are alerted._</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>   The announcement should include:</code></pre></td>
        <td class="diff"><pre><code>   The announcement should include:</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>   * The branch tag.</code></pre></td>
        <td class="diff"><pre><code>   * The branch tag.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>   * How to check out the branch using CVS.</code></pre></td>
        <td class="diff"><pre><code>   * How to check out the branch using CVS.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>   * The date/number of weeks until the release.</code></pre></td>
        <td class="diff"><pre><code>   * The date/number of weeks until the release.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>   * The branch commit policy still holds.</code></pre></td>
        <td class="diff"><pre><code>   * The branch commit policy still holds.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>18.5 Stabilize the branch</code></pre></td>
        <td class="diff"><pre><code>18.5 Stabilize the branch</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>=========================</code></pre></td>
        <td class="diff"><pre><code>=========================</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>Something goes here.</code></pre></td>
        <td class="diff"><pre><code>Something goes here.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>18.6 Create a Release</code></pre></td>
        <td class="diff"><pre><code>18.6 Create a Release</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>=====================</code></pre></td>
        <td class="diff"><pre><code>=====================</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>The process of creating and then making available a release is broken</code></pre></td>
        <td class="diff"><pre><code>The process of creating and then making available a release is broken</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>down into a number of stages.  The first part addresses the technical</code></pre></td>
        <td class="diff"><pre><code>down into a number of stages.  The first part addresses the technical</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>process of creating a releasable tar ball.  The later stages address the</code></pre></td>
        <td class="diff"><pre><code>process of creating a releasable tar ball.  The later stages address the</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>process of releasing that tar ball.</code></pre></td>
        <td class="diff"><pre><code>process of releasing that tar ball.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>   When making a release candidate just the first section is needed.</code></pre></td>
        <td class="diff"><pre><code>   When making a release candidate just the first section is needed.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>18.6.1 Create a release candidate</code></pre></td>
        <td class="diff"><pre><code>18.6.1 Create a release candidate</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>---------------------------------</code></pre></td>
        <td class="diff"><pre><code>---------------------------------</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>The objective at this stage is to create a set of tar balls that can be</code></pre></td>
        <td class="diff"><pre><code>The objective at this stage is to create a set of tar balls that can be</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>made available as a formal release (or as a less formal release</code></pre></td>
        <td class="diff"><pre><code>made available as a formal release (or as a less formal release</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>candidate).</code></pre></td>
        <td class="diff"><pre><code>candidate).</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>Freeze the branch</code></pre></td>
        <td class="diff"><pre><code>Freeze the branch</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>.................</code></pre></td>
        <td class="diff"><pre><code>.................</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>Send out an e-mail notifying everyone that the branch is frozen to</code></pre></td>
        <td class="diff"><pre><code>Send out an e-mail notifying everyone that the branch is frozen to</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code><gdb-patches@sources.redhat.com>.</code></pre></td>
        <td class="diff"><pre><code><gdb-patches@sources.redhat.com>.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>Establish a few defaults.</code></pre></td>
        <td class="diff"><pre><code>Establish a few defaults.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>.........................</code></pre></td>
        <td class="diff"><pre><code>.........................</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     $  b=gdb_5_2-branch</code></pre></td>
        <td class="diff"><pre><code>     $  b=gdb_5_2-branch</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     $  v=5.2</code></pre></td>
        <td class="diff"><pre><code>     $  v=5.2</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     $  t=/sourceware/snapshot-tmp/gdbadmin-tmp</code></pre></td>
        <td class="diff"><pre><code>     $  t=/sourceware/snapshot-tmp/gdbadmin-tmp</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     $  echo $t/$b/$v</code></pre></td>
        <td class="diff"><pre><code>     $  echo $t/$b/$v</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     /sourceware/snapshot-tmp/gdbadmin-tmp/gdb_5_2-branch/5.2</code></pre></td>
        <td class="diff"><pre><code>     /sourceware/snapshot-tmp/gdbadmin-tmp/gdb_5_2-branch/5.2</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     $  mkdir -p $t/$b/$v</code></pre></td>
        <td class="diff"><pre><code>     $  mkdir -p $t/$b/$v</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     $  cd $t/$b/$v</code></pre></td>
        <td class="diff"><pre><code>     $  cd $t/$b/$v</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     $  pwd</code></pre></td>
        <td class="diff"><pre><code>     $  pwd</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     /sourceware/snapshot-tmp/gdbadmin-tmp/gdb_5_2-branch/5.2</code></pre></td>
        <td class="diff"><pre><code>     /sourceware/snapshot-tmp/gdbadmin-tmp/gdb_5_2-branch/5.2</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     $  which autoconf</code></pre></td>
        <td class="diff"><pre><code>     $  which autoconf</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     /home/gdbadmin/bin/autoconf</code></pre></td>
        <td class="diff"><pre><code>     /home/gdbadmin/bin/autoconf</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     $</code></pre></td>
        <td class="diff"><pre><code>     $</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>Notes:</code></pre></td>
        <td class="diff"><pre><code>Notes:</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>   * Check the `autoconf' version carefully.  You want to be using the</code></pre></td>
        <td class="diff"><pre><code>   * Check the `autoconf' version carefully.  You want to be using the</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     version taken from the `binutils' snapshot directory, which can be</code></pre></td>
        <td class="diff"><pre><code>     version taken from the `binutils' snapshot directory, which can be</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     found at `ftp://sources.redhat.com/pub/binutils/'. It is very</code></pre></td>
        <td class="diff"><pre><code>     found at `ftp://sources.redhat.com/pub/binutils/'. It is very</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     unlikely that a system installed version of `autoconf' (e.g.,</code></pre></td>
        <td class="diff"><pre><code>     unlikely that a system installed version of `autoconf' (e.g.,</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     `/usr/bin/autoconf') is correct.</code></pre></td>
        <td class="diff"><pre><code>     `/usr/bin/autoconf') is correct.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>Check out the relevant modules:</code></pre></td>
        <td class="diff"><pre><code>Check out the relevant modules:</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>...............................</code></pre></td>
        <td class="diff"><pre><code>...............................</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     $  for m in gdb insight</code></pre></td>
        <td class="diff"><pre><code>     $  for m in gdb insight</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     do</code></pre></td>
        <td class="diff"><pre><code>     do</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     ( mkdir -p $m && cd $m && cvs -q -f -d /cvs/src co -P -r $b $m )</code></pre></td>
        <td class="diff"><pre><code>     ( mkdir -p $m && cd $m && cvs -q -f -d /cvs/src co -P -r $b $m )</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     done</code></pre></td>
        <td class="diff"><pre><code>     done</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     $</code></pre></td>
        <td class="diff"><pre><code>     $</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>Note:</code></pre></td>
        <td class="diff"><pre><code>Note:</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>   * The reading of `.cvsrc' is disabled (`-f') so that there isn't any</code></pre></td>
        <td class="diff"><pre><code>   * The reading of `.cvsrc' is disabled (`-f') so that there isn't any</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     confusion between what is written here and what your local `cvs'</code></pre></td>
        <td class="diff"><pre><code>     confusion between what is written here and what your local `cvs'</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     really does.</code></pre></td>
        <td class="diff"><pre><code>     really does.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>Update relevant files.</code></pre></td>
        <td class="diff"><pre><code>Update relevant files.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>......................</code></pre></td>
        <td class="diff"><pre><code>......................</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>`gdb/NEWS'</code></pre></td>
        <td class="diff"><pre><code>`gdb/NEWS'</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     Major releases get their comments added as part of the mainline.</code></pre></td>
        <td class="diff"><pre><code>     Major releases get their comments added as part of the mainline.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     Minor releases should probably mention any significant bugs that</code></pre></td>
        <td class="diff"><pre><code>     Minor releases should probably mention any significant bugs that</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     were fixed.</code></pre></td>
        <td class="diff"><pre><code>     were fixed.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     Don't forget to include the `ChangeLog' entry.</code></pre></td>
        <td class="diff"><pre><code>     Don't forget to include the `ChangeLog' entry.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>          $  emacs gdb/src/gdb/NEWS</code></pre></td>
        <td class="diff"><pre><code>          $  emacs gdb/src/gdb/NEWS</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>          ...</code></pre></td>
        <td class="diff"><pre><code>          ...</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>          c-x 4 a</code></pre></td>
        <td class="diff"><pre><code>          c-x 4 a</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>          ...</code></pre></td>
        <td class="diff"><pre><code>          ...</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>          c-x c-s c-x c-c</code></pre></td>
        <td class="diff"><pre><code>          c-x c-s c-x c-c</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>          $  cp gdb/src/gdb/NEWS insight/src/gdb/NEWS</code></pre></td>
        <td class="diff"><pre><code>          $  cp gdb/src/gdb/NEWS insight/src/gdb/NEWS</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>          $  cp gdb/src/gdb/ChangeLog insight/src/gdb/ChangeLog</code></pre></td>
        <td class="diff"><pre><code>          $  cp gdb/src/gdb/ChangeLog insight/src/gdb/ChangeLog</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>`gdb/README'</code></pre></td>
        <td class="diff"><pre><code>`gdb/README'</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     You'll need to update:</code></pre></td>
        <td class="diff"><pre><code>     You'll need to update:</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>        * The version.</code></pre></td>
        <td class="diff"><pre><code>        * The version.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>        * The update date.</code></pre></td>
        <td class="diff"><pre><code>        * The update date.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>        * Who did it.</code></pre></td>
        <td class="diff"><pre><code>        * Who did it.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>          $  emacs gdb/src/gdb/README</code></pre></td>
        <td class="diff"><pre><code>          $  emacs gdb/src/gdb/README</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>          ...</code></pre></td>
        <td class="diff"><pre><code>          ...</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>          c-x 4 a</code></pre></td>
        <td class="diff"><pre><code>          c-x 4 a</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>          ...</code></pre></td>
        <td class="diff"><pre><code>          ...</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>          c-x c-s c-x c-c</code></pre></td>
        <td class="diff"><pre><code>          c-x c-s c-x c-c</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>          $  cp gdb/src/gdb/README insight/src/gdb/README</code></pre></td>
        <td class="diff"><pre><code>          $  cp gdb/src/gdb/README insight/src/gdb/README</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>          $  cp gdb/src/gdb/ChangeLog insight/src/gdb/ChangeLog</code></pre></td>
        <td class="diff"><pre><code>          $  cp gdb/src/gdb/ChangeLog insight/src/gdb/ChangeLog</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     _Maintainer note: Hopefully the `README' file was reviewed before</code></pre></td>
        <td class="diff"><pre><code>     _Maintainer note: Hopefully the `README' file was reviewed before</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     the initial branch was cut so just a simple substitute is needed</code></pre></td>
        <td class="diff"><pre><code>     the initial branch was cut so just a simple substitute is needed</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     to get it updated._</code></pre></td>
        <td class="diff"><pre><code>     to get it updated._</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     _Maintainer note: Other projects generate `README' and `INSTALL'</code></pre></td>
        <td class="diff"><pre><code>     _Maintainer note: Other projects generate `README' and `INSTALL'</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     from the core documentation.  This might be worth pursuing._</code></pre></td>
        <td class="diff"><pre><code>     from the core documentation.  This might be worth pursuing._</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>`gdb/version.in'</code></pre></td>
        <td class="diff"><pre><code>`gdb/version.in'</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>          $  echo $v > gdb/src/gdb/version.in</code></pre></td>
        <td class="diff"><pre><code>          $  echo $v > gdb/src/gdb/version.in</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>          $  cat gdb/src/gdb/version.in</code></pre></td>
        <td class="diff"><pre><code>          $  cat gdb/src/gdb/version.in</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>          5.2</code></pre></td>
        <td class="diff"><pre><code>          5.2</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>          $  emacs gdb/src/gdb/version.in</code></pre></td>
        <td class="diff"><pre><code>          $  emacs gdb/src/gdb/version.in</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>          ...</code></pre></td>
        <td class="diff"><pre><code>          ...</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>          c-x 4 a</code></pre></td>
        <td class="diff"><pre><code>          c-x 4 a</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>          ... Bump to version ...</code></pre></td>
        <td class="diff"><pre><code>          ... Bump to version ...</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>          c-x c-s c-x c-c</code></pre></td>
        <td class="diff"><pre><code>          c-x c-s c-x c-c</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>          $  cp gdb/src/gdb/version.in insight/src/gdb/version.in</code></pre></td>
        <td class="diff"><pre><code>          $  cp gdb/src/gdb/version.in insight/src/gdb/version.in</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>          $  cp gdb/src/gdb/ChangeLog insight/src/gdb/ChangeLog</code></pre></td>
        <td class="diff"><pre><code>          $  cp gdb/src/gdb/ChangeLog insight/src/gdb/ChangeLog</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>Do the dirty work</code></pre></td>
        <td class="diff"><pre><code>Do the dirty work</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>.................</code></pre></td>
        <td class="diff"><pre><code>.................</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>This is identical to the process used to create the daily snapshot.</code></pre></td>
        <td class="diff"><pre><code>This is identical to the process used to create the daily snapshot.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     $  for m in gdb insight</code></pre></td>
        <td class="diff"><pre><code>     $  for m in gdb insight</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     do</code></pre></td>
        <td class="diff"><pre><code>     do</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     ( cd $m/src && gmake -f src-release $m.tar )</code></pre></td>
        <td class="diff"><pre><code>     ( cd $m/src && gmake -f src-release $m.tar )</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     done</code></pre></td>
        <td class="diff"><pre><code>     done</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>   If the top level source directory does not have `src-release' (GDB</code></pre></td>
        <td class="diff"><pre><code>   If the top level source directory does not have `src-release' (GDB</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>version 5.3.1 or earlier), try these commands instead:</code></pre></td>
        <td class="diff"><pre><code>version 5.3.1 or earlier), try these commands instead:</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     $  for m in gdb insight</code></pre></td>
        <td class="diff"><pre><code>     $  for m in gdb insight</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     do</code></pre></td>
        <td class="diff"><pre><code>     do</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     ( cd $m/src && gmake -f Makefile.in $m.tar )</code></pre></td>
        <td class="diff"><pre><code>     ( cd $m/src && gmake -f Makefile.in $m.tar )</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     done</code></pre></td>
        <td class="diff"><pre><code>     done</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>Check the source files</code></pre></td>
        <td class="diff"><pre><code>Check the source files</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>......................</code></pre></td>
        <td class="diff"><pre><code>......................</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>You're looking for files that have mysteriously disappeared.</code></pre></td>
        <td class="diff"><pre><code>You're looking for files that have mysteriously disappeared.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>`distclean' has the habit of deleting files it shouldn't.  Watch out</code></pre></td>
        <td class="diff"><pre><code>`distclean' has the habit of deleting files it shouldn't.  Watch out</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>for the `version.in' update `cronjob'.</code></pre></td>
        <td class="diff"><pre><code>for the `version.in' update `cronjob'.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     $  ( cd gdb/src && cvs -f -q -n update )</code></pre></td>
        <td class="diff"><pre><code>     $  ( cd gdb/src && cvs -f -q -n update )</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     M djunpack.bat</code></pre></td>
        <td class="diff"><pre><code>     M djunpack.bat</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     ? gdb-5.1.91.tar</code></pre></td>
        <td class="diff"><pre><code>     ? gdb-5.1.91.tar</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     ? proto-toplev</code></pre></td>
        <td class="diff"><pre><code>     ? proto-toplev</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     ... lots of generated files ...</code></pre></td>
        <td class="diff"><pre><code>     ... lots of generated files ...</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     M gdb/ChangeLog</code></pre></td>
        <td class="diff"><pre><code>     M gdb/ChangeLog</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     M gdb/NEWS</code></pre></td>
        <td class="diff"><pre><code>     M gdb/NEWS</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     M gdb/README</code></pre></td>
        <td class="diff"><pre><code>     M gdb/README</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     M gdb/version.in</code></pre></td>
        <td class="diff"><pre><code>     M gdb/version.in</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     ... lots of generated files ...</code></pre></td>
        <td class="diff"><pre><code>     ... lots of generated files ...</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     $</code></pre></td>
        <td class="diff"><pre><code>     $</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>_Don't worry about the `gdb.info-??' or `gdb/p-exp.tab.c'.  They were</code></pre></td>
        <td class="diff"><pre><code>_Don't worry about the `gdb.info-??' or `gdb/p-exp.tab.c'.  They were</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>generated (and yes `gdb.info-1' was also generated only something</code></pre></td>
        <td class="diff"><pre><code>generated (and yes `gdb.info-1' was also generated only something</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>strange with CVS means that they didn't get suppressed).  Fixing it</code></pre></td>
        <td class="diff"><pre><code>strange with CVS means that they didn't get suppressed).  Fixing it</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>would be nice though._</code></pre></td>
        <td class="diff"><pre><code>would be nice though._</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>Create compressed versions of the release</code></pre></td>
        <td class="diff"><pre><code>Create compressed versions of the release</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>.........................................</code></pre></td>
        <td class="diff"><pre><code>.........................................</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     $  cp */src/*.tar .</code></pre></td>
        <td class="diff"><pre><code>     $  cp */src/*.tar .</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     $  cp */src/*.bz2 .</code></pre></td>
        <td class="diff"><pre><code>     $  cp */src/*.bz2 .</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     $  ls -F</code></pre></td>
        <td class="diff"><pre><code>     $  ls -F</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     gdb/ gdb-5.2.tar insight/ insight-5.2.tar</code></pre></td>
        <td class="diff"><pre><code>     gdb/ gdb-5.2.tar insight/ insight-5.2.tar</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     $  for m in gdb insight</code></pre></td>
        <td class="diff"><pre><code>     $  for m in gdb insight</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     do</code></pre></td>
        <td class="diff"><pre><code>     do</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     bzip2 -v -9 -c $m-$v.tar > $m-$v.tar.bz2</code></pre></td>
        <td class="diff"><pre><code>     bzip2 -v -9 -c $m-$v.tar > $m-$v.tar.bz2</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     gzip -v -9 -c $m-$v.tar > $m-$v.tar.gz</code></pre></td>
        <td class="diff"><pre><code>     gzip -v -9 -c $m-$v.tar > $m-$v.tar.gz</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     done</code></pre></td>
        <td class="diff"><pre><code>     done</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     $</code></pre></td>
        <td class="diff"><pre><code>     $</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>Note:</code></pre></td>
        <td class="diff"><pre><code>Note:</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>   * A pipe such as `bunzip2 < xxx.bz2 | gzip -9 > xxx.gz' is not since,</code></pre></td>
        <td class="diff"><pre><code>   * A pipe such as `bunzip2 < xxx.bz2 | gzip -9 > xxx.gz' is not since,</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     in that mode, `gzip' does not know the name of the file and, hence,</code></pre></td>
        <td class="diff"><pre><code>     in that mode, `gzip' does not know the name of the file and, hence,</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     can not include it in the compressed file.  This is also why the</code></pre></td>
        <td class="diff"><pre><code>     can not include it in the compressed file.  This is also why the</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     release process runs `tar' and `bzip2' as separate passes.</code></pre></td>
        <td class="diff"><pre><code>     release process runs `tar' and `bzip2' as separate passes.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>18.6.2 Sanity check the tar ball</code></pre></td>
        <td class="diff"><pre><code>18.6.2 Sanity check the tar ball</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>--------------------------------</code></pre></td>
        <td class="diff"><pre><code>--------------------------------</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>Pick a popular machine (Solaris/PPC?) and try the build on that.</code></pre></td>
        <td class="diff"><pre><code>Pick a popular machine (Solaris/PPC?) and try the build on that.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     $  bunzip2 < gdb-5.2.tar.bz2 | tar xpf -</code></pre></td>
        <td class="diff"><pre><code>     $  bunzip2 < gdb-5.2.tar.bz2 | tar xpf -</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     $  cd gdb-5.2</code></pre></td>
        <td class="diff"><pre><code>     $  cd gdb-5.2</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     $  ./configure</code></pre></td>
        <td class="diff"><pre><code>     $  ./configure</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     $  make</code></pre></td>
        <td class="diff"><pre><code>     $  make</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     ...</code></pre></td>
        <td class="diff"><pre><code>     ...</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     $  ./gdb/gdb ./gdb/gdb</code></pre></td>
        <td class="diff"><pre><code>     $  ./gdb/gdb ./gdb/gdb</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     GNU gdb 5.2</code></pre></td>
        <td class="diff"><pre><code>     GNU gdb 5.2</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     ...</code></pre></td>
        <td class="diff"><pre><code>     ...</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     (gdb)  b main</code></pre></td>
        <td class="diff"><pre><code>     (gdb)  b main</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     Breakpoint 1 at 0x80732bc: file main.c, line 734.</code></pre></td>
        <td class="diff"><pre><code>     Breakpoint 1 at 0x80732bc: file main.c, line 734.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     (gdb)  run</code></pre></td>
        <td class="diff"><pre><code>     (gdb)  run</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     Starting program: /tmp/gdb-5.2/gdb/gdb</code></pre></td>
        <td class="diff"><pre><code>     Starting program: /tmp/gdb-5.2/gdb/gdb</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     Breakpoint 1, main (argc=1, argv=0xbffff8b4) at main.c:734</code></pre></td>
        <td class="diff"><pre><code>     Breakpoint 1, main (argc=1, argv=0xbffff8b4) at main.c:734</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     734       catch_errors (captured_main, &args, "", RETURN_MASK_ALL);</code></pre></td>
        <td class="diff"><pre><code>     734       catch_errors (captured_main, &args, "", RETURN_MASK_ALL);</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     (gdb)  print args</code></pre></td>
        <td class="diff"><pre><code>     (gdb)  print args</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     $1 = {argc = 136426532, argv = 0x821b7f0}</code></pre></td>
        <td class="diff"><pre><code>     $1 = {argc = 136426532, argv = 0x821b7f0}</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     (gdb)</code></pre></td>
        <td class="diff"><pre><code>     (gdb)</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>18.6.3 Make a release candidate available</code></pre></td>
        <td class="diff"><pre><code>18.6.3 Make a release candidate available</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>-----------------------------------------</code></pre></td>
        <td class="diff"><pre><code>-----------------------------------------</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>If this is a release candidate then the only remaining steps are:</code></pre></td>
        <td class="diff"><pre><code>If this is a release candidate then the only remaining steps are:</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>  1. Commit `version.in' and `ChangeLog'</code></pre></td>
        <td class="diff"><pre><code>  1. Commit `version.in' and `ChangeLog'</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>  2. Tweak `version.in' (and `ChangeLog' to read L.M.N-0000-00-00-cvs</code></pre></td>
        <td class="diff"><pre><code>  2. Tweak `version.in' (and `ChangeLog' to read L.M.N-0000-00-00-cvs</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     so that the version update process can restart.</code></pre></td>
        <td class="diff"><pre><code>     so that the version update process can restart.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>  3. Make the release candidate available in</code></pre></td>
        <td class="diff"><pre><code>  3. Make the release candidate available in</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     `ftp://sources.redhat.com/pub/gdb/snapshots/branch'</code></pre></td>
        <td class="diff"><pre><code>     `ftp://sources.redhat.com/pub/gdb/snapshots/branch'</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>  4. Notify the relevant mailing lists ( <gdb@sources.redhat.com> and</code></pre></td>
        <td class="diff"><pre><code>  4. Notify the relevant mailing lists ( <gdb@sources.redhat.com> and</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     <gdb-testers@sources.redhat.com> that the candidate is available.</code></pre></td>
        <td class="diff"><pre><code>     <gdb-testers@sources.redhat.com> that the candidate is available.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>18.6.4 Make a formal release available</code></pre></td>
        <td class="diff"><pre><code>18.6.4 Make a formal release available</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>--------------------------------------</code></pre></td>
        <td class="diff"><pre><code>--------------------------------------</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>(And you thought all that was required was to post an e-mail.)</code></pre></td>
        <td class="diff"><pre><code>(And you thought all that was required was to post an e-mail.)</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>Install on sware</code></pre></td>
        <td class="diff"><pre><code>Install on sware</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>................</code></pre></td>
        <td class="diff"><pre><code>................</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>Copy the new files to both the release and the old release directory:</code></pre></td>
        <td class="diff"><pre><code>Copy the new files to both the release and the old release directory:</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     $  cp *.bz2 *.gz ~ftp/pub/gdb/old-releases/</code></pre></td>
        <td class="diff"><pre><code>     $  cp *.bz2 *.gz ~ftp/pub/gdb/old-releases/</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     $  cp *.bz2 *.gz ~ftp/pub/gdb/releases</code></pre></td>
        <td class="diff"><pre><code>     $  cp *.bz2 *.gz ~ftp/pub/gdb/releases</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>Clean up the releases directory so that only the most recent releases</code></pre></td>
        <td class="diff"><pre><code>Clean up the releases directory so that only the most recent releases</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>are available (e.g. keep 5.2 and 5.2.1 but remove 5.1):</code></pre></td>
        <td class="diff"><pre><code>are available (e.g. keep 5.2 and 5.2.1 but remove 5.1):</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     $  cd ~ftp/pub/gdb/releases</code></pre></td>
        <td class="diff"><pre><code>     $  cd ~ftp/pub/gdb/releases</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     $  rm ...</code></pre></td>
        <td class="diff"><pre><code>     $  rm ...</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>Update the file `README' and `.message' in the releases directory:</code></pre></td>
        <td class="diff"><pre><code>Update the file `README' and `.message' in the releases directory:</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     $  vi README</code></pre></td>
        <td class="diff"><pre><code>     $  vi README</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     ...</code></pre></td>
        <td class="diff"><pre><code>     ...</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     $  rm -f .message</code></pre></td>
        <td class="diff"><pre><code>     $  rm -f .message</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     $  ln README .message</code></pre></td>
        <td class="diff"><pre><code>     $  ln README .message</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>Update the web pages.</code></pre></td>
        <td class="diff"><pre><code>Update the web pages.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>.....................</code></pre></td>
        <td class="diff"><pre><code>.....................</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>`htdocs/download/ANNOUNCEMENT'</code></pre></td>
        <td class="diff"><pre><code>`htdocs/download/ANNOUNCEMENT'</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     This file, which is posted as the official announcement, includes:</code></pre></td>
        <td class="diff"><pre><code>     This file, which is posted as the official announcement, includes:</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>        * General announcement.</code></pre></td>
        <td class="diff"><pre><code>        * General announcement.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>        * News.  If making an M.N.1 release, retain the news from</code></pre></td>
        <td class="diff"><pre><code>        * News.  If making an M.N.1 release, retain the news from</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>          earlier M.N release.</code></pre></td>
        <td class="diff"><pre><code>          earlier M.N release.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>        * Errata.</code></pre></td>
        <td class="diff"><pre><code>        * Errata.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>`htdocs/index.html'</code></pre></td>
        <td class="diff"><pre><code>`htdocs/index.html'</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>`htdocs/news/index.html'</code></pre></td>
        <td class="diff"><pre><code>`htdocs/news/index.html'</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>`htdocs/download/index.html'</code></pre></td>
        <td class="diff"><pre><code>`htdocs/download/index.html'</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     These files include:</code></pre></td>
        <td class="diff"><pre><code>     These files include:</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>        * Announcement of the most recent release.</code></pre></td>
        <td class="diff"><pre><code>        * Announcement of the most recent release.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>        * News entry (remember to update both the top level and the</code></pre></td>
        <td class="diff"><pre><code>        * News entry (remember to update both the top level and the</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>          news directory).</code></pre></td>
        <td class="diff"><pre><code>          news directory).</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     These pages also need to be regenerate using `index.sh'.</code></pre></td>
        <td class="diff"><pre><code>     These pages also need to be regenerate using `index.sh'.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>`download/onlinedocs/'</code></pre></td>
        <td class="diff"><pre><code>`download/onlinedocs/'</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     You need to find the magic command that is used to generate the</code></pre></td>
        <td class="diff"><pre><code>     You need to find the magic command that is used to generate the</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     online docs from the `.tar.bz2'.  The best way is to look in the</code></pre></td>
        <td class="diff"><pre><code>     online docs from the `.tar.bz2'.  The best way is to look in the</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     output from one of the nightly `cron' jobs and then just edit</code></pre></td>
        <td class="diff"><pre><code>     output from one of the nightly `cron' jobs and then just edit</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     accordingly.  Something like:</code></pre></td>
        <td class="diff"><pre><code>     accordingly.  Something like:</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>          $  ~/ss/update-web-docs \</code></pre></td>
        <td class="diff"><pre><code>          $  ~/ss/update-web-docs \</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>           ~ftp/pub/gdb/releases/gdb-5.2.tar.bz2 \</code></pre></td>
        <td class="diff"><pre><code>           ~ftp/pub/gdb/releases/gdb-5.2.tar.bz2 \</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>           $PWD/www \</code></pre></td>
        <td class="diff"><pre><code>           $PWD/www \</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>           /www/sourceware/htdocs/gdb/download/onlinedocs \</code></pre></td>
        <td class="diff"><pre><code>           /www/sourceware/htdocs/gdb/download/onlinedocs \</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>           gdb</code></pre></td>
        <td class="diff"><pre><code>           gdb</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>`download/ari/'</code></pre></td>
        <td class="diff"><pre><code>`download/ari/'</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     Just like the online documentation.  Something like:</code></pre></td>
        <td class="diff"><pre><code>     Just like the online documentation.  Something like:</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>          $  /bin/sh ~/ss/update-web-ari \</code></pre></td>
        <td class="diff"><pre><code>          $  /bin/sh ~/ss/update-web-ari \</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>           ~ftp/pub/gdb/releases/gdb-5.2.tar.bz2 \</code></pre></td>
        <td class="diff"><pre><code>           ~ftp/pub/gdb/releases/gdb-5.2.tar.bz2 \</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>           $PWD/www \</code></pre></td>
        <td class="diff"><pre><code>           $PWD/www \</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>           /www/sourceware/htdocs/gdb/download/ari \</code></pre></td>
        <td class="diff"><pre><code>           /www/sourceware/htdocs/gdb/download/ari \</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>           gdb</code></pre></td>
        <td class="diff"><pre><code>           gdb</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>Shadow the pages onto gnu</code></pre></td>
        <td class="diff"><pre><code>Shadow the pages onto gnu</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>.........................</code></pre></td>
        <td class="diff"><pre><code>.........................</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>Something goes here.</code></pre></td>
        <td class="diff"><pre><code>Something goes here.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>Install the GDB tar ball on GNU</code></pre></td>
        <td class="diff"><pre><code>Install the GDB tar ball on GNU</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>...............................</code></pre></td>
        <td class="diff"><pre><code>...............................</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>At the time of writing, the GNU machine was `gnudist.gnu.org' in</code></pre></td>
        <td class="diff"><pre><code>At the time of writing, the GNU machine was `gnudist.gnu.org' in</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>`~ftp/gnu/gdb'.</code></pre></td>
        <td class="diff"><pre><code>`~ftp/gnu/gdb'.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>Make the `ANNOUNCEMENT'</code></pre></td>
        <td class="diff"><pre><code>Make the `ANNOUNCEMENT'</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>.......................</code></pre></td>
        <td class="diff"><pre><code>.......................</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>Post the `ANNOUNCEMENT' file you created above to:</code></pre></td>
        <td class="diff"><pre><code>Post the `ANNOUNCEMENT' file you created above to:</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>   * GDB Announcement mailing list <gdb-announce@sources.redhat.com></code></pre></td>
        <td class="diff"><pre><code>   * GDB Announcement mailing list <gdb-announce@sources.redhat.com></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>   * General GNU Announcement list <info-gnu@gnu.org> (but delay it a</code></pre></td>
        <td class="diff"><pre><code>   * General GNU Announcement list <info-gnu@gnu.org> (but delay it a</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     day or so to let things get out)</code></pre></td>
        <td class="diff"><pre><code>     day or so to let things get out)</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>   * GDB Bug Report mailing list <bug-gdb@gnu.org></code></pre></td>
        <td class="diff"><pre><code>   * GDB Bug Report mailing list <bug-gdb@gnu.org></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>18.6.5 Cleanup</code></pre></td>
        <td class="diff"><pre><code>18.6.5 Cleanup</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>--------------</code></pre></td>
        <td class="diff"><pre><code>--------------</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>The release is out but you're still not finished.</code></pre></td>
        <td class="diff"><pre><code>The release is out but you're still not finished.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>Commit outstanding changes</code></pre></td>
        <td class="diff"><pre><code>Commit outstanding changes</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>..........................</code></pre></td>
        <td class="diff"><pre><code>..........................</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>In particular you'll need to commit any changes to:</code></pre></td>
        <td class="diff"><pre><code>In particular you'll need to commit any changes to:</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>   * `gdb/ChangeLog'</code></pre></td>
        <td class="diff"><pre><code>   * `gdb/ChangeLog'</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>   * `gdb/version.in'</code></pre></td>
        <td class="diff"><pre><code>   * `gdb/version.in'</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>   * `gdb/NEWS'</code></pre></td>
        <td class="diff"><pre><code>   * `gdb/NEWS'</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>   * `gdb/README'</code></pre></td>
        <td class="diff"><pre><code>   * `gdb/README'</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>Tag the release</code></pre></td>
        <td class="diff"><pre><code>Tag the release</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>...............</code></pre></td>
        <td class="diff"><pre><code>...............</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>Something like:</code></pre></td>
        <td class="diff"><pre><code>Something like:</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     $  d=`date -u +%Y-%m-%d`</code></pre></td>
        <td class="diff"><pre><code>     $  d=`date -u +%Y-%m-%d`</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     $  echo $d</code></pre></td>
        <td class="diff"><pre><code>     $  echo $d</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     2002-01-24</code></pre></td>
        <td class="diff"><pre><code>     2002-01-24</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     $  ( cd insight/src/gdb && cvs -f -q update )</code></pre></td>
        <td class="diff"><pre><code>     $  ( cd insight/src/gdb && cvs -f -q update )</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     $  ( cd insight/src && cvs -f -q tag gdb_5_2-$d-release )</code></pre></td>
        <td class="diff"><pre><code>     $  ( cd insight/src && cvs -f -q tag gdb_5_2-$d-release )</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>   Insight is used since that contains more of the release than GDB.</code></pre></td>
        <td class="diff"><pre><code>   Insight is used since that contains more of the release than GDB.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>Mention the release on the trunk</code></pre></td>
        <td class="diff"><pre><code>Mention the release on the trunk</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>................................</code></pre></td>
        <td class="diff"><pre><code>................................</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>Just put something in the `ChangeLog' so that the trunk also indicates</code></pre></td>
        <td class="diff"><pre><code>Just put something in the `ChangeLog' so that the trunk also indicates</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>when the release was made.</code></pre></td>
        <td class="diff"><pre><code>when the release was made.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>Restart `gdb/version.in'</code></pre></td>
        <td class="diff"><pre><code>Restart `gdb/version.in'</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>........................</code></pre></td>
        <td class="diff"><pre><code>........................</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>If `gdb/version.in' does not contain an ISO date such as `2002-01-24'</code></pre></td>
        <td class="diff"><pre><code>If `gdb/version.in' does not contain an ISO date such as `2002-01-24'</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>then the daily `cronjob' won't update it.  Having committed all the</code></pre></td>
        <td class="diff"><pre><code>then the daily `cronjob' won't update it.  Having committed all the</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>release changes it can be set to `5.2.0_0000-00-00-cvs' which will</code></pre></td>
        <td class="diff"><pre><code>release changes it can be set to `5.2.0_0000-00-00-cvs' which will</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>restart things (yes the `_' is important - it affects the snapshot</code></pre></td>
        <td class="diff"><pre><code>restart things (yes the `_' is important - it affects the snapshot</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>process).</code></pre></td>
        <td class="diff"><pre><code>process).</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>   Don't forget the `ChangeLog'.</code></pre></td>
        <td class="diff"><pre><code>   Don't forget the `ChangeLog'.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>Merge into trunk</code></pre></td>
        <td class="diff"><pre><code>Merge into trunk</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>................</code></pre></td>
        <td class="diff"><pre><code>................</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>The files committed to the branch may also need changes merged into the</code></pre></td>
        <td class="diff"><pre><code>The files committed to the branch may also need changes merged into the</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>trunk.</code></pre></td>
        <td class="diff"><pre><code>trunk.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>Revise the release schedule</code></pre></td>
        <td class="diff"><pre><code>Revise the release schedule</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>...........................</code></pre></td>
        <td class="diff"><pre><code>...........................</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>Post a revised release schedule to GDB Discussion List</code></pre></td>
        <td class="diff"><pre><code>Post a revised release schedule to GDB Discussion List</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code><gdb@sources.redhat.com> with an updated announcement.  The schedule</code></pre></td>
        <td class="diff"><pre><code><gdb@sources.redhat.com> with an updated announcement.  The schedule</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>can be generated by running:</code></pre></td>
        <td class="diff"><pre><code>can be generated by running:</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     $  ~/ss/schedule `date +%s` schedule</code></pre></td>
        <td class="diff"><pre><code>     $  ~/ss/schedule `date +%s` schedule</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>The first parameter is approximate date/time in seconds (from the epoch)</code></pre></td>
        <td class="diff"><pre><code>The first parameter is approximate date/time in seconds (from the epoch)</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>of the most recent release.</code></pre></td>
        <td class="diff"><pre><code>of the most recent release.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>   Also update the schedule `cronjob'.</code></pre></td>
        <td class="diff"><pre><code>   Also update the schedule `cronjob'.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>18.7 Post release</code></pre></td>
        <td class="diff"><pre><code>18.7 Post release</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>=================</code></pre></td>
        <td class="diff"><pre><code>=================</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>Remove any `OBSOLETE' code.</code></pre></td>
        <td class="diff"><pre><code>Remove any `OBSOLETE' code.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>File: gdbint.info,  Node: Testsuite,  Next: Hints,  Prev: Releasing GDB,  Up: Top</code></pre></td>
        <td class="diff"><pre><code>File: gdbint.info,  Node: Testsuite,  Next: Hints,  Prev: Releasing GDB,  Up: Top</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>19 Testsuite</code></pre></td>
        <td class="diff"><pre><code>19 Testsuite</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>************</code></pre></td>
        <td class="diff"><pre><code>************</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>The testsuite is an important component of the GDB package.  While it</code></pre></td>
        <td class="diff"><pre><code>The testsuite is an important component of the GDB package.  While it</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>is always worthwhile to encourage user testing, in practice this is</code></pre></td>
        <td class="diff"><pre><code>is always worthwhile to encourage user testing, in practice this is</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>rarely sufficient; users typically use only a small subset of the</code></pre></td>
        <td class="diff"><pre><code>rarely sufficient; users typically use only a small subset of the</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>available commands, and it has proven all too common for a change to</code></pre></td>
        <td class="diff"><pre><code>available commands, and it has proven all too common for a change to</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>cause a significant regression that went unnoticed for some time.</code></pre></td>
        <td class="diff"><pre><code>cause a significant regression that went unnoticed for some time.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>   The GDB testsuite uses the DejaGNU testing framework.  The tests</code></pre></td>
        <td class="diff"><pre><code>   The GDB testsuite uses the DejaGNU testing framework.  The tests</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>themselves are calls to various `Tcl' procs; the framework runs all the</code></pre></td>
        <td class="diff"><pre><code>themselves are calls to various `Tcl' procs; the framework runs all the</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>procs and summarizes the passes and fails.</code></pre></td>
        <td class="diff"><pre><code>procs and summarizes the passes and fails.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>19.1 Using the Testsuite</code></pre></td>
        <td class="diff"><pre><code>19.1 Using the Testsuite</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>========================</code></pre></td>
        <td class="diff"><pre><code>========================</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>To run the testsuite, simply go to the GDB object directory (or to the</code></pre></td>
        <td class="diff"><pre><code>To run the testsuite, simply go to the GDB object directory (or to the</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>testsuite's objdir) and type `make check'.  This just sets up some</code></pre></td>
        <td class="diff"><pre><code>testsuite's objdir) and type `make check'.  This just sets up some</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>environment variables and invokes DejaGNU's `runtest' script.  While</code></pre></td>
        <td class="diff"><pre><code>environment variables and invokes DejaGNU's `runtest' script.  While</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>the testsuite is running, you'll get mentions of which test file is in</code></pre></td>
        <td class="diff"><pre><code>the testsuite is running, you'll get mentions of which test file is in</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>use, and a mention of any unexpected passes or fails.  When the</code></pre></td>
        <td class="diff"><pre><code>use, and a mention of any unexpected passes or fails.  When the</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>testsuite is finished, you'll get a summary that looks like this:</code></pre></td>
        <td class="diff"><pre><code>testsuite is finished, you'll get a summary that looks like this:</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>                     === gdb Summary ===</code></pre></td>
        <td class="diff"><pre><code>                     === gdb Summary ===</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     # of expected passes            6016</code></pre></td>
        <td class="diff"><pre><code>     # of expected passes            6016</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     # of unexpected failures        58</code></pre></td>
        <td class="diff"><pre><code>     # of unexpected failures        58</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     # of unexpected successes       5</code></pre></td>
        <td class="diff"><pre><code>     # of unexpected successes       5</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     # of expected failures          183</code></pre></td>
        <td class="diff"><pre><code>     # of expected failures          183</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     # of unresolved testcases       3</code></pre></td>
        <td class="diff"><pre><code>     # of unresolved testcases       3</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     # of untested testcases         5</code></pre></td>
        <td class="diff"><pre><code>     # of untested testcases         5</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>   To run a specific test script, type:</code></pre></td>
        <td class="diff"><pre><code>   To run a specific test script, type:</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     make check RUNTESTFLAGS='TESTS'</code></pre></td>
        <td class="diff"><pre><code>     make check RUNTESTFLAGS='TESTS'</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>   where TESTS is a list of test script file names, separated by spaces.</code></pre></td>
        <td class="diff"><pre><code>   where TESTS is a list of test script file names, separated by spaces.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>   The ideal test run consists of expected passes only; however, reality</code></pre></td>
        <td class="diff"><pre><code>   The ideal test run consists of expected passes only; however, reality</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>conspires to keep us from this ideal.  Unexpected failures indicate</code></pre></td>
        <td class="diff"><pre><code>conspires to keep us from this ideal.  Unexpected failures indicate</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>real problems, whether in GDB or in the testsuite.  Expected failures</code></pre></td>
        <td class="diff"><pre><code>real problems, whether in GDB or in the testsuite.  Expected failures</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>are still failures, but ones which have been decided are too hard to</code></pre></td>
        <td class="diff"><pre><code>are still failures, but ones which have been decided are too hard to</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>deal with at the time; for instance, a test case might work everywhere</code></pre></td>
        <td class="diff"><pre><code>deal with at the time; for instance, a test case might work everywhere</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>except on AIX, and there is no prospect of the AIX case being fixed in</code></pre></td>
        <td class="diff"><pre><code>except on AIX, and there is no prospect of the AIX case being fixed in</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>the near future.  Expected failures should not be added lightly, since</code></pre></td>
        <td class="diff"><pre><code>the near future.  Expected failures should not be added lightly, since</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>you may be masking serious bugs in GDB.  Unexpected successes are</code></pre></td>
        <td class="diff"><pre><code>you may be masking serious bugs in GDB.  Unexpected successes are</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>expected fails that are passing for some reason, while unresolved and</code></pre></td>
        <td class="diff"><pre><code>expected fails that are passing for some reason, while unresolved and</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>untested cases often indicate some minor catastrophe, such as the</code></pre></td>
        <td class="diff"><pre><code>untested cases often indicate some minor catastrophe, such as the</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>compiler being unable to deal with a test program.</code></pre></td>
        <td class="diff"><pre><code>compiler being unable to deal with a test program.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>   When making any significant change to GDB, you should run the</code></pre></td>
        <td class="diff"><pre><code>   When making any significant change to GDB, you should run the</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>testsuite before and after the change, to confirm that there are no</code></pre></td>
        <td class="diff"><pre><code>testsuite before and after the change, to confirm that there are no</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>regressions.  Note that truly complete testing would require that you</code></pre></td>
        <td class="diff"><pre><code>regressions.  Note that truly complete testing would require that you</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>run the testsuite with all supported configurations and a variety of</code></pre></td>
        <td class="diff"><pre><code>run the testsuite with all supported configurations and a variety of</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>compilers; however this is more than really necessary.  In many cases</code></pre></td>
        <td class="diff"><pre><code>compilers; however this is more than really necessary.  In many cases</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>testing with a single configuration is sufficient.  Other useful</code></pre></td>
        <td class="diff"><pre><code>testing with a single configuration is sufficient.  Other useful</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>options are to test one big-endian (Sparc) and one little-endian (x86)</code></pre></td>
        <td class="diff"><pre><code>options are to test one big-endian (Sparc) and one little-endian (x86)</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>host, a cross config with a builtin simulator (powerpc-eabi, mips-elf),</code></pre></td>
        <td class="diff"><pre><code>host, a cross config with a builtin simulator (powerpc-eabi, mips-elf),</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>or a 64-bit host (Alpha).</code></pre></td>
        <td class="diff"><pre><code>or a 64-bit host (Alpha).</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>   If you add new functionality to GDB, please consider adding tests</code></pre></td>
        <td class="diff"><pre><code>   If you add new functionality to GDB, please consider adding tests</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>for it as well; this way future GDB hackers can detect and fix their</code></pre></td>
        <td class="diff"><pre><code>for it as well; this way future GDB hackers can detect and fix their</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>changes that break the functionality you added.  Similarly, if you fix</code></pre></td>
        <td class="diff"><pre><code>changes that break the functionality you added.  Similarly, if you fix</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>a bug that was not previously reported as a test failure, please add a</code></pre></td>
        <td class="diff"><pre><code>a bug that was not previously reported as a test failure, please add a</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>test case for it.  Some cases are extremely difficult to test, such as</code></pre></td>
        <td class="diff"><pre><code>test case for it.  Some cases are extremely difficult to test, such as</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>code that handles host OS failures or bugs in particular versions of</code></pre></td>
        <td class="diff"><pre><code>code that handles host OS failures or bugs in particular versions of</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>compilers, and it's OK not to try to write tests for all of those.</code></pre></td>
        <td class="diff"><pre><code>compilers, and it's OK not to try to write tests for all of those.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>   DejaGNU supports separate build, host, and target machines.  However,</code></pre></td>
        <td class="diff"><pre><code>   DejaGNU supports separate build, host, and target machines.  However,</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>some GDB test scripts do not work if the build machine and the host</code></pre></td>
        <td class="diff"><pre><code>some GDB test scripts do not work if the build machine and the host</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>machine are not the same.  In such an environment, these scripts will</code></pre></td>
        <td class="diff"><pre><code>machine are not the same.  In such an environment, these scripts will</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>give a result of "UNRESOLVED", like this:</code></pre></td>
        <td class="diff"><pre><code>give a result of "UNRESOLVED", like this:</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     UNRESOLVED: gdb.base/example.exp: This test script does not work on a remote host.</code></pre></td>
        <td class="diff"><pre><code>     UNRESOLVED: gdb.base/example.exp: This test script does not work on a remote host.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>19.2 Testsuite Organization</code></pre></td>
        <td class="diff"><pre><code>19.2 Testsuite Organization</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>===========================</code></pre></td>
        <td class="diff"><pre><code>===========================</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>The testsuite is entirely contained in `gdb/testsuite'.  While the</code></pre></td>
        <td class="diff"><pre><code>The testsuite is entirely contained in `gdb/testsuite'.  While the</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>testsuite includes some makefiles and configury, these are very minimal,</code></pre></td>
        <td class="diff"><pre><code>testsuite includes some makefiles and configury, these are very minimal,</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>and used for little besides cleaning up, since the tests themselves</code></pre></td>
        <td class="diff"><pre><code>and used for little besides cleaning up, since the tests themselves</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>handle the compilation of the programs that GDB will run.  The file</code></pre></td>
        <td class="diff"><pre><code>handle the compilation of the programs that GDB will run.  The file</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>`testsuite/lib/gdb.exp' contains common utility procs useful for all</code></pre></td>
        <td class="diff"><pre><code>`testsuite/lib/gdb.exp' contains common utility procs useful for all</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>GDB tests, while the directory `testsuite/config' contains</code></pre></td>
        <td class="diff"><pre><code>GDB tests, while the directory `testsuite/config' contains</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>configuration-specific files, typically used for special-purpose</code></pre></td>
        <td class="diff"><pre><code>configuration-specific files, typically used for special-purpose</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>definitions of procs like `gdb_load' and `gdb_start'.</code></pre></td>
        <td class="diff"><pre><code>definitions of procs like `gdb_load' and `gdb_start'.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>   The tests themselves are to be found in `testsuite/gdb.*' and</code></pre></td>
        <td class="diff"><pre><code>   The tests themselves are to be found in `testsuite/gdb.*' and</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>subdirectories of those.  The names of the test files must always end</code></pre></td>
        <td class="diff"><pre><code>subdirectories of those.  The names of the test files must always end</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>with `.exp'.  DejaGNU collects the test files by wildcarding in the</code></pre></td>
        <td class="diff"><pre><code>with `.exp'.  DejaGNU collects the test files by wildcarding in the</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>test directories, so both subdirectories and individual files get</code></pre></td>
        <td class="diff"><pre><code>test directories, so both subdirectories and individual files get</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>chosen and run in alphabetical order.</code></pre></td>
        <td class="diff"><pre><code>chosen and run in alphabetical order.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>   The following table lists the main types of subdirectories and what</code></pre></td>
        <td class="diff"><pre><code>   The following table lists the main types of subdirectories and what</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>they are for.  Since DejaGNU finds test files no matter where they are</code></pre></td>
        <td class="diff"><pre><code>they are for.  Since DejaGNU finds test files no matter where they are</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>located, and since each test file sets up its own compilation and</code></pre></td>
        <td class="diff"><pre><code>located, and since each test file sets up its own compilation and</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>execution environment, this organization is simply for convenience and</code></pre></td>
        <td class="diff"><pre><code>execution environment, this organization is simply for convenience and</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>intelligibility.</code></pre></td>
        <td class="diff"><pre><code>intelligibility.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>`gdb.base'</code></pre></td>
        <td class="diff"><pre><code>`gdb.base'</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     This is the base testsuite.  The tests in it should apply to all</code></pre></td>
        <td class="diff"><pre><code>     This is the base testsuite.  The tests in it should apply to all</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     configurations of GDB (but generic native-only tests may live</code></pre></td>
        <td class="diff"><pre><code>     configurations of GDB (but generic native-only tests may live</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     here).  The test programs should be in the subset of C that is</code></pre></td>
        <td class="diff"><pre><code>     here).  The test programs should be in the subset of C that is</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     valid K&R, ANSI/ISO, and C++ (`#ifdef's are allowed if necessary,</code></pre></td>
        <td class="diff"><pre><code>     valid K&R, ANSI/ISO, and C++ (`#ifdef's are allowed if necessary,</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     for instance for prototypes).</code></pre></td>
        <td class="diff"><pre><code>     for instance for prototypes).</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>`gdb.LANG'</code></pre></td>
        <td class="diff"><pre><code>`gdb.LANG'</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     Language-specific tests for any language LANG besides C.  Examples</code></pre></td>
        <td class="diff"><pre><code>     Language-specific tests for any language LANG besides C.  Examples</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     are `gdb.cp' and `gdb.java'.</code></pre></td>
        <td class="diff"><pre><code>     are `gdb.cp' and `gdb.java'.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>`gdb.PLATFORM'</code></pre></td>
        <td class="diff"><pre><code>`gdb.PLATFORM'</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     Non-portable tests.  The tests are specific to a specific</code></pre></td>
        <td class="diff"><pre><code>     Non-portable tests.  The tests are specific to a specific</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     configuration (host or target), such as HP-UX or eCos.  Example is</code></pre></td>
        <td class="diff"><pre><code>     configuration (host or target), such as HP-UX or eCos.  Example is</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     `gdb.hp', for HP-UX.</code></pre></td>
        <td class="diff"><pre><code>     `gdb.hp', for HP-UX.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>`gdb.COMPILER'</code></pre></td>
        <td class="diff"><pre><code>`gdb.COMPILER'</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     Tests specific to a particular compiler.  As of this writing (June</code></pre></td>
        <td class="diff"><pre><code>     Tests specific to a particular compiler.  As of this writing (June</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     1999), there aren't currently any groups of tests in this category</code></pre></td>
        <td class="diff"><pre><code>     1999), there aren't currently any groups of tests in this category</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     that couldn't just as sensibly be made platform-specific, but one</code></pre></td>
        <td class="diff"><pre><code>     that couldn't just as sensibly be made platform-specific, but one</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     could imagine a `gdb.gcc', for tests of GDB's handling of GCC</code></pre></td>
        <td class="diff"><pre><code>     could imagine a `gdb.gcc', for tests of GDB's handling of GCC</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     extensions.</code></pre></td>
        <td class="diff"><pre><code>     extensions.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>`gdb.SUBSYSTEM'</code></pre></td>
        <td class="diff"><pre><code>`gdb.SUBSYSTEM'</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     Tests that exercise a specific GDB subsystem in more depth.  For</code></pre></td>
        <td class="diff"><pre><code>     Tests that exercise a specific GDB subsystem in more depth.  For</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     instance, `gdb.disasm' exercises various disassemblers, while</code></pre></td>
        <td class="diff"><pre><code>     instance, `gdb.disasm' exercises various disassemblers, while</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     `gdb.stabs' tests pathways through the stabs symbol reader.</code></pre></td>
        <td class="diff"><pre><code>     `gdb.stabs' tests pathways through the stabs symbol reader.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>19.3 Writing Tests</code></pre></td>
        <td class="diff"><pre><code>19.3 Writing Tests</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>==================</code></pre></td>
        <td class="diff"><pre><code>==================</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>In many areas, the GDB tests are already quite comprehensive; you</code></pre></td>
        <td class="diff"><pre><code>In many areas, the GDB tests are already quite comprehensive; you</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>should be able to copy existing tests to handle new cases.</code></pre></td>
        <td class="diff"><pre><code>should be able to copy existing tests to handle new cases.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>   You should try to use `gdb_test' whenever possible, since it</code></pre></td>
        <td class="diff"><pre><code>   You should try to use `gdb_test' whenever possible, since it</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>includes cases to handle all the unexpected errors that might happen.</code></pre></td>
        <td class="diff"><pre><code>includes cases to handle all the unexpected errors that might happen.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>However, it doesn't cost anything to add new test procedures; for</code></pre></td>
        <td class="diff"><pre><code>However, it doesn't cost anything to add new test procedures; for</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>instance, `gdb.base/exprs.exp' defines a `test_expr' that calls</code></pre></td>
        <td class="diff"><pre><code>instance, `gdb.base/exprs.exp' defines a `test_expr' that calls</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>`gdb_test' multiple times.</code></pre></td>
        <td class="diff"><pre><code>`gdb_test' multiple times.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>   Only use `send_gdb' and `gdb_expect' when absolutely necessary.</code></pre></td>
        <td class="diff"><pre><code>   Only use `send_gdb' and `gdb_expect' when absolutely necessary.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>Even if GDB has several valid responses to a command, you can use</code></pre></td>
        <td class="diff"><pre><code>Even if GDB has several valid responses to a command, you can use</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>`gdb_test_multiple'.  Like `gdb_test', `gdb_test_multiple' recognizes</code></pre></td>
        <td class="diff"><pre><code>`gdb_test_multiple'.  Like `gdb_test', `gdb_test_multiple' recognizes</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>internal errors and unexpected prompts.</code></pre></td>
        <td class="diff"><pre><code>internal errors and unexpected prompts.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>   Do not write tests which expect a literal tab character from GDB.</code></pre></td>
        <td class="diff"><pre><code>   Do not write tests which expect a literal tab character from GDB.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>On some operating systems (e.g. OpenBSD) the TTY layer expands tabs to</code></pre></td>
        <td class="diff"><pre><code>On some operating systems (e.g. OpenBSD) the TTY layer expands tabs to</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>spaces, so by the time GDB's output reaches expect the tab is gone.</code></pre></td>
        <td class="diff"><pre><code>spaces, so by the time GDB's output reaches expect the tab is gone.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>   The source language programs do _not_ need to be in a consistent</code></pre></td>
        <td class="diff"><pre><code>   The source language programs do _not_ need to be in a consistent</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>style.  Since GDB is used to debug programs written in many different</code></pre></td>
        <td class="diff"><pre><code>style.  Since GDB is used to debug programs written in many different</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>styles, it's worth having a mix of styles in the testsuite; for</code></pre></td>
        <td class="diff"><pre><code>styles, it's worth having a mix of styles in the testsuite; for</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>instance, some GDB bugs involving the display of source lines would</code></pre></td>
        <td class="diff"><pre><code>instance, some GDB bugs involving the display of source lines would</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>never manifest themselves if the programs used GNU coding style</code></pre></td>
        <td class="diff"><pre><code>never manifest themselves if the programs used GNU coding style</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>uniformly.</code></pre></td>
        <td class="diff"><pre><code>uniformly.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>File: gdbint.info,  Node: Hints,  Next: GDB Observers,  Prev: Testsuite,  Up: Top</code></pre></td>
        <td class="diff"><pre><code>File: gdbint.info,  Node: Hints,  Next: GDB Observers,  Prev: Testsuite,  Up: Top</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>20 Hints</code></pre></td>
        <td class="diff"><pre><code>20 Hints</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>********</code></pre></td>
        <td class="diff"><pre><code>********</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>Check the `README' file, it often has useful information that does not</code></pre></td>
        <td class="diff"><pre><code>Check the `README' file, it often has useful information that does not</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>appear anywhere else in the directory.</code></pre></td>
        <td class="diff"><pre><code>appear anywhere else in the directory.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>* Menu:</code></pre></td>
        <td class="diff"><pre><code>* Menu:</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>* Getting Started::             Getting started working on GDB</code></pre></td>
        <td class="diff"><pre><code>* Getting Started::             Getting started working on GDB</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>* Debugging GDB::               Debugging GDB with itself</code></pre></td>
        <td class="diff"><pre><code>* Debugging GDB::               Debugging GDB with itself</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>File: gdbint.info,  Node: Getting Started,  Up: Hints</code></pre></td>
        <td class="diff"><pre><code>File: gdbint.info,  Node: Getting Started,  Up: Hints</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>20.1 Getting Started</code></pre></td>
        <td class="diff"><pre><code>20.1 Getting Started</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>====================</code></pre></td>
        <td class="diff"><pre><code>====================</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>GDB is a large and complicated program, and if you first starting to</code></pre></td>
        <td class="diff"><pre><code>GDB is a large and complicated program, and if you first starting to</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>work on it, it can be hard to know where to start.  Fortunately, if you</code></pre></td>
        <td class="diff"><pre><code>work on it, it can be hard to know where to start.  Fortunately, if you</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>know how to go about it, there are ways to figure out what is going on.</code></pre></td>
        <td class="diff"><pre><code>know how to go about it, there are ways to figure out what is going on.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>   This manual, the GDB Internals manual, has information which applies</code></pre></td>
        <td class="diff"><pre><code>   This manual, the GDB Internals manual, has information which applies</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>generally to many parts of GDB.</code></pre></td>
        <td class="diff"><pre><code>generally to many parts of GDB.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>   Information about particular functions or data structures are</code></pre></td>
        <td class="diff"><pre><code>   Information about particular functions or data structures are</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>located in comments with those functions or data structures.  If you</code></pre></td>
        <td class="diff"><pre><code>located in comments with those functions or data structures.  If you</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>run across a function or a global variable which does not have a</code></pre></td>
        <td class="diff"><pre><code>run across a function or a global variable which does not have a</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>comment correctly explaining what is does, this can be thought of as a</code></pre></td>
        <td class="diff"><pre><code>comment correctly explaining what is does, this can be thought of as a</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>bug in GDB; feel free to submit a bug report, with a suggested comment</code></pre></td>
        <td class="diff"><pre><code>bug in GDB; feel free to submit a bug report, with a suggested comment</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>if you can figure out what the comment should say.  If you find a</code></pre></td>
        <td class="diff"><pre><code>if you can figure out what the comment should say.  If you find a</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>comment which is actually wrong, be especially sure to report that.</code></pre></td>
        <td class="diff"><pre><code>comment which is actually wrong, be especially sure to report that.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>   Comments explaining the function of macros defined in host, target,</code></pre></td>
        <td class="diff"><pre><code>   Comments explaining the function of macros defined in host, target,</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>or native dependent files can be in several places.  Sometimes they are</code></pre></td>
        <td class="diff"><pre><code>or native dependent files can be in several places.  Sometimes they are</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>repeated every place the macro is defined.  Sometimes they are where the</code></pre></td>
        <td class="diff"><pre><code>repeated every place the macro is defined.  Sometimes they are where the</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>macro is used.  Sometimes there is a header file which supplies a</code></pre></td>
        <td class="diff"><pre><code>macro is used.  Sometimes there is a header file which supplies a</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>default definition of the macro, and the comment is there.  This manual</code></pre></td>
        <td class="diff"><pre><code>default definition of the macro, and the comment is there.  This manual</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>also documents all the available macros.</code></pre></td>
        <td class="diff"><pre><code>also documents all the available macros.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>   Start with the header files.  Once you have some idea of how GDB's</code></pre></td>
        <td class="diff"><pre><code>   Start with the header files.  Once you have some idea of how GDB's</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>internal symbol tables are stored (see `symtab.h', `gdbtypes.h'), you</code></pre></td>
        <td class="diff"><pre><code>internal symbol tables are stored (see `symtab.h', `gdbtypes.h'), you</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>will find it much easier to understand the code which uses and creates</code></pre></td>
        <td class="diff"><pre><code>will find it much easier to understand the code which uses and creates</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>those symbol tables.</code></pre></td>
        <td class="diff"><pre><code>those symbol tables.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>   You may wish to process the information you are getting somehow, to</code></pre></td>
        <td class="diff"><pre><code>   You may wish to process the information you are getting somehow, to</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>enhance your understanding of it.  Summarize it, translate it to another</code></pre></td>
        <td class="diff"><pre><code>enhance your understanding of it.  Summarize it, translate it to another</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>language, add some (perhaps trivial or non-useful) feature to GDB, use</code></pre></td>
        <td class="diff"><pre><code>language, add some (perhaps trivial or non-useful) feature to GDB, use</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>the code to predict what a test case would do and write the test case</code></pre></td>
        <td class="diff"><pre><code>the code to predict what a test case would do and write the test case</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>and verify your prediction, etc.  If you are reading code and your eyes</code></pre></td>
        <td class="diff"><pre><code>and verify your prediction, etc.  If you are reading code and your eyes</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>are starting to glaze over, this is a sign you need to use a more active</code></pre></td>
        <td class="diff"><pre><code>are starting to glaze over, this is a sign you need to use a more active</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>approach.</code></pre></td>
        <td class="diff"><pre><code>approach.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>   Once you have a part of GDB to start with, you can find more</code></pre></td>
        <td class="diff"><pre><code>   Once you have a part of GDB to start with, you can find more</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>specifically the part you are looking for by stepping through each</code></pre></td>
        <td class="diff"><pre><code>specifically the part you are looking for by stepping through each</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>function with the `next' command.  Do not use `step' or you will</code></pre></td>
        <td class="diff"><pre><code>function with the `next' command.  Do not use `step' or you will</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>quickly get distracted; when the function you are stepping through</code></pre></td>
        <td class="diff"><pre><code>quickly get distracted; when the function you are stepping through</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>calls another function try only to get a big-picture understanding</code></pre></td>
        <td class="diff"><pre><code>calls another function try only to get a big-picture understanding</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>(perhaps using the comment at the beginning of the function being</code></pre></td>
        <td class="diff"><pre><code>(perhaps using the comment at the beginning of the function being</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>called) of what it does.  This way you can identify which of the</code></pre></td>
        <td class="diff"><pre><code>called) of what it does.  This way you can identify which of the</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>functions being called by the function you are stepping through is the</code></pre></td>
        <td class="diff"><pre><code>functions being called by the function you are stepping through is the</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>one which you are interested in.  You may need to examine the data</code></pre></td>
        <td class="diff"><pre><code>one which you are interested in.  You may need to examine the data</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>structures generated at each stage, with reference to the comments in</code></pre></td>
        <td class="diff"><pre><code>structures generated at each stage, with reference to the comments in</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>the header files explaining what the data structures are supposed to</code></pre></td>
        <td class="diff"><pre><code>the header files explaining what the data structures are supposed to</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>look like.</code></pre></td>
        <td class="diff"><pre><code>look like.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>   Of course, this same technique can be used if you are just reading</code></pre></td>
        <td class="diff"><pre><code>   Of course, this same technique can be used if you are just reading</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>the code, rather than actually stepping through it.  The same general</code></pre></td>
        <td class="diff"><pre><code>the code, rather than actually stepping through it.  The same general</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>principle applies--when the code you are looking at calls something</code></pre></td>
        <td class="diff"><pre><code>principle applies--when the code you are looking at calls something</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>else, just try to understand generally what the code being called does,</code></pre></td>
        <td class="diff"><pre><code>else, just try to understand generally what the code being called does,</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>rather than worrying about all its details.</code></pre></td>
        <td class="diff"><pre><code>rather than worrying about all its details.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>   A good place to start when tracking down some particular area is with</code></pre></td>
        <td class="diff"><pre><code>   A good place to start when tracking down some particular area is with</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>a command which invokes that feature.  Suppose you want to know how</code></pre></td>
        <td class="diff"><pre><code>a command which invokes that feature.  Suppose you want to know how</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>single-stepping works.  As a GDB user, you know that the `step' command</code></pre></td>
        <td class="diff"><pre><code>single-stepping works.  As a GDB user, you know that the `step' command</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>invokes single-stepping.  The command is invoked via command tables</code></pre></td>
        <td class="diff"><pre><code>invokes single-stepping.  The command is invoked via command tables</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>(see `command.h'); by convention the function which actually performs</code></pre></td>
        <td class="diff"><pre><code>(see `command.h'); by convention the function which actually performs</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>the command is formed by taking the name of the command and adding</code></pre></td>
        <td class="diff"><pre><code>the command is formed by taking the name of the command and adding</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>`_command', or in the case of an `info' subcommand, `_info'.  For</code></pre></td>
        <td class="diff"><pre><code>`_command', or in the case of an `info' subcommand, `_info'.  For</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>example, the `step' command invokes the `step_command' function and the</code></pre></td>
        <td class="diff"><pre><code>example, the `step' command invokes the `step_command' function and the</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>`info display' command invokes `display_info'.  When this convention is</code></pre></td>
        <td class="diff"><pre><code>`info display' command invokes `display_info'.  When this convention is</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>not followed, you might have to use `grep' or `M-x tags-search' in</code></pre></td>
        <td class="diff"><pre><code>not followed, you might have to use `grep' or `M-x tags-search' in</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>emacs, or run GDB on itself and set a breakpoint in `execute_command'.</code></pre></td>
        <td class="diff"><pre><code>emacs, or run GDB on itself and set a breakpoint in `execute_command'.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>   If all of the above fail, it may be appropriate to ask for</code></pre></td>
        <td class="diff"><pre><code>   If all of the above fail, it may be appropriate to ask for</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>information on `bug-gdb'.  But _never_ post a generic question like "I</code></pre></td>
        <td class="diff"><pre><code>information on `bug-gdb'.  But _never_ post a generic question like "I</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>was wondering if anyone could give me some tips about understanding</code></pre></td>
        <td class="diff"><pre><code>was wondering if anyone could give me some tips about understanding</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>GDB"--if we had some magic secret we would put it in this manual.</code></pre></td>
        <td class="diff"><pre><code>GDB"--if we had some magic secret we would put it in this manual.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>Suggestions for improving the manual are always welcome, of course.</code></pre></td>
        <td class="diff"><pre><code>Suggestions for improving the manual are always welcome, of course.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>File: gdbint.info,  Node: Debugging GDB,  Up: Hints</code></pre></td>
        <td class="diff"><pre><code>File: gdbint.info,  Node: Debugging GDB,  Up: Hints</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>20.2 Debugging GDB with itself</code></pre></td>
        <td class="diff"><pre><code>20.2 Debugging GDB with itself</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>==============================</code></pre></td>
        <td class="diff"><pre><code>==============================</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>If GDB is limping on your machine, this is the preferred way to get it</code></pre></td>
        <td class="diff"><pre><code>If GDB is limping on your machine, this is the preferred way to get it</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>fully functional.  Be warned that in some ancient Unix systems, like</code></pre></td>
        <td class="diff"><pre><code>fully functional.  Be warned that in some ancient Unix systems, like</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>Ultrix 4.2, a program can't be running in one process while it is being</code></pre></td>
        <td class="diff"><pre><code>Ultrix 4.2, a program can't be running in one process while it is being</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>debugged in another.  Rather than typing the command `./gdb ./gdb',</code></pre></td>
        <td class="diff"><pre><code>debugged in another.  Rather than typing the command `./gdb ./gdb',</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>which works on Suns and such, you can copy `gdb' to `gdb2' and then</code></pre></td>
        <td class="diff"><pre><code>which works on Suns and such, you can copy `gdb' to `gdb2' and then</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>type `./gdb ./gdb2'.</code></pre></td>
        <td class="diff"><pre><code>type `./gdb ./gdb2'.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>   When you run GDB in the GDB source directory, it will read a</code></pre></td>
        <td class="diff"><pre><code>   When you run GDB in the GDB source directory, it will read a</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>`.gdbinit' file that sets up some simple things to make debugging gdb</code></pre></td>
        <td class="diff"><pre><code>`.gdbinit' file that sets up some simple things to make debugging gdb</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>easier.  The `info' command, when executed without a subcommand in a</code></pre></td>
        <td class="diff"><pre><code>easier.  The `info' command, when executed without a subcommand in a</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>GDB being debugged by gdb, will pop you back up to the top level gdb.</code></pre></td>
        <td class="diff"><pre><code>GDB being debugged by gdb, will pop you back up to the top level gdb.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>See `.gdbinit' for details.</code></pre></td>
        <td class="diff"><pre><code>See `.gdbinit' for details.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>   If you use emacs, you will probably want to do a `make TAGS' after</code></pre></td>
        <td class="diff"><pre><code>   If you use emacs, you will probably want to do a `make TAGS' after</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>you configure your distribution; this will put the machine dependent</code></pre></td>
        <td class="diff"><pre><code>you configure your distribution; this will put the machine dependent</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>routines for your local machine where they will be accessed first by</code></pre></td>
        <td class="diff"><pre><code>routines for your local machine where they will be accessed first by</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>`M-.'</code></pre></td>
        <td class="diff"><pre><code>`M-.'</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>   Also, make sure that you've either compiled GDB with your local cc,</code></pre></td>
        <td class="diff"><pre><code>   Also, make sure that you've either compiled GDB with your local cc,</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>or have run `fixincludes' if you are compiling with gcc.</code></pre></td>
        <td class="diff"><pre><code>or have run `fixincludes' if you are compiling with gcc.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>20.3 Submitting Patches</code></pre></td>
        <td class="diff"><pre><code>20.3 Submitting Patches</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>=======================</code></pre></td>
        <td class="diff"><pre><code>=======================</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>Thanks for thinking of offering your changes back to the community of</code></pre></td>
        <td class="diff"><pre><code>Thanks for thinking of offering your changes back to the community of</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>GDB users.  In general we like to get well designed enhancements.</code></pre></td>
        <td class="diff"><pre><code>GDB users.  In general we like to get well designed enhancements.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>Thanks also for checking in advance about the best way to transfer the</code></pre></td>
        <td class="diff"><pre><code>Thanks also for checking in advance about the best way to transfer the</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>changes.</code></pre></td>
        <td class="diff"><pre><code>changes.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>   The GDB maintainers will only install "cleanly designed" patches.</code></pre></td>
        <td class="diff"><pre><code>   The GDB maintainers will only install "cleanly designed" patches.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>This manual summarizes what we believe to be clean design for GDB.</code></pre></td>
        <td class="diff"><pre><code>This manual summarizes what we believe to be clean design for GDB.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>   If the maintainers don't have time to put the patch in when it</code></pre></td>
        <td class="diff"><pre><code>   If the maintainers don't have time to put the patch in when it</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>arrives, or if there is any question about a patch, it goes into a</code></pre></td>
        <td class="diff"><pre><code>arrives, or if there is any question about a patch, it goes into a</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>large queue with everyone else's patches and bug reports.</code></pre></td>
        <td class="diff"><pre><code>large queue with everyone else's patches and bug reports.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>   The legal issue is that to incorporate substantial changes requires a</code></pre></td>
        <td class="diff"><pre><code>   The legal issue is that to incorporate substantial changes requires a</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>copyright assignment from you and/or your employer, granting ownership</code></pre></td>
        <td class="diff"><pre><code>copyright assignment from you and/or your employer, granting ownership</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>of the changes to the Free Software Foundation.  You can get the</code></pre></td>
        <td class="diff"><pre><code>of the changes to the Free Software Foundation.  You can get the</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>standard documents for doing this by sending mail to `gnu@gnu.org' and</code></pre></td>
        <td class="diff"><pre><code>standard documents for doing this by sending mail to `gnu@gnu.org' and</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>asking for it.  We recommend that people write in "All programs owned</code></pre></td>
        <td class="diff"><pre><code>asking for it.  We recommend that people write in "All programs owned</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>by the Free Software Foundation" as "NAME OF PROGRAM", so that changes</code></pre></td>
        <td class="diff"><pre><code>by the Free Software Foundation" as "NAME OF PROGRAM", so that changes</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>in many programs (not just GDB, but GAS, Emacs, GCC, etc) can be</code></pre></td>
        <td class="diff"><pre><code>in many programs (not just GDB, but GAS, Emacs, GCC, etc) can be</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>contributed with only one piece of legalese pushed through the</code></pre></td>
        <td class="diff"><pre><code>contributed with only one piece of legalese pushed through the</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>bureaucracy and filed with the FSF.  We can't start merging changes</code></pre></td>
        <td class="diff"><pre><code>bureaucracy and filed with the FSF.  We can't start merging changes</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>until this paperwork is received by the FSF (their rules, which we</code></pre></td>
        <td class="diff"><pre><code>until this paperwork is received by the FSF (their rules, which we</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>follow since we maintain it for them).</code></pre></td>
        <td class="diff"><pre><code>follow since we maintain it for them).</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>   Technically, the easiest way to receive changes is to receive each</code></pre></td>
        <td class="diff"><pre><code>   Technically, the easiest way to receive changes is to receive each</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>feature as a small context diff or unidiff, suitable for `patch'.  Each</code></pre></td>
        <td class="diff"><pre><code>feature as a small context diff or unidiff, suitable for `patch'.  Each</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>message sent to me should include the changes to C code and header</code></pre></td>
        <td class="diff"><pre><code>message sent to me should include the changes to C code and header</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>files for a single feature, plus `ChangeLog' entries for each directory</code></pre></td>
        <td class="diff"><pre><code>files for a single feature, plus `ChangeLog' entries for each directory</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>where files were modified, and diffs for any changes needed to the</code></pre></td>
        <td class="diff"><pre><code>where files were modified, and diffs for any changes needed to the</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>manuals (`gdb/doc/gdb.texinfo' or `gdb/doc/gdbint.texinfo').  If there</code></pre></td>
        <td class="diff"><pre><code>manuals (`gdb/doc/gdb.texinfo' or `gdb/doc/gdbint.texinfo').  If there</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>are a lot of changes for a single feature, they can be split down into</code></pre></td>
        <td class="diff"><pre><code>are a lot of changes for a single feature, they can be split down into</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>multiple messages.</code></pre></td>
        <td class="diff"><pre><code>multiple messages.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>   In this way, if we read and like the feature, we can add it to the</code></pre></td>
        <td class="diff"><pre><code>   In this way, if we read and like the feature, we can add it to the</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>sources with a single patch command, do some testing, and check it in.</code></pre></td>
        <td class="diff"><pre><code>sources with a single patch command, do some testing, and check it in.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>If you leave out the `ChangeLog', we have to write one.  If you leave</code></pre></td>
        <td class="diff"><pre><code>If you leave out the `ChangeLog', we have to write one.  If you leave</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>out the doc, we have to puzzle out what needs documenting.  Etc., etc.</code></pre></td>
        <td class="diff"><pre><code>out the doc, we have to puzzle out what needs documenting.  Etc., etc.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>   The reason to send each change in a separate message is that we will</code></pre></td>
        <td class="diff"><pre><code>   The reason to send each change in a separate message is that we will</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>not install some of the changes.  They'll be returned to you with</code></pre></td>
        <td class="diff"><pre><code>not install some of the changes.  They'll be returned to you with</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>questions or comments.  If we're doing our job correctly, the message</code></pre></td>
        <td class="diff"><pre><code>questions or comments.  If we're doing our job correctly, the message</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>back to you will say what you have to fix in order to make the change</code></pre></td>
        <td class="diff"><pre><code>back to you will say what you have to fix in order to make the change</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>acceptable.  The reason to have separate messages for separate features</code></pre></td>
        <td class="diff"><pre><code>acceptable.  The reason to have separate messages for separate features</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>is so that the acceptable changes can be installed while one or more</code></pre></td>
        <td class="diff"><pre><code>is so that the acceptable changes can be installed while one or more</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>changes are being reworked.  If multiple features are sent in a single</code></pre></td>
        <td class="diff"><pre><code>changes are being reworked.  If multiple features are sent in a single</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>message, we tend to not put in the effort to sort out the acceptable</code></pre></td>
        <td class="diff"><pre><code>message, we tend to not put in the effort to sort out the acceptable</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>changes from the unacceptable, so none of the features get installed</code></pre></td>
        <td class="diff"><pre><code>changes from the unacceptable, so none of the features get installed</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>until all are acceptable.</code></pre></td>
        <td class="diff"><pre><code>until all are acceptable.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>   If this sounds painful or authoritarian, well, it is.  But we get a</code></pre></td>
        <td class="diff"><pre><code>   If this sounds painful or authoritarian, well, it is.  But we get a</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>lot of bug reports and a lot of patches, and many of them don't get</code></pre></td>
        <td class="diff"><pre><code>lot of bug reports and a lot of patches, and many of them don't get</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>installed because we don't have the time to finish the job that the bug</code></pre></td>
        <td class="diff"><pre><code>installed because we don't have the time to finish the job that the bug</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>reporter or the contributor could have done.  Patches that arrive</code></pre></td>
        <td class="diff"><pre><code>reporter or the contributor could have done.  Patches that arrive</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>complete, working, and well designed, tend to get installed on the day</code></pre></td>
        <td class="diff"><pre><code>complete, working, and well designed, tend to get installed on the day</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>they arrive.  The others go into a queue and get installed as time</code></pre></td>
        <td class="diff"><pre><code>they arrive.  The others go into a queue and get installed as time</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>permits, which, since the maintainers have many demands to meet, may not</code></pre></td>
        <td class="diff"><pre><code>permits, which, since the maintainers have many demands to meet, may not</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>be for quite some time.</code></pre></td>
        <td class="diff"><pre><code>be for quite some time.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>   Please send patches directly to the GDB maintainers</code></pre></td>
        <td class="diff"><pre><code>   Please send patches directly to the GDB maintainers</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code><gdb-patches@sources.redhat.com>.</code></pre></td>
        <td class="diff"><pre><code><gdb-patches@sources.redhat.com>.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>20.4 Obsolete Conditionals</code></pre></td>
        <td class="diff"><pre><code>20.4 Obsolete Conditionals</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>==========================</code></pre></td>
        <td class="diff"><pre><code>==========================</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>Fragments of old code in GDB sometimes reference or set the following</code></pre></td>
        <td class="diff"><pre><code>Fragments of old code in GDB sometimes reference or set the following</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>configuration macros.  They should not be used by new code, and old uses</code></pre></td>
        <td class="diff"><pre><code>configuration macros.  They should not be used by new code, and old uses</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>should be removed as those parts of the debugger are otherwise touched.</code></pre></td>
        <td class="diff"><pre><code>should be removed as those parts of the debugger are otherwise touched.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>`STACK_END_ADDR'</code></pre></td>
        <td class="diff"><pre><code>`STACK_END_ADDR'</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     This macro used to define where the end of the stack appeared, for</code></pre></td>
        <td class="diff"><pre><code>     This macro used to define where the end of the stack appeared, for</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     use in interpreting core file formats that don't record this</code></pre></td>
        <td class="diff"><pre><code>     use in interpreting core file formats that don't record this</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     address in the core file itself.  This information is now</code></pre></td>
        <td class="diff"><pre><code>     address in the core file itself.  This information is now</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     configured in BFD, and GDB gets the info portably from there.  The</code></pre></td>
        <td class="diff"><pre><code>     configured in BFD, and GDB gets the info portably from there.  The</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     values in GDB's configuration files should be moved into BFD</code></pre></td>
        <td class="diff"><pre><code>     values in GDB's configuration files should be moved into BFD</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     configuration files (if needed there), and deleted from all of</code></pre></td>
        <td class="diff"><pre><code>     configuration files (if needed there), and deleted from all of</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     GDB's config files.</code></pre></td>
        <td class="diff"><pre><code>     GDB's config files.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     Any `FOO-xdep.c' file that references STACK_END_ADDR is so old</code></pre></td>
        <td class="diff"><pre><code>     Any `FOO-xdep.c' file that references STACK_END_ADDR is so old</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     that it has never been converted to use BFD.  Now that's old!</code></pre></td>
        <td class="diff"><pre><code>     that it has never been converted to use BFD.  Now that's old!</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>20.5 Build Script</code></pre></td>
        <td class="diff"><pre><code>20.5 Build Script</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>=================</code></pre></td>
        <td class="diff"><pre><code>=================</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>The script `gdb_buildall.sh' builds GDB with flag</code></pre></td>
        <td class="diff"><pre><code>The script `gdb_buildall.sh' builds GDB with flag</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>`--enable-targets=all' set.  This builds GDB with all supported targets</code></pre></td>
        <td class="diff"><pre><code>`--enable-targets=all' set.  This builds GDB with all supported targets</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>activated.  This helps testing GDB when doing changes that affect more</code></pre></td>
        <td class="diff"><pre><code>activated.  This helps testing GDB when doing changes that affect more</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>than one architecture and is much faster than using `gdb_mbuild.sh'.</code></pre></td>
        <td class="diff"><pre><code>than one architecture and is much faster than using `gdb_mbuild.sh'.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>   After building GDB the script checks which architectures are</code></pre></td>
        <td class="diff"><pre><code>   After building GDB the script checks which architectures are</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>supported and then switches the current architecture to each of those</code></pre></td>
        <td class="diff"><pre><code>supported and then switches the current architecture to each of those</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>to get information about the architecture.  The test results are stored</code></pre></td>
        <td class="diff"><pre><code>to get information about the architecture.  The test results are stored</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>in log files in the directory the script was called from.</code></pre></td>
        <td class="diff"><pre><code>in log files in the directory the script was called from.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>File: gdbint.info,  Node: GDB Observers,  Next: GNU Free Documentation License,  Prev: Hints,  Up: Top</code></pre></td>
        <td class="diff"><pre><code>File: gdbint.info,  Node: GDB Observers,  Next: GNU Free Documentation License,  Prev: Hints,  Up: Top</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>Appendix A GDB Currently available observers</code></pre></td>
        <td class="diff"><pre><code>Appendix A GDB Currently available observers</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>********************************************</code></pre></td>
        <td class="diff"><pre><code>********************************************</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>A.1 Implementation rationale</code></pre></td>
        <td class="diff"><pre><code>A.1 Implementation rationale</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>============================</code></pre></td>
        <td class="diff"><pre><code>============================</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>An "observer" is an entity which is interested in being notified when</code></pre></td>
        <td class="diff"><pre><code>An "observer" is an entity which is interested in being notified when</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>GDB reaches certain states, or certain events occur in GDB.  The entity</code></pre></td>
        <td class="diff"><pre><code>GDB reaches certain states, or certain events occur in GDB.  The entity</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>being observed is called the "subject".  To receive notifications, the</code></pre></td>
        <td class="diff"><pre><code>being observed is called the "subject".  To receive notifications, the</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>observer attaches a callback to the subject.  One subject can have</code></pre></td>
        <td class="diff"><pre><code>observer attaches a callback to the subject.  One subject can have</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>several observers.</code></pre></td>
        <td class="diff"><pre><code>several observers.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>   `observer.c' implements an internal generic low-level event</code></pre></td>
        <td class="diff"><pre><code>   `observer.c' implements an internal generic low-level event</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>notification mechanism.  This generic event notification mechanism is</code></pre></td>
        <td class="diff"><pre><code>notification mechanism.  This generic event notification mechanism is</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>then re-used to implement the exported high-level notification</code></pre></td>
        <td class="diff"><pre><code>then re-used to implement the exported high-level notification</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>management routines for all possible notifications.</code></pre></td>
        <td class="diff"><pre><code>management routines for all possible notifications.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>   The current implementation of the generic observer provides support</code></pre></td>
        <td class="diff"><pre><code>   The current implementation of the generic observer provides support</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>for contextual data.  This contextual data is given to the subject when</code></pre></td>
        <td class="diff"><pre><code>for contextual data.  This contextual data is given to the subject when</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>attaching the callback.  In return, the subject will provide this</code></pre></td>
        <td class="diff"><pre><code>attaching the callback.  In return, the subject will provide this</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>contextual data back to the observer as a parameter of the callback.</code></pre></td>
        <td class="diff"><pre><code>contextual data back to the observer as a parameter of the callback.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>   Note that the current support for the contextual data is only</code></pre></td>
        <td class="diff"><pre><code>   Note that the current support for the contextual data is only</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>partial, as it lacks a mechanism that would deallocate this data when</code></pre></td>
        <td class="diff"><pre><code>partial, as it lacks a mechanism that would deallocate this data when</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>the callback is detached.  This is not a problem so far, as this</code></pre></td>
        <td class="diff"><pre><code>the callback is detached.  This is not a problem so far, as this</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>contextual data is only used internally to hold a function pointer.</code></pre></td>
        <td class="diff"><pre><code>contextual data is only used internally to hold a function pointer.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>Later on, if a certain observer needs to provide support for user-level</code></pre></td>
        <td class="diff"><pre><code>Later on, if a certain observer needs to provide support for user-level</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>contextual data, then the generic notification mechanism will need to be</code></pre></td>
        <td class="diff"><pre><code>contextual data, then the generic notification mechanism will need to be</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>enhanced to allow the observer to provide a routine to deallocate the</code></pre></td>
        <td class="diff"><pre><code>enhanced to allow the observer to provide a routine to deallocate the</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>data when attaching the callback.</code></pre></td>
        <td class="diff"><pre><code>data when attaching the callback.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>   The observer implementation is also currently not reentrant.  In</code></pre></td>
        <td class="diff"><pre><code>   The observer implementation is also currently not reentrant.  In</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>particular, it is therefore not possible to call the attach or detach</code></pre></td>
        <td class="diff"><pre><code>particular, it is therefore not possible to call the attach or detach</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>routines during a notification.</code></pre></td>
        <td class="diff"><pre><code>routines during a notification.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>A.2 Debugging</code></pre></td>
        <td class="diff"><pre><code>A.2 Debugging</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>=============</code></pre></td>
        <td class="diff"><pre><code>=============</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>Observer notifications can be traced using the command `set debug</code></pre></td>
        <td class="diff"><pre><code>Observer notifications can be traced using the command `set debug</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>observer 1' (*note Optional messages about internal happenings:</code></pre></td>
        <td class="diff"><pre><code>observer 1' (*note Optional messages about internal happenings:</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>(gdb)Debugging Output.).</code></pre></td>
        <td class="diff"><pre><code>(gdb)Debugging Output.).</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>A.3 `normal_stop' Notifications</code></pre></td>
        <td class="diff"><pre><code>A.3 `normal_stop' Notifications</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>===============================</code></pre></td>
        <td class="diff"><pre><code>===============================</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>GDB notifies all `normal_stop' observers when the inferior execution</code></pre></td>
        <td class="diff"><pre><code>GDB notifies all `normal_stop' observers when the inferior execution</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>has just stopped, the associated messages and annotations have been</code></pre></td>
        <td class="diff"><pre><code>has just stopped, the associated messages and annotations have been</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>printed, and the control is about to be returned to the user.</code></pre></td>
        <td class="diff"><pre><code>printed, and the control is about to be returned to the user.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>   Note that the `normal_stop' notification is not emitted when the</code></pre></td>
        <td class="diff"><pre><code>   Note that the `normal_stop' notification is not emitted when the</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>execution stops due to a breakpoint, and this breakpoint has a</code></pre></td>
        <td class="diff"><pre><code>execution stops due to a breakpoint, and this breakpoint has a</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>condition that is not met.  If the breakpoint has any associated</code></pre></td>
        <td class="diff"><pre><code>condition that is not met.  If the breakpoint has any associated</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>commands list, the commands are executed after the notification is</code></pre></td>
        <td class="diff"><pre><code>commands list, the commands are executed after the notification is</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>emitted.</code></pre></td>
        <td class="diff"><pre><code>emitted.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>   The following interfaces are available to manage observers:</code></pre></td>
        <td class="diff"><pre><code>   The following interfaces are available to manage observers:</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code> -- Function: extern struct observer *observer_attach_EVENT</code></pre></td>
        <td class="diff"><pre><code> -- Function: extern struct observer *observer_attach_EVENT</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>          (observer_EVENT_ftype *F)</code></pre></td>
        <td class="diff"><pre><code>          (observer_EVENT_ftype *F)</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     Using the function F, create an observer that is notified when</code></pre></td>
        <td class="diff"><pre><code>     Using the function F, create an observer that is notified when</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     ever EVENT occurs, return the observer.</code></pre></td>
        <td class="diff"><pre><code>     ever EVENT occurs, return the observer.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code> -- Function: extern void observer_detach_EVENT (struct observer</code></pre></td>
        <td class="diff"><pre><code> -- Function: extern void observer_detach_EVENT (struct observer</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>          *OBSERVER);</code></pre></td>
        <td class="diff"><pre><code>          *OBSERVER);</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     Remove OBSERVER from the list of observers to be notified when</code></pre></td>
        <td class="diff"><pre><code>     Remove OBSERVER from the list of observers to be notified when</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     EVENT occurs.</code></pre></td>
        <td class="diff"><pre><code>     EVENT occurs.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code> -- Function: extern void observer_notify_EVENT (void);</code></pre></td>
        <td class="diff"><pre><code> -- Function: extern void observer_notify_EVENT (void);</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     Send a notification to all EVENT observers.</code></pre></td>
        <td class="diff"><pre><code>     Send a notification to all EVENT observers.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>   The following observable events are defined:</code></pre></td>
        <td class="diff"><pre><code>   The following observable events are defined:</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code> -- Function: void normal_stop (struct bpstats *BS)</code></pre></td>
        <td class="diff"><pre><code> -- Function: void normal_stop (struct bpstats *BS)</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     The inferior has stopped for real.</code></pre></td>
        <td class="diff"><pre><code>     The inferior has stopped for real.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code> -- Function: void target_changed (struct target_ops *TARGET)</code></pre></td>
        <td class="diff"><pre><code> -- Function: void target_changed (struct target_ops *TARGET)</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     The target's register contents have changed.</code></pre></td>
        <td class="diff"><pre><code>     The target's register contents have changed.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code> -- Function: void executable_changed (void *UNUSED_ARGS)</code></pre></td>
        <td class="diff"><pre><code> -- Function: void executable_changed (void *UNUSED_ARGS)</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     The executable being debugged by GDB has changed: The user decided</code></pre></td>
        <td class="diff"><pre><code>     The executable being debugged by GDB has changed: The user decided</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     to debug a different program, or the program he was debugging has</code></pre></td>
        <td class="diff"><pre><code>     to debug a different program, or the program he was debugging has</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     been modified since being loaded by the debugger (by being</code></pre></td>
        <td class="diff"><pre><code>     been modified since being loaded by the debugger (by being</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     recompiled, for instance).</code></pre></td>
        <td class="diff"><pre><code>     recompiled, for instance).</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code> -- Function: void inferior_created (struct target_ops *OBJFILE, int</code></pre></td>
        <td class="diff"><pre><code> -- Function: void inferior_created (struct target_ops *OBJFILE, int</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>          FROM_TTY)</code></pre></td>
        <td class="diff"><pre><code>          FROM_TTY)</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     GDB has just connected to an inferior.  For `run', GDB calls this</code></pre></td>
        <td class="diff"><pre><code>     GDB has just connected to an inferior.  For `run', GDB calls this</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     observer while the inferior is still stopped at the entry-point</code></pre></td>
        <td class="diff"><pre><code>     observer while the inferior is still stopped at the entry-point</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     instruction.  For `attach' and `core', GDB calls this observer</code></pre></td>
        <td class="diff"><pre><code>     instruction.  For `attach' and `core', GDB calls this observer</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     immediately after connecting to the inferior, and before any</code></pre></td>
        <td class="diff"><pre><code>     immediately after connecting to the inferior, and before any</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     information on the inferior has been printed.</code></pre></td>
        <td class="diff"><pre><code>     information on the inferior has been printed.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code> -- Function: void solib_loaded (struct so_list *SOLIB)</code></pre></td>
        <td class="diff"><pre><code> -- Function: void solib_loaded (struct so_list *SOLIB)</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     The shared library specified by SOLIB has been loaded.  Note that</code></pre></td>
        <td class="diff"><pre><code>     The shared library specified by SOLIB has been loaded.  Note that</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     when GDB calls this observer, the library's symbols probably</code></pre></td>
        <td class="diff"><pre><code>     when GDB calls this observer, the library's symbols probably</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     haven't been loaded yet.</code></pre></td>
        <td class="diff"><pre><code>     haven't been loaded yet.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code> -- Function: void solib_unloaded (struct so_list *SOLIB)</code></pre></td>
        <td class="diff"><pre><code> -- Function: void solib_unloaded (struct so_list *SOLIB)</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     The shared library specified by SOLIB has been unloaded.</code></pre></td>
        <td class="diff"><pre><code>     The shared library specified by SOLIB has been unloaded.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code> -- Function: void new_objfile (struct objfile *OBJFILE)</code></pre></td>
        <td class="diff"><pre><code> -- Function: void new_objfile (struct objfile *OBJFILE)</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     The symbol file specified by OBJFILE has been loaded.  Called with</code></pre></td>
        <td class="diff"><pre><code>     The symbol file specified by OBJFILE has been loaded.  Called with</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     OBJFILE equal to `NULL' to indicate previously loaded symbol table</code></pre></td>
        <td class="diff"><pre><code>     OBJFILE equal to `NULL' to indicate previously loaded symbol table</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     data has now been invalidated.</code></pre></td>
        <td class="diff"><pre><code>     data has now been invalidated.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>File: gdbint.info,  Node: GNU Free Documentation License,  Next: Index,  Prev: GDB Observers,  Up: Top</code></pre></td>
        <td class="diff"><pre><code>File: gdbint.info,  Node: GNU Free Documentation License,  Next: Index,  Prev: GDB Observers,  Up: Top</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>Appendix B GNU Free Documentation License</code></pre></td>
        <td class="diff"><pre><code>Appendix B GNU Free Documentation License</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>*****************************************</code></pre></td>
        <td class="diff"><pre><code>*****************************************</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>                      Version 1.2, November 2002</code></pre></td>
        <td class="diff"><pre><code>                      Version 1.2, November 2002</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     Copyright (C) 2000,2001,2002 Free Software Foundation, Inc.</code></pre></td>
        <td class="diff"><pre><code>     Copyright (C) 2000,2001,2002 Free Software Foundation, Inc.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.</code></pre></td>
        <td class="diff"><pre><code>     51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     Everyone is permitted to copy and distribute verbatim copies</code></pre></td>
        <td class="diff"><pre><code>     Everyone is permitted to copy and distribute verbatim copies</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     of this license document, but changing it is not allowed.</code></pre></td>
        <td class="diff"><pre><code>     of this license document, but changing it is not allowed.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>  0. PREAMBLE</code></pre></td>
        <td class="diff"><pre><code>  0. PREAMBLE</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     The purpose of this License is to make a manual, textbook, or other</code></pre></td>
        <td class="diff"><pre><code>     The purpose of this License is to make a manual, textbook, or other</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     functional and useful document "free" in the sense of freedom: to</code></pre></td>
        <td class="diff"><pre><code>     functional and useful document "free" in the sense of freedom: to</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     assure everyone the effective freedom to copy and redistribute it,</code></pre></td>
        <td class="diff"><pre><code>     assure everyone the effective freedom to copy and redistribute it,</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     with or without modifying it, either commercially or</code></pre></td>
        <td class="diff"><pre><code>     with or without modifying it, either commercially or</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     noncommercially.  Secondarily, this License preserves for the</code></pre></td>
        <td class="diff"><pre><code>     noncommercially.  Secondarily, this License preserves for the</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     author and publisher a way to get credit for their work, while not</code></pre></td>
        <td class="diff"><pre><code>     author and publisher a way to get credit for their work, while not</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     being considered responsible for modifications made by others.</code></pre></td>
        <td class="diff"><pre><code>     being considered responsible for modifications made by others.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     This License is a kind of "copyleft", which means that derivative</code></pre></td>
        <td class="diff"><pre><code>     This License is a kind of "copyleft", which means that derivative</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     works of the document must themselves be free in the same sense.</code></pre></td>
        <td class="diff"><pre><code>     works of the document must themselves be free in the same sense.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     It complements the GNU General Public License, which is a copyleft</code></pre></td>
        <td class="diff"><pre><code>     It complements the GNU General Public License, which is a copyleft</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     license designed for free software.</code></pre></td>
        <td class="diff"><pre><code>     license designed for free software.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     We have designed this License in order to use it for manuals for</code></pre></td>
        <td class="diff"><pre><code>     We have designed this License in order to use it for manuals for</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     free software, because free software needs free documentation: a</code></pre></td>
        <td class="diff"><pre><code>     free software, because free software needs free documentation: a</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     free program should come with manuals providing the same freedoms</code></pre></td>
        <td class="diff"><pre><code>     free program should come with manuals providing the same freedoms</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     that the software does.  But this License is not limited to</code></pre></td>
        <td class="diff"><pre><code>     that the software does.  But this License is not limited to</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     software manuals; it can be used for any textual work, regardless</code></pre></td>
        <td class="diff"><pre><code>     software manuals; it can be used for any textual work, regardless</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     of subject matter or whether it is published as a printed book.</code></pre></td>
        <td class="diff"><pre><code>     of subject matter or whether it is published as a printed book.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     We recommend this License principally for works whose purpose is</code></pre></td>
        <td class="diff"><pre><code>     We recommend this License principally for works whose purpose is</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     instruction or reference.</code></pre></td>
        <td class="diff"><pre><code>     instruction or reference.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>  1. APPLICABILITY AND DEFINITIONS</code></pre></td>
        <td class="diff"><pre><code>  1. APPLICABILITY AND DEFINITIONS</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     This License applies to any manual or other work, in any medium,</code></pre></td>
        <td class="diff"><pre><code>     This License applies to any manual or other work, in any medium,</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     that contains a notice placed by the copyright holder saying it</code></pre></td>
        <td class="diff"><pre><code>     that contains a notice placed by the copyright holder saying it</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     can be distributed under the terms of this License.  Such a notice</code></pre></td>
        <td class="diff"><pre><code>     can be distributed under the terms of this License.  Such a notice</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     grants a world-wide, royalty-free license, unlimited in duration,</code></pre></td>
        <td class="diff"><pre><code>     grants a world-wide, royalty-free license, unlimited in duration,</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     to use that work under the conditions stated herein.  The</code></pre></td>
        <td class="diff"><pre><code>     to use that work under the conditions stated herein.  The</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     "Document", below, refers to any such manual or work.  Any member</code></pre></td>
        <td class="diff"><pre><code>     "Document", below, refers to any such manual or work.  Any member</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     of the public is a licensee, and is addressed as "you".  You</code></pre></td>
        <td class="diff"><pre><code>     of the public is a licensee, and is addressed as "you".  You</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     accept the license if you copy, modify or distribute the work in a</code></pre></td>
        <td class="diff"><pre><code>     accept the license if you copy, modify or distribute the work in a</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     way requiring permission under copyright law.</code></pre></td>
        <td class="diff"><pre><code>     way requiring permission under copyright law.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     A "Modified Version" of the Document means any work containing the</code></pre></td>
        <td class="diff"><pre><code>     A "Modified Version" of the Document means any work containing the</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     Document or a portion of it, either copied verbatim, or with</code></pre></td>
        <td class="diff"><pre><code>     Document or a portion of it, either copied verbatim, or with</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     modifications and/or translated into another language.</code></pre></td>
        <td class="diff"><pre><code>     modifications and/or translated into another language.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     A "Secondary Section" is a named appendix or a front-matter section</code></pre></td>
        <td class="diff"><pre><code>     A "Secondary Section" is a named appendix or a front-matter section</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     of the Document that deals exclusively with the relationship of the</code></pre></td>
        <td class="diff"><pre><code>     of the Document that deals exclusively with the relationship of the</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     publishers or authors of the Document to the Document's overall</code></pre></td>
        <td class="diff"><pre><code>     publishers or authors of the Document to the Document's overall</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     subject (or to related matters) and contains nothing that could</code></pre></td>
        <td class="diff"><pre><code>     subject (or to related matters) and contains nothing that could</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     fall directly within that overall subject.  (Thus, if the Document</code></pre></td>
        <td class="diff"><pre><code>     fall directly within that overall subject.  (Thus, if the Document</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     is in part a textbook of mathematics, a Secondary Section may not</code></pre></td>
        <td class="diff"><pre><code>     is in part a textbook of mathematics, a Secondary Section may not</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     explain any mathematics.)  The relationship could be a matter of</code></pre></td>
        <td class="diff"><pre><code>     explain any mathematics.)  The relationship could be a matter of</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     historical connection with the subject or with related matters, or</code></pre></td>
        <td class="diff"><pre><code>     historical connection with the subject or with related matters, or</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     of legal, commercial, philosophical, ethical or political position</code></pre></td>
        <td class="diff"><pre><code>     of legal, commercial, philosophical, ethical or political position</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     regarding them.</code></pre></td>
        <td class="diff"><pre><code>     regarding them.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     The "Invariant Sections" are certain Secondary Sections whose</code></pre></td>
        <td class="diff"><pre><code>     The "Invariant Sections" are certain Secondary Sections whose</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     titles are designated, as being those of Invariant Sections, in</code></pre></td>
        <td class="diff"><pre><code>     titles are designated, as being those of Invariant Sections, in</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     the notice that says that the Document is released under this</code></pre></td>
        <td class="diff"><pre><code>     the notice that says that the Document is released under this</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     License.  If a section does not fit the above definition of</code></pre></td>
        <td class="diff"><pre><code>     License.  If a section does not fit the above definition of</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     Secondary then it is not allowed to be designated as Invariant.</code></pre></td>
        <td class="diff"><pre><code>     Secondary then it is not allowed to be designated as Invariant.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     The Document may contain zero Invariant Sections.  If the Document</code></pre></td>
        <td class="diff"><pre><code>     The Document may contain zero Invariant Sections.  If the Document</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     does not identify any Invariant Sections then there are none.</code></pre></td>
        <td class="diff"><pre><code>     does not identify any Invariant Sections then there are none.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     The "Cover Texts" are certain short passages of text that are</code></pre></td>
        <td class="diff"><pre><code>     The "Cover Texts" are certain short passages of text that are</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     listed, as Front-Cover Texts or Back-Cover Texts, in the notice</code></pre></td>
        <td class="diff"><pre><code>     listed, as Front-Cover Texts or Back-Cover Texts, in the notice</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     that says that the Document is released under this License.  A</code></pre></td>
        <td class="diff"><pre><code>     that says that the Document is released under this License.  A</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     Front-Cover Text may be at most 5 words, and a Back-Cover Text may</code></pre></td>
        <td class="diff"><pre><code>     Front-Cover Text may be at most 5 words, and a Back-Cover Text may</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     be at most 25 words.</code></pre></td>
        <td class="diff"><pre><code>     be at most 25 words.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     A "Transparent" copy of the Document means a machine-readable copy,</code></pre></td>
        <td class="diff"><pre><code>     A "Transparent" copy of the Document means a machine-readable copy,</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     represented in a format whose specification is available to the</code></pre></td>
        <td class="diff"><pre><code>     represented in a format whose specification is available to the</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     general public, that is suitable for revising the document</code></pre></td>
        <td class="diff"><pre><code>     general public, that is suitable for revising the document</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     straightforwardly with generic text editors or (for images</code></pre></td>
        <td class="diff"><pre><code>     straightforwardly with generic text editors or (for images</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     composed of pixels) generic paint programs or (for drawings) some</code></pre></td>
        <td class="diff"><pre><code>     composed of pixels) generic paint programs or (for drawings) some</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     widely available drawing editor, and that is suitable for input to</code></pre></td>
        <td class="diff"><pre><code>     widely available drawing editor, and that is suitable for input to</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     text formatters or for automatic translation to a variety of</code></pre></td>
        <td class="diff"><pre><code>     text formatters or for automatic translation to a variety of</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     formats suitable for input to text formatters.  A copy made in an</code></pre></td>
        <td class="diff"><pre><code>     formats suitable for input to text formatters.  A copy made in an</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     otherwise Transparent file format whose markup, or absence of</code></pre></td>
        <td class="diff"><pre><code>     otherwise Transparent file format whose markup, or absence of</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     markup, has been arranged to thwart or discourage subsequent</code></pre></td>
        <td class="diff"><pre><code>     markup, has been arranged to thwart or discourage subsequent</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     modification by readers is not Transparent.  An image format is</code></pre></td>
        <td class="diff"><pre><code>     modification by readers is not Transparent.  An image format is</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     not Transparent if used for any substantial amount of text.  A</code></pre></td>
        <td class="diff"><pre><code>     not Transparent if used for any substantial amount of text.  A</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     copy that is not "Transparent" is called "Opaque".</code></pre></td>
        <td class="diff"><pre><code>     copy that is not "Transparent" is called "Opaque".</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     Examples of suitable formats for Transparent copies include plain</code></pre></td>
        <td class="diff"><pre><code>     Examples of suitable formats for Transparent copies include plain</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     ASCII without markup, Texinfo input format, LaTeX input format,</code></pre></td>
        <td class="diff"><pre><code>     ASCII without markup, Texinfo input format, LaTeX input format,</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     SGML or XML using a publicly available DTD, and</code></pre></td>
        <td class="diff"><pre><code>     SGML or XML using a publicly available DTD, and</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     standard-conforming simple HTML, PostScript or PDF designed for</code></pre></td>
        <td class="diff"><pre><code>     standard-conforming simple HTML, PostScript or PDF designed for</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     human modification.  Examples of transparent image formats include</code></pre></td>
        <td class="diff"><pre><code>     human modification.  Examples of transparent image formats include</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     PNG, XCF and JPG.  Opaque formats include proprietary formats that</code></pre></td>
        <td class="diff"><pre><code>     PNG, XCF and JPG.  Opaque formats include proprietary formats that</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     can be read and edited only by proprietary word processors, SGML or</code></pre></td>
        <td class="diff"><pre><code>     can be read and edited only by proprietary word processors, SGML or</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     XML for which the DTD and/or processing tools are not generally</code></pre></td>
        <td class="diff"><pre><code>     XML for which the DTD and/or processing tools are not generally</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     available, and the machine-generated HTML, PostScript or PDF</code></pre></td>
        <td class="diff"><pre><code>     available, and the machine-generated HTML, PostScript or PDF</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     produced by some word processors for output purposes only.</code></pre></td>
        <td class="diff"><pre><code>     produced by some word processors for output purposes only.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     The "Title Page" means, for a printed book, the title page itself,</code></pre></td>
        <td class="diff"><pre><code>     The "Title Page" means, for a printed book, the title page itself,</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     plus such following pages as are needed to hold, legibly, the</code></pre></td>
        <td class="diff"><pre><code>     plus such following pages as are needed to hold, legibly, the</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     material this License requires to appear in the title page.  For</code></pre></td>
        <td class="diff"><pre><code>     material this License requires to appear in the title page.  For</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     works in formats which do not have any title page as such, "Title</code></pre></td>
        <td class="diff"><pre><code>     works in formats which do not have any title page as such, "Title</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     Page" means the text near the most prominent appearance of the</code></pre></td>
        <td class="diff"><pre><code>     Page" means the text near the most prominent appearance of the</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     work's title, preceding the beginning of the body of the text.</code></pre></td>
        <td class="diff"><pre><code>     work's title, preceding the beginning of the body of the text.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     A section "Entitled XYZ" means a named subunit of the Document</code></pre></td>
        <td class="diff"><pre><code>     A section "Entitled XYZ" means a named subunit of the Document</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     whose title either is precisely XYZ or contains XYZ in parentheses</code></pre></td>
        <td class="diff"><pre><code>     whose title either is precisely XYZ or contains XYZ in parentheses</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     following text that translates XYZ in another language.  (Here XYZ</code></pre></td>
        <td class="diff"><pre><code>     following text that translates XYZ in another language.  (Here XYZ</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     stands for a specific section name mentioned below, such as</code></pre></td>
        <td class="diff"><pre><code>     stands for a specific section name mentioned below, such as</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     "Acknowledgements", "Dedications", "Endorsements", or "History".)</code></pre></td>
        <td class="diff"><pre><code>     "Acknowledgements", "Dedications", "Endorsements", or "History".)</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     To "Preserve the Title" of such a section when you modify the</code></pre></td>
        <td class="diff"><pre><code>     To "Preserve the Title" of such a section when you modify the</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     Document means that it remains a section "Entitled XYZ" according</code></pre></td>
        <td class="diff"><pre><code>     Document means that it remains a section "Entitled XYZ" according</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     to this definition.</code></pre></td>
        <td class="diff"><pre><code>     to this definition.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     The Document may include Warranty Disclaimers next to the notice</code></pre></td>
        <td class="diff"><pre><code>     The Document may include Warranty Disclaimers next to the notice</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     which states that this License applies to the Document.  These</code></pre></td>
        <td class="diff"><pre><code>     which states that this License applies to the Document.  These</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     Warranty Disclaimers are considered to be included by reference in</code></pre></td>
        <td class="diff"><pre><code>     Warranty Disclaimers are considered to be included by reference in</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     this License, but only as regards disclaiming warranties: any other</code></pre></td>
        <td class="diff"><pre><code>     this License, but only as regards disclaiming warranties: any other</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     implication that these Warranty Disclaimers may have is void and</code></pre></td>
        <td class="diff"><pre><code>     implication that these Warranty Disclaimers may have is void and</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     has no effect on the meaning of this License.</code></pre></td>
        <td class="diff"><pre><code>     has no effect on the meaning of this License.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>  2. VERBATIM COPYING</code></pre></td>
        <td class="diff"><pre><code>  2. VERBATIM COPYING</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     You may copy and distribute the Document in any medium, either</code></pre></td>
        <td class="diff"><pre><code>     You may copy and distribute the Document in any medium, either</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     commercially or noncommercially, provided that this License, the</code></pre></td>
        <td class="diff"><pre><code>     commercially or noncommercially, provided that this License, the</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     copyright notices, and the license notice saying this License</code></pre></td>
        <td class="diff"><pre><code>     copyright notices, and the license notice saying this License</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     applies to the Document are reproduced in all copies, and that you</code></pre></td>
        <td class="diff"><pre><code>     applies to the Document are reproduced in all copies, and that you</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     add no other conditions whatsoever to those of this License.  You</code></pre></td>
        <td class="diff"><pre><code>     add no other conditions whatsoever to those of this License.  You</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     may not use technical measures to obstruct or control the reading</code></pre></td>
        <td class="diff"><pre><code>     may not use technical measures to obstruct or control the reading</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     or further copying of the copies you make or distribute.  However,</code></pre></td>
        <td class="diff"><pre><code>     or further copying of the copies you make or distribute.  However,</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     you may accept compensation in exchange for copies.  If you</code></pre></td>
        <td class="diff"><pre><code>     you may accept compensation in exchange for copies.  If you</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     distribute a large enough number of copies you must also follow</code></pre></td>
        <td class="diff"><pre><code>     distribute a large enough number of copies you must also follow</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     the conditions in section 3.</code></pre></td>
        <td class="diff"><pre><code>     the conditions in section 3.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     You may also lend copies, under the same conditions stated above,</code></pre></td>
        <td class="diff"><pre><code>     You may also lend copies, under the same conditions stated above,</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     and you may publicly display copies.</code></pre></td>
        <td class="diff"><pre><code>     and you may publicly display copies.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>  3. COPYING IN QUANTITY</code></pre></td>
        <td class="diff"><pre><code>  3. COPYING IN QUANTITY</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     If you publish printed copies (or copies in media that commonly</code></pre></td>
        <td class="diff"><pre><code>     If you publish printed copies (or copies in media that commonly</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     have printed covers) of the Document, numbering more than 100, and</code></pre></td>
        <td class="diff"><pre><code>     have printed covers) of the Document, numbering more than 100, and</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     the Document's license notice requires Cover Texts, you must</code></pre></td>
        <td class="diff"><pre><code>     the Document's license notice requires Cover Texts, you must</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     enclose the copies in covers that carry, clearly and legibly, all</code></pre></td>
        <td class="diff"><pre><code>     enclose the copies in covers that carry, clearly and legibly, all</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     these Cover Texts: Front-Cover Texts on the front cover, and</code></pre></td>
        <td class="diff"><pre><code>     these Cover Texts: Front-Cover Texts on the front cover, and</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     Back-Cover Texts on the back cover.  Both covers must also clearly</code></pre></td>
        <td class="diff"><pre><code>     Back-Cover Texts on the back cover.  Both covers must also clearly</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     and legibly identify you as the publisher of these copies.  The</code></pre></td>
        <td class="diff"><pre><code>     and legibly identify you as the publisher of these copies.  The</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     front cover must present the full title with all words of the</code></pre></td>
        <td class="diff"><pre><code>     front cover must present the full title with all words of the</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     title equally prominent and visible.  You may add other material</code></pre></td>
        <td class="diff"><pre><code>     title equally prominent and visible.  You may add other material</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     on the covers in addition.  Copying with changes limited to the</code></pre></td>
        <td class="diff"><pre><code>     on the covers in addition.  Copying with changes limited to the</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     covers, as long as they preserve the title of the Document and</code></pre></td>
        <td class="diff"><pre><code>     covers, as long as they preserve the title of the Document and</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     satisfy these conditions, can be treated as verbatim copying in</code></pre></td>
        <td class="diff"><pre><code>     satisfy these conditions, can be treated as verbatim copying in</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     other respects.</code></pre></td>
        <td class="diff"><pre><code>     other respects.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     If the required texts for either cover are too voluminous to fit</code></pre></td>
        <td class="diff"><pre><code>     If the required texts for either cover are too voluminous to fit</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     legibly, you should put the first ones listed (as many as fit</code></pre></td>
        <td class="diff"><pre><code>     legibly, you should put the first ones listed (as many as fit</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     reasonably) on the actual cover, and continue the rest onto</code></pre></td>
        <td class="diff"><pre><code>     reasonably) on the actual cover, and continue the rest onto</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     adjacent pages.</code></pre></td>
        <td class="diff"><pre><code>     adjacent pages.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     If you publish or distribute Opaque copies of the Document</code></pre></td>
        <td class="diff"><pre><code>     If you publish or distribute Opaque copies of the Document</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     numbering more than 100, you must either include a</code></pre></td>
        <td class="diff"><pre><code>     numbering more than 100, you must either include a</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     machine-readable Transparent copy along with each Opaque copy, or</code></pre></td>
        <td class="diff"><pre><code>     machine-readable Transparent copy along with each Opaque copy, or</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     state in or with each Opaque copy a computer-network location from</code></pre></td>
        <td class="diff"><pre><code>     state in or with each Opaque copy a computer-network location from</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     which the general network-using public has access to download</code></pre></td>
        <td class="diff"><pre><code>     which the general network-using public has access to download</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     using public-standard network protocols a complete Transparent</code></pre></td>
        <td class="diff"><pre><code>     using public-standard network protocols a complete Transparent</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     copy of the Document, free of added material.  If you use the</code></pre></td>
        <td class="diff"><pre><code>     copy of the Document, free of added material.  If you use the</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     latter option, you must take reasonably prudent steps, when you</code></pre></td>
        <td class="diff"><pre><code>     latter option, you must take reasonably prudent steps, when you</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     begin distribution of Opaque copies in quantity, to ensure that</code></pre></td>
        <td class="diff"><pre><code>     begin distribution of Opaque copies in quantity, to ensure that</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     this Transparent copy will remain thus accessible at the stated</code></pre></td>
        <td class="diff"><pre><code>     this Transparent copy will remain thus accessible at the stated</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     location until at least one year after the last time you</code></pre></td>
        <td class="diff"><pre><code>     location until at least one year after the last time you</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     distribute an Opaque copy (directly or through your agents or</code></pre></td>
        <td class="diff"><pre><code>     distribute an Opaque copy (directly or through your agents or</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     retailers) of that edition to the public.</code></pre></td>
        <td class="diff"><pre><code>     retailers) of that edition to the public.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     It is requested, but not required, that you contact the authors of</code></pre></td>
        <td class="diff"><pre><code>     It is requested, but not required, that you contact the authors of</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     the Document well before redistributing any large number of</code></pre></td>
        <td class="diff"><pre><code>     the Document well before redistributing any large number of</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     copies, to give them a chance to provide you with an updated</code></pre></td>
        <td class="diff"><pre><code>     copies, to give them a chance to provide you with an updated</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     version of the Document.</code></pre></td>
        <td class="diff"><pre><code>     version of the Document.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>  4. MODIFICATIONS</code></pre></td>
        <td class="diff"><pre><code>  4. MODIFICATIONS</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     You may copy and distribute a Modified Version of the Document</code></pre></td>
        <td class="diff"><pre><code>     You may copy and distribute a Modified Version of the Document</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     under the conditions of sections 2 and 3 above, provided that you</code></pre></td>
        <td class="diff"><pre><code>     under the conditions of sections 2 and 3 above, provided that you</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     release the Modified Version under precisely this License, with</code></pre></td>
        <td class="diff"><pre><code>     release the Modified Version under precisely this License, with</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     the Modified Version filling the role of the Document, thus</code></pre></td>
        <td class="diff"><pre><code>     the Modified Version filling the role of the Document, thus</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     licensing distribution and modification of the Modified Version to</code></pre></td>
        <td class="diff"><pre><code>     licensing distribution and modification of the Modified Version to</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     whoever possesses a copy of it.  In addition, you must do these</code></pre></td>
        <td class="diff"><pre><code>     whoever possesses a copy of it.  In addition, you must do these</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     things in the Modified Version:</code></pre></td>
        <td class="diff"><pre><code>     things in the Modified Version:</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>       A. Use in the Title Page (and on the covers, if any) a title</code></pre></td>
        <td class="diff"><pre><code>       A. Use in the Title Page (and on the covers, if any) a title</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>          distinct from that of the Document, and from those of</code></pre></td>
        <td class="diff"><pre><code>          distinct from that of the Document, and from those of</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>          previous versions (which should, if there were any, be listed</code></pre></td>
        <td class="diff"><pre><code>          previous versions (which should, if there were any, be listed</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>          in the History section of the Document).  You may use the</code></pre></td>
        <td class="diff"><pre><code>          in the History section of the Document).  You may use the</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>          same title as a previous version if the original publisher of</code></pre></td>
        <td class="diff"><pre><code>          same title as a previous version if the original publisher of</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>          that version gives permission.</code></pre></td>
        <td class="diff"><pre><code>          that version gives permission.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>       B. List on the Title Page, as authors, one or more persons or</code></pre></td>
        <td class="diff"><pre><code>       B. List on the Title Page, as authors, one or more persons or</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>          entities responsible for authorship of the modifications in</code></pre></td>
        <td class="diff"><pre><code>          entities responsible for authorship of the modifications in</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>          the Modified Version, together with at least five of the</code></pre></td>
        <td class="diff"><pre><code>          the Modified Version, together with at least five of the</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>          principal authors of the Document (all of its principal</code></pre></td>
        <td class="diff"><pre><code>          principal authors of the Document (all of its principal</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>          authors, if it has fewer than five), unless they release you</code></pre></td>
        <td class="diff"><pre><code>          authors, if it has fewer than five), unless they release you</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>          from this requirement.</code></pre></td>
        <td class="diff"><pre><code>          from this requirement.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>       C. State on the Title page the name of the publisher of the</code></pre></td>
        <td class="diff"><pre><code>       C. State on the Title page the name of the publisher of the</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>          Modified Version, as the publisher.</code></pre></td>
        <td class="diff"><pre><code>          Modified Version, as the publisher.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>       D. Preserve all the copyright notices of the Document.</code></pre></td>
        <td class="diff"><pre><code>       D. Preserve all the copyright notices of the Document.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>       E. Add an appropriate copyright notice for your modifications</code></pre></td>
        <td class="diff"><pre><code>       E. Add an appropriate copyright notice for your modifications</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>          adjacent to the other copyright notices.</code></pre></td>
        <td class="diff"><pre><code>          adjacent to the other copyright notices.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>       F. Include, immediately after the copyright notices, a license</code></pre></td>
        <td class="diff"><pre><code>       F. Include, immediately after the copyright notices, a license</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>          notice giving the public permission to use the Modified</code></pre></td>
        <td class="diff"><pre><code>          notice giving the public permission to use the Modified</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>          Version under the terms of this License, in the form shown in</code></pre></td>
        <td class="diff"><pre><code>          Version under the terms of this License, in the form shown in</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>          the Addendum below.</code></pre></td>
        <td class="diff"><pre><code>          the Addendum below.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>       G. Preserve in that license notice the full lists of Invariant</code></pre></td>
        <td class="diff"><pre><code>       G. Preserve in that license notice the full lists of Invariant</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>          Sections and required Cover Texts given in the Document's</code></pre></td>
        <td class="diff"><pre><code>          Sections and required Cover Texts given in the Document's</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>          license notice.</code></pre></td>
        <td class="diff"><pre><code>          license notice.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>       H. Include an unaltered copy of this License.</code></pre></td>
        <td class="diff"><pre><code>       H. Include an unaltered copy of this License.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>       I. Preserve the section Entitled "History", Preserve its Title,</code></pre></td>
        <td class="diff"><pre><code>       I. Preserve the section Entitled "History", Preserve its Title,</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>          and add to it an item stating at least the title, year, new</code></pre></td>
        <td class="diff"><pre><code>          and add to it an item stating at least the title, year, new</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>          authors, and publisher of the Modified Version as given on</code></pre></td>
        <td class="diff"><pre><code>          authors, and publisher of the Modified Version as given on</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>          the Title Page.  If there is no section Entitled "History" in</code></pre></td>
        <td class="diff"><pre><code>          the Title Page.  If there is no section Entitled "History" in</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>          the Document, create one stating the title, year, authors,</code></pre></td>
        <td class="diff"><pre><code>          the Document, create one stating the title, year, authors,</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>          and publisher of the Document as given on its Title Page,</code></pre></td>
        <td class="diff"><pre><code>          and publisher of the Document as given on its Title Page,</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>          then add an item describing the Modified Version as stated in</code></pre></td>
        <td class="diff"><pre><code>          then add an item describing the Modified Version as stated in</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>          the previous sentence.</code></pre></td>
        <td class="diff"><pre><code>          the previous sentence.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>       J. Preserve the network location, if any, given in the Document</code></pre></td>
        <td class="diff"><pre><code>       J. Preserve the network location, if any, given in the Document</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>          for public access to a Transparent copy of the Document, and</code></pre></td>
        <td class="diff"><pre><code>          for public access to a Transparent copy of the Document, and</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>          likewise the network locations given in the Document for</code></pre></td>
        <td class="diff"><pre><code>          likewise the network locations given in the Document for</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>          previous versions it was based on.  These may be placed in</code></pre></td>
        <td class="diff"><pre><code>          previous versions it was based on.  These may be placed in</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>          the "History" section.  You may omit a network location for a</code></pre></td>
        <td class="diff"><pre><code>          the "History" section.  You may omit a network location for a</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>          work that was published at least four years before the</code></pre></td>
        <td class="diff"><pre><code>          work that was published at least four years before the</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>          Document itself, or if the original publisher of the version</code></pre></td>
        <td class="diff"><pre><code>          Document itself, or if the original publisher of the version</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>          it refers to gives permission.</code></pre></td>
        <td class="diff"><pre><code>          it refers to gives permission.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>       K. For any section Entitled "Acknowledgements" or "Dedications",</code></pre></td>
        <td class="diff"><pre><code>       K. For any section Entitled "Acknowledgements" or "Dedications",</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>          Preserve the Title of the section, and preserve in the</code></pre></td>
        <td class="diff"><pre><code>          Preserve the Title of the section, and preserve in the</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>          section all the substance and tone of each of the contributor</code></pre></td>
        <td class="diff"><pre><code>          section all the substance and tone of each of the contributor</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>          acknowledgements and/or dedications given therein.</code></pre></td>
        <td class="diff"><pre><code>          acknowledgements and/or dedications given therein.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>       L. Preserve all the Invariant Sections of the Document,</code></pre></td>
        <td class="diff"><pre><code>       L. Preserve all the Invariant Sections of the Document,</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>          unaltered in their text and in their titles.  Section numbers</code></pre></td>
        <td class="diff"><pre><code>          unaltered in their text and in their titles.  Section numbers</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>          or the equivalent are not considered part of the section</code></pre></td>
        <td class="diff"><pre><code>          or the equivalent are not considered part of the section</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>          titles.</code></pre></td>
        <td class="diff"><pre><code>          titles.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>       M. Delete any section Entitled "Endorsements".  Such a section</code></pre></td>
        <td class="diff"><pre><code>       M. Delete any section Entitled "Endorsements".  Such a section</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>          may not be included in the Modified Version.</code></pre></td>
        <td class="diff"><pre><code>          may not be included in the Modified Version.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>       N. Do not retitle any existing section to be Entitled</code></pre></td>
        <td class="diff"><pre><code>       N. Do not retitle any existing section to be Entitled</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>          "Endorsements" or to conflict in title with any Invariant</code></pre></td>
        <td class="diff"><pre><code>          "Endorsements" or to conflict in title with any Invariant</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>          Section.</code></pre></td>
        <td class="diff"><pre><code>          Section.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>       O. Preserve any Warranty Disclaimers.</code></pre></td>
        <td class="diff"><pre><code>       O. Preserve any Warranty Disclaimers.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     If the Modified Version includes new front-matter sections or</code></pre></td>
        <td class="diff"><pre><code>     If the Modified Version includes new front-matter sections or</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     appendices that qualify as Secondary Sections and contain no</code></pre></td>
        <td class="diff"><pre><code>     appendices that qualify as Secondary Sections and contain no</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     material copied from the Document, you may at your option</code></pre></td>
        <td class="diff"><pre><code>     material copied from the Document, you may at your option</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     designate some or all of these sections as invariant.  To do this,</code></pre></td>
        <td class="diff"><pre><code>     designate some or all of these sections as invariant.  To do this,</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     add their titles to the list of Invariant Sections in the Modified</code></pre></td>
        <td class="diff"><pre><code>     add their titles to the list of Invariant Sections in the Modified</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     Version's license notice.  These titles must be distinct from any</code></pre></td>
        <td class="diff"><pre><code>     Version's license notice.  These titles must be distinct from any</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     other section titles.</code></pre></td>
        <td class="diff"><pre><code>     other section titles.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     You may add a section Entitled "Endorsements", provided it contains</code></pre></td>
        <td class="diff"><pre><code>     You may add a section Entitled "Endorsements", provided it contains</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     nothing but endorsements of your Modified Version by various</code></pre></td>
        <td class="diff"><pre><code>     nothing but endorsements of your Modified Version by various</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     parties--for example, statements of peer review or that the text</code></pre></td>
        <td class="diff"><pre><code>     parties--for example, statements of peer review or that the text</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     has been approved by an organization as the authoritative</code></pre></td>
        <td class="diff"><pre><code>     has been approved by an organization as the authoritative</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     definition of a standard.</code></pre></td>
        <td class="diff"><pre><code>     definition of a standard.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     You may add a passage of up to five words as a Front-Cover Text,</code></pre></td>
        <td class="diff"><pre><code>     You may add a passage of up to five words as a Front-Cover Text,</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     and a passage of up to 25 words as a Back-Cover Text, to the end</code></pre></td>
        <td class="diff"><pre><code>     and a passage of up to 25 words as a Back-Cover Text, to the end</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     of the list of Cover Texts in the Modified Version.  Only one</code></pre></td>
        <td class="diff"><pre><code>     of the list of Cover Texts in the Modified Version.  Only one</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     passage of Front-Cover Text and one of Back-Cover Text may be</code></pre></td>
        <td class="diff"><pre><code>     passage of Front-Cover Text and one of Back-Cover Text may be</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     added by (or through arrangements made by) any one entity.  If the</code></pre></td>
        <td class="diff"><pre><code>     added by (or through arrangements made by) any one entity.  If the</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     Document already includes a cover text for the same cover,</code></pre></td>
        <td class="diff"><pre><code>     Document already includes a cover text for the same cover,</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     previously added by you or by arrangement made by the same entity</code></pre></td>
        <td class="diff"><pre><code>     previously added by you or by arrangement made by the same entity</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     you are acting on behalf of, you may not add another; but you may</code></pre></td>
        <td class="diff"><pre><code>     you are acting on behalf of, you may not add another; but you may</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     replace the old one, on explicit permission from the previous</code></pre></td>
        <td class="diff"><pre><code>     replace the old one, on explicit permission from the previous</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     publisher that added the old one.</code></pre></td>
        <td class="diff"><pre><code>     publisher that added the old one.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     The author(s) and publisher(s) of the Document do not by this</code></pre></td>
        <td class="diff"><pre><code>     The author(s) and publisher(s) of the Document do not by this</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     License give permission to use their names for publicity for or to</code></pre></td>
        <td class="diff"><pre><code>     License give permission to use their names for publicity for or to</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     assert or imply endorsement of any Modified Version.</code></pre></td>
        <td class="diff"><pre><code>     assert or imply endorsement of any Modified Version.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>  5. COMBINING DOCUMENTS</code></pre></td>
        <td class="diff"><pre><code>  5. COMBINING DOCUMENTS</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     You may combine the Document with other documents released under</code></pre></td>
        <td class="diff"><pre><code>     You may combine the Document with other documents released under</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     this License, under the terms defined in section 4 above for</code></pre></td>
        <td class="diff"><pre><code>     this License, under the terms defined in section 4 above for</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     modified versions, provided that you include in the combination</code></pre></td>
        <td class="diff"><pre><code>     modified versions, provided that you include in the combination</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     all of the Invariant Sections of all of the original documents,</code></pre></td>
        <td class="diff"><pre><code>     all of the Invariant Sections of all of the original documents,</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     unmodified, and list them all as Invariant Sections of your</code></pre></td>
        <td class="diff"><pre><code>     unmodified, and list them all as Invariant Sections of your</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     combined work in its license notice, and that you preserve all</code></pre></td>
        <td class="diff"><pre><code>     combined work in its license notice, and that you preserve all</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     their Warranty Disclaimers.</code></pre></td>
        <td class="diff"><pre><code>     their Warranty Disclaimers.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     The combined work need only contain one copy of this License, and</code></pre></td>
        <td class="diff"><pre><code>     The combined work need only contain one copy of this License, and</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     multiple identical Invariant Sections may be replaced with a single</code></pre></td>
        <td class="diff"><pre><code>     multiple identical Invariant Sections may be replaced with a single</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     copy.  If there are multiple Invariant Sections with the same name</code></pre></td>
        <td class="diff"><pre><code>     copy.  If there are multiple Invariant Sections with the same name</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     but different contents, make the title of each such section unique</code></pre></td>
        <td class="diff"><pre><code>     but different contents, make the title of each such section unique</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     by adding at the end of it, in parentheses, the name of the</code></pre></td>
        <td class="diff"><pre><code>     by adding at the end of it, in parentheses, the name of the</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     original author or publisher of that section if known, or else a</code></pre></td>
        <td class="diff"><pre><code>     original author or publisher of that section if known, or else a</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     unique number.  Make the same adjustment to the section titles in</code></pre></td>
        <td class="diff"><pre><code>     unique number.  Make the same adjustment to the section titles in</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     the list of Invariant Sections in the license notice of the</code></pre></td>
        <td class="diff"><pre><code>     the list of Invariant Sections in the license notice of the</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     combined work.</code></pre></td>
        <td class="diff"><pre><code>     combined work.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     In the combination, you must combine any sections Entitled</code></pre></td>
        <td class="diff"><pre><code>     In the combination, you must combine any sections Entitled</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     "History" in the various original documents, forming one section</code></pre></td>
        <td class="diff"><pre><code>     "History" in the various original documents, forming one section</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     Entitled "History"; likewise combine any sections Entitled</code></pre></td>
        <td class="diff"><pre><code>     Entitled "History"; likewise combine any sections Entitled</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     "Acknowledgements", and any sections Entitled "Dedications".  You</code></pre></td>
        <td class="diff"><pre><code>     "Acknowledgements", and any sections Entitled "Dedications".  You</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     must delete all sections Entitled "Endorsements."</code></pre></td>
        <td class="diff"><pre><code>     must delete all sections Entitled "Endorsements."</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>  6. COLLECTIONS OF DOCUMENTS</code></pre></td>
        <td class="diff"><pre><code>  6. COLLECTIONS OF DOCUMENTS</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     You may make a collection consisting of the Document and other</code></pre></td>
        <td class="diff"><pre><code>     You may make a collection consisting of the Document and other</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     documents released under this License, and replace the individual</code></pre></td>
        <td class="diff"><pre><code>     documents released under this License, and replace the individual</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     copies of this License in the various documents with a single copy</code></pre></td>
        <td class="diff"><pre><code>     copies of this License in the various documents with a single copy</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     that is included in the collection, provided that you follow the</code></pre></td>
        <td class="diff"><pre><code>     that is included in the collection, provided that you follow the</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     rules of this License for verbatim copying of each of the</code></pre></td>
        <td class="diff"><pre><code>     rules of this License for verbatim copying of each of the</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     documents in all other respects.</code></pre></td>
        <td class="diff"><pre><code>     documents in all other respects.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     You may extract a single document from such a collection, and</code></pre></td>
        <td class="diff"><pre><code>     You may extract a single document from such a collection, and</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     distribute it individually under this License, provided you insert</code></pre></td>
        <td class="diff"><pre><code>     distribute it individually under this License, provided you insert</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     a copy of this License into the extracted document, and follow</code></pre></td>
        <td class="diff"><pre><code>     a copy of this License into the extracted document, and follow</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     this License in all other respects regarding verbatim copying of</code></pre></td>
        <td class="diff"><pre><code>     this License in all other respects regarding verbatim copying of</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     that document.</code></pre></td>
        <td class="diff"><pre><code>     that document.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>  7. AGGREGATION WITH INDEPENDENT WORKS</code></pre></td>
        <td class="diff"><pre><code>  7. AGGREGATION WITH INDEPENDENT WORKS</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     A compilation of the Document or its derivatives with other</code></pre></td>
        <td class="diff"><pre><code>     A compilation of the Document or its derivatives with other</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     separate and independent documents or works, in or on a volume of</code></pre></td>
        <td class="diff"><pre><code>     separate and independent documents or works, in or on a volume of</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     a storage or distribution medium, is called an "aggregate" if the</code></pre></td>
        <td class="diff"><pre><code>     a storage or distribution medium, is called an "aggregate" if the</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     copyright resulting from the compilation is not used to limit the</code></pre></td>
        <td class="diff"><pre><code>     copyright resulting from the compilation is not used to limit the</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     legal rights of the compilation's users beyond what the individual</code></pre></td>
        <td class="diff"><pre><code>     legal rights of the compilation's users beyond what the individual</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     works permit.  When the Document is included in an aggregate, this</code></pre></td>
        <td class="diff"><pre><code>     works permit.  When the Document is included in an aggregate, this</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     License does not apply to the other works in the aggregate which</code></pre></td>
        <td class="diff"><pre><code>     License does not apply to the other works in the aggregate which</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     are not themselves derivative works of the Document.</code></pre></td>
        <td class="diff"><pre><code>     are not themselves derivative works of the Document.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     If the Cover Text requirement of section 3 is applicable to these</code></pre></td>
        <td class="diff"><pre><code>     If the Cover Text requirement of section 3 is applicable to these</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     copies of the Document, then if the Document is less than one half</code></pre></td>
        <td class="diff"><pre><code>     copies of the Document, then if the Document is less than one half</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     of the entire aggregate, the Document's Cover Texts may be placed</code></pre></td>
        <td class="diff"><pre><code>     of the entire aggregate, the Document's Cover Texts may be placed</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     on covers that bracket the Document within the aggregate, or the</code></pre></td>
        <td class="diff"><pre><code>     on covers that bracket the Document within the aggregate, or the</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     electronic equivalent of covers if the Document is in electronic</code></pre></td>
        <td class="diff"><pre><code>     electronic equivalent of covers if the Document is in electronic</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     form.  Otherwise they must appear on printed covers that bracket</code></pre></td>
        <td class="diff"><pre><code>     form.  Otherwise they must appear on printed covers that bracket</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     the whole aggregate.</code></pre></td>
        <td class="diff"><pre><code>     the whole aggregate.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>  8. TRANSLATION</code></pre></td>
        <td class="diff"><pre><code>  8. TRANSLATION</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     Translation is considered a kind of modification, so you may</code></pre></td>
        <td class="diff"><pre><code>     Translation is considered a kind of modification, so you may</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     distribute translations of the Document under the terms of section</code></pre></td>
        <td class="diff"><pre><code>     distribute translations of the Document under the terms of section</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     4.  Replacing Invariant Sections with translations requires special</code></pre></td>
        <td class="diff"><pre><code>     4.  Replacing Invariant Sections with translations requires special</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     permission from their copyright holders, but you may include</code></pre></td>
        <td class="diff"><pre><code>     permission from their copyright holders, but you may include</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     translations of some or all Invariant Sections in addition to the</code></pre></td>
        <td class="diff"><pre><code>     translations of some or all Invariant Sections in addition to the</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     original versions of these Invariant Sections.  You may include a</code></pre></td>
        <td class="diff"><pre><code>     original versions of these Invariant Sections.  You may include a</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     translation of this License, and all the license notices in the</code></pre></td>
        <td class="diff"><pre><code>     translation of this License, and all the license notices in the</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     Document, and any Warranty Disclaimers, provided that you also</code></pre></td>
        <td class="diff"><pre><code>     Document, and any Warranty Disclaimers, provided that you also</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     include the original English version of this License and the</code></pre></td>
        <td class="diff"><pre><code>     include the original English version of this License and the</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     original versions of those notices and disclaimers.  In case of a</code></pre></td>
        <td class="diff"><pre><code>     original versions of those notices and disclaimers.  In case of a</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     disagreement between the translation and the original version of</code></pre></td>
        <td class="diff"><pre><code>     disagreement between the translation and the original version of</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     this License or a notice or disclaimer, the original version will</code></pre></td>
        <td class="diff"><pre><code>     this License or a notice or disclaimer, the original version will</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     prevail.</code></pre></td>
        <td class="diff"><pre><code>     prevail.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     If a section in the Document is Entitled "Acknowledgements",</code></pre></td>
        <td class="diff"><pre><code>     If a section in the Document is Entitled "Acknowledgements",</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     "Dedications", or "History", the requirement (section 4) to</code></pre></td>
        <td class="diff"><pre><code>     "Dedications", or "History", the requirement (section 4) to</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     Preserve its Title (section 1) will typically require changing the</code></pre></td>
        <td class="diff"><pre><code>     Preserve its Title (section 1) will typically require changing the</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     actual title.</code></pre></td>
        <td class="diff"><pre><code>     actual title.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>  9. TERMINATION</code></pre></td>
        <td class="diff"><pre><code>  9. TERMINATION</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     You may not copy, modify, sublicense, or distribute the Document</code></pre></td>
        <td class="diff"><pre><code>     You may not copy, modify, sublicense, or distribute the Document</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     except as expressly provided for under this License.  Any other</code></pre></td>
        <td class="diff"><pre><code>     except as expressly provided for under this License.  Any other</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     attempt to copy, modify, sublicense or distribute the Document is</code></pre></td>
        <td class="diff"><pre><code>     attempt to copy, modify, sublicense or distribute the Document is</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     void, and will automatically terminate your rights under this</code></pre></td>
        <td class="diff"><pre><code>     void, and will automatically terminate your rights under this</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     License.  However, parties who have received copies, or rights,</code></pre></td>
        <td class="diff"><pre><code>     License.  However, parties who have received copies, or rights,</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     from you under this License will not have their licenses</code></pre></td>
        <td class="diff"><pre><code>     from you under this License will not have their licenses</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     terminated so long as such parties remain in full compliance.</code></pre></td>
        <td class="diff"><pre><code>     terminated so long as such parties remain in full compliance.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code> 10. FUTURE REVISIONS OF THIS LICENSE</code></pre></td>
        <td class="diff"><pre><code> 10. FUTURE REVISIONS OF THIS LICENSE</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     The Free Software Foundation may publish new, revised versions of</code></pre></td>
        <td class="diff"><pre><code>     The Free Software Foundation may publish new, revised versions of</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     the GNU Free Documentation License from time to time.  Such new</code></pre></td>
        <td class="diff"><pre><code>     the GNU Free Documentation License from time to time.  Such new</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     versions will be similar in spirit to the present version, but may</code></pre></td>
        <td class="diff"><pre><code>     versions will be similar in spirit to the present version, but may</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     differ in detail to address new problems or concerns.  See</code></pre></td>
        <td class="diff"><pre><code>     differ in detail to address new problems or concerns.  See</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     `http://www.gnu.org/copyleft/'.</code></pre></td>
        <td class="diff"><pre><code>     `http://www.gnu.org/copyleft/'.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     Each version of the License is given a distinguishing version</code></pre></td>
        <td class="diff"><pre><code>     Each version of the License is given a distinguishing version</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     number.  If the Document specifies that a particular numbered</code></pre></td>
        <td class="diff"><pre><code>     number.  If the Document specifies that a particular numbered</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     version of this License "or any later version" applies to it, you</code></pre></td>
        <td class="diff"><pre><code>     version of this License "or any later version" applies to it, you</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     have the option of following the terms and conditions either of</code></pre></td>
        <td class="diff"><pre><code>     have the option of following the terms and conditions either of</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     that specified version or of any later version that has been</code></pre></td>
        <td class="diff"><pre><code>     that specified version or of any later version that has been</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     published (not as a draft) by the Free Software Foundation.  If</code></pre></td>
        <td class="diff"><pre><code>     published (not as a draft) by the Free Software Foundation.  If</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     the Document does not specify a version number of this License,</code></pre></td>
        <td class="diff"><pre><code>     the Document does not specify a version number of this License,</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     you may choose any version ever published (not as a draft) by the</code></pre></td>
        <td class="diff"><pre><code>     you may choose any version ever published (not as a draft) by the</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>     Free Software Foundation.</code></pre></td>
        <td class="diff"><pre><code>     Free Software Foundation.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>B.1 ADDENDUM: How to use this License for your documents</code></pre></td>
        <td class="diff"><pre><code>B.1 ADDENDUM: How to use this License for your documents</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>========================================================</code></pre></td>
        <td class="diff"><pre><code>========================================================</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>To use this License in a document you have written, include a copy of</code></pre></td>
        <td class="diff"><pre><code>To use this License in a document you have written, include a copy of</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>the License in the document and put the following copyright and license</code></pre></td>
        <td class="diff"><pre><code>the License in the document and put the following copyright and license</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>notices just after the title page:</code></pre></td>
        <td class="diff"><pre><code>notices just after the title page:</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>       Copyright (C)  YEAR  YOUR NAME.</code></pre></td>
        <td class="diff"><pre><code>       Copyright (C)  YEAR  YOUR NAME.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>       Permission is granted to copy, distribute and/or modify this document</code></pre></td>
        <td class="diff"><pre><code>       Permission is granted to copy, distribute and/or modify this document</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>       under the terms of the GNU Free Documentation License, Version 1.2</code></pre></td>
        <td class="diff"><pre><code>       under the terms of the GNU Free Documentation License, Version 1.2</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>       or any later version published by the Free Software Foundation;</code></pre></td>
        <td class="diff"><pre><code>       or any later version published by the Free Software Foundation;</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>       with no Invariant Sections, no Front-Cover Texts, and no Back-Cover</code></pre></td>
        <td class="diff"><pre><code>       with no Invariant Sections, no Front-Cover Texts, and no Back-Cover</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>       Texts.  A copy of the license is included in the section entitled ``GNU</code></pre></td>
        <td class="diff"><pre><code>       Texts.  A copy of the license is included in the section entitled ``GNU</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>       Free Documentation License''.</code></pre></td>
        <td class="diff"><pre><code>       Free Documentation License''.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>   If you have Invariant Sections, Front-Cover Texts and Back-Cover</code></pre></td>
        <td class="diff"><pre><code>   If you have Invariant Sections, Front-Cover Texts and Back-Cover</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>Texts, replace the "with...Texts." line with this:</code></pre></td>
        <td class="diff"><pre><code>Texts, replace the "with...Texts." line with this:</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>         with the Invariant Sections being LIST THEIR TITLES, with</code></pre></td>
        <td class="diff"><pre><code>         with the Invariant Sections being LIST THEIR TITLES, with</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>         the Front-Cover Texts being LIST, and with the Back-Cover Texts</code></pre></td>
        <td class="diff"><pre><code>         the Front-Cover Texts being LIST, and with the Back-Cover Texts</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>         being LIST.</code></pre></td>
        <td class="diff"><pre><code>         being LIST.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>   If you have Invariant Sections without Cover Texts, or some other</code></pre></td>
        <td class="diff"><pre><code>   If you have Invariant Sections without Cover Texts, or some other</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>combination of the three, merge those two alternatives to suit the</code></pre></td>
        <td class="diff"><pre><code>combination of the three, merge those two alternatives to suit the</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>situation.</code></pre></td>
        <td class="diff"><pre><code>situation.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>   If your document contains nontrivial examples of program code, we</code></pre></td>
        <td class="diff"><pre><code>   If your document contains nontrivial examples of program code, we</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>recommend releasing these examples in parallel under your choice of</code></pre></td>
        <td class="diff"><pre><code>recommend releasing these examples in parallel under your choice of</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>free software license, such as the GNU General Public License, to</code></pre></td>
        <td class="diff"><pre><code>free software license, such as the GNU General Public License, to</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code>permit their use in free software.</code></pre></td>
        <td class="diff"><pre><code>permit their use in free software.</code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre><code></code></pre></td>
        <td class="diff"><pre><code></code></pre></td>
      </tr>
      <tr class="diffcode">
        <td class="diff"><pre> </pre></td>
        <td class="diff"><pre> </pre></td>
      </tr>
    </tbody>
   </table>
</div>
</div>
<div id="websvnfooter">
    <p style="padding:0; margin:0"><small>powered by: <a href="http://www.websvn.info">WebSVN 2.1.0</a></small></p>
</div>
        </div>

                
        <div style="clear: both; margin-left: 200px;">
            <ins
                class="adsbygoogle"
                style="display:inline-block;width:728px;height:90px"
                data-ad-client="ca-pub-8561717607970465"
                data-ad-slot="4128044249"></ins>
            <script type="text/javascript">(adsbygoogle = window.adsbygoogle || []).push({});</script>
        </div>
        
            </div>
    <div class="bot">
        © copyright 1999-2024
OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.
    </div>
</div>

<!-- Old browser warning -->
<script type="text/javascript">
  if (!('borderImage' in document.createElement('div').style)) {
    var div = document.getElementById('old-browser-warning')
    div.innerHTML = '<b>Your browser is out-of-date!</b>        Update your browser to view this website correctly.'
    div.setAttribute('style', 'background-color: red; border-bottom: 2px solid black; margin: 0 -12px 12px -12px; padding: 12px; text-align: center;')
  }
</script>
<!-- /Old browser warning -->
<!-- Google search -->
<script type="text/javascript" src="//www.google.com/jsapi"></script>
<script type="text/javascript">google.load("elements", "1", {packages: "transliteration"});</script>
<script type="text/javascript" src="//www.google.com/coop/cse/t13n?form=cse-search-box&t13n_langs=en"></script>
<script type="text/javascript" src="//www.google.com/coop/cse/brand?form=cse-search-box&lang=en"></script>
<!-- /Google search -->

</body>
</html>

Browse

Tools

Subversion Repositories openrisc_2011-10-31

[/] [openrisc/] [tags/] [gnu-src/] [gdb-6.8/] [pre-binutils-2.20.1-sync/] [gdb/] [doc/] [gdbint.info-1] - Diff between revs 157 and 223