/* Interprets the prefix of NUM that consists of digits of the given BASE
as an integer of that BASE, with the string EXP as an exponent.
Puts value in yylval, and returns INT, if the string is valid. Causes
- an error if the number is improperly formated. BASE, if NULL, defaults
+ an error if the number is improperly formatted. BASE, if NULL, defaults
to "10", and EXP to "1". The EXP does not contain a leading 'e' or 'E'.
*/
amdgpu_gdbarch_tdep *tdep = get_amdgpu_gdbarch_tdep (gdbarch);
/* If the register has read-only bits, invalidate the value in the regcache
- as the value actualy written may differ. */
+ as the value actually written may differ. */
if (tdep->register_properties[regno]
& AMD_DBGAPI_REGISTER_PROPERTY_READONLY_BITS)
regcache->invalidate (regno);
struct regcache *regcache, int regnum,
const void *gregs, size_t size);
-/* Reads regsiters from the NT_ARC_V2 data array into the regcache. */
+/* Reads registers from the NT_ARC_V2 data array into the regcache. */
void arc_linux_supply_v2_regset (const struct regset *regset,
struct regcache *regcache, int regnum,
struct arm_dwarf2_prev_register_cache
{
- /* Cached value of the coresponding stack pointer for the inner frame. */
+ /* Cached value of the corresponding stack pointer for the inner frame. */
CORE_ADDR sp;
CORE_ADDR msp;
CORE_ADDR msp_s;
/* No NULL conditions or failed bytecode generation. Build a
condition list for this location's address. If we have software
and hardware locations at the same address, they aren't
- considered duplicates, but we still marge all the conditions
+ considered duplicates, but we still merge all the conditions
anyway, as it's simpler, and doesn't really make a practical
difference. */
for (bp_location *loc : loc_range)
if (alias == nullptr || !user_documented_alias (*alias))
{
- /* Case of a normal command, or an alias not explictly
+ /* Case of a normal command, or an alias not explicitly
documented by the user. */
/* If the user asked 'help somecommand' and there is no alias,
the false indicates to not output the (single) command name. */
}
else
{
- /* Case of an alias explictly documented by the user.
+ /* Case of an alias explicitly documented by the user.
Only output the alias definition and its explicit documentation. */
fput_alias_definition_styled (*alias, stream);
fput_command_names_styled (*alias, false, "\n", stream);
/* Check that removing parameter info out of NAME produces EXPECTED.
COMPLETION_MODE indicates whether we're testing normal and
completion mode. FILE and LINE are used to provide better test
- location information in case ithe check fails. */
+ location information in case the check fails. */
static void
check_remove_params (const char *file, int line,
int offset = 0;
gdb_byte reg_buf[16];
- /* Ensure getting s0~s63 from vrx if tdep->has_vr0 is ture. */
+ /* Ensure getting s0~s63 from vrx if tdep->has_vr0 is true. */
if (tdep->has_vr0)
{
if (regnum < 64)
{ /* Nothing. */ }
};
-/* A dissassembler class that provides 'print_insn', a method for
+/* A disassembler class that provides 'print_insn', a method for
disassembling a single instruction to the output stream. */
struct gdb_disassembler : public gdb_printing_disassembler,
/* The long double is defined as a base type in C. GCC creates a long
double typedef with target-type _Float128 for the long double to
identify it as the IEEE Float128 value. This is a GCC hack since the
- DWARF doesn't distinquish between the IBM long double and IEEE
+ DWARF doesn't distinguish between the IBM long double and IEEE
128-bit float. Replace the GCC workaround for the long double
typedef with the actual type information copied from the target-type
with the correct long double base type name. */
if (sentinel_frame != nullptr)
{
/* If frame 0's id is not computed, it is not in the frame stash, so its
- dealloc functions will not be called when emptying the frash stash.
+ dealloc functions will not be called when emptying the frame stash.
Call frame_info_del manually in that case. */
frame_info *current_frame = sentinel_frame->prev;
if (current_frame != nullptr
)
-# The DWARF info currently does not distinquish between IEEE 128-bit floating
+# The DWARF info currently does not distinguish between IEEE 128-bit floating
# point values and the IBM 128-bit floating point format. GCC has an internal
# hack to identify the IEEE 128-bit floating point value. The long double is a
# defined base type in C. The GCC hack uses a typedef for long double to
/* Value of the sigcode in case of a boundary fault. */
-#define SIG_CODE_BONDARY_FAULT 3
+#define SIG_CODE_BOUNDARY_FAULT 3
/* i386 GNU/Linux implementation of the report_signal_info
gdbarch hook. Displays information related to MPX bound
}
/* If this is not a boundary violation just return. */
- if (sig_code != SIG_CODE_BONDARY_FAULT)
+ if (sig_code != SIG_CODE_BOUNDARY_FAULT)
return;
is_upper = (access > upper_bound ? 1 : 0);
{
/* We are executing the reverse-finish command.
If the system supports multiple entry points and we are finishing a
- function in reverse. If we are between the entry points singe-step
+ function in reverse. If we are between the entry points single-step
back to the alternate entry point. If we are at the alternate entry
point -- just need to back up by one more single-step, which
should take us back to the function call. */
return true if so. It wasn't writable before Linux 2.6.39, but
there's no way to know whether the feature was backported to older
kernels. So we check to see if it works. The result is cached,
- and this is garanteed to be called once early during inferior
+ and this is guaranteed to be called once early during inferior
startup, so that any warning is printed out consistently between
GDB invocations. Note we don't call it during GDB startup instead
though, because then we might warn with e.g. just "gdb --version"
all future arguments will also be passed on the stack,
i.e., the last argument register may be left unused
due to the aligned register pair rule.
- long double data tpye is passed in an aligned GAR pair,
+ long double data type is passed in an aligned GAR pair,
the first register in the pair is even-numbered. */
if (gar >= 2)
{
/* Using /sys/.../possible is preferred, because it handles the case where
we are in a container that has access to a subset of the host's cores.
It will return a size that considers all the CPU cores available to the
- host. If that fials for some reason, fall back to sysconf. */
+ host. If that fails for some reason, fall back to sysconf. */
gdb::optional<size_t> count = get_core_array_size_using_sys_possible ();
if (count.has_value ())
return *count;
/* One and only one of these three functions returns true, indicating
whether the corresponding interface is the one we detected. The
- interface must already have been detected as a precontidion. */
+ interface must already have been detected as a precondition. */
bool hwdebug_p ()
{
/* DAWR interface allows to watch up to 512 byte wide ranges. */
region_size = 512;
/* DAWR interface allows to watch up to 512 byte wide ranges which
- can't cross a 512 byte bondary on machines that doesn't have a
+ can't cross a 512 byte boundary on machines that doesn't have a
second DAWR (P9 or less). */
if (!(hwdebug_info.features & PPC_DEBUG_FEATURE_DATA_BP_ARCH_31))
region_align = 512;
}
/* Copy the per-process state associated with the pid of PARENT to the
- sate of CHILD_PID. GDB expects that a forked process will have the
+ state of CHILD_PID. GDB expects that a forked process will have the
same hardware breakpoints and watchpoints as the parent.
If we're using the HWDEBUG interface, also copy the thread debug
memaddr, info, nullptr);
}
- /* Upon destruction mark m_diasm_info as invalid. */
+ /* Upon destruction mark m_disasm_info as invalid. */
~scoped_disasm_info_object ()
{
/* Invalidate the original DisassembleInfo object as well as any copies
regcache *new_regcache = new regcache (inf_for_target_calls, arch, aspace);
new_regcache->set_ptid (ptid);
/* Work around a problem with g++ 4.8 (PR96537): Call the regcache_up
- constructor explictly instead of implicitly. */
+ constructor explicitly instead of implicitly. */
ptid_regc_map.insert (std::make_pair (ptid, regcache_up (new_regcache)));
return new_regcache;
# You should have received a copy of the GNU General Public License
# along with this program. If not, see <http://www.gnu.org/licenses/>.
-# This test case is to test the speed of GDB when it is doing singe step.
+# This test case is to test the speed of GDB when it is doing single step.
# There is one parameter in this test:
# - SINGLE_STEP_COUNT is the number of single step GDB performs.
# The data directory the testing GDB will use. By default, assume
# we're testing a non-installed GDB in the build directory. Users may
-# also explictly override the -data-directory from the command line.
+# also explicitly override the -data-directory from the command line.
if ![info exists GDB_DATA_DIRECTORY] {
set GDB_DATA_DIRECTORY [file normalize "[pwd]/../data-directory"]
}
#endif
}
- /* Keycodes above KEY_MAX are not garanteed to be stable.
+ /* Keycodes above KEY_MAX are not guaranteed to be stable.
Compare keyname instead. */
if (ch >= KEY_MAX)
{
struct tui_source_windows
{
- /* Work around Wmaybe-uninitalized warning with g++ 11.0.0, see also
+ /* Work around Wmaybe-uninitialized warning with g++ 11.0.0, see also
PR gcc/96295. Note that "tui_source_windows () = default" doesn't work
around the warning. */
tui_source_windows () {}
/* var->value->type and var->type might also reference the objfile.
This is taken care of in value.c:preserve_values which deals with
- making sure that objfile-owend types are replaced with
+ making sure that objfile-owned types are replaced with
gdbarch-owned equivalents. */
});
}
info = &ez80_adl_main_insn_table[4]; /* skip force_nops */
break;
default:
- info = &ez80_main_insn_table[8]; /* skip eZ80 prefices and force_nops */
+ info = &ez80_main_insn_table[8]; /* skip eZ80 prefixes and force_nops */
break;
}
do
else
{
/* The LWP stopped due to a plain signal or a syscall signal. Either way,
- event_chid->waitstatus wasn't filled in with the details, so look at
+ event_child->waitstatus wasn't filled in with the details, so look at
the wait status W. */
if (WSTOPSIG (w) == SYSCALL_SIGTRAP)
{
foo (1, 2, gdb::array_view<value *>(values, nargs));
Or, better, using make_array_view, which has the advantage of
- inferring the arrav_view element's type:
+ inferring the array_view element's type:
foo (1, 2, gdb::make_array_view (values, nargs));
*/
projects / binutils-gdb.git / commitdiff