# rule has no dependencies and always regenerates gdb.pot. This is
# relatively harmless since the .po files do not directly depend on
# it. The .pot file is left in the build directory. Since GDB's
-# Makefile lacks a cannonical list of sources (missing xm, tm and nm
+# Makefile lacks a canonical list of sources (missing xm, tm and nm
# files) force this rule.
$(PACKAGE).pot: po/$(PACKAGE).pot
po/$(PACKAGE).pot: force
* The printf command now accepts a '%V' output format which will
format an expression just as the 'print' command would. Print
- options can be placed withing '[...]' after the '%V' to modify how
+ options can be placed within '[...]' after the '%V' to modify how
the value is printed. E.g:
printf "%V", some_array
printf "%V[-array-indexes on]", some_array
target.
qXfer:auxv:read:
- Fetch an OS auxilliary vector from the remote stub. This packet is a
+ Fetch an OS auxiliary vector from the remote stub. This packet is a
more efficient replacement for qPart:auxv:read.
qXfer:memory-map:read:
* MIPS 64 remote protocol
A long standing bug in the mips64 remote protocol where by GDB
-expected certain 32 bit registers (ex SR) to be transfered as 32
+expected certain 32 bit registers (ex SR) to be transferred as 32
instead of 64 bits has been fixed.
The command ``set remote-mips64-transfers-32bit-regs on'' has been
This version includes preliminary support for Chill, a Pascal like language
used by telecommunications companies. Chill support is also being integrated
-into the GNU compiler, but we don't know when it will be publically available.
+into the GNU compiler, but we don't know when it will be publicly available.
*** Changes in GDB-4.8:
if (i < len0 + 3
&& encoded[i] == 'N' && encoded[i+1] == '_' && encoded[i+2] == '_')
{
- /* Backtrack a bit up until we reach either the begining of
+ /* Backtrack a bit up until we reach either the beginning of
the encoded name, or "__". Make sure that we only find
digits or lowercase characters. */
const char *ptr = encoded + i - 1;
/* ??? We should not modify STR directly, as we are doing below. This
is fine in this case, but may become problematic later if we find
that this alternative did not work, and want to try matching
- another one from the begining of STR. Since we modified it, we
- won't be able to find the begining of the string anymore! */
+ another one from the beginning of STR. Since we modified it, we
+ won't be able to find the beginning of the string anymore! */
if (str[0] == 'X')
{
str += 1;
encoded and the resulting name is equal to it. Similarly, if the name
starts with '<', it is copied verbatim. Otherwise, it differs
from NAME0 in that:
- + Characters between '...' are transfered verbatim to yylval.ssym.
+ + Characters between '...' are transferred verbatim to yylval.ssym.
+ Trailing "'" characters in quoted sequences are removed (a leading quote is
preserved to indicate that the name is not to be GNAT-encoded).
+ Unquoted whitespace is removed.
reference it - this number is printed beside each task in the tasks
info listing displayed by "info tasks". This number is equal to
its index in the vector + 1. Reciprocally, to compute the index
- of a task in the vector, we need to substract 1 from its number. */
+ of a task in the vector, we need to subtract 1 from its number. */
std::vector<ada_task_info> task_list;
};
int sc_fpregs_offset = 0;
int jb_pc = 0; /* Offset to PC value in jump buffer.
- If htis is negative, longjmp support
+ If this is negative, longjmp support
will be disabled. */
size_t jb_elt_size = 0; /* And the size of each entry in the buf. */
};
CORE_ADDR next_pc = arc_insn_get_linear_next_pc (curr_insn);
std::vector<CORE_ADDR> next_pcs;
- /* For instructions with delay slots, the fall thru is not the
+ /* For instructions with delay slots, the fall through is not the
instruction immediately after the current instruction, but the one
after that. */
if (curr_insn.has_delay_slot)
1) Store instruction for each callee-saved register (R25 - R13 + 1)
2) Two instructions for FP
3) One for BLINK
- 4) Three substract instructions for SP (for variadic args, for
+ 4) Three subtract instructions for SP (for variadic args, for
callee saved regs and for local vars) and assuming that those SUB use
long-immediate (hence double length).
5) Stores of arguments registers are considered part of prologue too
return true;
}
-/* Check for the existance of "lp_start" and "lp_end" in target description.
+/* Check for the existence of "lp_start" and "lp_end" in target description.
If both are present, assume there is hardware loop support in the target.
This can be improved by looking into "lpc_size" field of "isa_config"
auxiliary register. */
si = pop_stack_item (si);
}
- /* Finally, update teh SP register. */
+ /* Finally, update the SP register. */
regcache_cooked_write_unsigned (regcache, ARM_SP_REGNUM, sp);
return sp;
record_buf[arm_insn_r->reg_rec_count++] = reg_dest;
/* The LDR instruction is capable of doing branching. If MOV LR, PC
- preceeds a LDR instruction having R15 as reg_base, it
+ precedes a LDR instruction having R15 as reg_base, it
emulates a branch and link instruction, and hence we need to save
CPSR and PC as well. */
if (ARM_PC_REGNUM == reg_dest)
if (15 == reg_src2)
{
/* If R15 was used as Rn, hence current PC+8. */
- /* Pre-indexed mode doesnt reach here ; illegal insn. */
+ /* Pre-indexed mode doesn't reach here ; illegal insn. */
u_regval[0] = u_regval[0] + 8;
}
/* Calculate target store address, Rn +/- Rm, register offset. */
/* Handle B, BL, BLX(1) insns. */
/* B simply branches so we do nothing here. */
- /* Note: BLX(1) doesnt fall here but instead it falls into
+ /* Note: BLX(1) doesn't fall here but instead it falls into
extension space. */
if (bit (arm_insn_r->arm_insn, 24))
{
/* Auxiliary Vector information structure. This is used by GDB
for caching purposes for each inferior. This helps reduce the
- overhead of transfering data from a remote target to the local host. */
+ overhead of transferring data from a remote target to the local host. */
struct auxv_info
{
std::optional<gdb::byte_vector> data;
}
}
- /* Now go thru the 'found' chain and delete them. */
+ /* Now go through the 'found' chain and delete them. */
if (found.empty ())
{
if (arg)
static int pe_file;
/* Chain of typedefs of pointers to empty struct/union types.
- They are chained thru the SYMBOL_VALUE_CHAIN. */
+ They are chained through the SYMBOL_VALUE_CHAIN. */
static struct symbol *opaque_type_chain[HASHSIZE];
This is not just a consequence of GDB's type
management; CC and GCC (at least through version
2.4) both output variables of either type char *
- or caddr_t with the type refering to the C_TPDEF
+ or caddr_t with the type referring to the C_TPDEF
symbol for caddr_t. If a future compiler cleans
this up it GDB is not ready for it yet, but if it
becomes ready we somehow need to disable this
if (seen[file] && (skipped[bug_n_file] < skip[bug_n_file])) {
# ari.*.bug: <FILE>:<LINE>: <CATEGORY>: <BUG>: <DOC>
b = file " missing " bug
- print_bug(file, 0, "", "internal", file " missing " bug, "Expecting " skip[bug_n_file] " occurances of bug " bug " in file " file ", only found " skipped[bug_n_file])
+ print_bug(file, 0, "", "internal", file " missing " bug, "Expecting " skip[bug_n_file] " occurrences of bug " bug " in file " file ", only found " skipped[bug_n_file])
}
}
}
return value;
}
-/* Handles the assign addresing mode for the ADD, SUB, CMP, AND, OR and MOVE
+/* Handles the assign addressing mode for the ADD, SUB, CMP, AND, OR and MOVE
instructions. The MOVE instruction is the move from source to register. */
static void
inst_env->disable_interrupt = 0;
}
-/* Handles the index addresing mode for the ADD, SUB, CMP, AND, OR and MOVE
+/* Handles the index addressing mode for the ADD, SUB, CMP, AND, OR and MOVE
instructions. The MOVE instruction is the move from source to register. */
static void
inst_env->disable_interrupt = 0;
}
-/* Handles the autoincrement and indirect addresing mode for the ADD, SUB,
+/* Handles the autoincrement and indirect addressing mode for the ADD, SUB,
CMP, AND OR and MOVE instruction. The MOVE instruction is the move from
source to register. */
struct mdict_iterator
{
- /* The multidictionary with whcih this iterator is associated. */
+ /* The multidictionary with which this iterator is associated. */
const struct multidictionary *mdict;
/* The iterator used to iterate through individual dictionaries. */
system state. Effectively, it is like going back in time to the
moment when the checkpoint was saved.
-Thus, if you're stepping thru a program and you think you're
+Thus, if you're stepping through a program and you think you're
getting close to the point where things go wrong, you can save
a checkpoint. Then, if you accidentally go too far and miss
the critical statement, instead of having to restart your program
statement in the called function (typically a return statement).
Also, as with the @code{step} command, if non-debuggable functions are
-called, @code{reverse-step} will run thru them backward without stopping.
+called, @code{reverse-step} will run through them backward without stopping.
@kindex reverse-stepi
@kindex rsi @r{(@code{reverse-stepi})}
its return address. As a result the return address will
point at some random instruction, and the CFI for that
instruction is probably worthless to us. GCC's unwinder solves
- this problem by substracting 1 from the return address to get an
+ this problem by subtracting 1 from the return address to get an
address in the middle of a presumed call instruction (or the
instruction in the associated delay slot). This should only be
done for "normal" frames and not for resume-type frames (signal
ULONGEST retaddr_column = fs.retaddr_column;
/* It seems rather bizarre to specify an "empty" column as
- the return adress column. However, this is exactly
+ the return address column. However, this is exactly
what GCC does on some targets. It turns out that GCC
assumes that the return address can be found in the
register corresponding to the return address column.
via its tail calls (incl. transitively). Throw NO_ENTRY_VALUE_ERROR if it
can call itself via tail calls.
- If a funtion can tail call itself its entry value based parameters are
+ If a function can tail call itself its entry value based parameters are
unreliable. There is no verification whether the value of some/all
parameters is unchanged through the self tail call, we expect if there is
a self tail call all the parameters can be modified. */
which value is non-zero. However, we have to be careful with
DIEs having a DW_AT_specification attribute, because dwarf2_attr()
(via dwarf2_flag_true_p) follows this attribute. So we may
- end up accidently finding a declaration attribute that belongs
+ end up accidentally finding a declaration attribute that belongs
to a different DIE referenced by the specification attribute,
even though the given DIE does not have a declaration attribute. */
return (dwarf2_flag_true_p (die, DW_AT_declaration, cu)
/* Found a function symbol. Now we will substitute its
value in place of the message dispatcher (obj_msgSend),
- so that we call the method directly instead of thru
+ so that we call the method directly instead of through
the dispatcher. The main reason for doing this is that
we can now evaluate the return value and parameter values
according to their known data types, in case we need to
/* The current extension language we've called out to, or
extension_language_gdb if there isn't one.
- This must be set everytime we call out to an extension language, and reset
+ This must be set every time we call out to an extension language, and reset
to the previous value when it returns. Note that the previous value may
be a different (or the same) extension language. */
static const struct extension_language_defn *active_ext_lang
}
/* Identify address space identifier by type_instance_flags and return
- the string version of the adress space name. */
+ the string version of the address space name. */
const char *
address_space_type_instance_flags_to_name (struct gdbarch *gdbarch,
If TYPEPTR and *TYPEPTR are non-zero, then *TYPEPTR points to
storage to hold the new qualified type; *TYPEPTR and TYPE must be
in the same objfile. Otherwise, allocate fresh memory for the new
- type whereever TYPE lives. If TYPEPTR is non-zero, set it to the
+ type wherever TYPE lives. If TYPEPTR is non-zero, set it to the
new type we construct. */
struct type *
undefined by setting it to zero. Although we are not expected
to trust TYPE_LENGTH in this case, setting the size to zero
allows us to avoid allocating objects of random sizes in case
- we accidently do. */
+ we accidentally do. */
result_type->set_length (0);
}
}
/* Smash TYPE to be a type of pointers to members of SELF_TYPE with type
- TO_TYPE. A member pointer is a wierd thing -- it amounts to a
+ TO_TYPE. A member pointer is a weird thing -- it amounts to a
typed offset into a struct, e.g. "an int at offset 8". A MEMBER
TYPE doesn't include the offset (that's the value of the MEMBER
itself), but does include the structure type into which it points
#ifdef HAVE_PTRACE_GETREGS
/* Fetch all floating-point registers from process/thread TID and store
- thier values in GDB's register array. */
+ their values in GDB's register array. */
static void
fetch_fpregs (struct regcache *regcache, int tid)
tdep->st0_regnum = I386_ST0_REGNUM;
- /* I386_NUM_XREGS includes %mxcsr, so substract one. */
+ /* I386_NUM_XREGS includes %mxcsr, so subtract one. */
tdep->num_xmm_regs = I386_NUM_XREGS - 1;
tdep->jb_pc_offset = -1;
/* Predicate registers: There are 64 of these 1-bit registers. We
define a single register which is used to communicate these values
to/from the target. We will somehow contrive to make it appear
- that IA64_PR0_REGNUM thru IA64_PR63_REGNUM hold the actual values. */
+ that IA64_PR0_REGNUM through IA64_PR63_REGNUM hold the actual values. */
#define IA64_PR_REGNUM 330
/* Instruction pointer: 64 bits wide. */
case TARGET_OBJECT_AUXV:
#if defined (PT_IO) && defined (PIOD_READ_AUXV)
/* OpenBSD 4.5 has a new PIOD_READ_AUXV operation for the PT_IO
- request that allows us to read the auxilliary vector. Other
+ request that allows us to read the auxiliary vector. Other
BSD's may follow if they feel the need to support PIE. */
{
struct ptrace_io_desc piod;
/* Linux-specific cached data. This is used by GDB for caching
purposes for each inferior. This helps reduce the overhead of
- transfering data from a remote target to the local host. */
+ transferring data from a remote target to the local host. */
struct linux_info
{
/* Cache of the inferior's vsyscall/vDSO mapping range. Only valid
#ifdef HAVE_PTRACE_GETREGS
/* Fetch all floating-point registers from process/thread TID and store
- thier values in GDB's register array. */
+ their values in GDB's register array. */
static void
fetch_fpregs (struct regcache *regcache, int tid)
consequence of GDB's type management; CC and GCC (at
least through version 2.4) both output variables of
either type char * or caddr_t with the type
- refering to the stTypedef symbol for caddr_t. If a future
+ referring to the stTypedef symbol for caddr_t. If a future
compiler cleans this up it GDB is not ready for it
yet, but if it becomes ready we somehow need to
disable this check (without breaking the PCC/GCC2.4
/* On certain platforms, some extra label symbols can be
generated by the linker. One possible usage for this kind
- of symbols is to represent the address of the begining of a
+ of symbols is to represent the address of the beginning of a
given section. For instance, on Tru64 5.1, the address of
the _ftext label is the start address of the .text section.
The storage class of these symbols is usually directly
related to the section to which the symbol refers. For
instance, on Tru64 5.1, the storage class for the _fdata
- label is scData, refering to the .data section.
+ label is scData, referring to the .data section.
It is actually possible that the section associated to the
storage class of the label does not exist. On True64 5.1
int ix = std::distance (user_mem_region_list.begin (), it);
/* Check for an overlapping memory region. We only need to check
- in the vincinity - at most one before and one after the
+ in the vicinity - at most one before and one after the
insertion point. */
for (int i = ix - 1; i < ix + 1; i++)
{
/* The base of the current frame is in a frame pointer register.
This register is noted in frame_extra_info->fp_regnum.
- Note that the existance of an FP might also indicate that the
+ Note that the existence of an FP might also indicate that the
function has called alloca. */
#define MICROBLAZE_MY_FRAME_IN_FP 0x2
}
/* Determine if a MIPS3 or later cpu is operating in MIPS{1,2} FPU
- compatiblity mode. A return value of 1 means that we have
+ compatibility mode. A return value of 1 means that we have
physical 64-bit registers, but should treat them as 32-bit registers. */
static int
/* FIXME drow 2002-03-10: This is disabled until we can do it consistently,
in all the places we deal with FP registers. PR gdb/413. */
/* Otherwise check the FR bit in the status register - it controls
- the FP compatiblity mode. If it is clear we are in compatibility
+ the FP compatibility mode. If it is clear we are in compatibility
mode. */
if ((get_frame_register_unsigned (frame, MIPS_PS_REGNUM) & ST0_FR) == 0)
return 1;
static struct cmd_list_element *setmipscmdlist = NULL;
static struct cmd_list_element *showmipscmdlist = NULL;
-/* Integer registers 0 thru 31 are handled explicitly by
+/* Integer registers 0 through 31 are handled explicitly by
mips_register_name(). Processor specific registers 32 and above
are listed in the following tables. */
}
/* This predicate tests for the case of a value of less than 8
- bytes in width that is being transfered to or from an 8 byte
+ bytes in width that is being transferred to or from an 8 byte
general purpose register. */
static int
mips_convert_register_gpreg_case_p (struct gdbarch *gdbarch, int regnum,
return builtin_type (gdbarch)->builtin_int32;
else if (tdep->mips64_transfers_32bit_regs_p)
/* The target, while possibly using a 64-bit register buffer,
- is only transfering 32-bits of each integer register.
+ is only transferring 32-bits of each integer register.
Reflect this in the cooked/pseudo (ABI) register value. */
return builtin_type (gdbarch)->builtin_int32;
else if (mips_abi_regsize (gdbarch) == 4)
find_pc_partial_function (pc, NULL, &start_addr, NULL);
if (start_addr == 0)
start_addr = heuristic_proc_start (gdbarch, pc);
- /* We can't analyze the prologue if we couldn't find the begining
+ /* We can't analyze the prologue if we couldn't find the beginning
of the function. */
if (start_addr == 0)
return cache;
find_pc_partial_function (pc, NULL, &start_addr, NULL);
if (start_addr == 0)
start_addr = heuristic_proc_start (get_frame_arch (this_frame), pc);
- /* We can't analyze the prologue if we couldn't find the begining
+ /* We can't analyze the prologue if we couldn't find the beginning
of the function. */
if (start_addr == 0)
return cache;
find_pc_partial_function (pc, NULL, &start_addr, NULL);
if (start_addr == 0)
start_addr = heuristic_proc_start (gdbarch, pc);
- /* We can't analyze the prologue if we couldn't find the begining
+ /* We can't analyze the prologue if we couldn't find the beginning
of the function. */
if (start_addr == 0)
return cache;
}
/* Now load as many as possible of the first arguments into
- registers, and push the rest onto the stack. Loop thru args
+ registers, and push the rest onto the stack. Loop through args
from first to last. */
for (argnum = 0; argnum < nargs; argnum++)
{
}
/* Note!!! This is NOT an else clause. Odd sized
- structs may go thru BOTH paths. Floating point
+ structs may go through BOTH paths. Floating point
arguments will not. */
/* Write this portion of the argument to a general
purpose register. */
}
/* Now load as many as possible of the first arguments into
- registers, and push the rest onto the stack. Loop thru args
+ registers, and push the rest onto the stack. Loop through args
from first to last. */
for (argnum = 0; argnum < nargs; argnum++)
{
}
/* Note!!! This is NOT an else clause. Odd sized
- structs may go thru BOTH paths. */
+ structs may go through BOTH paths. */
/* Write this portion of the argument to a general
purpose register. */
if (argreg <= mips_last_arg_regnum (gdbarch))
}
/* Now load as many as possible of the first arguments into
- registers, and push the rest onto the stack. Loop thru args
+ registers, and push the rest onto the stack. Loop through args
from first to last. */
for (argnum = 0; argnum < nargs; argnum++)
{
}
/* Note!!! This is NOT an else clause. Odd sized
- structs may go thru BOTH paths. */
+ structs may go through BOTH paths. */
/* Write this portion of the argument to a general
purpose register. */
if (argreg <= mips_last_arg_regnum (gdbarch))
}
/* Now load as many as possible of the first arguments into
- registers, and push the rest onto the stack. Loop thru args
+ registers, and push the rest onto the stack. Loop through args
from first to last. */
for (argnum = 0; argnum < nargs; argnum++)
{
}
/* Note!!! This is NOT an else clause. Odd sized
- structs may go thru BOTH paths. */
+ structs may go through BOTH paths. */
/* Write this portion of the argument to a general
purpose register. */
if (argreg <= mips_last_arg_regnum (gdbarch))
*
* Implements the "Info selectors" command. Takes an optional regexp
* arg. Lists all objective c selectors that match the regexp. Works
- * by grepping thru all symbols for objective c methods. Output list
+ * by grepping through all symbols for objective c methods. Output list
* is sorted and uniqued.
*/
error (_("Invalid regexp (%s): %s"), val, regexp);
}
- /* First time thru is JUST to get max length and count. */
+ /* First time through is JUST to get max length and count. */
for (objfile *objfile : current_program_space->objfiles ())
{
for (minimal_symbol *msymbol : objfile->msymbols ())
*
* Implements the "info classes" command for objective c classes.
* Lists all objective c classes that match the optional regexp.
- * Works by grepping thru the list of objective c methods. List will
+ * Works by grepping through the list of objective c methods. List will
* be sorted and uniqued (since one class may have many methods).
* BUGS: will not list a class that has no methods.
*/
error (_("Invalid regexp (%s): %s"), val, regexp);
}
- /* First time thru is JUST to get max length and count. */
+ /* First time through is JUST to get max length and count. */
for (objfile *objfile : current_program_space->objfiles ())
{
for (minimal_symbol *msymbol : objfile->msymbols ())
(gdb) b main
Breakpoint 2 at 0x100006a0: file gdb.base/shmain.c, line 44.
- Examine the instruction (and the immediatly following instruction)
+ Examine the instruction (and the immediately following instruction)
upon which the breakpoint was placed. Note that the PLT entry
for shr1 contains zeros.
concerning a /proc process. There should be exactly one procinfo
for each process, and since GDB currently can debug only one
process at a time, that means there should be only one procinfo.
- All of the LWP's of a process can be accessed indirectly thru the
+ All of the LWP's of a process can be accessed indirectly through the
single process procinfo.
However, against the day when GDB may debug more than one process,
# Figure out the name of the current architecture. There
# should always be a current inferior, but if, somehow, there
# isn't, then leave curr_arch as the empty string, which will
- # not then match agaisnt any architecture in the dictionary.
+ # not then match against any architecture in the dictionary.
curr_arch = ""
if gdb.selected_inferior() is not None:
curr_arch = gdb.selected_inferior().architecture().name()
/* FIXME: cagney/1999-09-23: Even though getpkt was called with
``forever'' still use the normal timeout mechanism. This is
- currently used by the ASYNC code to guarentee that target reads
+ currently used by the ASYNC code to guarantee that target reads
during the initial connect always time-out. Once getpkt has been
modified to return a timeout indication and, in turn
remote_wait()/wait_for_inferior() have gained a timeout parameter
/* FIXME: This is a good reason to drop the packet. */
/* Possibly, there is a duplicate response. */
/* Possibilities :
- retransmit immediatly - race conditions
+ retransmit immediately - race conditions
retransmit after timeout - yes
exit
wait for packet, then exit
/* Start the remote connection. If error() or QUIT, discard this
target (we'd otherwise be in an inconsistent state) and then
- propogate the error on up the exception chain. This ensures that
+ propagate the error on up the exception chain. This ensures that
the caller doesn't stumble along blindly assuming that the
function succeeded. The CLI doesn't have this problem but other
UI's, such as MI do.
static void
remote_async_serial_handler (struct serial *scb, void *context)
{
- /* Don't propogate error information up to the client. Instead let
+ /* Don't propagate error information up to the client. Instead let
the client find out about the error by querying the target. */
inferior_event_handler (INF_REG_EVENT);
}
return op;
}
-/* GCC generates several well-known sequences of instructions at the begining
+/* GCC generates several well-known sequences of instructions at the beginning
of each function prologue when compiling with -fstack-check. If one of
such sequences starts at START_PC, then return the address of the
instruction immediately past this sequence. Otherwise, return START_PC. */
ACC[7][3] -> VSR[31]
NOTE:
- In ISA 3.1 the ACC is mapped on top of VSR[0] thru VSR[31].
+ In ISA 3.1 the ACC is mapped on top of VSR[0] through VSR[31].
In the future, the ACC may be implemented as an independent register file
rather than mapping on top of the VSRs. This will then require the ACC to
/* Create a new slice type. NAME is the name of the type. ELT_TYPE
is the type of the elements of the slice. USIZE_TYPE is the Rust
- "usize" type to use. The new type is allocated whereever ELT_TYPE
+ "usize" type to use. The new type is allocated wherever ELT_TYPE
is allocated. */
extern struct type *rust_slice_type (const char *name, struct type *elt_type,
struct type *usize_type);
for S/390 ELF Application Binary Interface Supplement".
SP is the current stack pointer. We must put arguments, links,
- padding, etc. whereever they belong, and return the new stack
+ padding, etc. wherever they belong, and return the new stack
pointer value.
If STRUCT_RETURN is non-zero, then the function we're calling is
/* FD_EVENT: This is scheduled when the input FIFO is empty (and there
is no pending error). As soon as data arrives, it is read into the
input FIFO and the client notified. The client should then drain
- the FIFO using readchar(). If the FIFO isn't immediatly emptied,
+ the FIFO using readchar(). If the FIFO isn't immediately emptied,
push_event() is used to nag the client until it is. */
static void
pre-reads the input into that FIFO. Once that has been emptied,
further data is obtained by polling the input FD using the device
specific readchar() function. Note: reschedule() is called after
- every read. This is because there is no guarentee that the lower
+ every read. This is because there is no guarantee that the lower
level fd_event() poll_event() code (which also calls reschedule())
will be called. */
/* Now load as many as possible of the first arguments into
registers, and push the rest onto the stack. There are 16 bytes
- in four registers available. Loop thru args from first to last. */
+ in four registers available. Loop through args from first to last. */
for (argnum = 0; argnum < nargs; argnum++)
{
type = args[argnum]->type ();
/* Now load as many as possible of the first arguments into
registers, and push the rest onto the stack. There are 16 bytes
- in four registers available. Loop thru args from first to last. */
+ in four registers available. Loop through args from first to last. */
for (argnum = 0; argnum < nargs; argnum++)
{
type = args[argnum]->type ();
/* Scan for DESIRED_DYNTAG in .dynamic section of the target's main executable,
- found by consulting the OS auxillary vector. If DESIRED_DYNTAG is found, 1
+ found by consulting the OS auxiliary vector. If DESIRED_DYNTAG is found, 1
is returned and the corresponding PTR is set. */
static int
}
/* If we were not able to find the base address of the loader
- from our so_list, then try using the AT_BASE auxilliary entry. */
+ from our so_list, then try using the AT_BASE auxiliary entry. */
if (!load_addr_found)
if (target_auxv_search (AT_BASE, &load_addr) > 0)
{
return 0;
}
- /* Verify that the auxilliary vector describes the same file as exec_bfd, by
- comparing their program headers. If the program headers in the auxilliary
+ /* Verify that the auxiliary vector describes the same file as exec_bfd, by
+ comparing their program headers. If the program headers in the auxiliary
vector do not match the program headers in the executable, then we are
looking at a different file than the one used by the kernel - for
instance, "gdb program" connected to "gdbserver :PORT ld.so program". */
return cache;
}
-/* GCC generates several well-known sequences of instructions at the begining
+/* GCC generates several well-known sequences of instructions at the beginning
of each function prologue when compiling with -fstack-check. If one of
such sequences starts at START_PC, then return the address of the
instruction immediately past this sequence. Otherwise, return START_PC. */
if ((*pp)[0] == 'o' && (*pp)[1] == 'p' && is_cplus_marker ((*pp)[2]))
{
- /* This is a completely wierd case. In order to stuff in the
+ /* This is a completely weird case. In order to stuff in the
names that might contain colons (the usual name delimiter),
Mike Tiemann defined a different name format which is
signalled if the identifier is "op$". In that case, the
extern int within_function;
/* Hash table of global symbols whose values are not known yet.
- They are chained thru the SYMBOL_VALUE_CHAIN, since we don't
+ They are chained through the SYMBOL_VALUE_CHAIN, since we don't
have the correct data for that slot yet.
The use of the LOC_BLOCK code in this chain is nonstandard--
/* Predicate registers: There are 64 of these 1-bit registers. We
define a single register which is used to communicate these values
to/from the target. We will somehow contrive to make it appear
- that IA64_PR0_REGNUM thru IA64_PR63_REGNUM hold the actual values. */
+ that IA64_PR0_REGNUM through IA64_PR63_REGNUM hold the actual values. */
#define IA64_PR_REGNUM 330
/* Instruction pointer: 64 bits wide. */
if (instr0 == 0x1E || instr0 == 0x1F) /* JL or JMP */
if ((instr[1] & 0xF0) == 0xC0)
- return 2; /* jump thru a register */
+ return 2; /* jump through a register. */
if (instr0 == 0x7C || instr0 == 0x7D || /* BC, BNC, BL, BRA */
instr0 == 0x7E || instr0 == 0x7F)
case 1: /* RTE */
return registers[BPC] & ~3; /* pop BPC into PC */
case 2: /* JL or JMP */
- return registers[instr[1] & 0x0F] & ~3; /* jump thru a register */
+ return registers[instr[1] & 0x0F] & ~3; /* jump through a register. */
case 3: /* BC, BNC, BL, BRA (short, 8-bit relative offset) */
return (((int) instr) & ~3) + ((char) instr[1] << 2);
case 4: /* BC, BNC, BL, BRA (long, 24-bit relative offset) */
callback))
return;
- /* Same search rules as above apply here, but now we look thru the
+ /* Same search rules as above apply here, but now we look through the
psymtabs. */
for (objfile *objfile : pspace->objfiles ())
if (objfile->map_symtabs_matching_filename (name, real_path.get (),
If an error occurs, no guarantee is made about the contents of the data at
MYADDR. In particular, the caller should not depend upon partial reads
filling the buffer with good data. There is no way for the caller to know
- how much good data might have been transfered anyway. Callers that can
+ how much good data might have been transferred anyway. Callers that can
deal with partial reads should call target_read (which will retry until
it makes no progress, and then return how much was transferred). */
INF_EXEC_COMPLETE,
};
\f
-/* Target objects which can be transfered using target_read,
+/* Target objects which can be transferred using target_read,
target_write, et cetera. */
enum target_object
TARGET_OBJECT_CODE_MEMORY,
/* Kernel Unwind Table. See "ia64-tdep.c". */
TARGET_OBJECT_UNWIND_TABLE,
- /* Transfer auxilliary vector. */
+ /* Transfer auxiliary vector. */
TARGET_OBJECT_AUXV,
/* StackGhost cookie. See "sparc-tdep.c". */
TARGET_OBJECT_WCOOKIE,
/* Currently loaded libraries specific to AIX systems, in XML format. */
TARGET_OBJECT_LIBRARIES_AIX,
/* Get OS specific data. The ANNEX specifies the type (running
- processes, etc.). The data being transfered is expected to follow
+ processes, etc.). The data being transferred is expected to follow
the DTD specified in features/osdata.dtd. */
TARGET_OBJECT_OSDATA,
/* Extra signal info. Usually the contents of `siginfo_t' on unix
transferring if desired. This is handled in target.c.
The interface does not support a "retry" mechanism. Instead it
- assumes that at least one addressable unit will be transfered on each
+ assumes that at least one addressable unit will be transferred on each
successful call.
NOTE: cagney/2003-10-17: The current interface can lead to
clean_restart "${binfile}$EXEEXT"
-# Ensure we don't accidently use the main symbol cache.
+# Ensure we don't accidentally use the main symbol cache.
gdb_test_no_output "mt set symbol-cache-size 0"
# Put something in the symbol lookup cache that will get looked up when
return -1
}
-# Now taht the core file has been created, we can start the real
+# Now that the core file has been created, we can start the real
# part of this testcase, which is to debug using that core file.
# Restart GDB and load that core file.
# If we managed to get the breakpoing address, then check that
# we inserted it at the expected location by examining the
# instruction at that address (we're not interested in the insn
- # itself, but rather at the address printed at the begining of
+ # itself, but rather at the address printed at the beginning of
# the instruction).
if {$address != ""} {
gdb_test "x /i $address" \
# If we managed to get the breakpoing address, then check that
# we inserted it at the expected location by examining the
# instruction at that address (we're not interested in the insn
- # itself, but rather at the address printed at the begining of
+ # itself, but rather at the address printed at the beginning of
# the instruction).
if {$address != ""} {
gdb_test "x /i $address" \
# if the breakpoint is set past the syscall due to faulty prologue skipping,
# the breakpoint will not trigger.
#
-# In particular, we're trying to excercise the instruction analysis
+# In particular, we're trying to exercise the instruction analysis
# functionality of prologue skipping. If non-minimal symbols are
# read, then that functionality might not be used because f.i.
# line-info is used instead. So, we use nodebug.
}
# Currently it is expected that all of the target descriptions in
- # this test will load successfully, so we expect no additonal
+ # this test will load successfully, so we expect no additional
# output from GDB.
gdb_test_no_output "set tdesc filename $test_path" \
"check [file tail $filename]"
# known, both failed to print a final "source and line" and misplaced
# the frame ("No frame").
- # The test is writen so that it only reports one FAIL/PASS for the
+ # The test is written so that it only reports one FAIL/PASS for the
# entire operation. The value returned is checked further down.
# "return_value_unknown", if non-empty, records why GDB realised
# that it didn't know where the return value was.
gdb_exit
}
-# Run filename completetion tests for those command that accept quoting and
+# Run filename completion tests for those command that accept quoting and
# escaping of the filename argument.
#
# ROOT is the base directory as returned from setup_directory_tree, though,
}
-# Run filename completetion tests for a sample of commands that take an
+# Run filename completion tests for a sample of commands that take an
# unquoted, unescaped filename as an argument. Only a sample of commands
# are (currently) tested as there's a lot of commands that accept this style
# of filename argument.
return 1
}
- # The "if" condition is artifical to test regression of a former patch.
+ # The "if" condition is artificial to test regression of a former patch.
gdb_breakpoint "[gdb_get_line_number "break-at-nextcall"] if i && (int) gnu_ifunc (i) != 42"
gdb_breakpoint [gdb_get_line_number "break-at-call"]
}
}
- # Now check ARGS agaisnt the values held in INFO_SOURCES map.
+ # Now check ARGS against the values held in INFO_SOURCES map.
foreach {objfile sourcefile} $args {
# First, figure out if we're expecting SOURCEFILE to be present,
# or not.
}
}
-# Try stepping the program. Stepping may go through diferent code
+# Try stepping the program. Stepping may go through different code
# paths in the target backends.
with_test_prefix "stepi" {
test {
# #included by a given source file in a list sorted by the line at
# which they were #included; this gives GDB the chance to detect
# multiple #inclusions at the same line, complain, and assign
-# distinct, albiet incorrect, line numbers to each #inclusion.
+# distinct, albeit incorrect, line numbers to each #inclusion.
#
# However, at one point GDB was sorting the list in reverse order,
# while the code to assign new, distinct line numbers assumed it was
}
# Verify that early-mapped overlays have been bumped out
-# by later-mapped overlays layed over in the same VMA range.
+# by later-mapped overlays laid over in the same VMA range.
send_gdb "overlay list\n"
gdb_expect {
# This test is known to tickle the following problems: kernel letting
# the inferior execute both the system call, and the instruction
# following, when single-stepping a system call; kernel failing to
-# propogate the single-step state when single-stepping the sigreturn
+# propagate the single-step state when single-stepping the sigreturn
# system call, instead resuming the inferior at full speed; GDB
# doesn't know how to software single-step across a sigreturn
# instruction. Since the kernel problems can be "fixed" using
"next to ++count #2"
sleep 2
- # ...call the function, which is immediatly interrupted
+ # ...call the function, which is immediately interrupted
gdb_test "p func1 ()" \
"Breakpoint \[0-9\]*, handler.*
while (1)
{
/* Wait until a signal has become pending, that way when this
- handler returns it will be immediatly delivered leading to
+ handler returns it will be immediately delivered leading to
back-to-back signals. */
sigset_t set;
sigemptyset (&set);
gdb_test "continue" "register struct f_${t} u = f_${t};" \
"continue field ${t}"
- # Match either the return statement, or the line immediatly after
+ # Match either the return statement, or the line immediately after
# it. The compiler can end up merging the return statement into
# the return instruction.
gdb_test "next" "(return u;|\})" "next field ${t}"
# known, both failed to print a final "source and line" and misplaced
# the frame ("No frame").
- # The test is writen so that it only reports one FAIL/PASS for the
+ # The test is written so that it only reports one FAIL/PASS for the
# entire operation. The value returned is checked further down.
# "return_value_known", if non-zero, indicates that GDB knew where
# the return value was located.
}
-re "$gdb_prompt $" {
# If this fails, bail out, otherwise we get stuck in
- # an infinite loop. The caller will end up emiting a
+ # an infinite loop. The caller will end up emitting a
# FAIL.
return "<fail>"
}
#
# If the target has non-continuable watchpoints, while GDB thinks it
# has continuable watchpoints, GDB will see a watchpoint trigger,
-# notice no value changed, and immediatly continue the target. Now,
+# notice no value changed, and immediately continue the target. Now,
# either the target manages to step-over the watchpoint transparently,
# and GDB thus fails to present to value change to the user, or, the
# watchpoint will keep re-triggering, with the program never making
return 1
}
-# The following list is layed out as a table. It is composed by
+# The following list is laid out as a table. It is composed by
# sub-lists (lines), with each line representing one whatis/ptype
# test. The sub-list (line) elements (columns) are (in order):
#
# NOTE: carlton/2004-01-14: This test with an "<incomplete type>"
# message because, within rtt1.cc, GDB has no way of knowing that the
-# class is called 'n2::D2' instead of just 'D2'. This is an artifical
+# class is called 'n2::D2' instead of just 'D2'. This is an artificial
# test case, though: if we were using these classes in a more
# substantial way, G++ would emit more debug info. As is, I don't
# think there's anything that GDB can do about this case until G++
if { $use_header } {
# This test will not pass due to poor debug information
- # generated by GCC (at least upto 10.x). See
+ # generated by GCC (at least up to 10.x). See
# https://gcc.gnu.org/bugzilla/show_bug.cgi?id=94474
return
}
[function_range frame3 [list ${srcdir}/${subdir}/$srcfile]]
# Very simple info for this test program. We don't care about
- # this information being correct (w.r.t. funtion / argument types)
+ # this information being correct (w.r.t. function / argument types)
# just so long as the compilation using makes use of the
# .debug_ranges data then the test achieves its objective.
cu { label cu_label } {
.byte 0x87
.4byte .Lskeleton_debug_line0 /* DW_AT_stmt_list */
- /* Manually inserted to have a DW_AT_specification refering to
+ /* Manually inserted to have a DW_AT_specification referring to
something and appearing ahead of it. */
.uleb128 0x8 /* DW_TAG_class_type */
.4byte .Ltu_class_type - .Ltu_start_dwo
standard_testfile main.c .S
# Create the DWARF. This is derived from the reproducer in the bug
-# mentioned above. This DIE tree is typical of compilations wtih
+# mentioned above. This DIE tree is typical of compilations with
# LTO enabled.
set asm_file [standard_output_file $srcfile2]
.byte 0x87
.4byte .Ldebug_line0 /* DW_AT_stmt_list */
- /* Manually inserted to have a DW_AT_specification refering to
+ /* Manually inserted to have a DW_AT_specification referring to
something and appearing ahead of it. */
.uleb128 0x8 /* DW_TAG_class_type */
.4byte .Ltu_class_type - .Ldebug_types0
.byte 0x3 /* DW_OP_addr */
.4byte baz
- /* Manually inserted to have a DW_AT_specification refering to
+ /* Manually inserted to have a DW_AT_specification referring to
something and appearing ahead of it. */
.uleb128 0x8 /* DW_TAG_class_type */
.4byte .Lcu_class_type - .Ldebug_info0 /* DW_AT_specification */
# Test various floating point formats
# this used to guess whether to look for "real*4" or
- # "real*8" based on a target config variable, but noone
+ # "real*8" based on a target config variable, but no one
# maintained it properly.
gdb_test "pt .44" "type = real\\*\[0-9\]+"
return -1
}
-# Check VLA with arbitary length and check that elements outside of
+# Check VLA with arbitrary length and check that elements outside of
# bounds of the passed VLA can be accessed correctly.
gdb_breakpoint [gdb_get_line_number "end-of-bar"]
gdb_continue_to_breakpoint "end-of-bar"
-gdb_test "p array1(42)" " = 3" "print arbitary array1(42)"
-gdb_test "p array1(100)" " = 100" "print arbitary array1(100)"
-gdb_test "p array2(4,10)" " = 1" "print arbitary array2(4,10)"
-gdb_test "p array2(4,100)" " = 1" "print arbitary array2(4,100)"
+gdb_test "p array1(42)" " = 3" "print arbitrary array1(42)"
+gdb_test "p array1(100)" " = 100" "print arbitrary array1(100)"
+gdb_test "p array2(4,10)" " = 1" "print arbitrary array2(4,10)"
+gdb_test "p array2(4,100)" " = 1" "print arbitrary array2(4,100)"
# Test the htab_t pretty-printer.
gdb_test -prompt $outer_prompt_re "print all_bfds" "htab_t with ${::decimal} elements = \\{${::hex}.*\\}"
- # Test the intrusive_list pretty-printer. A bug occured in the
+ # Test the intrusive_list pretty-printer. A bug occurred in the
# pretty-printer for lists with more than one element. Verify that
# we see both elements of the inferior_list list being printed.
gdb_test -prompt $outer_prompt_re "print inferior_list" "intrusive list of inferior = {.*, num = 1,.*, num = 2,.*}"
gdb_test "print j + k" " = 5"
gdb_test "print i + j + k" " = 6"
-# Test substraction
+# Test subtraction
gdb_test "print j - i" " = 1"
gdb_test "print i - j" "= -1"
gdb_test "print k -i -j" " = 0"
gdb_test_no_output "set max-completions unlimited"
# Confirm that the important global namespace typedefs were indeed
-# emited in the debug info.
+# emitted in the debug info.
gdb_test "ptype NS2" "type = int"
gdb_test "ptype object" "type = struct NS1::NS2::object {.*"
gdb_test "ptype Templ1" "type = struct NS1::NS2::Templ1<unsigned int> .*"
}
}
-# Test completion of a const-overloaded funtion (const-overload).
+# Test completion of a const-overloaded function (const-overload).
# Note that "const" appears after the function/method parameters.
proc_with_prefix const-overload {} {
test_insert_delete_modify
}
-# Test 'breakpoint-modified' notification is emited when pending breakpoints are
+# Test 'breakpoint-modified' notification is emitted when pending breakpoints are
# resolved.
proc test_pending_resolved { } {
# UI.
if {$mode eq "separate"} {
with_spawn_id $gdb_main_spawn_id {
- gdb_test_multiple "" "drain CLI output upto breakpoint" {
+ gdb_test_multiple "" "drain CLI output up to breakpoint" {
-re "Thread 1 \[^\r\n\]+ hit Breakpoint $decimal,\
breakpt \\(\\) at\
\[^\r\n\]+\r\n$decimal\\s+\[^\r\n\]+\r\n" {
"attach"] == 0} {
# The program is now stopped, but if testing against
- # gdbserver, then the inferior's output emmitted before it
+ # gdbserver, then the inferior's output emitted before it
# stopped isn't flushed unless we explicitly do so,
# because it is on a different spawn_id. Do it now, to
# avoid confusing tests further below.
# set past the syscall due to faulty prologue skipping, the breakpoint will not
# trigger.
#
-# In particular, we're trying to excercise the instruction analysis
+# In particular, we're trying to exercise the instruction analysis
# functionality of prologue skipping. If the non-minimal symbols are
# read for libc, then that functionality might not be used because f.i.
# line-info is used instead. Also, if the minimal symbols are not read
gdb_test "print r + (-5)" " = -3\\.7(499.*|5|500.*)"
gdb_test "print r + (-10)" " = -8\\.7(499.*|5|500.*)"
-# Test substraction
+# Test subtraction
gdb_test "print r - s" " = -0\\.9(499.*|5|500.*)"
gdb_test "print r - t" " = 4\\.4(499.*|5|500.*)"
gdb_test "print j + k" " = 5"
gdb_test "print i + j + k" " = 6"
-# Test substraction
+# Test subtraction
gdb_test "print j - i" " = 1"
gdb_test "print i - j" "= -1"
gdb_test "print k -i -j" " = 0"
# Test various floating point formats
# this used to guess whether to look for "real*4" or
- # "real*8" based on a target config variable, but noone
+ # "real*8" based on a target config variable, but no one
# maintained it properly.
gdb_test "pt .44" "type = double"
# A regular expression for a non-expanded C++ reference.
#
-# Stringifying a C++ reference produces an address preceeded by a "@" in
+# Stringifying a C++ reference produces an address preceded by a "@" in
# Python, but, by default, the C++ reference/class is expanded by the
# GDB print command.
set default_ref_regexp "@${default_pointer_regexp}"
gdb_test_no_output "record" "turn on process record"
# This regression test verifies the reverse-step and reverse-next
- # commands work properly when executing backwards thru a source line
+ # commands work properly when executing backwards through a source line
# containing two function calls on the same source line, i.e.
# func1 (); func2 ();. This test is compiled so the dwarf info
# does not contain the line table information.
# the called function, stopping at the beginning of the last
# statement in the called function (typically a return statement).
# Also, as with the step command, if non-debuggable functions are
- # called, reverse-step will run thru them backward without
+ # called, reverse-step will run through them backward without
# stopping.
gdb_continue_to_breakpoint \
}
}
-# stepi thru return of a function call
+# stepi through return of a function call
set test_message "stepi back from function call"
gdb_test_multiple "stepi" "$test_message" {
gdb_test_no_output "set exec-dir reverse" "set reverse execution"
-# stepi backward thru return and into a function
+# stepi backward through return and into a function
set stepi_location [gdb_get_line_number "ARRIVED IN CALLEE" "$srcfile"]
-set test_message "reverse stepi thru function return"
+set test_message "reverse stepi through function return"
gdb_test_multiple "stepi" "$test_message" {
-re "NEXTI TEST.*$gdb_prompt $" {
fail "$test_message (start statement)"
}
}
-# stepi thru return of a function call
+# stepi through return of a function call
set test_message "stepi back from function call"
gdb_test_multiple "stepi" "$test_message" {
# Set reverse execution direction
gdb_test_no_output "set exec-dir reverse" "set reverse execution"
-# stepi backward thru return and into a function
+# stepi backward through return and into a function
set stepi_location [gdb_get_line_number "ARRIVED IN CALLEE" "$srcfile"]
-set test_message "reverse stepi thru function return"
+set test_message "reverse stepi through function return"
gdb_test_multiple "stepi" "$test_message" {
-re "NEXTI TEST.*$gdb_prompt $" {
fail "$test_message (start statement)"
#
# However, we might be too quick sending the 'info threads 99' command,
# so, if we see the output of that command without any thread exited
- # text, we wait for a short while and try again. We wait for upto 5
+ # text, we wait for a short while and try again. We wait for up to 5
# seconds (5 tries). However, this might mean on a _really_ slow
# machine that the thread still hasn't exited. I guess if we start
# seeing that then we can just update ATTEMPT_COUNT below.
#
-# set breakpoint at thread fucntion tf
+# set breakpoint at thread function tf
#
gdb_test "break tf" \
"Breakpoint.*at.* file .*$srcfile, line.*" \
# collected. In C, an array as function parameters is a special
# case; it's just a pointer into the caller's array, and as such,
# that's what normally the debug info describes. Maybe this was
- # originaly written for a compiler where array parameters were
+ # originally written for a compiler where array parameters were
# really described as arrays in debug info.
setup_xfail "*-*-*"
# are collected. In C, an array as function parameters is a
# special case; it's just a pointer into the caller's array,
# and as such, that's what normally the debug info describes.
- # Maybe this was originaly written for a compiler where array
+ # Maybe this was originally written for a compiler where array
# parameters were really described as arrays in debug info.
setup_xfail "*-*-*"
}
}
-# Test 'breakpoint-modified' notification is emited when pending tracepoints are
+# Test 'breakpoint-modified' notification is emitted when pending tracepoints are
# resolved.
proc test_pending_resolved { } {
Term::command "winheight cmd + 3"
# As the tuiterm.exp library just waits for the prompt and command to
-# be echo'ed bcak to the screen, multiple 'info win' calls like this
+# be echo'ed back to the screen, multiple 'info win' calls like this
# have a problem. Dejagnu will send the command to gdb, but will then
# immediately see the '(gdb) info win' output from the first use
# above. This means we end up rushing ahead, and some tests might
# section_version n
# - section version number to emit
# default = 2
- # seg_size n - the size of the adress selector in bytes: 0, 4, or 8
+ # seg_size n - the size of the address selector in bytes: 0, 4, or 8
# default = 0
#
# LABEL is the label of the corresponding CU.
} else {
set src2 $target
}
- verbose -log "Resolved symlink $file targetting $target as $src2"
+ verbose -log "Resolved symlink $file targeting $target as $src2"
set file $src2
set loop [expr $loop + 1]
# self-test, then return an empty string.
proc selftest_prepare {} {
# Are we testing with a remote board? In that case, the target
- # won't have access to the GDB's auxilliary data files
+ # won't have access to the GDB's auxiliary data files
# (data-directory, etc.). It's simpler to just skip.
if { [is_remote target] || [is_remote host] } {
return
/* Mapping between the general-purpose registers in `struct user'
format and GDB's register array layout. Note that we map the
- first 56 registers (0 thru 55) one-to-one. GDB maps the pc to
+ first 56 registers (0 through 55) one-to-one. GDB maps the pc to
slot 64, but ptrace returns it in slot 56. */
static const int regmap[] =
{
if you're in a user-defined command or especially in a
loop, then you need a way to detect that the command
failed WITHOUT aborting. This allows you to write
- scripts that search thru the trace buffer until the end,
+ scripts that search through the trace buffer until the end,
and then continue on to do something else. */
if (from_tty)
E_R149_REGNUM,
E_NUM_OF_V850E2_REGS,
- /* v850e3v5 system registers, selID 1 thru 7. */
+ /* v850e3v5 system registers, selID 1 through 7. */
E_SELID_1_R0_REGNUM = E_NUM_OF_V850E2_REGS,
E_SELID_1_R31_REGNUM = E_SELID_1_R0_REGNUM + 31,
/* Now load as many as possible of the first arguments into
registers, and push the rest onto the stack. There are 16 bytes
- in four registers available. Loop thru args from first to last. */
+ in four registers available. Loop through args from first to last. */
for (argnum = 0; argnum < nargs; argnum++)
{
int len;
nonzero lower bound.
FIXME: A previous comment here indicated that this routine should
- be substracting the array's lower bound. It's not clear to me that
+ be subtracting the array's lower bound. It's not clear to me that
this is correct. Given an array subscripting operation, it would
certainly work to do the adjustment here, essentially computing:
RD is the destination register.
RN is the input register.
- IMM is the immediate to substract to RN. */
+ IMM is the immediate to subtract to RN. */
static int
emit_sub (uint32_t *buf, struct aarch64_register rd,
unsigned long pcl = regbuf->stop_pc & ~3L;
supply_register_by_name (regcache, "pcl", &pcl);
- /* Other auxilliary registers. */
+ /* Other auxiliary registers. */
supply_register_by_name (regcache, "status32", &(regbuf->scratch.status32));
/* BTA. */
}
/* Read memory from the inferior.
- BYTE_ORDER is ignored and there to keep compatiblity with GDB's
+ BYTE_ORDER is ignored and there to keep compatibility with GDB's
read_memory_unsigned_integer. */
static ULONGEST
get_next_pcs_read_memory_unsigned_integer (CORE_ADDR memaddr,
gdb_signal_to_host() returns 0 and prints a warning() on GDB's
console if SIGNO has no equivalent host representation. */
/* FIXME: cagney/1999-11-22: Here ``host'' is used incorrectly, it is
- refering to the target operating system's signal numbering.
+ referring to the target operating system's signal numbering.
Similarly, ``enum gdb_signal'' is named incorrectly, ``enum
- gdb_signal'' would probably be better as it is refering to GDB's
+ gdb_signal'' would probably be better as it is referring to GDB's
internal representation of a target operating system's signal. */
extern enum gdb_signal gdb_signal_from_host (int);
extern int gdb_signal_to_host (enum gdb_signal);
- You can compare offsets of the same type for equality and order.
You can't compare an offset with an unrelated type.
- - You can add/substract an integer to/from an offset, which gives
+ - You can add/subtract an integer to/from an offset, which gives
you back a shifted offset.
- You can subtract two offsets of the same type, which gives you
projects / thirdparty / binutils-gdb.git / commitdiff
