| This is gdb.info, produced by makeinfo version 4.8 from |
| ../.././gdb/doc/gdb.texinfo. |
| |
| INFO-DIR-SECTION Software development |
| START-INFO-DIR-ENTRY |
| * Gdb: (gdb). The GNU debugger. |
| END-INFO-DIR-ENTRY |
| |
| This file documents the GNU debugger GDB. |
| |
| This is the Ninth Edition, of `Debugging with GDB: the GNU |
| Source-Level Debugger' for GDB Version 6.8. |
| |
| Copyright (C) 1988, 1989, 1990, 1991, 1992, 1993, 1994, 1995, 1996, |
| 1998, |
| 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006 |
| Free Software Foundation, Inc. |
| |
| Permission is granted to copy, distribute and/or modify this document |
| under the terms of the GNU Free Documentation License, Version 1.1 or |
| any later version published by the Free Software Foundation; with the |
| Invariant Sections being "Free Software" and "Free Software Needs Free |
| Documentation", with the Front-Cover Texts being "A GNU Manual," and |
| with the Back-Cover Texts as in (a) below. |
| |
| (a) The FSF's Back-Cover Text is: "You are free to copy and modify |
| this GNU Manual. Buying copies from GNU Press supports the FSF in |
| developing GNU and promoting software freedom." |
| |
| |
| File: gdb.info, Node: Bytecode Descriptions, Next: Using Agent Expressions, Prev: General Bytecode Design, Up: Agent Expressions |
| |
| E.2 Bytecode Descriptions |
| ========================= |
| |
| Each bytecode description has the following form: |
| |
| `add' (0x02): A B => A+B |
| Pop the top two stack items, A and B, as integers; push their sum, |
| as an integer. |
| |
| |
| In this example, `add' is the name of the bytecode, and `(0x02)' is |
| the one-byte value used to encode the bytecode, in hexadecimal. The |
| phrase "A B => A+B" shows the stack before and after the bytecode |
| executes. Beforehand, the stack must contain at least two values, A |
| and B; since the top of the stack is to the right, B is on the top of |
| the stack, and A is underneath it. After execution, the bytecode will |
| have popped A and B from the stack, and replaced them with a single |
| value, A+B. There may be other values on the stack below those shown, |
| but the bytecode affects only those shown. |
| |
| Here is another example: |
| |
| `const8' (0x22) N: => N |
| Push the 8-bit integer constant N on the stack, without sign |
| extension. |
| |
| |
| In this example, the bytecode `const8' takes an operand N directly |
| from the bytecode stream; the operand follows the `const8' bytecode |
| itself. We write any such operands immediately after the name of the |
| bytecode, before the colon, and describe the exact encoding of the |
| operand in the bytecode stream in the body of the bytecode description. |
| |
| For the `const8' bytecode, there are no stack items given before the |
| =>; this simply means that the bytecode consumes no values from the |
| stack. If a bytecode consumes no values, or produces no values, the |
| list on either side of the => may be empty. |
| |
| If a value is written as A, B, or N, then the bytecode treats it as |
| an integer. If a value is written is ADDR, then the bytecode treats it |
| as an address. |
| |
| We do not fully describe the floating point operations here; although |
| this design can be extended in a clean way to handle floating point |
| values, they are not of immediate interest to the customer, so we avoid |
| describing them, to save time. |
| |
| `float' (0x01): => |
| Prefix for floating-point bytecodes. Not implemented yet. |
| |
| `add' (0x02): A B => A+B |
| Pop two integers from the stack, and push their sum, as an integer. |
| |
| `sub' (0x03): A B => A-B |
| Pop two integers from the stack, subtract the top value from the |
| next-to-top value, and push the difference. |
| |
| `mul' (0x04): A B => A*B |
| Pop two integers from the stack, multiply them, and push the |
| product on the stack. Note that, when one multiplies two N-bit |
| numbers yielding another N-bit number, it is irrelevant whether the |
| numbers are signed or not; the results are the same. |
| |
| `div_signed' (0x05): A B => A/B |
| Pop two signed integers from the stack; divide the next-to-top |
| value by the top value, and push the quotient. If the divisor is |
| zero, terminate with an error. |
| |
| `div_unsigned' (0x06): A B => A/B |
| Pop two unsigned integers from the stack; divide the next-to-top |
| value by the top value, and push the quotient. If the divisor is |
| zero, terminate with an error. |
| |
| `rem_signed' (0x07): A B => A MODULO B |
| Pop two signed integers from the stack; divide the next-to-top |
| value by the top value, and push the remainder. If the divisor is |
| zero, terminate with an error. |
| |
| `rem_unsigned' (0x08): A B => A MODULO B |
| Pop two unsigned integers from the stack; divide the next-to-top |
| value by the top value, and push the remainder. If the divisor is |
| zero, terminate with an error. |
| |
| `lsh' (0x09): A B => A<<B |
| Pop two integers from the stack; let A be the next-to-top value, |
| and B be the top value. Shift A left by B bits, and push the |
| result. |
| |
| `rsh_signed' (0x0a): A B => `(signed)'A>>B |
| Pop two integers from the stack; let A be the next-to-top value, |
| and B be the top value. Shift A right by B bits, inserting copies |
| of the top bit at the high end, and push the result. |
| |
| `rsh_unsigned' (0x0b): A B => A>>B |
| Pop two integers from the stack; let A be the next-to-top value, |
| and B be the top value. Shift A right by B bits, inserting zero |
| bits at the high end, and push the result. |
| |
| `log_not' (0x0e): A => !A |
| Pop an integer from the stack; if it is zero, push the value one; |
| otherwise, push the value zero. |
| |
| `bit_and' (0x0f): A B => A&B |
| Pop two integers from the stack, and push their bitwise `and'. |
| |
| `bit_or' (0x10): A B => A|B |
| Pop two integers from the stack, and push their bitwise `or'. |
| |
| `bit_xor' (0x11): A B => A^B |
| Pop two integers from the stack, and push their bitwise |
| exclusive-`or'. |
| |
| `bit_not' (0x12): A => ~A |
| Pop an integer from the stack, and push its bitwise complement. |
| |
| `equal' (0x13): A B => A=B |
| Pop two integers from the stack; if they are equal, push the value |
| one; otherwise, push the value zero. |
| |
| `less_signed' (0x14): A B => A<B |
| Pop two signed integers from the stack; if the next-to-top value |
| is less than the top value, push the value one; otherwise, push |
| the value zero. |
| |
| `less_unsigned' (0x15): A B => A<B |
| Pop two unsigned integers from the stack; if the next-to-top value |
| is less than the top value, push the value one; otherwise, push |
| the value zero. |
| |
| `ext' (0x16) N: A => A, sign-extended from N bits |
| Pop an unsigned value from the stack; treating it as an N-bit |
| twos-complement value, extend it to full length. This means that |
| all bits to the left of bit N-1 (where the least significant bit |
| is bit 0) are set to the value of bit N-1. Note that N may be |
| larger than or equal to the width of the stack elements of the |
| bytecode engine; in this case, the bytecode should have no effect. |
| |
| The number of source bits to preserve, N, is encoded as a single |
| byte unsigned integer following the `ext' bytecode. |
| |
| `zero_ext' (0x2a) N: A => A, zero-extended from N bits |
| Pop an unsigned value from the stack; zero all but the bottom N |
| bits. This means that all bits to the left of bit N-1 (where the |
| least significant bit is bit 0) are set to the value of bit N-1. |
| |
| The number of source bits to preserve, N, is encoded as a single |
| byte unsigned integer following the `zero_ext' bytecode. |
| |
| `ref8' (0x17): ADDR => A |
| `ref16' (0x18): ADDR => A |
| `ref32' (0x19): ADDR => A |
| `ref64' (0x1a): ADDR => A |
| Pop an address ADDR from the stack. For bytecode `ref'N, fetch an |
| N-bit value from ADDR, using the natural target endianness. Push |
| the fetched value as an unsigned integer. |
| |
| Note that ADDR may not be aligned in any particular way; the |
| `refN' bytecodes should operate correctly for any address. |
| |
| If attempting to access memory at ADDR would cause a processor |
| exception of some sort, terminate with an error. |
| |
| `ref_float' (0x1b): ADDR => D |
| `ref_double' (0x1c): ADDR => D |
| `ref_long_double' (0x1d): ADDR => D |
| `l_to_d' (0x1e): A => D |
| `d_to_l' (0x1f): D => A |
| Not implemented yet. |
| |
| `dup' (0x28): A => A A |
| Push another copy of the stack's top element. |
| |
| `swap' (0x2b): A B => B A |
| Exchange the top two items on the stack. |
| |
| `pop' (0x29): A => |
| Discard the top value on the stack. |
| |
| `if_goto' (0x20) OFFSET: A => |
| Pop an integer off the stack; if it is non-zero, branch to the |
| given offset in the bytecode string. Otherwise, continue to the |
| next instruction in the bytecode stream. In other words, if A is |
| non-zero, set the `pc' register to `start' + OFFSET. Thus, an |
| offset of zero denotes the beginning of the expression. |
| |
| The OFFSET is stored as a sixteen-bit unsigned value, stored |
| immediately following the `if_goto' bytecode. It is always stored |
| most significant byte first, regardless of the target's normal |
| endianness. The offset is not guaranteed to fall at any particular |
| alignment within the bytecode stream; thus, on machines where |
| fetching a 16-bit on an unaligned address raises an exception, you |
| should fetch the offset one byte at a time. |
| |
| `goto' (0x21) OFFSET: => |
| Branch unconditionally to OFFSET; in other words, set the `pc' |
| register to `start' + OFFSET. |
| |
| The offset is stored in the same way as for the `if_goto' bytecode. |
| |
| `const8' (0x22) N: => N |
| `const16' (0x23) N: => N |
| `const32' (0x24) N: => N |
| `const64' (0x25) N: => N |
| Push the integer constant N on the stack, without sign extension. |
| To produce a small negative value, push a small twos-complement |
| value, and then sign-extend it using the `ext' bytecode. |
| |
| The constant N is stored in the appropriate number of bytes |
| following the `const'B bytecode. The constant N is always stored |
| most significant byte first, regardless of the target's normal |
| endianness. The constant is not guaranteed to fall at any |
| particular alignment within the bytecode stream; thus, on machines |
| where fetching a 16-bit on an unaligned address raises an |
| exception, you should fetch N one byte at a time. |
| |
| `reg' (0x26) N: => A |
| Push the value of register number N, without sign extension. The |
| registers are numbered following GDB's conventions. |
| |
| The register number N is encoded as a 16-bit unsigned integer |
| immediately following the `reg' bytecode. It is always stored most |
| significant byte first, regardless of the target's normal |
| endianness. The register number is not guaranteed to fall at any |
| particular alignment within the bytecode stream; thus, on machines |
| where fetching a 16-bit on an unaligned address raises an |
| exception, you should fetch the register number one byte at a time. |
| |
| `trace' (0x0c): ADDR SIZE => |
| Record the contents of the SIZE bytes at ADDR in a trace buffer, |
| for later retrieval by GDB. |
| |
| `trace_quick' (0x0d) SIZE: ADDR => ADDR |
| Record the contents of the SIZE bytes at ADDR in a trace buffer, |
| for later retrieval by GDB. SIZE is a single byte unsigned |
| integer following the `trace' opcode. |
| |
| This bytecode is equivalent to the sequence `dup const8 SIZE |
| trace', but we provide it anyway to save space in bytecode strings. |
| |
| `trace16' (0x30) SIZE: ADDR => ADDR |
| Identical to trace_quick, except that SIZE is a 16-bit big-endian |
| unsigned integer, not a single byte. This should probably have |
| been named `trace_quick16', for consistency. |
| |
| `end' (0x27): => |
| Stop executing bytecode; the result should be the top element of |
| the stack. If the purpose of the expression was to compute an |
| lvalue or a range of memory, then the next-to-top of the stack is |
| the lvalue's address, and the top of the stack is the lvalue's |
| size, in bytes. |
| |
| |
| |
| File: gdb.info, Node: Using Agent Expressions, Next: Varying Target Capabilities, Prev: Bytecode Descriptions, Up: Agent Expressions |
| |
| E.3 Using Agent Expressions |
| =========================== |
| |
| Here is a sketch of a full non-stop debugging cycle, showing how agent |
| expressions fit into the process. |
| |
| * The user selects trace points in the program's code at which GDB |
| should collect data. |
| |
| * The user specifies expressions to evaluate at each trace point. |
| These expressions may denote objects in memory, in which case |
| those objects' contents are recorded as the program runs, or |
| computed values, in which case the values themselves are recorded. |
| |
| * GDB transmits the tracepoints and their associated expressions to |
| the GDB agent, running on the debugging target. |
| |
| * The agent arranges to be notified when a trace point is hit. Note |
| that, on some systems, the target operating system is completely |
| responsible for collecting the data; see *Note Tracing on |
| Symmetrix::. |
| |
| * When execution on the target reaches a trace point, the agent |
| evaluates the expressions associated with that trace point, and |
| records the resulting values and memory ranges. |
| |
| * Later, when the user selects a given trace event and inspects the |
| objects and expression values recorded, GDB talks to the agent to |
| retrieve recorded data as necessary to meet the user's requests. |
| If the user asks to see an object whose contents have not been |
| recorded, GDB reports an error. |
| |
| |
| |
| File: gdb.info, Node: Varying Target Capabilities, Next: Tracing on Symmetrix, Prev: Using Agent Expressions, Up: Agent Expressions |
| |
| E.4 Varying Target Capabilities |
| =============================== |
| |
| Some targets don't support floating-point, and some would rather not |
| have to deal with `long long' operations. Also, different targets will |
| have different stack sizes, and different bytecode buffer lengths. |
| |
| Thus, GDB needs a way to ask the target about itself. We haven't |
| worked out the details yet, but in general, GDB should be able to send |
| the target a packet asking it to describe itself. The reply should be a |
| packet whose length is explicit, so we can add new information to the |
| packet in future revisions of the agent, without confusing old versions |
| of GDB, and it should contain a version number. It should contain at |
| least the following information: |
| |
| * whether floating point is supported |
| |
| * whether `long long' is supported |
| |
| * maximum acceptable size of bytecode stack |
| |
| * maximum acceptable length of bytecode expressions |
| |
| * which registers are actually available for collection |
| |
| * whether the target supports disabled tracepoints |
| |
| |
| |
| File: gdb.info, Node: Tracing on Symmetrix, Next: Rationale, Prev: Varying Target Capabilities, Up: Agent Expressions |
| |
| E.5 Tracing on Symmetrix |
| ======================== |
| |
| This section documents the API used by the GDB agent to collect data on |
| Symmetrix systems. |
| |
| Cygnus originally implemented these tracing features to help EMC |
| Corporation debug their Symmetrix high-availability disk drives. The |
| Symmetrix application code already includes substantial tracing |
| facilities; the GDB agent for the Symmetrix system uses those facilities |
| for its own data collection, via the API described here. |
| |
| -- Function: DTC_RESPONSE adbg_find_memory_in_frame (FRAME_DEF *FRAME, |
| char *ADDRESS, char **BUFFER, unsigned int *SIZE) |
| Search the trace frame FRAME for memory saved from ADDRESS. If |
| the memory is available, provide the address of the buffer holding |
| it; otherwise, provide the address of the next saved area. |
| |
| * If the memory at ADDRESS was saved in FRAME, set `*BUFFER' to |
| point to the buffer in which that memory was saved, set |
| `*SIZE' to the number of bytes from ADDRESS that are saved at |
| `*BUFFER', and return `OK_TARGET_RESPONSE'. (Clearly, in |
| this case, the function will always set `*SIZE' to a value |
| greater than zero.) |
| |
| * If FRAME does not record any memory at ADDRESS, set `*SIZE' |
| to the distance from ADDRESS to the start of the saved region |
| with the lowest address higher than ADDRESS. If there is no |
| memory saved from any higher address, set `*SIZE' to zero. |
| Return `NOT_FOUND_TARGET_RESPONSE'. |
| |
| These two possibilities allow the caller to either retrieve the |
| data, or walk the address space to the next saved area. |
| |
| This function allows the GDB agent to map the regions of memory |
| saved in a particular frame, and retrieve their contents efficiently. |
| |
| This function also provides a clean interface between the GDB agent |
| and the Symmetrix tracing structures, making it easier to adapt the GDB |
| agent to future versions of the Symmetrix system, and vice versa. This |
| function searches all data saved in FRAME, whether the data is there at |
| the request of a bytecode expression, or because it falls in one of the |
| format's memory ranges, or because it was saved from the top of the |
| stack. EMC can arbitrarily change and enhance the tracing mechanism, |
| but as long as this function works properly, all collected memory is |
| visible to GDB. |
| |
| The function itself is straightforward to implement. A single pass |
| over the trace frame's stack area, memory ranges, and expression blocks |
| can yield the address of the buffer (if the requested address was |
| saved), and also note the address of the next higher range of memory, |
| to be returned when the search fails. |
| |
| As an example, suppose the trace frame `f' has saved sixteen bytes |
| from address `0x8000' in a buffer at `0x1000', and thirty-two bytes |
| from address `0xc000' in a buffer at `0x1010'. Here are some sample |
| calls, and the effect each would have: |
| |
| `adbg_find_memory_in_frame (f, (char*) 0x8000, &buffer, &size)' |
| This would set `buffer' to `0x1000', set `size' to sixteen, and |
| return `OK_TARGET_RESPONSE', since `f' saves sixteen bytes from |
| `0x8000' at `0x1000'. |
| |
| `adbg_find_memory_in_frame (f, (char *) 0x8004, &buffer, &size)' |
| This would set `buffer' to `0x1004', set `size' to twelve, and |
| return `OK_TARGET_RESPONSE', since `f' saves the twelve bytes from |
| `0x8004' starting four bytes into the buffer at `0x1000'. This |
| shows that request addresses may fall in the middle of saved |
| areas; the function should return the address and size of the |
| remainder of the buffer. |
| |
| `adbg_find_memory_in_frame (f, (char *) 0x8100, &buffer, &size)' |
| This would set `size' to `0x3f00' and return |
| `NOT_FOUND_TARGET_RESPONSE', since there is no memory saved in `f' |
| from the address `0x8100', and the next memory available is at |
| `0x8100 + 0x3f00', or `0xc000'. This shows that request addresses |
| may fall outside of all saved memory ranges; the function should |
| indicate the next saved area, if any. |
| |
| `adbg_find_memory_in_frame (f, (char *) 0x7000, &buffer, &size)' |
| This would set `size' to `0x1000' and return |
| `NOT_FOUND_TARGET_RESPONSE', since the next saved memory is at |
| `0x7000 + 0x1000', or `0x8000'. |
| |
| `adbg_find_memory_in_frame (f, (char *) 0xf000, &buffer, &size)' |
| This would set `size' to zero, and return |
| `NOT_FOUND_TARGET_RESPONSE'. This shows how the function tells the |
| caller that no further memory ranges have been saved. |
| |
| |
| As another example, here is a function which will print out the |
| addresses of all memory saved in the trace frame `frame' on the |
| Symmetrix INLINES console: |
| void |
| print_frame_addresses (FRAME_DEF *frame) |
| { |
| char *addr; |
| char *buffer; |
| unsigned long size; |
| |
| addr = 0; |
| for (;;) |
| { |
| /* Either find out how much memory we have here, or discover |
| where the next saved region is. */ |
| if (adbg_find_memory_in_frame (frame, addr, &buffer, &size) |
| == OK_TARGET_RESPONSE) |
| printp ("saved %x to %x\n", addr, addr + size); |
| if (size == 0) |
| break; |
| addr += size; |
| } |
| } |
| |
| Note that there is not necessarily any connection between the order |
| in which the data is saved in the trace frame, and the order in which |
| `adbg_find_memory_in_frame' will return those memory ranges. The code |
| above will always print the saved memory regions in order of increasing |
| address, while the underlying frame structure might store the data in a |
| random order. |
| |
| [[This section should cover the rest of the Symmetrix functions the |
| stub relies upon, too.]] |
| |
| |
| File: gdb.info, Node: Rationale, Prev: Tracing on Symmetrix, Up: Agent Expressions |
| |
| E.6 Rationale |
| ============= |
| |
| Some of the design decisions apparent above are arguable. |
| |
| What about stack overflow/underflow? |
| GDB should be able to query the target to discover its stack size. |
| Given that information, GDB can determine at translation time |
| whether a given expression will overflow the stack. But this spec |
| isn't about what kinds of error-checking GDB ought to do. |
| |
| Why are you doing everything in LONGEST? |
| Speed isn't important, but agent code size is; using LONGEST |
| brings in a bunch of support code to do things like division, etc. |
| So this is a serious concern. |
| |
| First, note that you don't need different bytecodes for different |
| operand sizes. You can generate code without _knowing_ how big the |
| stack elements actually are on the target. If the target only |
| supports 32-bit ints, and you don't send any 64-bit bytecodes, |
| everything just works. The observation here is that the MIPS and |
| the Alpha have only fixed-size registers, and you can still get |
| C's semantics even though most instructions only operate on |
| full-sized words. You just need to make sure everything is |
| properly sign-extended at the right times. So there is no need |
| for 32- and 64-bit variants of the bytecodes. Just implement |
| everything using the largest size you support. |
| |
| GDB should certainly check to see what sizes the target supports, |
| so the user can get an error earlier, rather than later. But this |
| information is not necessary for correctness. |
| |
| Why don't you have `>' or `<=' operators? |
| I want to keep the interpreter small, and we don't need them. We |
| can combine the `less_' opcodes with `log_not', and swap the order |
| of the operands, yielding all four asymmetrical comparison |
| operators. For example, `(x <= y)' is `! (x > y)', which is `! (y |
| < x)'. |
| |
| Why do you have `log_not'? |
| Why do you have `ext'? |
| Why do you have `zero_ext'? |
| These are all easily synthesized from other instructions, but I |
| expect them to be used frequently, and they're simple, so I |
| include them to keep bytecode strings short. |
| |
| `log_not' is equivalent to `const8 0 equal'; it's used in half the |
| relational operators. |
| |
| `ext N' is equivalent to `const8 S-N lsh const8 S-N rsh_signed', |
| where S is the size of the stack elements; it follows `refM' and |
| REG bytecodes when the value should be signed. See the next |
| bulleted item. |
| |
| `zero_ext N' is equivalent to `constM MASK log_and'; it's used |
| whenever we push the value of a register, because we can't assume |
| the upper bits of the register aren't garbage. |
| |
| Why not have sign-extending variants of the `ref' operators? |
| Because that would double the number of `ref' operators, and we |
| need the `ext' bytecode anyway for accessing bitfields. |
| |
| Why not have constant-address variants of the `ref' operators? |
| Because that would double the number of `ref' operators again, and |
| `const32 ADDRESS ref32' is only one byte longer. |
| |
| Why do the `refN' operators have to support unaligned fetches? |
| GDB will generate bytecode that fetches multi-byte values at |
| unaligned addresses whenever the executable's debugging |
| information tells it to. Furthermore, GDB does not know the value |
| the pointer will have when GDB generates the bytecode, so it |
| cannot determine whether a particular fetch will be aligned or not. |
| |
| In particular, structure bitfields may be several bytes long, but |
| follow no alignment rules; members of packed structures are not |
| necessarily aligned either. |
| |
| In general, there are many cases where unaligned references occur |
| in correct C code, either at the programmer's explicit request, or |
| at the compiler's discretion. Thus, it is simpler to make the GDB |
| agent bytecodes work correctly in all circumstances than to make |
| GDB guess in each case whether the compiler did the usual thing. |
| |
| Why are there no side-effecting operators? |
| Because our current client doesn't want them? That's a cheap |
| answer. I think the real answer is that I'm afraid of |
| implementing function calls. We should re-visit this issue after |
| the present contract is delivered. |
| |
| Why aren't the `goto' ops PC-relative? |
| The interpreter has the base address around anyway for PC bounds |
| checking, and it seemed simpler. |
| |
| Why is there only one offset size for the `goto' ops? |
| Offsets are currently sixteen bits. I'm not happy with this |
| situation either: |
| |
| Suppose we have multiple branch ops with different offset sizes. |
| As I generate code left-to-right, all my jumps are forward jumps |
| (there are no loops in expressions), so I never know the target |
| when I emit the jump opcode. Thus, I have to either always assume |
| the largest offset size, or do jump relaxation on the code after I |
| generate it, which seems like a big waste of time. |
| |
| I can imagine a reasonable expression being longer than 256 bytes. |
| I can't imagine one being longer than 64k. Thus, we need 16-bit |
| offsets. This kind of reasoning is so bogus, but relaxation is |
| pathetic. |
| |
| The other approach would be to generate code right-to-left. Then |
| I'd always know my offset size. That might be fun. |
| |
| Where is the function call bytecode? |
| When we add side-effects, we should add this. |
| |
| Why does the `reg' bytecode take a 16-bit register number? |
| Intel's IA-64 architecture has 128 general-purpose registers, and |
| 128 floating-point registers, and I'm sure it has some random |
| control registers. |
| |
| Why do we need `trace' and `trace_quick'? |
| Because GDB needs to record all the memory contents and registers |
| an expression touches. If the user wants to evaluate an expression |
| `x->y->z', the agent must record the values of `x' and `x->y' as |
| well as the value of `x->y->z'. |
| |
| Don't the `trace' bytecodes make the interpreter less general? |
| They do mean that the interpreter contains special-purpose code, |
| but that doesn't mean the interpreter can only be used for that |
| purpose. If an expression doesn't use the `trace' bytecodes, they |
| don't get in its way. |
| |
| Why doesn't `trace_quick' consume its arguments the way everything else does? |
| In general, you do want your operators to consume their arguments; |
| it's consistent, and generally reduces the amount of stack |
| rearrangement necessary. However, `trace_quick' is a kludge to |
| save space; it only exists so we needn't write `dup const8 SIZE |
| trace' before every memory reference. Therefore, it's okay for it |
| not to consume its arguments; it's meant for a specific context in |
| which we know exactly what it should do with the stack. If we're |
| going to have a kludge, it should be an effective kludge. |
| |
| Why does `trace16' exist? |
| That opcode was added by the customer that contracted Cygnus for |
| the data tracing work. I personally think it is unnecessary; |
| objects that large will be quite rare, so it is okay to use `dup |
| const16 SIZE trace' in those cases. |
| |
| Whatever we decide to do with `trace16', we should at least leave |
| opcode 0x30 reserved, to remain compatible with the customer who |
| added it. |
| |
| |
| |
| File: gdb.info, Node: Target Descriptions, Next: Copying, Prev: Agent Expressions, Up: Top |
| |
| Appendix F Target Descriptions |
| ****************************** |
| |
| *Warning:* target descriptions are still under active development, and |
| the contents and format may change between GDB releases. The format is |
| expected to stabilize in the future. |
| |
| One of the challenges of using GDB to debug embedded systems is that |
| there are so many minor variants of each processor architecture in use. |
| It is common practice for vendors to start with a standard processor |
| core -- ARM, PowerPC, or MIPS, for example -- and then make changes to |
| adapt it to a particular market niche. Some architectures have |
| hundreds of variants, available from dozens of vendors. This leads to |
| a number of problems: |
| |
| * With so many different customized processors, it is difficult for |
| the GDB maintainers to keep up with the changes. |
| |
| * Since individual variants may have short lifetimes or limited |
| audiences, it may not be worthwhile to carry information about |
| every variant in the GDB source tree. |
| |
| * When GDB does support the architecture of the embedded system at |
| hand, the task of finding the correct architecture name to give the |
| `set architecture' command can be error-prone. |
| |
| To address these problems, the GDB remote protocol allows a target |
| system to not only identify itself to GDB, but to actually describe its |
| own features. This lets GDB support processor variants it has never |
| seen before -- to the extent that the descriptions are accurate, and |
| that GDB understands them. |
| |
| GDB must be linked with the Expat library to support XML target |
| descriptions. *Note Expat::. |
| |
| * Menu: |
| |
| * Retrieving Descriptions:: How descriptions are fetched from a target. |
| * Target Description Format:: The contents of a target description. |
| * Predefined Target Types:: Standard types available for target |
| descriptions. |
| * Standard Target Features:: Features GDB knows about. |
| |
| |
| File: gdb.info, Node: Retrieving Descriptions, Next: Target Description Format, Up: Target Descriptions |
| |
| F.1 Retrieving Descriptions |
| =========================== |
| |
| Target descriptions can be read from the target automatically, or |
| specified by the user manually. The default behavior is to read the |
| description from the target. GDB retrieves it via the remote protocol |
| using `qXfer' requests (*note qXfer: General Query Packets.). The |
| ANNEX in the `qXfer' packet will be `target.xml'. The contents of the |
| `target.xml' annex are an XML document, of the form described in *Note |
| Target Description Format::. |
| |
| Alternatively, you can specify a file to read for the target |
| description. If a file is set, the target will not be queried. The |
| commands to specify a file are: |
| |
| `set tdesc filename PATH' |
| Read the target description from PATH. |
| |
| `unset tdesc filename' |
| Do not read the XML target description from a file. GDB will use |
| the description supplied by the current target. |
| |
| `show tdesc filename' |
| Show the filename to read for a target description, if any. |
| |
| |
| File: gdb.info, Node: Target Description Format, Next: Predefined Target Types, Prev: Retrieving Descriptions, Up: Target Descriptions |
| |
| F.2 Target Description Format |
| ============================= |
| |
| A target description annex is an XML (http://www.w3.org/XML/) document |
| which complies with the Document Type Definition provided in the GDB |
| sources in `gdb/features/gdb-target.dtd'. This means you can use |
| generally available tools like `xmllint' to check that your feature |
| descriptions are well-formed and valid. However, to help people |
| unfamiliar with XML write descriptions for their targets, we also |
| describe the grammar here. |
| |
| Target descriptions can identify the architecture of the remote |
| target and (for some architectures) provide information about custom |
| register sets. GDB can use this information to autoconfigure for your |
| target, or to warn you if you connect to an unsupported target. |
| |
| Here is a simple target description: |
| |
| <target version="1.0"> |
| <architecture>i386:x86-64</architecture> |
| </target> |
| |
| This minimal description only says that the target uses the x86-64 |
| architecture. |
| |
| A target description has the following overall form, with [ ] marking |
| optional elements and ... marking repeatable elements. The elements |
| are explained further below. |
| |
| <?xml version="1.0"?> |
| <!DOCTYPE target SYSTEM "gdb-target.dtd"> |
| <target version="1.0"> |
| [ARCHITECTURE] |
| [FEATURE...] |
| </target> |
| |
| The description is generally insensitive to whitespace and line breaks, |
| under the usual common-sense rules. The XML version declaration and |
| document type declaration can generally be omitted (GDB does not |
| require them), but specifying them may be useful for XML validation |
| tools. The `version' attribute for `<target>' may also be omitted, but |
| we recommend including it; if future versions of GDB use an incompatible |
| revision of `gdb-target.dtd', they will detect and report the version |
| mismatch. |
| |
| F.2.1 Inclusion |
| --------------- |
| |
| It can sometimes be valuable to split a target description up into |
| several different annexes, either for organizational purposes, or to |
| share files between different possible target descriptions. You can |
| divide a description into multiple files by replacing any element of |
| the target description with an inclusion directive of the form: |
| |
| <xi:include href="DOCUMENT"/> |
| |
| When GDB encounters an element of this form, it will retrieve the named |
| XML DOCUMENT, and replace the inclusion directive with the contents of |
| that document. If the current description was read using `qXfer', then |
| so will be the included document; DOCUMENT will be interpreted as the |
| name of an annex. If the current description was read from a file, GDB |
| will look for DOCUMENT as a file in the same directory where it found |
| the original description. |
| |
| F.2.2 Architecture |
| ------------------ |
| |
| An `<architecture>' element has this form: |
| |
| <architecture>ARCH</architecture> |
| |
| ARCH is an architecture name from the same selection accepted by |
| `set architecture' (*note Specifying a Debugging Target: Targets.). |
| |
| F.2.3 Features |
| -------------- |
| |
| Each `<feature>' describes some logical portion of the target system. |
| Features are currently used to describe available CPU registers and the |
| types of their contents. A `<feature>' element has this form: |
| |
| <feature name="NAME"> |
| [TYPE...] |
| REG... |
| </feature> |
| |
| Each feature's name should be unique within the description. The name |
| of a feature does not matter unless GDB has some special knowledge of |
| the contents of that feature; if it does, the feature should have its |
| standard name. *Note Standard Target Features::. |
| |
| F.2.4 Types |
| ----------- |
| |
| Any register's value is a collection of bits which GDB must interpret. |
| The default interpretation is a two's complement integer, but other |
| types can be requested by name in the register description. Some |
| predefined types are provided by GDB (*note Predefined Target Types::), |
| and the description can define additional composite types. |
| |
| Each type element must have an `id' attribute, which gives a unique |
| (within the containing `<feature>') name to the type. Types must be |
| defined before they are used. |
| |
| Some targets offer vector registers, which can be treated as arrays |
| of scalar elements. These types are written as `<vector>' elements, |
| specifying the array element type, TYPE, and the number of elements, |
| COUNT: |
| |
| <vector id="ID" type="TYPE" count="COUNT"/> |
| |
| If a register's value is usefully viewed in multiple ways, define it |
| with a union type containing the useful representations. The `<union>' |
| element contains one or more `<field>' elements, each of which has a |
| NAME and a TYPE: |
| |
| <union id="ID"> |
| <field name="NAME" type="TYPE"/> |
| ... |
| </union> |
| |
| F.2.5 Registers |
| --------------- |
| |
| Each register is represented as an element with this form: |
| |
| <reg name="NAME" |
| bitsize="SIZE" |
| [regnum="NUM"] |
| [save-restore="SAVE-RESTORE"] |
| [type="TYPE"] |
| [group="GROUP"]/> |
| |
| The components are as follows: |
| |
| NAME |
| The register's name; it must be unique within the target |
| description. |
| |
| BITSIZE |
| The register's size, in bits. |
| |
| REGNUM |
| The register's number. If omitted, a register's number is one |
| greater than that of the previous register (either in the current |
| feature or in a preceeding feature); the first register in the |
| target description defaults to zero. This register number is used |
| to read or write the register; e.g. it is used in the remote `p' |
| and `P' packets, and registers appear in the `g' and `G' packets |
| in order of increasing register number. |
| |
| SAVE-RESTORE |
| Whether the register should be preserved across inferior function |
| calls; this must be either `yes' or `no'. The default is `yes', |
| which is appropriate for most registers except for some system |
| control registers; this is not related to the target's ABI. |
| |
| TYPE |
| The type of the register. TYPE may be a predefined type, a type |
| defined in the current feature, or one of the special types `int' |
| and `float'. `int' is an integer type of the correct size for |
| BITSIZE, and `float' is a floating point type (in the |
| architecture's normal floating point format) of the correct size |
| for BITSIZE. The default is `int'. |
| |
| GROUP |
| The register group to which this register belongs. GROUP must be |
| either `general', `float', or `vector'. If no GROUP is specified, |
| GDB will not display the register in `info registers'. |
| |
| |
| |
| File: gdb.info, Node: Predefined Target Types, Next: Standard Target Features, Prev: Target Description Format, Up: Target Descriptions |
| |
| F.3 Predefined Target Types |
| =========================== |
| |
| Type definitions in the self-description can build up composite types |
| from basic building blocks, but can not define fundamental types. |
| Instead, standard identifiers are provided by GDB for the fundamental |
| types. The currently supported types are: |
| |
| `int8' |
| `int16' |
| `int32' |
| `int64' |
| `int128' |
| Signed integer types holding the specified number of bits. |
| |
| `uint8' |
| `uint16' |
| `uint32' |
| `uint64' |
| `uint128' |
| Unsigned integer types holding the specified number of bits. |
| |
| `code_ptr' |
| `data_ptr' |
| Pointers to unspecified code and data. The program counter and |
| any dedicated return address register may be marked as code |
| pointers; printing a code pointer converts it into a symbolic |
| address. The stack pointer and any dedicated address registers |
| may be marked as data pointers. |
| |
| `ieee_single' |
| Single precision IEEE floating point. |
| |
| `ieee_double' |
| Double precision IEEE floating point. |
| |
| `arm_fpa_ext' |
| The 12-byte extended precision format used by ARM FPA registers. |
| |
| |
| |
| File: gdb.info, Node: Standard Target Features, Prev: Predefined Target Types, Up: Target Descriptions |
| |
| F.4 Standard Target Features |
| ============================ |
| |
| A target description must contain either no registers or all the |
| target's registers. If the description contains no registers, then GDB |
| will assume a default register layout, selected based on the |
| architecture. If the description contains any registers, the default |
| layout will not be used; the standard registers must be described in |
| the target description, in such a way that GDB can recognize them. |
| |
| This is accomplished by giving specific names to feature elements |
| which contain standard registers. GDB will look for features with |
| those names and verify that they contain the expected registers; if any |
| known feature is missing required registers, or if any required feature |
| is missing, GDB will reject the target description. You can add |
| additional registers to any of the standard features -- GDB will |
| display them just as if they were added to an unrecognized feature. |
| |
| This section lists the known features and their expected contents. |
| Sample XML documents for these features are included in the GDB source |
| tree, in the directory `gdb/features'. |
| |
| Names recognized by GDB should include the name of the company or |
| organization which selected the name, and the overall architecture to |
| which the feature applies; so e.g. the feature containing ARM core |
| registers is named `org.gnu.gdb.arm.core'. |
| |
| The names of registers are not case sensitive for the purpose of |
| recognizing standard features, but GDB will only display registers |
| using the capitalization used in the description. |
| |
| * Menu: |
| |
| * ARM Features:: |
| * MIPS Features:: |
| * M68K Features:: |
| * PowerPC Features:: |
| |
| |
| File: gdb.info, Node: ARM Features, Next: MIPS Features, Up: Standard Target Features |
| |
| F.4.1 ARM Features |
| ------------------ |
| |
| The `org.gnu.gdb.arm.core' feature is required for ARM targets. It |
| should contain registers `r0' through `r13', `sp', `lr', `pc', and |
| `cpsr'. |
| |
| The `org.gnu.gdb.arm.fpa' feature is optional. If present, it |
| should contain registers `f0' through `f7' and `fps'. |
| |
| The `org.gnu.gdb.xscale.iwmmxt' feature is optional. If present, it |
| should contain at least registers `wR0' through `wR15' and `wCGR0' |
| through `wCGR3'. The `wCID', `wCon', `wCSSF', and `wCASF' registers |
| are optional. |
| |
| |
| File: gdb.info, Node: MIPS Features, Next: M68K Features, Prev: ARM Features, Up: Standard Target Features |
| |
| F.4.2 MIPS Features |
| ------------------- |
| |
| The `org.gnu.gdb.mips.cpu' feature is required for MIPS targets. It |
| should contain registers `r0' through `r31', `lo', `hi', and `pc'. |
| They may be 32-bit or 64-bit depending on the target. |
| |
| The `org.gnu.gdb.mips.cp0' feature is also required. It should |
| contain at least the `status', `badvaddr', and `cause' registers. They |
| may be 32-bit or 64-bit depending on the target. |
| |
| The `org.gnu.gdb.mips.fpu' feature is currently required, though it |
| may be optional in a future version of GDB. It should contain |
| registers `f0' through `f31', `fcsr', and `fir'. They may be 32-bit or |
| 64-bit depending on the target. |
| |
| The `org.gnu.gdb.mips.linux' feature is optional. It should contain |
| a single register, `restart', which is used by the Linux kernel to |
| control restartable syscalls. |
| |
| |
| File: gdb.info, Node: M68K Features, Next: PowerPC Features, Prev: MIPS Features, Up: Standard Target Features |
| |
| F.4.3 M68K Features |
| ------------------- |
| |
| ``org.gnu.gdb.m68k.core'' |
| ``org.gnu.gdb.coldfire.core'' |
| ``org.gnu.gdb.fido.core'' |
| One of those features must be always present. The feature that is |
| present determines which flavor of m86k is used. The feature that |
| is present should contain registers `d0' through `d7', `a0' |
| through `a5', `fp', `sp', `ps' and `pc'. |
| |
| ``org.gnu.gdb.coldfire.fp'' |
| This feature is optional. If present, it should contain registers |
| `fp0' through `fp7', `fpcontrol', `fpstatus' and `fpiaddr'. |
| |
| |
| File: gdb.info, Node: PowerPC Features, Prev: M68K Features, Up: Standard Target Features |
| |
| F.4.4 PowerPC Features |
| ---------------------- |
| |
| The `org.gnu.gdb.power.core' feature is required for PowerPC targets. |
| It should contain registers `r0' through `r31', `pc', `msr', `cr', |
| `lr', `ctr', and `xer'. They may be 32-bit or 64-bit depending on the |
| target. |
| |
| The `org.gnu.gdb.power.fpu' feature is optional. It should contain |
| registers `f0' through `f31' and `fpscr'. |
| |
| The `org.gnu.gdb.power.altivec' feature is optional. It should |
| contain registers `vr0' through `vr31', `vscr', and `vrsave'. |
| |
| The `org.gnu.gdb.power.spe' feature is optional. It should contain |
| registers `ev0h' through `ev31h', `acc', and `spefscr'. SPE targets |
| should provide 32-bit registers in `org.gnu.gdb.power.core' and provide |
| the upper halves in `ev0h' through `ev31h'. GDB will combine these to |
| present registers `ev0' through `ev31' to the user. |
| |
| |
| File: gdb.info, Node: Copying, Next: GNU Free Documentation License, Prev: Target Descriptions, Up: Top |
| |
| Appendix G GNU GENERAL PUBLIC LICENSE |
| ************************************* |
| |
| Version 2, June 1991 |
| |
| Copyright (C) 1989, 1991 Free Software Foundation, Inc. |
| 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. |
| |
| Everyone is permitted to copy and distribute verbatim copies |
| of this license document, but changing it is not allowed. |
| |
| Preamble |
| ======== |
| |
| The licenses for most software are designed to take away your freedom |
| to share and change it. By contrast, the GNU General Public License is |
| intended to guarantee your freedom to share and change free |
| software--to make sure the software is free for all its users. This |
| General Public License applies to most of the Free Software |
| Foundation's software and to any other program whose authors commit to |
| using it. (Some other Free Software Foundation software is covered by |
| the GNU Library General Public License instead.) You can apply it to |
| your programs, too. |
| |
| When we speak of free software, we are referring to freedom, not |
| price. Our General Public Licenses are designed to make sure that you |
| have the freedom to distribute copies of free software (and charge for |
| this service if you wish), that you receive source code or can get it |
| if you want it, that you can change the software or use pieces of it in |
| new free programs; and that you know you can do these things. |
| |
| To protect your rights, we need to make restrictions that forbid |
| anyone to deny you these rights or to ask you to surrender the rights. |
| These restrictions translate to certain responsibilities for you if you |
| distribute copies of the software, or if you modify it. |
| |
| For example, if you distribute copies of such a program, whether |
| gratis or for a fee, you must give the recipients all the rights that |
| you have. You must make sure that they, too, receive or can get the |
| source code. And you must show them these terms so they know their |
| rights. |
| |
| We protect your rights with two steps: (1) copyright the software, |
| and (2) offer you this license which gives you legal permission to copy, |
| distribute and/or modify the software. |
| |
| Also, for each author's protection and ours, we want to make certain |
| that everyone understands that there is no warranty for this free |
| software. If the software is modified by someone else and passed on, we |
| want its recipients to know that what they have is not the original, so |
| that any problems introduced by others will not reflect on the original |
| authors' reputations. |
| |
| Finally, any free program is threatened constantly by software |
| patents. We wish to avoid the danger that redistributors of a free |
| program will individually obtain patent licenses, in effect making the |
| program proprietary. To prevent this, we have made it clear that any |
| patent must be licensed for everyone's free use or not licensed at all. |
| |
| The precise terms and conditions for copying, distribution and |
| modification follow. |
| |
| TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION |
| 0. This License applies to any program or other work which contains a |
| notice placed by the copyright holder saying it may be distributed |
| under the terms of this General Public License. The "Program", |
| below, refers to any such program or work, and a "work based on |
| the Program" means either the Program or any derivative work under |
| copyright law: that is to say, a work containing the Program or a |
| portion of it, either verbatim or with modifications and/or |
| translated into another language. (Hereinafter, translation is |
| included without limitation in the term "modification".) Each |
| licensee is addressed as "you". |
| |
| Activities other than copying, distribution and modification are |
| not covered by this License; they are outside its scope. The act |
| of running the Program is not restricted, and the output from the |
| Program is covered only if its contents constitute a work based on |
| the Program (independent of having been made by running the |
| Program). Whether that is true depends on what the Program does. |
| |
| 1. You may copy and distribute verbatim copies of the Program's |
| source code as you receive it, in any medium, provided that you |
| conspicuously and appropriately publish on each copy an appropriate |
| copyright notice and disclaimer of warranty; keep intact all the |
| notices that refer to this License and to the absence of any |
| warranty; and give any other recipients of the Program a copy of |
| this License along with the Program. |
| |
| You may charge a fee for the physical act of transferring a copy, |
| and you may at your option offer warranty protection in exchange |
| for a fee. |
| |
| 2. You may modify your copy or copies of the Program or any portion |
| of it, thus forming a work based on the Program, and copy and |
| distribute such modifications or work under the terms of Section 1 |
| above, provided that you also meet all of these conditions: |
| |
| a. You must cause the modified files to carry prominent notices |
| stating that you changed the files and the date of any change. |
| |
| b. You must cause any work that you distribute or publish, that |
| in whole or in part contains or is derived from the Program |
| or any part thereof, to be licensed as a whole at no charge |
| to all third parties under the terms of this License. |
| |
| c. If the modified program normally reads commands interactively |
| when run, you must cause it, when started running for such |
| interactive use in the most ordinary way, to print or display |
| an announcement including an appropriate copyright notice and |
| a notice that there is no warranty (or else, saying that you |
| provide a warranty) and that users may redistribute the |
| program under these conditions, and telling the user how to |
| view a copy of this License. (Exception: if the Program |
| itself is interactive but does not normally print such an |
| announcement, your work based on the Program is not required |
| to print an announcement.) |
| |
| These requirements apply to the modified work as a whole. If |
| identifiable sections of that work are not derived from the |
| Program, and can be reasonably considered independent and separate |
| works in themselves, then this License, and its terms, do not |
| apply to those sections when you distribute them as separate |
| works. But when you distribute the same sections as part of a |
| whole which is a work based on the Program, the distribution of |
| the whole must be on the terms of this License, whose permissions |
| for other licensees extend to the entire whole, and thus to each |
| and every part regardless of who wrote it. |
| |
| Thus, it is not the intent of this section to claim rights or |
| contest your rights to work written entirely by you; rather, the |
| intent is to exercise the right to control the distribution of |
| derivative or collective works based on the Program. |
| |
| In addition, mere aggregation of another work not based on the |
| Program with the Program (or with a work based on the Program) on |
| a volume of a storage or distribution medium does not bring the |
| other work under the scope of this License. |
| |
| 3. You may copy and distribute the Program (or a work based on it, |
| under Section 2) in object code or executable form under the terms |
| of Sections 1 and 2 above provided that you also do one of the |
| following: |
| |
| a. Accompany it with the complete corresponding machine-readable |
| source code, which must be distributed under the terms of |
| Sections 1 and 2 above on a medium customarily used for |
| software interchange; or, |
| |
| b. Accompany it with a written offer, valid for at least three |
| years, to give any third party, for a charge no more than your |
| cost of physically performing source distribution, a complete |
| machine-readable copy of the corresponding source code, to be |
| distributed under the terms of Sections 1 and 2 above on a |
| medium customarily used for software interchange; or, |
| |
| c. Accompany it with the information you received as to the offer |
| to distribute corresponding source code. (This alternative is |
| allowed only for noncommercial distribution and only if you |
| received the program in object code or executable form with |
| such an offer, in accord with Subsection b above.) |
| |
| The source code for a work means the preferred form of the work for |
| making modifications to it. For an executable work, complete |
| source code means all the source code for all modules it contains, |
| plus any associated interface definition files, plus the scripts |
| used to control compilation and installation of the executable. |
| However, as a special exception, the source code distributed need |
| not include anything that is normally distributed (in either |
| source or binary form) with the major components (compiler, |
| kernel, and so on) of the operating system on which the executable |
| runs, unless that component itself accompanies the executable. |
| |
| If distribution of executable or object code is made by offering |
| access to copy from a designated place, then offering equivalent |
| access to copy the source code from the same place counts as |
| distribution of the source code, even though third parties are not |
| compelled to copy the source along with the object code. |
| |
| 4. You may not copy, modify, sublicense, or distribute the Program |
| except as expressly provided under this License. Any attempt |
| otherwise to copy, modify, sublicense or distribute the Program is |
| void, and will automatically terminate your rights under this |
| License. However, parties who have received copies, or rights, |
| from you under this License will not have their licenses |
| terminated so long as such parties remain in full compliance. |
| |
| 5. You are not required to accept this License, since you have not |
| signed it. However, nothing else grants you permission to modify |
| or distribute the Program or its derivative works. These actions |
| are prohibited by law if you do not accept this License. |
| Therefore, by modifying or distributing the Program (or any work |
| based on the Program), you indicate your acceptance of this |
| License to do so, and all its terms and conditions for copying, |
| distributing or modifying the Program or works based on it. |
| |
| 6. Each time you redistribute the Program (or any work based on the |
| Program), the recipient automatically receives a license from the |
| original licensor to copy, distribute or modify the Program |
| subject to these terms and conditions. You may not impose any |
| further restrictions on the recipients' exercise of the rights |
| granted herein. You are not responsible for enforcing compliance |
| by third parties to this License. |
| |
| 7. If, as a consequence of a court judgment or allegation of patent |
| infringement or for any other reason (not limited to patent |
| issues), conditions are imposed on you (whether by court order, |
| agreement or otherwise) that contradict the conditions of this |
| License, they do not excuse you from the conditions of this |
| License. If you cannot distribute so as to satisfy simultaneously |
| your obligations under this License and any other pertinent |
| obligations, then as a consequence you may not distribute the |
| Program at all. For example, if a patent license would not permit |
| royalty-free redistribution of the Program by all those who |
| receive copies directly or indirectly through you, then the only |
| way you could satisfy both it and this License would be to refrain |
| entirely from distribution of the Program. |
| |
| If any portion of this section is held invalid or unenforceable |
| under any particular circumstance, the balance of the section is |
| intended to apply and the section as a whole is intended to apply |
| in other circumstances. |
| |
| It is not the purpose of this section to induce you to infringe any |
| patents or other property right claims or to contest validity of |
| any such claims; this section has the sole purpose of protecting |
| the integrity of the free software distribution system, which is |
| implemented by public license practices. Many people have made |
| generous contributions to the wide range of software distributed |
| through that system in reliance on consistent application of that |
| system; it is up to the author/donor to decide if he or she is |
| willing to distribute software through any other system and a |
| licensee cannot impose that choice. |
| |
| This section is intended to make thoroughly clear what is believed |
| to be a consequence of the rest of this License. |
| |
| 8. If the distribution and/or use of the Program is restricted in |
| certain countries either by patents or by copyrighted interfaces, |
| the original copyright holder who places the Program under this |
| License may add an explicit geographical distribution limitation |
| excluding those countries, so that distribution is permitted only |
| in or among countries not thus excluded. In such case, this |
| License incorporates the limitation as if written in the body of |
| this License. |
| |
| 9. The Free Software Foundation may publish revised and/or new |
| versions of the General Public License from time to time. Such |
| new versions will be similar in spirit to the present version, but |
| may differ in detail to address new problems or concerns. |
| |
| Each version is given a distinguishing version number. If the |
| Program specifies a version number of this License which applies |
| to it and "any later version", you have the option of following |
| the terms and conditions either of that version or of any later |
| version published by the Free Software Foundation. If the Program |
| does not specify a version number of this License, you may choose |
| any version ever published by the Free Software Foundation. |
| |
| 10. If you wish to incorporate parts of the Program into other free |
| programs whose distribution conditions are different, write to the |
| author to ask for permission. For software which is copyrighted |
| by the Free Software Foundation, write to the Free Software |
| Foundation; we sometimes make exceptions for this. Our decision |
| will be guided by the two goals of preserving the free status of |
| all derivatives of our free software and of promoting the sharing |
| and reuse of software generally. |
| |
| NO WARRANTY |
| 11. BECAUSE THE PROGRAM IS LICENSED FREE OF CHARGE, THERE IS NO |
| WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY APPLICABLE |
| LAW. EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT |
| HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM "AS IS" WITHOUT |
| WARRANTY OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT |
| NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND |
| FITNESS FOR A PARTICULAR PURPOSE. THE ENTIRE RISK AS TO THE |
| QUALITY AND PERFORMANCE OF THE PROGRAM IS WITH YOU. SHOULD THE |
| PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY |
| SERVICING, REPAIR OR CORRECTION. |
| |
| 12. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN |
| WRITING WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY |
| MODIFY AND/OR REDISTRIBUTE THE PROGRAM AS PERMITTED ABOVE, BE |
| LIABLE TO YOU FOR DAMAGES, INCLUDING ANY GENERAL, SPECIAL, |
| INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE USE OR |
| INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF |
| DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU |
| OR THIRD PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY |
| OTHER PROGRAMS), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN |
| ADVISED OF THE POSSIBILITY OF SUCH DAMAGES. |
| |
| END OF TERMS AND CONDITIONS |
| How to Apply These Terms to Your New Programs |
| ============================================= |
| |
| If you develop a new program, and you want it to be of the greatest |
| possible use to the public, the best way to achieve this is to make it |
| free software which everyone can redistribute and change under these |
| terms. |
| |
| To do so, attach the following notices to the program. It is safest |
| to attach them to the start of each source file to most effectively |
| convey the exclusion of warranty; and each file should have at least |
| the "copyright" line and a pointer to where the full notice is found. |
| |
| ONE LINE TO GIVE THE PROGRAM'S NAME AND A BRIEF IDEA OF WHAT IT DOES. |
| Copyright (C) YEAR NAME OF AUTHOR |
| |
| This program is free software; you can redistribute it and/or modify |
| it under the terms of the GNU General Public License as published by |
| the Free Software Foundation; either version 2 of the License, or |
| (at your option) any later version. |
| |
| This program is distributed in the hope that it will be useful, |
| but WITHOUT ANY WARRANTY; without even the implied warranty of |
| MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
| GNU General Public License for more details. |
| |
| You should have received a copy of the GNU General Public License |
| along with this program; if not, write to the Free Software |
| Foundation, Inc., 51 Franklin Street, Fifth Floor, |
| Boston, MA 02110-1301, USA. |
| |
| Also add information on how to contact you by electronic and paper |
| mail. |
| |
| If the program is interactive, make it output a short notice like |
| this when it starts in an interactive mode: |
| |
| Gnomovision version 69, Copyright (C) YEAR NAME OF AUTHOR |
| Gnomovision comes with ABSOLUTELY NO WARRANTY; for details |
| type `show w'. |
| This is free software, and you are welcome to redistribute it |
| under certain conditions; type `show c' for details. |
| |
| The hypothetical commands `show w' and `show c' should show the |
| appropriate parts of the General Public License. Of course, the |
| commands you use may be called something other than `show w' and `show |
| c'; they could even be mouse-clicks or menu items--whatever suits your |
| program. |
| |
| You should also get your employer (if you work as a programmer) or |
| your school, if any, to sign a "copyright disclaimer" for the program, |
| if necessary. Here is a sample; alter the names: |
| |
| Yoyodyne, Inc., hereby disclaims all copyright interest in the program |
| `Gnomovision' (which makes passes at compilers) written by James Hacker. |
| |
| SIGNATURE OF TY COON, 1 April 1989 |
| Ty Coon, President of Vice |
| |
| This General Public License does not permit incorporating your |
| program into proprietary programs. If your program is a subroutine |
| library, you may consider it more useful to permit linking proprietary |
| applications with the library. If this is what you want to do, use the |
| GNU Library General Public License instead of this License. |
| |
| |
| File: gdb.info, Node: GNU Free Documentation License, Next: Index, Prev: Copying, Up: Top |
| |
| Appendix H GNU Free Documentation License |
| ***************************************** |
| |
| Version 1.2, November 2002 |
| |
| Copyright (C) 2000,2001,2002 Free Software Foundation, Inc. |
| 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. |
| |
| Everyone is permitted to copy and distribute verbatim copies |
| of this license document, but changing it is not allowed. |
| |
| 0. PREAMBLE |
| |
| The purpose of this License is to make a manual, textbook, or other |
| functional and useful document "free" in the sense of freedom: to |
| assure everyone the effective freedom to copy and redistribute it, |
| with or without modifying it, either commercially or |
| noncommercially. Secondarily, this License preserves for the |
| author and publisher a way to get credit for their work, while not |
| being considered responsible for modifications made by others. |
| |
| This License is a kind of "copyleft", which means that derivative |
| works of the document must themselves be free in the same sense. |
| It complements the GNU General Public License, which is a copyleft |
| license designed for free software. |
| |
| We have designed this License in order to use it for manuals for |
| free software, because free software needs free documentation: a |
| free program should come with manuals providing the same freedoms |
| that the software does. But this License is not limited to |
| software manuals; it can be used for any textual work, regardless |
| of subject matter or whether it is published as a printed book. |
| We recommend this License principally for works whose purpose is |
| instruction or reference. |
| |
| 1. APPLICABILITY AND DEFINITIONS |
| |
| This License applies to any manual or other work, in any medium, |
| that contains a notice placed by the copyright holder saying it |
| can be distributed under the terms of this License. Such a notice |
| grants a world-wide, royalty-free license, unlimited in duration, |
| to use that work under the conditions stated herein. The |
| "Document", below, refers to any such manual or work. Any member |
| of the public is a licensee, and is addressed as "you". You |
| accept the license if you copy, modify or distribute the work in a |
| way requiring permission under copyright law. |
| |
| A "Modified Version" of the Document means any work containing the |
| Document or a portion of it, either copied verbatim, or with |
| modifications and/or translated into another language. |
| |
| A "Secondary Section" is a named appendix or a front-matter section |
| of the Document that deals exclusively with the relationship of the |
| publishers or authors of the Document to the Document's overall |
| subject (or to related matters) and contains nothing that could |
| fall directly within that overall subject. (Thus, if the Document |
| is in part a textbook of mathematics, a Secondary Section may not |
| explain any mathematics.) The relationship could be a matter of |
| historical connection with the subject or with related matters, or |
| of legal, commercial, philosophical, ethical or political position |
| regarding them. |
| |
| The "Invariant Sections" are certain Secondary Sections whose |
| titles are designated, as being those of Invariant Sections, in |
| the notice that says that the Document is released under this |
| License. If a section does not fit the above definition of |
| Secondary then it is not allowed to be designated as Invariant. |
| The Document may contain zero Invariant Sections. If the Document |
| does not identify any Invariant Sections then there are none. |
| |
| The "Cover Texts" are certain short passages of text that are |
| listed, as Front-Cover Texts or Back-Cover Texts, in the notice |
| that says that the Document is released under this License. A |
| Front-Cover Text may be at most 5 words, and a Back-Cover Text may |
| be at most 25 words. |
| |
| A "Transparent" copy of the Document means a machine-readable copy, |
| represented in a format whose specification is available to the |
| general public, that is suitable for revising the document |
| straightforwardly with generic text editors or (for images |
| composed of pixels) generic paint programs or (for drawings) some |
| widely available drawing editor, and that is suitable for input to |
| text formatters or for automatic translation to a variety of |
| formats suitable for input to text formatters. A copy made in an |
| otherwise Transparent file format whose markup, or absence of |
| markup, has been arranged to thwart or discourage subsequent |
| modification by readers is not Transparent. An image format is |
| not Transparent if used for any substantial amount of text. A |
| copy that is not "Transparent" is called "Opaque". |
| |
| Examples of suitable formats for Transparent copies include plain |
| ASCII without markup, Texinfo input format, LaTeX input format, |
| SGML or XML using a publicly available DTD, and |
| standard-conforming simple HTML, PostScript or PDF designed for |
| human modification. Examples of transparent image formats include |
| PNG, XCF and JPG. Opaque formats include proprietary formats that |
| can be read and edited only by proprietary word processors, SGML or |
| XML for which the DTD and/or processing tools are not generally |
| available, and the machine-generated HTML, PostScript or PDF |
| produced by some word processors for output purposes only. |
| |
| The "Title Page" means, for a printed book, the title page itself, |
| plus such following pages as are needed to hold, legibly, the |
| material this License requires to appear in the title page. For |
| works in formats which do not have any title page as such, "Title |
| Page" means the text near the most prominent appearance of the |
| work's title, preceding the beginning of the body of the text. |
| |
| A section "Entitled XYZ" means a named subunit of the Document |
| whose title either is precisely XYZ or contains XYZ in parentheses |
| following text that translates XYZ in another language. (Here XYZ |
| stands for a specific section name mentioned below, such as |
| "Acknowledgements", "Dedications", "Endorsements", or "History".) |
| To "Preserve the Title" of such a section when you modify the |
| Document means that it remains a section "Entitled XYZ" according |
| to this definition. |
| |
| The Document may include Warranty Disclaimers next to the notice |
| which states that this License applies to the Document. These |
| Warranty Disclaimers are considered to be included by reference in |
| this License, but only as regards disclaiming warranties: any other |
| implication that these Warranty Disclaimers may have is void and |
| has no effect on the meaning of this License. |
| |
| 2. VERBATIM COPYING |
| |
| You may copy and distribute the Document in any medium, either |
| commercially or noncommercially, provided that this License, the |
| copyright notices, and the license notice saying this License |
| applies to the Document are reproduced in all copies, and that you |
| add no other conditions whatsoever to those of this License. You |
| may not use technical measures to obstruct or control the reading |
| or further copying of the copies you make or distribute. However, |
| you may accept compensation in exchange for copies. If you |
| distribute a large enough number of copies you must also follow |
| the conditions in section 3. |
| |
| You may also lend copies, under the same conditions stated above, |
| and you may publicly display copies. |
| |
| 3. COPYING IN QUANTITY |
| |
| If you publish printed copies (or copies in media that commonly |
| have printed covers) of the Document, numbering more than 100, and |
| the Document's license notice requires Cover Texts, you must |
| enclose the copies in covers that carry, clearly and legibly, all |
| these Cover Texts: Front-Cover Texts on the front cover, and |
| Back-Cover Texts on the back cover. Both covers must also clearly |
| and legibly identify you as the publisher of these copies. The |
| front cover must present the full title with all words of the |
| title equally prominent and visible. You may add other material |
| on the covers in addition. Copying with changes limited to the |
| covers, as long as they preserve the title of the Document and |
| satisfy these conditions, can be treated as verbatim copying in |
| other respects. |
| |
| If the required texts for either cover are too voluminous to fit |
| legibly, you should put the first ones listed (as many as fit |
| reasonably) on the actual cover, and continue the rest onto |
| adjacent pages. |
| |
| If you publish or distribute Opaque copies of the Document |
| numbering more than 100, you must either include a |
| machine-readable Transparent copy along with each Opaque copy, or |
| state in or with each Opaque copy a computer-network location from |
| which the general network-using public has access to download |
| using public-standard network protocols a complete Transparent |
| copy of the Document, free of added material. If you use the |
| latter option, you must take reasonably prudent steps, when you |
| begin distribution of Opaque copies in quantity, to ensure that |
| this Transparent copy will remain thus accessible at the stated |
| location until at least one year after the last time you |
| distribute an Opaque copy (directly or through your agents or |
| retailers) of that edition to the public. |
| |
| It is requested, but not required, that you contact the authors of |
| the Document well before redistributing any large number of |
| copies, to give them a chance to provide you with an updated |
| version of the Document. |
| |
| 4. MODIFICATIONS |
| |
| You may copy and distribute a Modified Version of the Document |
| under the conditions of sections 2 and 3 above, provided that you |
| release the Modified Version under precisely this License, with |
| the Modified Version filling the role of the Document, thus |
| licensing distribution and modification of the Modified Version to |
| whoever possesses a copy of it. In addition, you must do these |
| things in the Modified Version: |
| |
| A. Use in the Title Page (and on the covers, if any) a title |
| distinct from that of the Document, and from those of |
| previous versions (which should, if there were any, be listed |
| in the History section of the Document). You may use the |
| same title as a previous version if the original publisher of |
| that version gives permission. |
| |
| B. List on the Title Page, as authors, one or more persons or |
| entities responsible for authorship of the modifications in |
| the Modified Version, together with at least five of the |
| principal authors of the Document (all of its principal |
| authors, if it has fewer than five), unless they release you |
| from this requirement. |
| |
| C. State on the Title page the name of the publisher of the |
| Modified Version, as the publisher. |
| |
| D. Preserve all the copyright notices of the Document. |
| |
| E. Add an appropriate copyright notice for your modifications |
| adjacent to the other copyright notices. |
| |
| F. Include, immediately after the copyright notices, a license |
| notice giving the public permission to use the Modified |
| Version under the terms of this License, in the form shown in |
| the Addendum below. |
| |
| G. Preserve in that license notice the full lists of Invariant |
| Sections and required Cover Texts given in the Document's |
| license notice. |
| |
| H. Include an unaltered copy of this License. |
| |
| I. Preserve the section Entitled "History", Preserve its Title, |
| and add to it an item stating at least the title, year, new |
| authors, and publisher of the Modified Version as given on |
| the Title Page. If there is no section Entitled "History" in |
| the Document, create one stating the title, year, authors, |
| and publisher of the Document as given on its Title Page, |
| then add an item describing the Modified Version as stated in |
| the previous sentence. |
| |
| J. Preserve the network location, if any, given in the Document |
| for public access to a Transparent copy of the Document, and |
| likewise the network locations given in the Document for |
| previous versions it was based on. These may be placed in |
| the "History" section. You may omit a network location for a |
| work that was published at least four years before the |
| Document itself, or if the original publisher of the version |
| it refers to gives permission. |
| |
| K. For any section Entitled "Acknowledgements" or "Dedications", |
| Preserve the Title of the section, and preserve in the |
| section all the substance and tone of each of the contributor |
| acknowledgements and/or dedications given therein. |
| |
| L. Preserve all the Invariant Sections of the Document, |
| unaltered in their text and in their titles. Section numbers |
| or the equivalent are not considered part of the section |
| titles. |
| |
| M. Delete any section Entitled "Endorsements". Such a section |
| may not be included in the Modified Version. |
| |
| N. Do not retitle any existing section to be Entitled |
| "Endorsements" or to conflict in title with any Invariant |
| Section. |
| |
| O. Preserve any Warranty Disclaimers. |
| |
| If the Modified Version includes new front-matter sections or |
| appendices that qualify as Secondary Sections and contain no |
| material copied from the Document, you may at your option |
| designate some or all of these sections as invariant. To do this, |
| add their titles to the list of Invariant Sections in the Modified |
| Version's license notice. These titles must be distinct from any |
| other section titles. |
| |
| You may add a section Entitled "Endorsements", provided it contains |
| nothing but endorsements of your Modified Version by various |
| parties--for example, statements of peer review or that the text |
| has been approved by an organization as the authoritative |
| definition of a standard. |
| |
| You may add a passage of up to five words as a Front-Cover Text, |
| and a passage of up to 25 words as a Back-Cover Text, to the end |
| of the list of Cover Texts in the Modified Version. Only one |
| passage of Front-Cover Text and one of Back-Cover Text may be |
| added by (or through arrangements made by) any one entity. If the |
| Document already includes a cover text for the same cover, |
| previously added by you or by arrangement made by the same entity |
| you are acting on behalf of, you may not add another; but you may |
| replace the old one, on explicit permission from the previous |
| publisher that added the old one. |
| |
| The author(s) and publisher(s) of the Document do not by this |
| License give permission to use their names for publicity for or to |
| assert or imply endorsement of any Modified Version. |
| |
| 5. COMBINING DOCUMENTS |
| |
| You may combine the Document with other documents released under |
| this License, under the terms defined in section 4 above for |
| modified versions, provided that you include in the combination |
| all of the Invariant Sections of all of the original documents, |
| unmodified, and list them all as Invariant Sections of your |
| combined work in its license notice, and that you preserve all |
| their Warranty Disclaimers. |
| |
| The combined work need only contain one copy of this License, and |
| multiple identical Invariant Sections may be replaced with a single |
| copy. If there are multiple Invariant Sections with the same name |
| but different contents, make the title of each such section unique |
| by adding at the end of it, in parentheses, the name of the |
| original author or publisher of that section if known, or else a |
| unique number. Make the same adjustment to the section titles in |
| the list of Invariant Sections in the license notice of the |
| combined work. |
| |
| In the combination, you must combine any sections Entitled |
| "History" in the various original documents, forming one section |
| Entitled "History"; likewise combine any sections Entitled |
| "Acknowledgements", and any sections Entitled "Dedications". You |
| must delete all sections Entitled "Endorsements." |
| |
| 6. COLLECTIONS OF DOCUMENTS |
| |
| You may make a collection consisting of the Document and other |
| documents released under this License, and replace the individual |
| copies of this License in the various documents with a single copy |
| that is included in the collection, provided that you follow the |
| rules of this License for verbatim copying of each of the |
| documents in all other respects. |
| |
| You may extract a single document from such a collection, and |
| distribute it individually under this License, provided you insert |
| a copy of this License into the extracted document, and follow |
| this License in all other respects regarding verbatim copying of |
| that document. |
| |
| 7. AGGREGATION WITH INDEPENDENT WORKS |
| |
| A compilation of the Document or its derivatives with other |
| separate and independent documents or works, in or on a volume of |
| a storage or distribution medium, is called an "aggregate" if the |
| copyright resulting from the compilation is not used to limit the |
| legal rights of the compilation's users beyond what the individual |
| works permit. When the Document is included in an aggregate, this |
| License does not apply to the other works in the aggregate which |
| are not themselves derivative works of the Document. |
| |
| If the Cover Text requirement of section 3 is applicable to these |
| copies of the Document, then if the Document is less than one half |
| of the entire aggregate, the Document's Cover Texts may be placed |
| on covers that bracket the Document within the aggregate, or the |
| electronic equivalent of covers if the Document is in electronic |
| form. Otherwise they must appear on printed covers that bracket |
| the whole aggregate. |
| |
| 8. TRANSLATION |
| |
| Translation is considered a kind of modification, so you may |
| distribute translations of the Document under the terms of section |
| 4. Replacing Invariant Sections with translations requires special |
| permission from their copyright holders, but you may include |
| translations of some or all Invariant Sections in addition to the |
| original versions of these Invariant Sections. You may include a |
| translation of this License, and all the license notices in the |
| Document, and any Warranty Disclaimers, provided that you also |
| include the original English version of this License and the |
| original versions of those notices and disclaimers. In case of a |
| disagreement between the translation and the original version of |
| this License or a notice or disclaimer, the original version will |
| prevail. |
| |
| If a section in the Document is Entitled "Acknowledgements", |
| "Dedications", or "History", the requirement (section 4) to |
| Preserve its Title (section 1) will typically require changing the |
| actual title. |
| |
| 9. TERMINATION |
| |
| You may not copy, modify, sublicense, or distribute the Document |
| except as expressly provided for under this License. Any other |
| attempt to copy, modify, sublicense or distribute the Document is |
| void, and will automatically terminate your rights under this |
| License. However, parties who have received copies, or rights, |
| from you under this License will not have their licenses |
| terminated so long as such parties remain in full compliance. |
| |
| 10. FUTURE REVISIONS OF THIS LICENSE |
| |
| The Free Software Foundation may publish new, revised versions of |
| the GNU Free Documentation License from time to time. Such new |
| versions will be similar in spirit to the present version, but may |
| differ in detail to address new problems or concerns. See |
| `http://www.gnu.org/copyleft/'. |
| |
| Each version of the License is given a distinguishing version |
| number. If the Document specifies that a particular numbered |
| version of this License "or any later version" applies to it, you |
| have the option of following the terms and conditions either of |
| that specified version or of any later version that has been |
| published (not as a draft) by the Free Software Foundation. If |
| the Document does not specify a version number of this License, |
| you may choose any version ever published (not as a draft) by the |
| Free Software Foundation. |
| |
| H.1 ADDENDUM: How to use this License for your documents |
| ======================================================== |
| |
| To use this License in a document you have written, include a copy of |
| the License in the document and put the following copyright and license |
| notices just after the title page: |
| |
| Copyright (C) YEAR YOUR NAME. |
| Permission is granted to copy, distribute and/or modify this document |
| under the terms of the GNU Free Documentation License, Version 1.2 |
| or any later version published by the Free Software Foundation; |
| with no Invariant Sections, no Front-Cover Texts, and no Back-Cover |
| Texts. A copy of the license is included in the section entitled ``GNU |
| Free Documentation License''. |
| |
| If you have Invariant Sections, Front-Cover Texts and Back-Cover |
| Texts, replace the "with...Texts." line with this: |
| |
| with the Invariant Sections being LIST THEIR TITLES, with |
| the Front-Cover Texts being LIST, and with the Back-Cover Texts |
| being LIST. |
| |
| If you have Invariant Sections without Cover Texts, or some other |
| combination of the three, merge those two alternatives to suit the |
| situation. |
| |
| If your document contains nontrivial examples of program code, we |
| recommend releasing these examples in parallel under your choice of |
| free software license, such as the GNU General Public License, to |
| permit their use in free software. |
| |
| |
| File: gdb.info, Node: Index, Prev: GNU Free Documentation License, Up: Top |
| |
| Index |
| ***** |
| |
| [index] |
| * Menu: |
| |
| * ! packet: Packets. (line 26) |
| * "No symbol "foo" in current context": Variables. (line 74) |
| * # (a comment): Command Syntax. (line 38) |
| * # in Modula-2: GDB/M2. (line 18) |
| * $: Value History. (line 13) |
| * $$: Value History. (line 13) |
| * $_ and info breakpoints: Set Breaks. (line 112) |
| * $_ and info line: Machine Code. (line 29) |
| * $_, $__, and value history: Memory. (line 91) |
| * $_, convenience variable: Convenience Vars. (line 64) |
| * $__, convenience variable: Convenience Vars. (line 73) |
| * $_exitcode, convenience variable: Convenience Vars. (line 79) |
| * $bpnum, convenience variable: Set Breaks. (line 6) |
| * $cdir, convenience variable: Source Path. (line 99) |
| * $cwd, convenience variable: Source Path. (line 99) |
| * $tpnum: Create and Delete Tracepoints. |
| (line 31) |
| * $trace_file: Tracepoint Variables. |
| (line 16) |
| * $trace_frame: Tracepoint Variables. |
| (line 6) |
| * $trace_func: Tracepoint Variables. |
| (line 19) |
| * $trace_line: Tracepoint Variables. |
| (line 13) |
| * $tracepoint: Tracepoint Variables. |
| (line 10) |
| * --annotate: Mode Options. (line 101) |
| * --args: Mode Options. (line 114) |
| * --batch: Mode Options. (line 23) |
| * --batch-silent: Mode Options. (line 39) |
| * --baud: Mode Options. (line 120) |
| * --cd: Mode Options. (line 80) |
| * --command: File Options. (line 51) |
| * --core: File Options. (line 43) |
| * --directory: File Options. (line 66) |
| * --epoch: Mode Options. (line 96) |
| * --eval-command: File Options. (line 56) |
| * --exec: File Options. (line 35) |
| * --fullname: Mode Options. (line 85) |
| * --interpreter: Mode Options. (line 141) |
| * --nowindows: Mode Options. (line 70) |
| * --nx: Mode Options. (line 11) |
| * --pid: File Options. (line 47) |
| * --quiet: Mode Options. (line 19) |
| * --readnow: File Options. (line 70) |
| * --return-child-result: Mode Options. (line 51) |
| * --se: File Options. (line 39) |
| * --silent: Mode Options. (line 19) |
| * --statistics: Mode Options. (line 158) |
| * --symbols: File Options. (line 31) |
| * --tty: Mode Options. (line 129) |
| * --tui: Mode Options. (line 132) |
| * --version: Mode Options. (line 162) |
| * --windows: Mode Options. (line 76) |
| * --with-sysroot: Files. (line 381) |
| * --write: Mode Options. (line 153) |
| * -b: Mode Options. (line 120) |
| * -break-after: GDB/MI Breakpoint Commands. |
| (line 11) |
| * -break-condition: GDB/MI Breakpoint Commands. |
| (line 54) |
| * -break-delete: GDB/MI Breakpoint Commands. |
| (line 91) |
| * -break-disable: GDB/MI Breakpoint Commands. |
| (line 125) |
| * -break-enable: GDB/MI Breakpoint Commands. |
| (line 161) |
| * -break-info: GDB/MI Breakpoint Commands. |
| (line 196) |
| * -break-insert: GDB/MI Breakpoint Commands. |
| (line 216) |
| * -break-list: GDB/MI Breakpoint Commands. |
| (line 314) |
| * -break-watch: GDB/MI Breakpoint Commands. |
| (line 389) |
| * -c: File Options. (line 43) |
| * -d: File Options. (line 66) |
| * -data-disassemble: GDB/MI Data Manipulation. |
| (line 12) |
| * -data-evaluate-expression: GDB/MI Data Manipulation. |
| (line 140) |
| * -data-list-changed-registers: GDB/MI Data Manipulation. |
| (line 178) |
| * -data-list-register-names: GDB/MI Data Manipulation. |
| (line 213) |
| * -data-list-register-values: GDB/MI Data Manipulation. |
| (line 253) |
| * -data-read-memory: GDB/MI Data Manipulation. |
| (line 343) |
| * -e: File Options. (line 35) |
| * -enable-timings: GDB/MI Miscellaneous Commands. |
| (line 235) |
| * -environment-cd: GDB/MI Program Context. |
| (line 50) |
| * -environment-directory: GDB/MI Program Context. |
| (line 73) |
| * -environment-path: GDB/MI Program Context. |
| (line 117) |
| * -environment-pwd: GDB/MI Program Context. |
| (line 158) |
| * -ex: File Options. (line 56) |
| * -exec-abort: GDB/MI Miscellaneous Commands. |
| (line 31) |
| * -exec-arguments: GDB/MI Program Context. |
| (line 9) |
| * -exec-continue: GDB/MI Program Execution. |
| (line 13) |
| * -exec-finish: GDB/MI Program Execution. |
| (line 40) |
| * -exec-interrupt: GDB/MI Program Execution. |
| (line 81) |
| * -exec-next: GDB/MI Program Execution. |
| (line 121) |
| * -exec-next-instruction: GDB/MI Program Execution. |
| (line 146) |
| * -exec-return: GDB/MI Program Execution. |
| (line 176) |
| * -exec-run: GDB/MI Program Execution. |
| (line 219) |
| * -exec-show-arguments: GDB/MI Program Context. |
| (line 30) |
| * -exec-step: GDB/MI Program Execution. |
| (line 279) |
| * -exec-step-instruction: GDB/MI Program Execution. |
| (line 319) |
| * -exec-until: GDB/MI Program Execution. |
| (line 358) |
| * -f: Mode Options. (line 85) |
| * -file-exec-and-symbols: GDB/MI File Commands. |
| (line 12) |
| * -file-exec-file: GDB/MI File Commands. |
| (line 40) |
| * -file-list-exec-sections: GDB/MI File Commands. |
| (line 67) |
| * -file-list-exec-source-file: GDB/MI File Commands. |
| (line 88) |
| * -file-list-exec-source-files: GDB/MI File Commands. |
| (line 114) |
| * -file-list-shared-libraries: GDB/MI File Commands. |
| (line 144) |
| * -file-list-symbol-files: GDB/MI File Commands. |
| (line 164) |
| * -file-symbol-file: GDB/MI File Commands. |
| (line 184) |
| * -gdb-exit: GDB/MI Miscellaneous Commands. |
| (line 9) |
| * -gdb-set: GDB/MI Miscellaneous Commands. |
| (line 51) |
| * -gdb-show: GDB/MI Miscellaneous Commands. |
| (line 74) |
| * -gdb-version: GDB/MI Miscellaneous Commands. |
| (line 97) |
| * -inferior-tty-set: GDB/MI Miscellaneous Commands. |
| (line 186) |
| * -inferior-tty-show: GDB/MI Miscellaneous Commands. |
| (line 209) |
| * -interpreter-exec: GDB/MI Miscellaneous Commands. |
| (line 160) |
| * -l: Mode Options. (line 124) |
| * -list-features: GDB/MI Miscellaneous Commands. |
| (line 131) |
| * -n: Mode Options. (line 11) |
| * -nw: Mode Options. (line 70) |
| * -p: File Options. (line 47) |
| * -q: Mode Options. (line 19) |
| * -r: File Options. (line 70) |
| * -s: File Options. (line 31) |
| * -stack-info-depth: GDB/MI Stack Manipulation. |
| (line 35) |
| * -stack-info-frame: GDB/MI Stack Manipulation. |
| (line 9) |
| * -stack-list-arguments: GDB/MI Stack Manipulation. |
| (line 73) |
| * -stack-list-frames: GDB/MI Stack Manipulation. |
| (line 157) |
| * -stack-list-locals: GDB/MI Stack Manipulation. |
| (line 253) |
| * -stack-select-frame: GDB/MI Stack Manipulation. |
| (line 290) |
| * -symbol-info-address: GDB/MI Symbol Query. (line 9) |
| * -symbol-info-file: GDB/MI Symbol Query. (line 29) |
| * -symbol-info-function: GDB/MI Symbol Query. (line 49) |
| * -symbol-info-line: GDB/MI Symbol Query. (line 69) |
| * -symbol-info-symbol: GDB/MI Symbol Query. (line 90) |
| * -symbol-list-functions: GDB/MI Symbol Query. (line 110) |
| * -symbol-list-lines: GDB/MI Symbol Query. (line 130) |
| * -symbol-list-types: GDB/MI Symbol Query. (line 155) |
| * -symbol-list-variables: GDB/MI Symbol Query. (line 176) |
| * -symbol-locate: GDB/MI Symbol Query. (line 196) |
| * -symbol-type: GDB/MI Symbol Query. (line 214) |
| * -t: Mode Options. (line 129) |
| * -target-attach: GDB/MI Target Manipulation. |
| (line 9) |
| * -target-compare-sections: GDB/MI Target Manipulation. |
| (line 29) |
| * -target-detach: GDB/MI Target Manipulation. |
| (line 50) |
| * -target-disconnect: GDB/MI Target Manipulation. |
| (line 74) |
| * -target-download: GDB/MI Target Manipulation. |
| (line 98) |
| * -target-exec-status: GDB/MI Target Manipulation. |
| (line 201) |
| * -target-file-delete: GDB/MI File Transfer Commands. |
| (line 57) |
| * -target-file-get: GDB/MI File Transfer Commands. |
| (line 33) |
| * -target-file-put: GDB/MI File Transfer Commands. |
| (line 9) |
| * -target-list-available-targets: GDB/MI Target Manipulation. |
| (line 222) |
| * -target-list-current-targets: GDB/MI Target Manipulation. |
| (line 242) |
| * -target-list-parameters: GDB/MI Target Manipulation. |
| (line 263) |
| * -target-select: GDB/MI Target Manipulation. |
| (line 281) |
| * -thread-info: GDB/MI Thread Commands. |
| (line 9) |
| * -thread-list-all-threads: GDB/MI Thread Commands. |
| (line 27) |
| * -thread-list-ids: GDB/MI Thread Commands. |
| (line 45) |
| * -thread-select: GDB/MI Thread Commands. |
| (line 79) |
| * -var-assign: GDB/MI Variable Objects. |
| (line 304) |
| * -var-create: GDB/MI Variable Objects. |
| (line 85) |
| * -var-delete: GDB/MI Variable Objects. |
| (line 126) |
| * -var-evaluate-expression: GDB/MI Variable Objects. |
| (line 287) |
| * -var-info-expression: GDB/MI Variable Objects. |
| (line 228) |
| * -var-info-num-children: GDB/MI Variable Objects. |
| (line 175) |
| * -var-info-path-expression: GDB/MI Variable Objects. |
| (line 252) |
| * -var-info-type: GDB/MI Variable Objects. |
| (line 215) |
| * -var-list-children: GDB/MI Variable Objects. |
| (line 187) |
| * -var-set-format: GDB/MI Variable Objects. |
| (line 139) |
| * -var-set-frozen: GDB/MI Variable Objects. |
| (line 381) |
| * -var-show-attributes: GDB/MI Variable Objects. |
| (line 273) |
| * -var-show-format: GDB/MI Variable Objects. |
| (line 162) |
| * -var-update: GDB/MI Variable Objects. |
| (line 328) |
| * -w: Mode Options. (line 76) |
| * -x: File Options. (line 51) |
| * ., Modula-2 scope operator: M2 Scope. (line 6) |
| * .build-id directory: Separate Debug Files. |
| (line 6) |
| * .debug subdirectories: Separate Debug Files. |
| (line 6) |
| * .gdbinit: Startup. (line 37) |
| * .gnu_debuglink sections: Separate Debug Files. |
| (line 77) |
| * .note.gnu.build-id sections: Separate Debug Files. |
| (line 95) |
| * .o files, reading symbols from: Files. (line 132) |
| * /proc: SVR4 Process Information. |
| (line 6) |
| * <architecture>: Target Description Format. |
| (line 70) |
| * <feature>: Target Description Format. |
| (line 80) |
| * <reg>: Target Description Format. |
| (line 127) |
| * <union>: Target Description Format. |
| (line 114) |
| * <vector>: Target Description Format. |
| (line 107) |
| * ? packet: Packets. (line 35) |
| * @, referencing memory as an array: Arrays. (line 6) |
| * ^connected: GDB/MI Result Records. |
| (line 18) |
| * ^done: GDB/MI Result Records. |
| (line 9) |
| * ^error: GDB/MI Result Records. |
| (line 21) |
| * ^exit: GDB/MI Result Records. |
| (line 25) |
| * ^running: GDB/MI Result Records. |
| (line 14) |
| * _NSPrintForDebugger, and printing Objective-C objects: The Print Command with Objective-C. |
| (line 11) |
| * A packet: Packets. (line 41) |
| * abbreviation: Command Syntax. (line 13) |
| * abort (C-g): Miscellaneous Commands. |
| (line 10) |
| * accept-line (Newline or Return): Commands For History. |
| (line 6) |
| * acknowledgment, for GDB remote: Overview. (line 33) |
| * actions: Tracepoint Actions. (line 6) |
| * active targets: Active Targets. (line 6) |
| * Ada: Ada. (line 6) |
| * Ada exception catching: Set Catchpoints. (line 19) |
| * Ada mode, general: Ada Mode Intro. (line 6) |
| * Ada, deviations from: Additions to Ada. (line 6) |
| * Ada, omissions from: Omissions from Ada. (line 6) |
| * Ada, problems: Ada Glitches. (line 6) |
| * adbg_find_memory_in_frame: Tracing on Symmetrix. |
| (line 17) |
| * add new commands for external monitor: Connecting. (line 104) |
| * add-shared-symbol-files: Files. (line 172) |
| * add-symbol-file: Files. (line 113) |
| * add-symbol-file-from-memory: Files. (line 162) |
| * address of a symbol: Symbols. (line 44) |
| * address size for remote targets: Remote Configuration. |
| (line 12) |
| * ADP (Angel Debugger Protocol) logging: ARM. (line 70) |
| * advance LOCATION: Continuing and Stepping. |
| (line 180) |
| * aggregates (Ada): Omissions from Ada. (line 44) |
| * AIX threads: Debugging Output. (line 28) |
| * alignment of remote memory accesses: Packets. (line 172) |
| * Alpha stack: MIPS. (line 6) |
| * AMD 29K register stack: A29K. (line 6) |
| * annotations: Annotations Overview. |
| (line 6) |
| * annotations for errors, warnings and interrupts: Errors. (line 6) |
| * annotations for invalidation messages: Invalidation. (line 6) |
| * annotations for prompts: Prompting. (line 6) |
| * annotations for running programs: Annotations for Running. |
| (line 6) |
| * annotations for source display: Source Annotations. (line 6) |
| * append: Dump/Restore Files. (line 35) |
| * append data to a file: Dump/Restore Files. (line 6) |
| * apply command to several threads: Threads. (line 146) |
| * apropos: Help. (line 62) |
| * architecture debugging info: Debugging Output. (line 18) |
| * argument count in user-defined commands: Define. (line 25) |
| * arguments (to your program): Arguments. (line 6) |
| * arguments, to gdbserver: Server. (line 34) |
| * arguments, to user-defined commands: Define. (line 6) |
| * ARM 32-bit mode: ARM. (line 25) |
| * ARM RDI: ARM. (line 6) |
| * array aggregates (Ada): Omissions from Ada. (line 44) |
| * arrays: Arrays. (line 6) |
| * arrays in expressions: Expressions. (line 14) |
| * artificial array: Arrays. (line 6) |
| * ASCII character set: Character Sets. (line 65) |
| * assembly instructions: Machine Code. (line 35) |
| * assf: Files. (line 172) |
| * assignment: Assignment. (line 6) |
| * async output in GDB/MI: GDB/MI Output Syntax. |
| (line 96) |
| * AT&T disassembly flavor: Machine Code. (line 67) |
| * attach: Attach. (line 6) |
| * attach to a program by name: Server. (line 79) |
| * automatic display: Auto Display. (line 6) |
| * automatic hardware breakpoints: Set Breaks. (line 269) |
| * automatic overlay debugging: Automatic Overlay Debugging. |
| (line 6) |
| * automatic thread selection: Threads. (line 169) |
| * auxiliary vector: OS Information. (line 21) |
| * AVR: AVR. (line 6) |
| * awatch: Set Watchpoints. (line 51) |
| * b (break): Set Breaks. (line 6) |
| * B packet: Packets. (line 68) |
| * b packet: Packets. (line 53) |
| * backtrace: Backtrace. (line 11) |
| * backtrace beyond main function: Backtrace. (line 87) |
| * backtrace limit: Backtrace. (line 123) |
| * backward-char (C-b): Commands For Moving. (line 15) |
| * backward-delete-char (Rubout): Commands For Text. (line 11) |
| * backward-kill-line (C-x Rubout): Commands For Killing. |
| (line 9) |
| * backward-kill-word (M-<DEL>): Commands For Killing. |
| (line 24) |
| * backward-word (M-b): Commands For Moving. (line 22) |
| * baud rate for remote targets: Remote Configuration. |
| (line 21) |
| * bcache statistics: Maintenance Commands. |
| (line 166) |
| * beginning-of-history (M-<): Commands For History. |
| (line 19) |
| * beginning-of-line (C-a): Commands For Moving. (line 6) |
| * bell-style: Readline Init File Syntax. |
| (line 35) |
| * bind-tty-special-chars: Readline Init File Syntax. |
| (line 42) |
| * bits in remote address: Remote Configuration. |
| (line 12) |
| * bookmark: Checkpoint/Restart. (line 6) |
| * break: Set Breaks. (line 6) |
| * break ... thread THREADNO: Thread Stops. (line 10) |
| * break in overloaded functions: Debugging C Plus Plus. |
| (line 9) |
| * break on fork/exec: Set Catchpoints. (line 33) |
| * break on load/unload of shared library: Set Catchpoints. (line 46) |
| * BREAK signal instead of Ctrl-C: Remote Configuration. |
| (line 29) |
| * break, and Objective-C: Method Names in Commands. |
| (line 9) |
| * breakpoint address adjusted: Breakpoint-related Warnings. |
| (line 6) |
| * breakpoint annotation: Annotations for Running. |
| (line 47) |
| * breakpoint commands: Break Commands. (line 6) |
| * breakpoint commands for GDB/MI: GDB/MI Breakpoint Commands. |
| (line 6) |
| * breakpoint conditions: Conditions. (line 6) |
| * breakpoint numbers: Breakpoints. (line 41) |
| * breakpoint on events: Breakpoints. (line 33) |
| * breakpoint on memory address: Breakpoints. (line 20) |
| * breakpoint on variable modification: Breakpoints. (line 20) |
| * breakpoint ranges: Breakpoints. (line 48) |
| * breakpoint subroutine, remote: Stub Contents. (line 31) |
| * breakpointing Ada elaboration code: Stopping Before Main Program. |
| (line 6) |
| * breakpoints: Breakpoints. (line 6) |
| * breakpoints and threads: Thread Stops. (line 10) |
| * breakpoints in functions matching a regexp: Set Breaks. (line 87) |
| * breakpoints in overlays: Overlay Commands. (line 93) |
| * breakpoints-invalid annotation: Invalidation. (line 13) |
| * bt (backtrace): Backtrace. (line 11) |
| * bug criteria: Bug Criteria. (line 6) |
| * bug reports: Bug Reporting. (line 6) |
| * bugs in GDB: GDB Bugs. (line 6) |
| * build ID sections: Separate Debug Files. |
| (line 95) |
| * build ID, and separate debugging files: Separate Debug Files. |
| (line 6) |
| * building GDB, requirements for: Requirements. (line 6) |
| * built-in simulator target: Target Commands. (line 73) |
| * c (continue): Continuing and Stepping. |
| (line 15) |
| * c (SingleKey TUI key): TUI Single Key Mode. (line 10) |
| * C and C++: C. (line 6) |
| * C and C++ checks: C Checks. (line 6) |
| * C and C++ constants: C Constants. (line 6) |
| * C and C++ defaults: C Defaults. (line 6) |
| * C and C++ operators: C Operators. (line 6) |
| * C packet: Packets. (line 80) |
| * c packet: Packets. (line 74) |
| * C++: C. (line 10) |
| * C++ compilers: C Plus Plus Expressions. |
| (line 8) |
| * C++ exception handling: Debugging C Plus Plus. |
| (line 19) |
| * C++ overload debugging info: Debugging Output. (line 80) |
| * C++ scope resolution: Variables. (line 54) |
| * C++ symbol decoding style: Print Settings. (line 294) |
| * C++ symbol display: Debugging C Plus Plus. |
| (line 28) |
| * C-L: TUI Keys. (line 65) |
| * C-x 1: TUI Keys. (line 19) |
| * C-x 2: TUI Keys. (line 26) |
| * C-x A: TUI Keys. (line 12) |
| * C-x a: TUI Keys. (line 11) |
| * C-x C-a: TUI Keys. (line 10) |
| * C-x o: TUI Keys. (line 34) |
| * C-x s: TUI Keys. (line 41) |
| * caching data of remote targets: Caching Remote Data. (line 6) |
| * call: Calling. (line 10) |
| * call dummy stack unwinding: Calling. (line 26) |
| * call overloaded functions: C Plus Plus Expressions. |
| (line 27) |
| * call stack: Stack. (line 9) |
| * call stack traces: Backtrace. (line 6) |
| * call-last-kbd-macro (C-x e): Keyboard Macros. (line 13) |
| * calling functions: Calling. (line 6) |
| * calling make: Shell Commands. (line 19) |
| * capitalize-word (M-c): Commands For Text. (line 49) |
| * case sensitivity in symbol names: Symbols. (line 27) |
| * case-insensitive symbol names: Symbols. (line 27) |
| * casts, in expressions: Expressions. (line 27) |
| * casts, to view memory: Expressions. (line 42) |
| * catch: Set Catchpoints. (line 10) |
| * catch Ada exceptions: Set Catchpoints. (line 19) |
| * catch exceptions, list active handlers: Frame Info. (line 60) |
| * catchpoints: Breakpoints. (line 33) |
| * catchpoints, setting: Set Catchpoints. (line 6) |
| * cd: Working Directory. (line 16) |
| * cdir: Source Path. (line 99) |
| * Cell Broadband Engine: SPU. (line 6) |
| * change working directory: Working Directory. (line 16) |
| * character sets: Character Sets. (line 6) |
| * character-search (C-]): Miscellaneous Commands. |
| (line 41) |
| * character-search-backward (M-C-]): Miscellaneous Commands. |
| (line 46) |
| * charset: Character Sets. (line 6) |
| * checkpoint: Checkpoint/Restart. (line 6) |
| * checkpoints and process id: Checkpoint/Restart. (line 80) |
| * checks, range: Type Checking. (line 65) |
| * checks, type: Checks. (line 31) |
| * checksum, for GDB remote: Overview. (line 20) |
| * choosing target byte order: Byte Order. (line 6) |
| * clear: Delete Breaks. (line 21) |
| * clear, and Objective-C: Method Names in Commands. |
| (line 9) |
| * clear-screen (C-l): Commands For Moving. (line 26) |
| * clearing breakpoints, watchpoints, catchpoints: Delete Breaks. |
| (line 6) |
| * close, file-i/o system call: close. (line 6) |
| * closest symbol and offset for an address: Symbols. (line 54) |
| * code address and its source line: Machine Code. (line 24) |
| * collect (tracepoints): Tracepoint Actions. (line 45) |
| * collected data discarded: Starting and Stopping Trace Experiments. |
| (line 6) |
| * colon, doubled as scope operator: M2 Scope. (line 6) |
| * colon-colon, context for variables/functions: Variables. (line 44) |
| * colon-colon, in Modula-2: M2 Scope. (line 6) |
| * command editing: Readline Bare Essentials. |
| (line 6) |
| * command files: Command Files. (line 6) |
| * command history: Command History. (line 6) |
| * command hooks: Hooks. (line 6) |
| * command interpreters: Interpreters. (line 6) |
| * command line editing: Editing. (line 6) |
| * command scripts, debugging: Messages/Warnings. (line 65) |
| * command tracing: Messages/Warnings. (line 60) |
| * commands: Break Commands. (line 11) |
| * commands annotation: Prompting. (line 27) |
| * commands for C++: Debugging C Plus Plus. |
| (line 6) |
| * comment: Command Syntax. (line 38) |
| * comment-begin: Readline Init File Syntax. |
| (line 47) |
| * COMMON blocks, Fortran: Special Fortran Commands. |
| (line 9) |
| * common targets: Target Commands. (line 46) |
| * compare-sections: Memory. (line 111) |
| * compatibility, GDB/MI and CLI: GDB/MI Compatibility with CLI. |
| (line 6) |
| * compilation directory: Source Path. (line 99) |
| * compiling, on Sparclet: Sparclet. (line 16) |
| * complete: Help. (line 76) |
| * complete (<TAB>): Commands For Completion. |
| (line 6) |
| * completion: Completion. (line 6) |
| * completion of quoted strings: Completion. (line 57) |
| * completion-query-items: Readline Init File Syntax. |
| (line 57) |
| * condition: Conditions. (line 45) |
| * conditional breakpoints: Conditions. (line 6) |
| * configuring GDB: Running Configure. (line 6) |
| * confirmation: Messages/Warnings. (line 50) |
| * console i/o as part of file-i/o: Console I/O. (line 6) |
| * console interpreter: Interpreters. (line 21) |
| * console output in GDB/MI: GDB/MI Output Syntax. |
| (line 104) |
| * constants, in file-i/o protocol: Constants. (line 6) |
| * continue: Continuing and Stepping. |
| (line 15) |
| * continuing: Continuing and Stepping. |
| (line 6) |
| * continuing threads: Thread Stops. (line 70) |
| * control C, and remote debugging: Bootstrapping. (line 25) |
| * controlling terminal: Input/Output. (line 23) |
| * convenience variables: Convenience Vars. (line 6) |
| * convenience variables for tracepoints: Tracepoint Variables. |
| (line 6) |
| * convenience variables, initializing: Convenience Vars. (line 41) |
| * convert-meta: Readline Init File Syntax. |
| (line 67) |
| * copy-backward-word (): Commands For Killing. |
| (line 49) |
| * copy-forward-word (): Commands For Killing. |
| (line 54) |
| * copy-region-as-kill (): Commands For Killing. |
| (line 45) |
| * core dump file: Files. (line 6) |
| * core dump file target: Target Commands. (line 54) |
| * core-file: Files. (line 97) |
| * crash of debugger: Bug Criteria. (line 9) |
| * CRC of memory block, remote request: General Query Packets. |
| (line 51) |
| * CRIS: CRIS. (line 6) |
| * CRIS mode: CRIS. (line 26) |
| * CRIS version: CRIS. (line 10) |
| * ctrl-c message, in file-i/o protocol: The Ctrl-C Message. (line 6) |
| * Ctrl-o (operate-and-get-next): Command Syntax. (line 42) |
| * current directory: Source Path. (line 99) |
| * current stack frame: Frames. (line 45) |
| * current thread: Threads. (line 41) |
| * current thread, remote request: General Query Packets. |
| (line 41) |
| * cwd: Source Path. (line 99) |
| * Cygwin DLL, debugging: Cygwin Native. (line 30) |
| * Cygwin-specific commands: Cygwin Native. (line 6) |
| * d (delete): Delete Breaks. (line 41) |
| * d (SingleKey TUI key): TUI Single Key Mode. (line 13) |
| * D packet: Packets. (line 92) |
| * d packet: Packets. (line 86) |
| * data breakpoints: Breakpoints. (line 20) |
| * data manipulation, in GDB/MI: GDB/MI Data Manipulation. |
| (line 6) |
| * dead names, GNU Hurd: Hurd Native. (line 85) |
| * debug formats and C++: C Plus Plus Expressions. |
| (line 8) |
| * debug link sections: Separate Debug Files. |
| (line 77) |
| * debug remote protocol: Debugging Output. (line 86) |
| * debug_chaos: M32R/D. (line 50) |
| * debugger crash: Bug Criteria. (line 9) |
| * debugging C++ programs: C Plus Plus Expressions. |
| (line 8) |
| * debugging information directory, global: Separate Debug Files. |
| (line 6) |
| * debugging information in separate files: Separate Debug Files. |
| (line 6) |
| * debugging multiple processes: Processes. (line 52) |
| * debugging multithreaded programs (on HP-UX): Threads. (line 85) |
| * debugging optimized code: Compilation. (line 26) |
| * debugging stub, example: Remote Stub. (line 6) |
| * debugging target: Targets. (line 6) |
| * debugging the Cygwin DLL: Cygwin Native. (line 30) |
| * decimal floating point format: Decimal Floating Point. |
| (line 6) |
| * default system root: Files. (line 381) |
| * define: Define. (line 37) |
| * defining macros interactively: Macros. (line 54) |
| * definition, showing a macro's: Macros. (line 50) |
| * delete: Delete Breaks. (line 41) |
| * delete breakpoints: Delete Breaks. (line 41) |
| * delete checkpoint CHECKPOINT-ID: Checkpoint/Restart. (line 56) |
| * delete display: Auto Display. (line 45) |
| * delete fork FORK-ID: Processes. (line 105) |
| * delete mem: Memory Region Attributes. |
| (line 34) |
| * delete tracepoint: Create and Delete Tracepoints. |
| (line 34) |
| * delete-char (C-d): Commands For Text. (line 6) |
| * delete-char-or-list (): Commands For Completion. |
| (line 30) |
| * delete-horizontal-space (): Commands For Killing. |
| (line 37) |
| * deleting breakpoints, watchpoints, catchpoints: Delete Breaks. |
| (line 6) |
| * deliver a signal to a program: Signaling. (line 6) |
| * demangling C++ names: Print Settings. (line 275) |
| * deprecated commands: Maintenance Commands. |
| (line 60) |
| * derived type of an object, printing: Print Settings. (line 327) |
| * descriptor tables display: DJGPP Native. (line 24) |
| * detach: Attach. (line 36) |
| * detach (remote): Connecting. (line 90) |
| * detach fork FORK-ID: Processes. (line 100) |
| * detach from task, GNU Hurd: Hurd Native. (line 60) |
| * detach from thread, GNU Hurd: Hurd Native. (line 110) |
| * digit-argument (M-0, M-1, ... M--): Numeric Arguments. (line 6) |
| * dir: Source Path. (line 39) |
| * direct memory access (DMA) on MS-DOS: DJGPP Native. (line 75) |
| * directories for source files: Source Path. (line 6) |
| * directory: Source Path. (line 39) |
| * directory, compilation: Source Path. (line 99) |
| * directory, current: Source Path. (line 99) |
| * dis (disable): Disabling. (line 38) |
| * disable: Disabling. (line 38) |
| * disable display: Auto Display. (line 52) |
| * disable mem: Memory Region Attributes. |
| (line 38) |
| * disable tracepoint: Enable and Disable Tracepoints. |
| (line 6) |
| * disable-completion: Readline Init File Syntax. |
| (line 73) |
| * disassemble: Machine Code. (line 35) |
| * disconnect: Connecting. (line 97) |
| * display: Auto Display. (line 23) |
| * display command history: Command History. (line 78) |
| * display derived types: Print Settings. (line 327) |
| * display disabled out of scope: Auto Display. (line 74) |
| * display GDB copyright: Help. (line 136) |
| * display of expressions: Auto Display. (line 6) |
| * display remote monitor communications: Target Commands. (line 108) |
| * display remote packets: Debugging Output. (line 86) |
| * DJGPP debugging: DJGPP Native. (line 6) |
| * dll-symbols: Cygwin Native. (line 26) |
| * DLLs with no debugging symbols: Non-debug DLL Symbols. |
| (line 6) |
| * do (down): Selection. (line 40) |
| * do not print frame argument values: Print Settings. (line 135) |
| * do-uppercase-version (M-a, M-b, M-X, ...): Miscellaneous Commands. |
| (line 14) |
| * document: Define. (line 46) |
| * documentation: Formatting Documentation. |
| (line 22) |
| * don't repeat command: Define. (line 58) |
| * dont-repeat: Define. (line 58) |
| * DOS serial data link, remote debugging: DJGPP Native. (line 121) |
| * DOS serial port status: DJGPP Native. (line 142) |
| * Down: TUI Keys. (line 56) |
| * down: Selection. (line 40) |
| * down-silently: Selection. (line 64) |
| * downcase-word (M-l): Commands For Text. (line 45) |
| * download server address (M32R): M32R/D. (line 27) |
| * download to Sparclet: Sparclet Download. (line 6) |
| * download to VxWorks: VxWorks Download. (line 6) |
| * DPMI: DJGPP Native. (line 6) |
| * dump: Dump/Restore Files. (line 13) |
| * dump all data collected at tracepoint: tdump. (line 6) |
| * dump core from inferior: Core File Generation. |
| (line 6) |
| * dump data to a file: Dump/Restore Files. (line 6) |
| * dump-functions (): Miscellaneous Commands. |
| (line 61) |
| * dump-macros (): Miscellaneous Commands. |
| (line 73) |
| * dump-variables (): Miscellaneous Commands. |
| (line 67) |
| * dump/restore files: Dump/Restore Files. (line 6) |
| * DWARF 2 compilation units cache: Maintenance Commands. |
| (line 202) |
| * DWARF-2 CFI and CRIS: CRIS. (line 18) |
| * dynamic linking: Files. (line 113) |
| * e (edit): Edit. (line 6) |
| * EBCDIC character set: Character Sets. (line 74) |
| * echo: Output. (line 12) |
| * edit: Edit. (line 6) |
| * editing: Editing. (line 15) |
| * editing command lines: Readline Bare Essentials. |
| (line 6) |
| * editing source files: Edit. (line 6) |
| * editing-mode: Readline Init File Syntax. |
| (line 78) |
| * eight-bit characters in strings: Print Settings. (line 220) |
| * elaboration phase: Starting. (line 82) |
| * else: Command Files. (line 56) |
| * Emacs: Emacs. (line 6) |
| * empty response, for unsupported packets: Overview. (line 90) |
| * enable: Disabling. (line 45) |
| * enable display: Auto Display. (line 57) |
| * enable mem: Memory Region Attributes. |
| (line 42) |
| * enable tracepoint: Enable and Disable Tracepoints. |
| (line 12) |
| * enable-keypad: Readline Init File Syntax. |
| (line 84) |
| * enable/disable a breakpoint: Disabling. (line 6) |
| * end (breakpoint commands): Break Commands. (line 11) |
| * end (if/else/while commands): Command Files. (line 85) |
| * end (user-defined commands): Define. (line 46) |
| * end-kbd-macro (C-x )): Keyboard Macros. (line 9) |
| * end-of-history (M->): Commands For History. |
| (line 22) |
| * end-of-line (C-e): Commands For Moving. (line 9) |
| * entering numbers: Numbers. (line 6) |
| * environment (of your program): Environment. (line 6) |
| * errno values, in file-i/o protocol: Errno Values. (line 6) |
| * error annotation: Errors. (line 10) |
| * error on valid input: Bug Criteria. (line 12) |
| * error-begin annotation: Errors. (line 22) |
| * event debugging info: Debugging Output. (line 35) |
| * event designators: Event Designators. (line 6) |
| * event handling: Set Catchpoints. (line 6) |
| * examine process image: SVR4 Process Information. |
| (line 6) |
| * examining data: Data. (line 6) |
| * examining memory: Memory. (line 9) |
| * exception handlers: Set Catchpoints. (line 6) |
| * exception handlers, how to list: Frame Info. (line 60) |
| * exceptionHandler: Bootstrapping. (line 38) |
| * exchange-point-and-mark (C-x C-x): Miscellaneous Commands. |
| (line 36) |
| * exec-file: Files. (line 39) |
| * executable file: Files. (line 16) |
| * executable file target: Target Commands. (line 50) |
| * executable file, for remote target: Remote Configuration. |
| (line 79) |
| * execute commands from a file: Command Files. (line 14) |
| * execute remote command, remote request: General Query Packets. |
| (line 203) |
| * exited annotation: Annotations for Running. |
| (line 18) |
| * exiting GDB: Quitting GDB. (line 6) |
| * expand macro once: Macros. (line 41) |
| * expand-tilde: Readline Init File Syntax. |
| (line 89) |
| * expanding preprocessor macros: Macros. (line 32) |
| * expression debugging info: Debugging Output. (line 42) |
| * expressions: Expressions. (line 6) |
| * expressions in Ada: Ada. (line 11) |
| * expressions in C or C++: C. (line 6) |
| * expressions in C++: C Plus Plus Expressions. |
| (line 6) |
| * expressions in Modula-2: Modula-2. (line 12) |
| * extend GDB for remote targets: Connecting. (line 104) |
| * f (frame): Selection. (line 11) |
| * f (SingleKey TUI key): TUI Single Key Mode. (line 16) |
| * F packet: Packets. (line 103) |
| * F reply packet: The F Reply Packet. (line 6) |
| * F request packet: The F Request Packet. |
| (line 6) |
| * fatal signal: Bug Criteria. (line 9) |
| * fatal signals: Signals. (line 15) |
| * FDL, GNU Free Documentation License: GNU Free Documentation License. |
| (line 6) |
| * features of the remote protocol: General Query Packets. |
| (line 228) |
| * fg (resume foreground execution): Continuing and Stepping. |
| (line 15) |
| * file: Files. (line 16) |
| * file transfer: File Transfer. (line 6) |
| * file transfer, remote protocol: Host I/O Packets. (line 6) |
| * file-i/o examples: File-I/O Examples. (line 6) |
| * file-i/o overview: File-I/O Overview. (line 6) |
| * File-I/O remote protocol extension: File-I/O Remote Protocol Extension. |
| (line 6) |
| * file-i/o reply packet: The F Reply Packet. (line 6) |
| * file-i/o request packet: The F Request Packet. |
| (line 6) |
| * find downloadable SREC files (M32R): M32R/D. (line 15) |
| * find trace snapshot: tfind. (line 6) |
| * finish: Continuing and Stepping. |
| (line 110) |
| * flinching: Messages/Warnings. (line 50) |
| * float promotion: ABI. (line 29) |
| * floating point: Floating Point Hardware. |
| (line 6) |
| * floating point registers: Registers. (line 15) |
| * floating point, MIPS remote: MIPS Embedded. (line 60) |
| * flush_i_cache: Bootstrapping. (line 60) |
| * flushregs: Maintenance Commands. |
| (line 158) |
| * focus: TUI Commands. (line 34) |
| * focus of debugging: Threads. (line 41) |
| * foo: Symbol Errors. (line 50) |
| * fork FORK-ID: Processes. (line 85) |
| * fork, debugging programs which call: Processes. (line 6) |
| * format options: Print Settings. (line 6) |
| * formatted output: Output Formats. (line 6) |
| * Fortran: Summary. (line 35) |
| * Fortran Defaults: Fortran Defaults. (line 6) |
| * Fortran operators and expressions: Fortran Operators. (line 6) |
| * Fortran-specific support in GDB: Fortran. (line 6) |
| * forward-backward-delete-char (): Commands For Text. (line 15) |
| * forward-char (C-f): Commands For Moving. (line 12) |
| * forward-search: Search. (line 9) |
| * forward-search-history (C-s): Commands For History. |
| (line 30) |
| * forward-word (M-f): Commands For Moving. (line 18) |
| * FR-V shared-library debugging: Debugging Output. (line 104) |
| * frame debugging info: Debugging Output. (line 50) |
| * frame number: Frames. (line 28) |
| * frame pointer: Frames. (line 21) |
| * frame pointer register: Registers. (line 26) |
| * frame, command: Frames. (line 45) |
| * frame, definition: Frames. (line 6) |
| * frame, selecting: Selection. (line 11) |
| * frameless execution: Frames. (line 34) |
| * frames-invalid annotation: Invalidation. (line 9) |
| * free memory information (MS-DOS): DJGPP Native. (line 19) |
| * fstat, file-i/o system call: stat/fstat. (line 6) |
| * Fujitsu: Remote Stub. (line 69) |
| * full symbol tables, listing GDB's internal: Symbols. (line 270) |
| * function call arguments, optimized out: Backtrace. (line 65) |
| * function entry/exit, wrong values of variables: Variables. (line 58) |
| * functions without line info, and stepping: Continuing and Stepping. |
| (line 93) |
| * G packet: Packets. (line 124) |
| * g packet: Packets. (line 108) |
| * g++, GNU C++ compiler: C. (line 10) |
| * garbled pointers: DJGPP Native. (line 42) |
| * GCC and C++: C Plus Plus Expressions. |
| (line 8) |
| * gcore: Core File Generation. |
| (line 18) |
| * GDB bugs, reporting: Bug Reporting. (line 6) |
| * GDB reference card: Formatting Documentation. |
| (line 6) |
| * GDB startup: Startup. (line 6) |
| * GDB version number: Help. (line 126) |
| * gdb.ini: Startup. (line 37) |
| * GDB/MI development: GDB/MI Development and Front Ends. |
| (line 6) |
| * GDB/MI, breakpoint commands: GDB/MI Breakpoint Commands. |
| (line 6) |
| * GDB/MI, compatibility with CLI: GDB/MI Compatibility with CLI. |
| (line 6) |
| * GDB/MI, data manipulation: GDB/MI Data Manipulation. |
| (line 6) |
| * GDB/MI, input syntax: GDB/MI Input Syntax. (line 6) |
| * GDB/MI, its purpose: GDB/MI. (line 9) |
| * GDB/MI, out-of-band records: GDB/MI Out-of-band Records. |
| (line 6) |
| * GDB/MI, output syntax: GDB/MI Output Syntax. |
| (line 6) |
| * GDB/MI, result records: GDB/MI Result Records. |
| (line 6) |
| * GDB/MI, simple examples: GDB/MI Simple Examples. |
| (line 6) |
| * GDB/MI, stream records: GDB/MI Stream Records. |
| (line 6) |
| * gdbarch debugging info: Debugging Output. (line 18) |
| * GDBHISTFILE, environment variable: Command History. (line 26) |
| * gdbserver: Server. (line 6) |
| * gdbserver, multiple processes: Server. (line 91) |
| * GDT: DJGPP Native. (line 24) |
| * generate-core-file: Core File Generation. |
| (line 18) |
| * get thread-local storage address, remote request: General Query Packets. |
| (line 87) |
| * getDebugChar: Bootstrapping. (line 14) |
| * gettimeofday, file-i/o system call: gettimeofday. (line 6) |
| * global debugging information directory: Separate Debug Files. |
| (line 6) |
| * GNU C++: C. (line 10) |
| * GNU Emacs: Emacs. (line 6) |
| * GNU Hurd debugging: Hurd Native. (line 6) |
| * GNU/Linux LWP debug messages: Debugging Output. (line 66) |
| * gnu_debuglink_crc32: Separate Debug Files. |
| (line 144) |
| * h (help): Help. (line 9) |
| * H packet: Packets. (line 135) |
| * handle: Signals. (line 45) |
| * handle_exception: Stub Contents. (line 15) |
| * handling signals: Signals. (line 27) |
| * hardware breakpoints: Set Breaks. (line 57) |
| * hardware watchpoints: Set Watchpoints. (line 22) |
| * hash mark while downloading: Target Commands. (line 99) |
| * hbreak: Set Breaks. (line 57) |
| * help: Help. (line 6) |
| * help target: Target Commands. (line 19) |
| * help user-defined: Define. (line 63) |
| * heuristic-fence-post (Alpha, MIPS): MIPS. (line 14) |
| * history events: Event Designators. (line 7) |
| * history expansion: History Interaction. (line 6) |
| * history expansion, turn on/off: Command History. (line 53) |
| * history file: Command History. (line 26) |
| * history number: Value History. (line 13) |
| * history of values printed by GDB: Value History. (line 6) |
| * history size: Command History. (line 45) |
| * history substitution: Command History. (line 26) |
| * history-preserve-point: Readline Init File Syntax. |
| (line 93) |
| * history-search-backward (): Commands For History. |
| (line 50) |
| * history-search-forward (): Commands For History. |
| (line 45) |
| * HISTSIZE, environment variable: Command History. (line 45) |
| * hook: Hooks. (line 6) |
| * hookpost: Hooks. (line 11) |
| * hooks, for commands: Hooks. (line 6) |
| * hooks, post-command: Hooks. (line 11) |
| * hooks, pre-command: Hooks. (line 6) |
| * horizontal-scroll-mode: Readline Init File Syntax. |
| (line 98) |
| * host character set: Character Sets. (line 6) |
| * Host I/O, remote protocol: Host I/O Packets. (line 6) |
| * how many arguments (user-defined commands): Define. (line 25) |
| * HPPA support: HPPA. (line 6) |
| * htrace: OpenRISC 1000. (line 69) |
| * hwatch: OpenRISC 1000. (line 59) |
| * i (info): Help. (line 99) |
| * I packet: Packets. (line 154) |
| * i packet: Packets. (line 149) |
| * i/o: Input/Output. (line 6) |
| * I/O registers (Atmel AVR): AVR. (line 10) |
| * i386: Remote Stub. (line 57) |
| * i386-stub.c: Remote Stub. (line 57) |
| * IBM1047 character set: Character Sets. (line 74) |
| * IDT: DJGPP Native. (line 24) |
| * if: Command Files. (line 56) |
| * ignore: Conditions. (line 77) |
| * ignore count (of breakpoint): Conditions. (line 66) |
| * INCLUDE_RDB: VxWorks. (line 33) |
| * incomplete type: Symbols. (line 99) |
| * indentation in structure display: Print Settings. (line 196) |
| * inferior debugging info: Debugging Output. (line 57) |
| * inferior functions, calling: Calling. (line 6) |
| * inferior tty: Input/Output. (line 44) |
| * infinite recursion in user-defined commands: Define. (line 73) |
| * info: Help. (line 99) |
| * info address: Symbols. (line 44) |
| * info all-registers: Registers. (line 15) |
| * info args: Frame Info. (line 51) |
| * info auxv: OS Information. (line 33) |
| * info breakpoints: Set Breaks. (line 112) |
| * info catch: Frame Info. (line 60) |
| * info checkpoints: Checkpoint/Restart. (line 31) |
| * info classes: Symbols. (line 197) |
| * info common: Special Fortran Commands. |
| (line 9) |
| * info copying: Help. (line 136) |
| * info dcache: Caching Remote Data. (line 22) |
| * info display: Auto Display. (line 66) |
| * info dll: Cygwin Native. (line 23) |
| * info dos: DJGPP Native. (line 15) |
| * info extensions: Show. (line 34) |
| * info f (info frame): Frame Info. (line 17) |
| * info files: Files. (line 191) |
| * info float: Floating Point Hardware. |
| (line 9) |
| * info for known object files: Maintenance Commands. |
| (line 161) |
| * info forks: Processes. (line 80) |
| * info frame: Frame Info. (line 17) |
| * info frame, show the source language: Show. (line 15) |
| * info functions: Symbols. (line 176) |
| * info handle: Signals. (line 33) |
| * info io_registers, AVR: AVR. (line 10) |
| * info line: Machine Code. (line 13) |
| * info line, and Objective-C: Method Names in Commands. |
| (line 9) |
| * info locals: Frame Info. (line 55) |
| * info macro: Macros. (line 50) |
| * info mem: Memory Region Attributes. |
| (line 45) |
| * info meminfo: SVR4 Process Information. |
| (line 78) |
| * info or1k spr: OpenRISC 1000. (line 20) |
| * info pidlist: SVR4 Process Information. |
| (line 74) |
| * info proc: SVR4 Process Information. |
| (line 16) |
| * info program: Stopping. (line 18) |
| * info registers: Registers. (line 11) |
| * info scope: Symbols. (line 130) |
| * info selectors: Symbols. (line 203) |
| * info serial: DJGPP Native. (line 142) |
| * info set: Help. (line 119) |
| * info share: Files. (line 326) |
| * info sharedlibrary: Files. (line 326) |
| * info signals: Signals. (line 33) |
| * info source: Symbols. (line 151) |
| * info source, show the source language: Show. (line 21) |
| * info sources: Symbols. (line 170) |
| * info spu: SPU. (line 10) |
| * info stack: Backtrace. (line 34) |
| * info symbol: Symbols. (line 54) |
| * info target: Files. (line 191) |
| * info terminal: Input/Output. (line 12) |
| * info threads: Threads. (line 62) |
| * info threads (HP-UX): Threads. (line 99) |
| * info tp: Listing Tracepoints. (line 6) |
| * info tracepoints: Listing Tracepoints. (line 6) |
| * info types: Symbols. (line 116) |
| * info udot: OS Information. (line 16) |
| * info variables: Symbols. (line 188) |
| * info vector: Vector Unit. (line 9) |
| * info w32: Cygwin Native. (line 12) |
| * info warranty: Help. (line 140) |
| * info watchpoints [N]: Set Watchpoints. (line 55) |
| * info win: TUI Commands. (line 12) |
| * information about tracepoints: Listing Tracepoints. (line 6) |
| * inheritance: Debugging C Plus Plus. |
| (line 24) |
| * init file: Startup. (line 11) |
| * init file name: Startup. (line 37) |
| * init-if-undefined: Convenience Vars. (line 41) |
| * initial frame: Frames. (line 12) |
| * initialization file, readline: Readline Init File. (line 6) |
| * innermost frame: Frames. (line 12) |
| * input syntax for GDB/MI: GDB/MI Input Syntax. (line 6) |
| * input-meta: Readline Init File Syntax. |
| (line 105) |
| * insert-comment (M-#): Miscellaneous Commands. |
| (line 51) |
| * insert-completions (M-*): Commands For Completion. |
| (line 14) |
| * inspect: Data. (line 6) |
| * installation: Installing GDB. (line 6) |
| * instructions, assembly: Machine Code. (line 35) |
| * integral datatypes, in file-i/o protocol: Integral Datatypes. |
| (line 6) |
| * Intel: Remote Stub. (line 57) |
| * Intel disassembly flavor: Machine Code. (line 67) |
| * interaction, readline: Readline Interaction. |
| (line 6) |
| * internal commands: Maintenance Commands. |
| (line 6) |
| * internal GDB breakpoints: Set Breaks. (line 289) |
| * interpreter-exec: Interpreters. (line 43) |
| * interrupt: Quitting GDB. (line 13) |
| * interrupt remote programs: Remote Configuration. |
| (line 29) |
| * interrupting remote programs: Connecting. (line 77) |
| * interrupting remote targets: Bootstrapping. (line 25) |
| * interrupts (remote protocol): Interrupts. (line 6) |
| * invalid input: Bug Criteria. (line 16) |
| * invoke another interpreter: Interpreters. (line 37) |
| * isatty, file-i/o system call: isatty. (line 6) |
| * isearch-terminators: Readline Init File Syntax. |
| (line 112) |
| * ISO 8859-1 character set: Character Sets. (line 68) |
| * ISO Latin 1 character set: Character Sets. (line 68) |
| * jump: Jumping. (line 10) |
| * jump, and Objective-C: Method Names in Commands. |
| (line 9) |
| * k packet: Packets. (line 158) |
| * kernel crash dump: BSD libkvm Interface. |
| (line 6) |
| * kernel memory image: BSD libkvm Interface. |
| (line 6) |
| * keymap: Readline Init File Syntax. |
| (line 119) |
| * kill: Kill Process. (line 6) |
| * kill ring: Readline Killing Commands. |
| (line 19) |
| * kill-line (C-k): Commands For Killing. |
| (line 6) |
| * kill-region (): Commands For Killing. |
| (line 41) |
| * kill-whole-line (): Commands For Killing. |
| (line 15) |
| * kill-word (M-d): Commands For Killing. |
| (line 19) |
| * killing text: Readline Killing Commands. |
| (line 6) |
| * kvm: BSD libkvm Interface. |
| (line 24) |
| * l (list): List. (line 6) |
| * languages: Languages. (line 6) |
| * last tracepoint number: Create and Delete Tracepoints. |
| (line 31) |
| * latest breakpoint: Set Breaks. (line 6) |
| * layout: TUI Commands. (line 15) |
| * LDT: DJGPP Native. (line 24) |
| * leaving GDB: Quitting GDB. (line 6) |
| * Left: TUI Keys. (line 59) |
| * libkvm: BSD libkvm Interface. |
| (line 6) |
| * library list format, remote protocol: Library List Format. (line 6) |
| * limit hardware breakpoints and watchpoints: Remote Configuration. |
| (line 72) |
| * limit on number of printed array elements: Print Settings. (line 123) |
| * limits, in file-i/o protocol: Limits. (line 6) |
| * linespec: Specify Location. (line 6) |
| * Linux lightweight processes: Debugging Output. (line 66) |
| * list: List. (line 6) |
| * list active threads, remote request: General Query Packets. |
| (line 60) |
| * list of supported file-i/o calls: List of Supported Calls. |
| (line 6) |
| * list output in GDB/MI: GDB/MI Output Syntax. |
| (line 115) |
| * list, and Objective-C: Method Names in Commands. |
| (line 9) |
| * list, how many lines to display: List. (line 30) |
| * listing GDB's internal symbol tables: Symbols. (line 270) |
| * listing machine instructions: Machine Code. (line 35) |
| * listing mapped overlays: Overlay Commands. (line 60) |
| * load address, overlay's: How Overlays Work. (line 6) |
| * load FILENAME: Target Commands. (line 115) |
| * load shared library: Files. (line 323) |
| * load symbols from memory: Files. (line 162) |
| * local variables: Symbols. (line 130) |
| * locate address: Output Formats. (line 35) |
| * lock scheduler: Thread Stops. (line 90) |
| * log output in GDB/MI: GDB/MI Output Syntax. |
| (line 111) |
| * logging file name: Logging Output. (line 13) |
| * logging GDB output: Logging Output. (line 6) |
| * loop_break: Command Files. (line 75) |
| * loop_continue: Command Files. (line 79) |
| * lseek flags, in file-i/o protocol: Lseek Flags. (line 6) |
| * lseek, file-i/o system call: lseek. (line 6) |
| * M packet: Packets. (line 185) |
| * m packet: Packets. (line 165) |
| * M32-EVA target board address: M32R/D. (line 21) |
| * M32R/Chaos debugging: M32R/D. (line 50) |
| * m680x0: Remote Stub. (line 60) |
| * m68k-stub.c: Remote Stub. (line 60) |
| * machine instructions: Machine Code. (line 35) |
| * macro define: Macros. (line 54) |
| * macro definition, showing: Macros. (line 50) |
| * macro exp1: Macros. (line 39) |
| * macro expand: Macros. (line 32) |
| * macro expansion, showing the results of preprocessor: Macros. |
| (line 32) |
| * macro list: Macros. (line 76) |
| * macro undef: Macros. (line 69) |
| * macros, example of debugging with: Macros. (line 80) |
| * macros, user-defined: Macros. (line 54) |
| * mailing lists: GDB/MI Development and Front Ends. |
| (line 39) |
| * maint agent: Maintenance Commands. |
| (line 12) |
| * maint check-symtabs: Maintenance Commands. |
| (line 48) |
| * maint cplus first_component: Maintenance Commands. |
| (line 51) |
| * maint cplus namespace: Maintenance Commands. |
| (line 54) |
| * maint demangle: Maintenance Commands. |
| (line 57) |
| * maint deprecate: Maintenance Commands. |
| (line 60) |
| * maint dump-me: Maintenance Commands. |
| (line 68) |
| * maint info breakpoints: Maintenance Commands. |
| (line 17) |
| * maint info psymtabs: Symbols. (line 270) |
| * maint info sections: Files. (line 200) |
| * maint info sol-threads: Threads. (line 129) |
| * maint info symtabs: Symbols. (line 270) |
| * maint internal-error: Maintenance Commands. |
| (line 73) |
| * maint internal-warning: Maintenance Commands. |
| (line 73) |
| * maint packet: Maintenance Commands. |
| (line 94) |
| * maint print architecture: Maintenance Commands. |
| (line 100) |
| * maint print c-tdesc: Maintenance Commands. |
| (line 104) |
| * maint print cooked-registers: Maintenance Commands. |
| (line 127) |
| * maint print dummy-frames: Maintenance Commands. |
| (line 109) |
| * maint print objfiles: Maintenance Commands. |
| (line 161) |
| * maint print psymbols: Symbols. (line 251) |
| * maint print raw-registers: Maintenance Commands. |
| (line 127) |
| * maint print reggroups: Maintenance Commands. |
| (line 142) |
| * maint print register-groups: Maintenance Commands. |
| (line 127) |
| * maint print registers: Maintenance Commands. |
| (line 127) |
| * maint print statistics: Maintenance Commands. |
| (line 166) |
| * maint print symbols: Symbols. (line 251) |
| * maint print target-stack: Maintenance Commands. |
| (line 179) |
| * maint print type: Maintenance Commands. |
| (line 191) |
| * maint print unwind, HPPA: HPPA. (line 17) |
| * maint set dwarf2 max-cache-age: Maintenance Commands. |
| (line 198) |
| * maint set profile: Maintenance Commands. |
| (line 212) |
| * maint show dwarf2 max-cache-age: Maintenance Commands. |
| (line 198) |
| * maint show profile: Maintenance Commands. |
| (line 212) |
| * maint show-debug-regs: Maintenance Commands. |
| (line 228) |
| * maint space: Maintenance Commands. |
| (line 235) |
| * maint time: Maintenance Commands. |
| (line 242) |
| * maint translate-address: Maintenance Commands. |
| (line 249) |
| * maint undeprecate: Maintenance Commands. |
| (line 60) |
| * maintenance commands: Maintenance Commands. |
| (line 6) |
| * make: Shell Commands. (line 19) |
| * manual overlay debugging: Overlay Commands. (line 23) |
| * map an overlay: Overlay Commands. (line 30) |
| * mapinfo list, QNX Neutrino: SVR4 Process Information. |
| (line 78) |
| * mapped address: How Overlays Work. (line 6) |
| * mapped overlays: How Overlays Work. (line 6) |
| * mark-modified-lines: Readline Init File Syntax. |
| (line 132) |
| * mark-symlinked-directories: Readline Init File Syntax. |
| (line 137) |
| * match-hidden-files: Readline Init File Syntax. |
| (line 142) |
| * maximum value for offset of closest symbol: Print Settings. (line 70) |
| * mem: Memory Region Attributes. |
| (line 22) |
| * member functions: C Plus Plus Expressions. |
| (line 18) |
| * memory address space mappings: SVR4 Process Information. |
| (line 32) |
| * memory map format: Memory Map Format. (line 6) |
| * memory region attributes: Memory Region Attributes. |
| (line 6) |
| * memory tracing: Breakpoints. (line 20) |
| * memory transfer, in file-i/o protocol: Memory Transfer. (line 6) |
| * memory used by commands: Maintenance Commands. |
| (line 235) |
| * memory used for symbol tables: Files. (line 311) |
| * memory, alignment and size of remote accesses: Packets. (line 172) |
| * memory, viewing as typed object: Expressions. (line 42) |
| * memset: Bootstrapping. (line 70) |
| * menu-complete (): Commands For Completion. |
| (line 18) |
| * meta-flag: Readline Init File Syntax. |
| (line 105) |
| * mi interpreter: Interpreters. (line 26) |
| * mi1 interpreter: Interpreters. (line 34) |
| * mi2 interpreter: Interpreters. (line 31) |
| * minimal language: Unsupported Languages. |
| (line 6) |
| * Minimal symbols and DLLs: Non-debug DLL Symbols. |
| (line 6) |
| * MIPS addresses, masking: MIPS. (line 61) |
| * MIPS boards: MIPS Embedded. (line 6) |
| * MIPS remote floating point: MIPS Embedded. (line 60) |
| * MIPS stack: MIPS. (line 6) |
| * MMX registers (x86): Registers. (line 71) |
| * mode_t values, in file-i/o protocol: mode_t Values. (line 6) |
| * Modula-2: Summary. (line 27) |
| * Modula-2 built-ins: Built-In Func/Proc. (line 6) |
| * Modula-2 checks: M2 Checks. (line 6) |
| * Modula-2 constants: Built-In Func/Proc. (line 112) |
| * Modula-2 defaults: M2 Defaults. (line 6) |
| * Modula-2 operators: M2 Operators. (line 6) |
| * Modula-2 types: M2 Types. (line 6) |
| * Modula-2, deviations from: Deviations. (line 6) |
| * Modula-2, GDB support: Modula-2. (line 6) |
| * monitor: Connecting. (line 104) |
| * monitor commands, for gdbserver: Server. (line 149) |
| * Motorola 680x0: Remote Stub. (line 60) |
| * MS Windows debugging: Cygwin Native. (line 6) |
| * MS-DOS system info: DJGPP Native. (line 19) |
| * MS-DOS-specific commands: DJGPP Native. (line 6) |
| * multiple processes: Processes. (line 6) |
| * multiple processes with gdbserver: Server. (line 91) |
| * multiple targets: Active Targets. (line 6) |
| * multiple threads: Threads. (line 6) |
| * multiple threads, backtrace: Backtrace. (line 37) |
| * n (next): Continuing and Stepping. |
| (line 78) |
| * n (SingleKey TUI key): TUI Single Key Mode. (line 19) |
| * names of symbols: Symbols. (line 14) |
| * namespace in C++: C Plus Plus Expressions. |
| (line 22) |
| * native Cygwin debugging: Cygwin Native. (line 6) |
| * native DJGPP debugging: DJGPP Native. (line 6) |
| * negative breakpoint numbers: Set Breaks. (line 289) |
| * NetROM ROM emulator target: Target Commands. (line 88) |
| * New SYSTAG message: Threads. (line 47) |
| * New SYSTAG message, on HP-UX: Threads. (line 89) |
| * next: Continuing and Stepping. |
| (line 78) |
| * next-history (C-n): Commands For History. |
| (line 16) |
| * nexti: Continuing and Stepping. |
| (line 202) |
| * ni (nexti): Continuing and Stepping. |
| (line 202) |
| * non-incremental-forward-search-history (M-n): Commands For History. |
| (line 40) |
| * non-incremental-reverse-search-history (M-p): Commands For History. |
| (line 35) |
| * non-member C++ functions, set breakpoint in: Set Breaks. (line 103) |
| * noninvasive task options: Hurd Native. (line 73) |
| * nosharedlibrary: Files. (line 339) |
| * notation, readline: Readline Bare Essentials. |
| (line 6) |
| * notational conventions, for GDB/MI: GDB/MI. (line 25) |
| * notify output in GDB/MI: GDB/MI Output Syntax. |
| (line 100) |
| * NULL elements in arrays: Print Settings. (line 187) |
| * number of array elements to print: Print Settings. (line 123) |
| * number representation: Numbers. (line 6) |
| * numbers for breakpoints: Breakpoints. (line 41) |
| * object files, relocatable, reading symbols from: Files. (line 132) |
| * Objective-C: Objective-C. (line 6) |
| * Objective-C, classes and selectors: Symbols. (line 197) |
| * Objective-C, print objects: The Print Command with Objective-C. |
| (line 6) |
| * observer debugging info: Debugging Output. (line 73) |
| * octal escapes in strings: Print Settings. (line 220) |
| * online documentation: Help. (line 6) |
| * opaque data types: Symbols. (line 233) |
| * open flags, in file-i/o protocol: Open Flags. (line 6) |
| * open, file-i/o system call: open. (line 6) |
| * OpenRISC 1000: OpenRISC 1000. (line 6) |
| * OpenRISC 1000 htrace: OpenRISC 1000. (line 58) |
| * optimized code, debugging: Compilation. (line 26) |
| * optimized code, wrong values of variables: Variables. (line 58) |
| * optional debugging messages: Debugging Output. (line 6) |
| * optional warnings: Messages/Warnings. (line 6) |
| * or1k boards: OpenRISC 1000. (line 6) |
| * or1ksim: OpenRISC 1000. (line 16) |
| * OS ABI: ABI. (line 11) |
| * OS information: OS Information. (line 6) |
| * out-of-band records in GDB/MI: GDB/MI Out-of-band Records. |
| (line 6) |
| * outermost frame: Frames. (line 12) |
| * output: Output. (line 35) |
| * output formats: Output Formats. (line 6) |
| * output syntax of GDB/MI: GDB/MI Output Syntax. |
| (line 6) |
| * output-meta: Readline Init File Syntax. |
| (line 149) |
| * overlay: Overlay Commands. (line 17) |
| * overlay area: How Overlays Work. (line 6) |
| * overlay example program: Overlay Sample Program. |
| (line 6) |
| * overlays: Overlays. (line 6) |
| * overlays, setting breakpoints in: Overlay Commands. (line 93) |
| * overload-choice annotation: Prompting. (line 32) |
| * overloaded functions, calling: C Plus Plus Expressions. |
| (line 27) |
| * overloaded functions, overload resolution: Debugging C Plus Plus. |
| (line 47) |
| * overloading: Breakpoint Menus. (line 6) |
| * overloading in C++: Debugging C Plus Plus. |
| (line 14) |
| * overwrite-mode (): Commands For Text. (line 53) |
| * P packet: Packets. (line 213) |
| * p packet: Packets. (line 198) |
| * packet size, remote protocol: General Query Packets. |
| (line 326) |
| * packets, reporting on stdout: Debugging Output. (line 86) |
| * packets, tracepoint: Tracepoint Packets. (line 6) |
| * page tables display (MS-DOS): DJGPP Native. (line 56) |
| * page-completions: Readline Init File Syntax. |
| (line 154) |
| * partial symbol dump: Symbols. (line 251) |
| * partial symbol tables, listing GDB's internal: Symbols. (line 270) |
| * Pascal: Summary. (line 30) |
| * Pascal objects, static members display: Print Settings. (line 351) |
| * Pascal support in GDB, limitations: Pascal. (line 6) |
| * pass signals to inferior, remote request: General Query Packets. |
| (line 175) |
| * passcount: Tracepoint Passcounts. |
| (line 6) |
| * patching binaries: Patching. (line 6) |
| * patching object files: Files. (line 26) |
| * path: Environment. (line 14) |
| * pause current task (GNU Hurd): Hurd Native. (line 49) |
| * pause current thread (GNU Hurd): Hurd Native. (line 91) |
| * pauses in output: Screen Size. (line 6) |
| * pending breakpoints: Set Breaks. (line 217) |
| * PgDn: TUI Keys. (line 50) |
| * PgUp: TUI Keys. (line 47) |
| * physical address from linear address: DJGPP Native. (line 81) |
| * pipe, target remote to: Connecting. (line 60) |
| * pipes: Starting. (line 54) |
| * pmon, MIPS remote: MIPS Embedded. (line 132) |
| * po (print-object): The Print Command with Objective-C. |
| (line 6) |
| * pointer values, in file-i/o protocol: Pointer Values. (line 6) |
| * pointer, finding referent: Print Settings. (line 79) |
| * port rights, GNU Hurd: Hurd Native. (line 85) |
| * port sets, GNU Hurd: Hurd Native. (line 85) |
| * possible-completions (M-?): Commands For Completion. |
| (line 11) |
| * post-commands annotation: Prompting. (line 27) |
| * post-overload-choice annotation: Prompting. (line 32) |
| * post-prompt annotation: Prompting. (line 24) |
| * post-prompt-for-continue annotation: Prompting. (line 40) |
| * post-query annotation: Prompting. (line 36) |
| * PowerPC architecture: PowerPC. (line 6) |
| * pre-commands annotation: Prompting. (line 27) |
| * pre-overload-choice annotation: Prompting. (line 32) |
| * pre-prompt annotation: Prompting. (line 24) |
| * pre-prompt-for-continue annotation: Prompting. (line 40) |
| * pre-query annotation: Prompting. (line 36) |
| * prefix for shared library file names: Files. (line 369) |
| * prefix-meta (<ESC>): Miscellaneous Commands. |
| (line 18) |
| * premature return from system calls: Thread Stops. (line 37) |
| * preprocessor macro expansion, showing the results of: Macros. |
| (line 32) |
| * pretty print arrays: Print Settings. (line 98) |
| * pretty print C++ virtual function tables: Print Settings. (line 362) |
| * previous-history (C-p): Commands For History. |
| (line 12) |
| * print: Data. (line 6) |
| * print all frame argument values: Print Settings. (line 135) |
| * print an Objective-C object description: The Print Command with Objective-C. |
| (line 11) |
| * print array indexes: Print Settings. (line 108) |
| * print frame argument values for scalars only: Print Settings. |
| (line 135) |
| * print messages on thread start and exit: Threads. (line 155) |
| * print settings: Print Settings. (line 6) |
| * print structures in indented form: Print Settings. (line 196) |
| * print-object: The Print Command with Objective-C. |
| (line 6) |
| * print/don't print memory addresses: Print Settings. (line 13) |
| * printf: Output. (line 46) |
| * printing byte arrays: Output Formats. (line 60) |
| * printing data: Data. (line 6) |
| * printing frame argument values: Print Settings. (line 135) |
| * printing strings: Output Formats. (line 60) |
| * proc-trace-entry: SVR4 Process Information. |
| (line 70) |
| * proc-trace-exit: SVR4 Process Information. |
| (line 70) |
| * proc-untrace-entry: SVR4 Process Information. |
| (line 70) |
| * proc-untrace-exit: SVR4 Process Information. |
| (line 70) |
| * process detailed status information: SVR4 Process Information. |
| (line 40) |
| * process ID: SVR4 Process Information. |
| (line 16) |
| * process info via /proc: SVR4 Process Information. |
| (line 6) |
| * process list, QNX Neutrino: SVR4 Process Information. |
| (line 74) |
| * process PROCESS-ID: Processes. (line 90) |
| * process status register: Registers. (line 26) |
| * processes, multiple: Processes. (line 6) |
| * procfs API calls: SVR4 Process Information. |
| (line 53) |
| * profiling GDB: Maintenance Commands. |
| (line 212) |
| * program counter register: Registers. (line 26) |
| * program entry point: Backtrace. (line 87) |
| * prompt: Prompt. (line 6) |
| * prompt annotation: Prompting. (line 24) |
| * prompt-for-continue annotation: Prompting. (line 40) |
| * protocol basics, file-i/o: Protocol Basics. (line 6) |
| * protocol, GDB remote serial: Overview. (line 14) |
| * protocol-specific representation of datatypes, in file-i/o protocol: Protocol-specific Representation of Datatypes. |
| (line 6) |
| * ptrace system call: OS Information. (line 9) |
| * ptype: Symbols. (line 77) |
| * putDebugChar: Bootstrapping. (line 20) |
| * pwd: Working Directory. (line 19) |
| * q (quit): Quitting GDB. (line 6) |
| * q (SingleKey TUI key): TUI Single Key Mode. (line 22) |
| * Q packet: Packets. (line 226) |
| * q packet: Packets. (line 226) |
| * qC packet: General Query Packets. |
| (line 41) |
| * qCRC packet: General Query Packets. |
| (line 51) |
| * qfThreadInfo packet: General Query Packets. |
| (line 60) |
| * qGetTLSAddr packet: General Query Packets. |
| (line 87) |
| * QNX Neutrino: Neutrino. (line 6) |
| * qOffsets packet: General Query Packets. |
| (line 139) |
| * qP packet: General Query Packets. |
| (line 166) |
| * QPassSignals packet: General Query Packets. |
| (line 175) |
| * qRcmd packet: General Query Packets. |
| (line 203) |
| * qsThreadInfo packet: General Query Packets. |
| (line 60) |
| * qSupported packet: General Query Packets. |
| (line 228) |
| * qSymbol packet: General Query Packets. |
| (line 367) |
| * qThreadExtraInfo packet: General Query Packets. |
| (line 403) |
| * query annotation: Prompting. (line 36) |
| * quit [EXPRESSION]: Quitting GDB. (line 6) |
| * quit annotation: Errors. (line 6) |
| * quoted-insert (C-q or C-v): Commands For Text. (line 20) |
| * quotes in commands: Completion. (line 57) |
| * quoting Ada internal identifiers: Additions to Ada. (line 76) |
| * quoting names: Symbols. (line 14) |
| * qXfer packet: General Query Packets. |
| (line 429) |
| * r (run): Starting. (line 6) |
| * r (SingleKey TUI key): TUI Single Key Mode. (line 25) |
| * R packet: Packets. (line 235) |
| * r packet: Packets. (line 230) |
| * raise exceptions: Set Catchpoints. (line 80) |
| * range checking: Type Checking. (line 65) |
| * ranges of breakpoints: Breakpoints. (line 48) |
| * rbreak: Set Breaks. (line 87) |
| * RDI heartbeat: ARM. (line 93) |
| * rdilogenable: ARM. (line 76) |
| * rdilogfile: ARM. (line 70) |
| * re-read-init-file (C-x C-r): Miscellaneous Commands. |
| (line 6) |
| * read special object, remote request: General Query Packets. |
| (line 429) |
| * read, file-i/o system call: read. (line 6) |
| * read-only sections: Files. (line 258) |
| * reading symbols from relocatable object files: Files. (line 132) |
| * reading symbols immediately: Files. (line 90) |
| * readline: Editing. (line 6) |
| * readnow: Files. (line 90) |
| * receive rights, GNU Hurd: Hurd Native. (line 85) |
| * recent tracepoint number: Create and Delete Tracepoints. |
| (line 31) |
| * record aggregates (Ada): Omissions from Ada. (line 44) |
| * record serial communications on file: Remote Configuration. |
| (line 57) |
| * recording a session script: Bug Reporting. (line 104) |
| * redirection: Input/Output. (line 6) |
| * redraw-current-line (): Commands For Moving. (line 30) |
| * reference card: Formatting Documentation. |
| (line 6) |
| * reference declarations: C Plus Plus Expressions. |
| (line 51) |
| * refresh: TUI Commands. (line 52) |
| * register stack, AMD29K: A29K. (line 6) |
| * registers: Registers. (line 6) |
| * regs, Super-H: Super-H. (line 9) |
| * regular expression: Set Breaks. (line 87) |
| * reloading symbols: Symbols. (line 209) |
| * reloading the overlay table: Overlay Commands. (line 52) |
| * relocatable object files, reading symbols from: Files. (line 132) |
| * remote connection without stubs: Server. (line 6) |
| * remote debugging: Remote Debugging. (line 6) |
| * remote delete: File Transfer. (line 23) |
| * remote get: File Transfer. (line 19) |
| * remote memory comparison: Memory. (line 105) |
| * remote monitor prompt: MIPS Embedded. (line 107) |
| * remote packets, enabling and disabling: Remote Configuration. |
| (line 84) |
| * remote programs, interrupting: Connecting. (line 77) |
| * remote protocol debugging: Debugging Output. (line 86) |
| * remote protocol, binary data: Overview. (line 55) |
| * remote protocol, field separator: Overview. (line 47) |
| * remote put: File Transfer. (line 15) |
| * remote query requests: General Query Packets. |
| (line 6) |
| * remote serial debugging summary: Debug Session. (line 6) |
| * remote serial debugging, overview: Remote Stub. (line 14) |
| * remote serial protocol: Overview. (line 14) |
| * remote serial stub: Stub Contents. (line 6) |
| * remote serial stub list: Remote Stub. (line 54) |
| * remote serial stub, initialization: Stub Contents. (line 10) |
| * remote serial stub, main routine: Stub Contents. (line 15) |
| * remote stub, example: Remote Stub. (line 6) |
| * remote stub, support routines: Bootstrapping. (line 6) |
| * remote target: Target Commands. (line 58) |
| * remote target, file transfer: File Transfer. (line 6) |
| * remote target, limit break- and watchpoints: Remote Configuration. |
| (line 72) |
| * remote timeout: Remote Configuration. |
| (line 65) |
| * remotetimeout: Sparclet. (line 12) |
| * remove actions from a tracepoint: Tracepoint Actions. (line 17) |
| * rename, file-i/o system call: rename. (line 6) |
| * Renesas: Remote Stub. (line 63) |
| * repeated array elements: Print Settings. (line 174) |
| * repeating command sequences: Command Syntax. (line 42) |
| * repeating commands: Command Syntax. (line 21) |
| * reporting bugs in GDB: GDB Bugs. (line 6) |
| * reprint the last value: Data. (line 21) |
| * reset SDI connection, M32R: M32R/D. (line 44) |
| * response time, MIPS debugging: MIPS. (line 10) |
| * restart: Checkpoint/Restart. (line 6) |
| * restart CHECKPOINT-ID: Checkpoint/Restart. (line 44) |
| * restore: Dump/Restore Files. (line 41) |
| * restore data from a file: Dump/Restore Files. (line 6) |
| * result records in GDB/MI: GDB/MI Result Records. |
| (line 6) |
| * resuming execution: Continuing and Stepping. |
| (line 6) |
| * RET (repeat last command): Command Syntax. (line 21) |
| * retransmit-timeout, MIPS protocol: MIPS Embedded. (line 83) |
| * return: Returning. (line 6) |
| * returning from a function: Returning. (line 6) |
| * reverse-search: Search. (line 16) |
| * reverse-search-history (C-r): Commands For History. |
| (line 26) |
| * revert-line (M-r): Miscellaneous Commands. |
| (line 25) |
| * rewind program state: Checkpoint/Restart. (line 6) |
| * Right: TUI Keys. (line 62) |
| * ROM at zero address, RDI: ARM. (line 83) |
| * run: Starting. (line 6) |
| * run to main procedure: Starting. (line 71) |
| * run until specified location: Continuing and Stepping. |
| (line 117) |
| * running: Starting. (line 6) |
| * running and debugging Sparclet programs: Sparclet Execution. |
| (line 6) |
| * running VxWorks tasks: VxWorks Attach. (line 6) |
| * running, on Sparclet: Sparclet. (line 28) |
| * rwatch: Set Watchpoints. (line 47) |
| * s (SingleKey TUI key): TUI Single Key Mode. (line 28) |
| * s (step): Continuing and Stepping. |
| (line 46) |
| * S packet: Packets. (line 248) |
| * s packet: Packets. (line 242) |
| * save command history: Command History. (line 36) |
| * save GDB output to a file: Logging Output. (line 6) |
| * save tracepoints for future sessions: save-tracepoints. (line 6) |
| * save-tracepoints: save-tracepoints. (line 6) |
| * scheduler locking mode: Thread Stops. (line 90) |
| * scope: M2 Scope. (line 6) |
| * scripting commands: Command Files. (line 6) |
| * sdireset: M32R/D. (line 44) |
| * sdistatus: M32R/D. (line 47) |
| * SDS protocol: PowerPC Embedded. (line 34) |
| * sds, a command: PowerPC Embedded. (line 45) |
| * search: Search. (line 9) |
| * searching source files: Search. (line 6) |
| * section: Files. (line 182) |
| * section offsets, remote request: General Query Packets. |
| (line 139) |
| * segment descriptor tables: DJGPP Native. (line 24) |
| * select trace snapshot: tfind. (line 6) |
| * select-frame: Frames. (line 51) |
| * selected frame: Stack. (line 19) |
| * selecting frame silently: Frames. (line 51) |
| * self-insert (a, b, A, 1, !, ...): Commands For Text. (line 27) |
| * send command to remote monitor: Connecting. (line 104) |
| * send command to simulator: Embedded Processors. (line 9) |
| * send PMON command: MIPS Embedded. (line 132) |
| * send rights, GNU Hurd: Hurd Native. (line 85) |
| * sending files to remote systems: File Transfer. (line 6) |
| * separate debugging information files: Separate Debug Files. |
| (line 6) |
| * sequence-id, for GDB remote: Overview. (line 29) |
| * serial connections, debugging: Debugging Output. (line 86) |
| * serial line, target remote: Connecting. (line 18) |
| * serial protocol, GDB remote: Overview. (line 14) |
| * server prefix: Server Prefix. (line 6) |
| * server, command prefix: Command History. (line 20) |
| * set: Help. (line 107) |
| * set ABI for MIPS: MIPS. (line 32) |
| * set annotate: Annotations Overview. |
| (line 29) |
| * set architecture: Targets. (line 21) |
| * set args: Arguments. (line 21) |
| * set arm: ARM. (line 18) |
| * set auto-solib-add: Files. (line 303) |
| * set backtrace: Backtrace. (line 98) |
| * set board-address: M32R/D. (line 21) |
| * set breakpoint auto-hw: Set Breaks. (line 279) |
| * set breakpoint pending: Set Breaks. (line 248) |
| * set breakpoints in many functions: Set Breaks. (line 87) |
| * set breakpoints on all functions: Set Breaks. (line 107) |
| * set can-use-hw-watchpoints: Set Watchpoints. (line 74) |
| * set case-sensitive: Symbols. (line 27) |
| * set charset: Character Sets. (line 47) |
| * set check range: Range Checking. (line 34) |
| * set check type: Type Checking. (line 42) |
| * set coerce-float-to-double: ABI. (line 41) |
| * set com1base: DJGPP Native. (line 125) |
| * set com1irq: DJGPP Native. (line 125) |
| * set com2base: DJGPP Native. (line 125) |
| * set com2irq: DJGPP Native. (line 125) |
| * set com3base: DJGPP Native. (line 125) |
| * set com3irq: DJGPP Native. (line 125) |
| * set com4base: DJGPP Native. (line 125) |
| * set com4irq: DJGPP Native. (line 125) |
| * set complaints: Messages/Warnings. (line 29) |
| * set confirm: Messages/Warnings. (line 50) |
| * set cp-abi: ABI. (line 53) |
| * set cygwin-exceptions: Cygwin Native. (line 30) |
| * set debug: Debugging Output. (line 18) |
| * set debug hppa: HPPA. (line 10) |
| * set debug mips: MIPS. (line 81) |
| * set debug monitor: Target Commands. (line 108) |
| * set debug nto-debug: Neutrino. (line 9) |
| * set debug-file-directory: Separate Debug Files. |
| (line 68) |
| * set debugevents: Cygwin Native. (line 59) |
| * set debugexceptions: Cygwin Native. (line 70) |
| * set debugexec: Cygwin Native. (line 66) |
| * set debugmemory: Cygwin Native. (line 74) |
| * set demangle-style: Print Settings. (line 294) |
| * set detach-on-fork: Processes. (line 55) |
| * set disassembly-flavor: Machine Code. (line 67) |
| * set download-path: M32R/D. (line 15) |
| * set editing: Editing. (line 15) |
| * set endian: Byte Order. (line 13) |
| * set environment: Environment. (line 39) |
| * set exceptions, Hurd command: Hurd Native. (line 40) |
| * set exec-done-display: Debugging Output. (line 11) |
| * set extension-language: Show. (line 30) |
| * set follow-fork-mode: Processes. (line 35) |
| * set gnutarget: Target Commands. (line 28) |
| * set hash, for remote monitors: Target Commands. (line 99) |
| * set height: Screen Size. (line 21) |
| * set history expansion: Command History. (line 65) |
| * set history filename: Command History. (line 26) |
| * set history save: Command History. (line 36) |
| * set history size: Command History. (line 45) |
| * set host-charset: Character Sets. (line 34) |
| * set inferior controlling terminal: Input/Output. (line 44) |
| * set inferior-tty: Input/Output. (line 49) |
| * set input-radix: Numbers. (line 14) |
| * set language: Manually. (line 9) |
| * set listsize: List. (line 33) |
| * set logging: Logging Output. (line 9) |
| * set max-user-call-depth: Define. (line 73) |
| * set mem inaccessible-by-default: Memory Region Attributes. |
| (line 130) |
| * set mips abi: MIPS. (line 32) |
| * set mips mask-address: MIPS. (line 61) |
| * set mipsfpu: MIPS Embedded. (line 60) |
| * set monitor-prompt, MIPS remote: MIPS Embedded. (line 107) |
| * set monitor-warnings, MIPS remote: MIPS Embedded. (line 123) |
| * set new-console: Cygwin Native. (line 42) |
| * set new-group: Cygwin Native. (line 51) |
| * set opaque-type-resolution: Symbols. (line 233) |
| * set osabi: ABI. (line 11) |
| * set output-radix: Numbers. (line 31) |
| * set overload-resolution: Debugging C Plus Plus. |
| (line 47) |
| * set pagination: Screen Size. (line 38) |
| * set powerpc: PowerPC Embedded. (line 8) |
| * set print: Print Settings. (line 11) |
| * set print thread-events: Threads. (line 155) |
| * set processor: Targets. (line 31) |
| * set procfs-file: SVR4 Process Information. |
| (line 59) |
| * set procfs-trace: SVR4 Process Information. |
| (line 53) |
| * set prompt: Prompt. (line 16) |
| * set radix: Numbers. (line 44) |
| * set rdiheartbeat: ARM. (line 93) |
| * set rdiromatzero: ARM. (line 83) |
| * set remote: Remote Configuration. |
| (line 6) |
| * set remote system-call-allowed: system. (line 38) |
| * set remote-mips64-transfers-32bit-regs: MIPS. (line 71) |
| * set remotecache: Caching Remote Data. (line 14) |
| * set remoteflow: Remote Configuration. |
| (line 41) |
| * set retransmit-timeout: MIPS Embedded. (line 83) |
| * set rstack_high_address: A29K. (line 6) |
| * set sdstimeout: PowerPC Embedded. (line 38) |
| * set server-address: M32R/D. (line 27) |
| * set shell: Cygwin Native. (line 78) |
| * set signal-thread: Hurd Native. (line 21) |
| * set signals, Hurd command: Hurd Native. (line 11) |
| * set sigs, Hurd command: Hurd Native. (line 11) |
| * set sigthread: Hurd Native. (line 21) |
| * set solib-absolute-prefix: Files. (line 369) |
| * set solib-search-path: Files. (line 390) |
| * set step-mode: Continuing and Stepping. |
| (line 92) |
| * set stop-on-solib-events: Files. (line 349) |
| * set stopped, Hurd command: Hurd Native. (line 32) |
| * set struct-convention: i386. (line 7) |
| * set substitute-path: Source Path. (line 114) |
| * set symbol-reloading: Symbols. (line 216) |
| * set syn-garbage-limit, MIPS remote: MIPS Embedded. (line 98) |
| * set sysroot: Files. (line 369) |
| * set target-charset: Character Sets. (line 28) |
| * set task, Hurd commands: Hurd Native. (line 49) |
| * set tdesc filename: Retrieving Descriptions. |
| (line 18) |
| * set thread, Hurd command: Hurd Native. (line 91) |
| * set timeout: MIPS Embedded. (line 83) |
| * set trace-commands: Messages/Warnings. (line 65) |
| * set tracepoint: Create and Delete Tracepoints. |
| (line 6) |
| * set trust-readonly-sections: Files. (line 258) |
| * set tui active-border-mode: TUI Configuration. (line 24) |
| * set tui border-kind: TUI Configuration. (line 9) |
| * set tui border-mode: TUI Configuration. (line 23) |
| * set unwindonsignal: Calling. (line 26) |
| * set variable: Assignment. (line 16) |
| * set verbose: Messages/Warnings. (line 15) |
| * set watchdog: Maintenance Commands. |
| (line 262) |
| * set width: Screen Size. (line 21) |
| * set write: Patching. (line 15) |
| * set-mark (C-@): Miscellaneous Commands. |
| (line 32) |
| * set_debug_traps: Stub Contents. (line 10) |
| * setting variables: Assignment. (line 6) |
| * setting watchpoints: Set Watchpoints. (line 6) |
| * SH: Remote Stub. (line 63) |
| * sh-stub.c: Remote Stub. (line 63) |
| * share: Files. (line 330) |
| * shared libraries: Files. (line 281) |
| * shared library events, remote reply: Stop Reply Packets. (line 52) |
| * sharedlibrary: Files. (line 330) |
| * shell: Shell Commands. (line 10) |
| * shell escape: Shell Commands. (line 10) |
| * show: Help. (line 112) |
| * show all user variables: Convenience Vars. (line 37) |
| * show annotate: Annotations Overview. |
| (line 34) |
| * show architecture: Targets. (line 21) |
| * show args: Arguments. (line 28) |
| * show arm: ARM. (line 22) |
| * show auto-solib-add: Files. (line 320) |
| * show backtrace: Backtrace. (line 105) |
| * show board-address: M32R/D. (line 24) |
| * show breakpoint auto-hw: Set Breaks. (line 279) |
| * show breakpoint pending: Set Breaks. (line 248) |
| * show can-use-hw-watchpoints: Set Watchpoints. (line 77) |
| * show case-sensitive: Symbols. (line 40) |
| * show charset: Character Sets. (line 53) |
| * show check range: Range Checking. (line 34) |
| * show check type: Type Checking. (line 42) |
| * show coerce-float-to-double: ABI. (line 50) |
| * show com1base: DJGPP Native. (line 137) |
| * show com1irq: DJGPP Native. (line 137) |
| * show com2base: DJGPP Native. (line 137) |
| * show com2irq: DJGPP Native. (line 137) |
| * show com3base: DJGPP Native. (line 137) |
| * show com3irq: DJGPP Native. (line 137) |
| * show com4base: DJGPP Native. (line 137) |
| * show com4irq: DJGPP Native. (line 137) |
| * show commands: Command History. (line 78) |
| * show complaints: Messages/Warnings. (line 35) |
| * show confirm: Messages/Warnings. (line 56) |
| * show convenience: Convenience Vars. (line 37) |
| * show copying: Help. (line 136) |
| * show cp-abi: ABI. (line 53) |
| * show cygwin-exceptions: Cygwin Native. (line 38) |
| * show debug: Debugging Output. (line 22) |
| * show debug mips: MIPS. (line 85) |
| * show debug monitor: Target Commands. (line 112) |
| * show debug nto-debug: Neutrino. (line 13) |
| * show debug-file-directory: Separate Debug Files. |
| (line 72) |
| * show detach-on-fork: Processes. (line 71) |
| * show directories: Source Path. (line 111) |
| * show disassembly-flavor: Machine Code. (line 76) |
| * show download-path: M32R/D. (line 18) |
| * show editing: Editing. (line 22) |
| * show environment: Environment. (line 33) |
| * show exceptions, Hurd command: Hurd Native. (line 46) |
| * show exec-done-display: Debugging Output. (line 14) |
| * show follow-fork-mode: Processes. (line 49) |
| * show gnutarget: Target Commands. (line 40) |
| * show hash, for remote monitors: Target Commands. (line 105) |
| * show height: Screen Size. (line 21) |
| * show history: Command History. (line 70) |
| * show host-charset: Character Sets. (line 56) |
| * show inferior-tty: Input/Output. (line 52) |
| * show input-radix: Numbers. (line 36) |
| * show language: Show. (line 10) |
| * show last commands: Command History. (line 78) |
| * show listsize: List. (line 37) |
| * show logging: Logging Output. (line 26) |
| * show max-user-call-depth: Define. (line 73) |
| * show mem inaccessible-by-default: Memory Region Attributes. |
| (line 136) |
| * show mips abi: MIPS. (line 54) |
| * show mips mask-address: MIPS. (line 67) |
| * show mipsfpu: MIPS Embedded. (line 60) |
| * show monitor-prompt, MIPS remote: MIPS Embedded. (line 119) |
| * show monitor-warnings, MIPS remote: MIPS Embedded. (line 129) |
| * show new-console: Cygwin Native. (line 47) |
| * show new-group: Cygwin Native. (line 56) |
| * show opaque-type-resolution: Symbols. (line 248) |
| * show osabi: ABI. (line 11) |
| * show output-radix: Numbers. (line 39) |
| * show overload-resolution: Debugging C Plus Plus. |
| (line 64) |
| * show pagination: Screen Size. (line 42) |
| * show paths: Environment. (line 29) |
| * show print: Print Settings. (line 39) |
| * show print thread-events: Threads. (line 165) |
| * show processor: Targets. (line 31) |
| * show procfs-file: SVR4 Process Information. |
| (line 64) |
| * show procfs-trace: SVR4 Process Information. |
| (line 56) |
| * show prompt: Prompt. (line 19) |
| * show radix: Numbers. (line 44) |
| * show rdiheartbeat: ARM. (line 98) |
| * show rdiromatzero: ARM. (line 90) |
| * show remote: Remote Configuration. |
| (line 6) |
| * show remote system-call-allowed: system. (line 42) |
| * show remote-mips64-transfers-32bit-regs: MIPS. (line 77) |
| * show remotecache: Caching Remote Data. (line 19) |
| * show remoteflow: Remote Configuration. |
| (line 45) |
| * show retransmit-timeout: MIPS Embedded. (line 83) |
| * show rstack_high_address: A29K. (line 17) |
| * show sdstimeout: PowerPC Embedded. (line 42) |
| * show server-address: M32R/D. (line 31) |
| * show shell: Cygwin Native. (line 82) |
| * show signal-thread: Hurd Native. (line 28) |
| * show signals, Hurd command: Hurd Native. (line 17) |
| * show sigs, Hurd command: Hurd Native. (line 17) |
| * show sigthread: Hurd Native. (line 28) |
| * show solib-search-path: Files. (line 401) |
| * show stop-on-solib-events: Files. (line 355) |
| * show stopped, Hurd command: Hurd Native. (line 37) |
| * show struct-convention: i386. (line 15) |
| * show substitute-path: Source Path. (line 151) |
| * show symbol-reloading: Symbols. (line 230) |
| * show syn-garbage-limit, MIPS remote: MIPS Embedded. (line 103) |
| * show sysroot: Files. (line 387) |
| * show target-charset: Character Sets. (line 59) |
| * show task, Hurd commands: Hurd Native. (line 57) |
| * show tdesc filename: Retrieving Descriptions. |
| (line 25) |
| * show thread, Hurd command: Hurd Native. (line 101) |
| * show timeout: MIPS Embedded. (line 83) |
| * show unwindonsignal: Calling. (line 33) |
| * show user: Define. (line 67) |
| * show values: Value History. (line 47) |
| * show verbose: Messages/Warnings. (line 21) |
| * show version: Help. (line 126) |
| * show warranty: Help. (line 140) |
| * show width: Screen Size. (line 21) |
| * show write: Patching. (line 26) |
| * show-all-if-ambiguous: Readline Init File Syntax. |
| (line 164) |
| * show-all-if-unmodified: Readline Init File Syntax. |
| (line 170) |
| * si (stepi): Continuing and Stepping. |
| (line 189) |
| * signal: Signaling. (line 6) |
| * signal annotation: Annotations for Running. |
| (line 42) |
| * signal-name annotation: Annotations for Running. |
| (line 22) |
| * signal-name-end annotation: Annotations for Running. |
| (line 22) |
| * signal-string annotation: Annotations for Running. |
| (line 22) |
| * signal-string-end annotation: Annotations for Running. |
| (line 22) |
| * signalled annotation: Annotations for Running. |
| (line 22) |
| * signals: Signals. (line 6) |
| * SIGQUIT signal, dump core of GDB: Maintenance Commands. |
| (line 69) |
| * silent: Break Commands. (line 38) |
| * sim: Z8000. (line 15) |
| * sim, a command: Embedded Processors. (line 13) |
| * simulator, Z8000: Z8000. (line 6) |
| * size of remote memory accesses: Packets. (line 172) |
| * size of screen: Screen Size. (line 6) |
| * snapshot of a process: Checkpoint/Restart. (line 6) |
| * software watchpoints: Set Watchpoints. (line 22) |
| * source: Command Files. (line 14) |
| * source annotation: Source Annotations. (line 6) |
| * source file and line of a symbol: Print Settings. (line 51) |
| * source line and its code address: Machine Code. (line 6) |
| * source path: Source Path. (line 6) |
| * Sparc: Remote Stub. (line 66) |
| * sparc-stub.c: Remote Stub. (line 66) |
| * sparcl-stub.c: Remote Stub. (line 69) |
| * Sparclet: Sparclet. (line 6) |
| * SparcLite:
|