changed.
** New methods added to the gdb.PendingFrame class. These methods
- have the same behaviour as the corresponding methods on
+ have the same behavior as the corresponding methods on
gdb.Frame. The new methods are:
- gdb.PendingFrame.name: Return the name for the frame's
* MI changes
** The '-add-inferior' with no option flags now inherits the
- connection of the current inferior, this restores the behaviour of
+ connection of the current inferior, this restores the behavior of
GDB as it was prior to GDB 10.
** The '-add-inferior' command now accepts a '--no-connection'
|source-and-location|source-line|auto]
show print frame-info
This controls what frame information is printed by the commands printing
- a frame. This setting will e.g. influence the behaviour of 'backtrace',
+ a frame. This setting will e.g. influence the behavior of 'backtrace',
'frame', 'stepi'. The python frame filtering also respect this setting.
The 'backtrace' '-frame-info' option can override this global setting.
set remoteaddresssize 32
-can be used to revert to the old behaviour. For existing remote stubs
+can be used to revert to the old behavior. For existing remote stubs
the change should not be noticed, as the additional address information
will be discarded.
It is possible for a program to detect when it is run under GDB and
to change its behavior so that unwanted behavior may only appear
when a program is run under GDB. Any issues that arise due to an
- untrusted program detecting GDB and changing its behaviour are not
+ untrusted program detecting GDB and changing its behavior are not
security issues in GDB unless the issue also meet some other
definition of a security bug.
There are known bugs in GDB related to loading malformed executables
and parsing the debug information, a consequence of these bugs is
- that a malicious program could trigger undefined behaviour in GDB,
+ that a malicious program could trigger undefined behavior in GDB,
which could be used to trigger arbitrary code execution.
Given these risks, the advice of the GDB project is that, when using
environment.
As there are already known bugs in GDB relating to undefined
- behaviour triggered from malformed programs, further bugs in this
+ behavior triggered from malformed programs, further bugs in this
area should still be reported, but are unlikely to be given high
priority. Bugs in GDB that are triggered by well-formed programs
should also be reported, and are likely to be treated as higher
}
else
{
- /* For a structure or union the behaviour is as if the value had
+ /* For a structure or union the behavior is as if the value had
been stored to word-aligned memory and then loaded into
registers with 64-bit load instruction(s). */
int len = type->length ();
}
else
{
- /* For a structure or union the behaviour is as if the value had
+ /* For a structure or union the behavior is as if the value had
been stored to word-aligned memory and then loaded into
registers with 64-bit load instruction(s). */
int len = type->length ();
CORE_ADDR rip = pc - insn_offset;
/* If we just stepped over a breakpoint insn, we don't backup
- the pc on purpose; this is to match behaviour without
+ the pc on purpose; this is to match behavior without
stepping. */
regcache_write_pc (regs, rip);
are on, we only sometimes print the annotation, and only sometimes
update the current symtab and line. However, this particular annotation
has behaved this way for some time, and front ends that still use
- annotations now depend on this behaviour. */
+ annotations now depend on this behavior. */
extern bool annotate_source_line (struct symtab *s, int line,
int mid_statement, CORE_ADDR pc);
gdb_assert (regnum >= 0 && regnum < gdbarch_num_regs (gdbarch));
/* NOTE: cagney/2002-05-13: The old code did it this way and it is
suspected that some GDB/SIM combinations may rely on this
- behaviour. The default should be one2one_register_sim_regno
+ behavior. The default should be one2one_register_sim_regno
(below). */
if (gdbarch_register_name (gdbarch, regnum)[0] != '\0')
return regnum;
(struct gdbarch *gdbarch, CORE_ADDR prologue_start, CORE_ADDR prologue_end,
struct arm_prologue_cache *cache, const arm_instruction_reader &insn_reader);
-/* Architecture version for displaced stepping. This effects the behaviour of
+/* Architecture version for displaced stepping. This effects the behavior of
certain instructions, and really should not be hard-wired. */
#define DISPLACED_STEPPING_ARCH_VERSION 5
}
else
{
- /* Unpredictable behaviour. Try to do something sensible (switch to ARM
+ /* Unpredictable behavior. Try to do something sensible (switch to ARM
mode, align dest to 4 bytes). */
warning (_("Single-stepping BX to non-word-aligned ARM instruction."));
regcache_cooked_write_unsigned (regs, ARM_PS_REGNUM, ps & ~t_bit);
undefined instruction trap. ARM7TDMI is nominally ARMv4T, but does
not in fact add the new instructions. The new undefined
instructions in ARMv4 are all instructions that had no defined
- behaviour in earlier chips. There is no guarantee that they will
+ behavior in earlier chips. There is no guarantee that they will
raise an exception, but may be treated as NOP's. In practice, it
may only safe to rely on instructions matching:
}
else
{
- /* For a structure or union the behaviour is as if the value had
+ /* For a structure or union the behavior is as if the value had
been stored to word-aligned memory and then loaded into
registers with 32-bit load instruction(s). */
int len = type->length ();
fields are not addressable, and all addressable subfields of
unions always start at offset zero.
- This function is based on the behaviour of GCC 2.95.1.
+ This function is based on the behavior of GCC 2.95.1.
See: gcc/arm.c: arm_return_in_memory() for details.
Note: All versions of GCC before GCC 2.95.2 do not set up the
}
else
{
- /* For a structure or union the behaviour is as if the value had
+ /* For a structure or union the behavior is as if the value had
been stored to word-aligned memory and then loaded into
registers with 32-bit load instruction(s). */
int len = type->length ();
maybe_add_script_file (pspace_info, is_safe, debugfile, debugfile,
language);
- /* To preserve existing behaviour we don't check for whether the
+ /* To preserve existing behavior we don't check for whether the
script was already in the table, and always load it.
It's highly unlikely that we'd ever load it twice,
and these scripts are required to be idempotent under multiple
which exists for backwards compatibility reasons. Traditionally this
flag, if it occurred immediately after the 'if' condition, would be
treated as part of the 'if' condition. When the breakpoint condition
- parsing code was rewritten, this behaviour was retained. */
+ parsing code was rewritten, this behavior was retained. */
gdb_assert (backward_results.empty ()
|| (forward_results.back ().get_type ()
== token::type::CONDITION));
addr = value_as_address (value);
/* Prior to the fix for PR 16196 read_string would ignore fetchlimit
- if length > 0. The old "broken" behaviour is the behaviour we want:
+ if length > 0. The old "broken" behavior is the behavior we want:
The caller may want to fetch 100 bytes from a variable length array
implemented using the common idiom of having an array of length 1 at
the end of a struct. In this case we want to ignore the declared
size of the array. However, it's counterintuitive to implement that
- behaviour in read_string: what does fetchlimit otherwise mean if
- length > 0. Therefore we implement the behaviour we want here:
+ behavior in read_string: what does fetchlimit otherwise mean if
+ length > 0. Therefore we implement the behavior we want here:
If *length > 0, don't specify a fetchlimit. This preserves the
- previous behaviour. We could move this check above where we know
+ previous behavior. We could move this check above where we know
whether the array is declared with a fixed size, but we only want
- to apply this behaviour when calling read_string. PR 16286. */
+ to apply this behavior when calling read_string. PR 16286. */
if (*length > 0)
fetchlimit = UINT_MAX;
python_prefix=
fi
if test ! -x "${python_prog}"; then
- # Fall back to gdb 7.0/7.1 behaviour.
+ # Fall back to gdb 7.0/7.1 behavior.
python_prog=missing
python_prefix=${with_python}
fi
python_prefix=
fi
if test ! -x "${python_prog}"; then
- # Fall back to gdb 7.0/7.1 behaviour.
+ # Fall back to gdb 7.0/7.1 behavior.
python_prog=missing
python_prefix=${with_python}
fi
inbetween->between, in between, in-between
sofar->so far
doens't->doesn't
+behavour->behavior
+behaviour->behavior
# Identity rules.
# In some situations gdb can exit without creating an index. This is
# not an error.
-# E.g., if $file is stripped. This behaviour is akin to stripping an
+# E.g., if $file is stripped. This behavior is akin to stripping an
# already stripped binary, it's a no-op.
status=0
exactly lively, are they? On the other hand, if we don't claim
that each & every one is alive, then we don't get any of them
to appear in an "info thread" command, which is quite a useful
- behaviour.
+ behavior.
*/
bool
core_target::thread_alive (ptid_t ptid)
process, use the @code{file} command with the parent executable name
as its argument. By default, after an @code{exec} call executes,
@value{GDBN} discards the symbols of the previous executable image.
-You can change this behaviour with the @w{@code{set follow-exec-mode}}
+You can change this behavior with the @w{@code{set follow-exec-mode}}
command.
@table @code
breakpoints set with @code{hbreak}, @value{GDBN} will always use hardware
breakpoints.
-You can control this automatic behaviour with the following commands:
+You can control this automatic behavior with the following commands:
@kindex set breakpoint auto-hw
@kindex show breakpoint auto-hw
executed, given control to the debugger. By default, the program
code is so modified only when the program is resumed. As soon as
the program stops, @value{GDBN} restores the original instructions. This
-behaviour guards against leaving breakpoints inserted in the
+behavior guards against leaving breakpoints inserted in the
target should gdb abrubptly disconnect. However, with slow remote
targets, inserting and removing breakpoint can reduce the performance.
This behavior can be controlled with the following commands::
It can also print mixed source+disassembly if you specify the the
@code{/m} or @code{/s} modifier, and print the raw instructions in hex
as well as in symbolic form by specifying the @code{/r} or @code{/b}
-modifier. The behaviour of the @code{/m}, @code{/s}, @code{/r}, and
+modifier. The behavior of the @code{/m}, @code{/s}, @code{/r}, and
@code{/b} modifiers are the same as for the @kbd{disassemble} command
(@pxref{disassemble,,@kbd{disassemble}}).
@value{GDBN} can be instructed to refuse accesses to memory that is
not explicitly described. This can be useful if accessing such
regions has undesired effects for a specific target, or to provide
-better error checking. The following commands control this behaviour.
+better error checking. The following commands control this behavior.
@table @code
@kindex set mem inaccessible-by-default
to manipulate decimal floating point numbers, it is not possible to convert
(using a cast, for example) integers wider than 32-bit to decimal float.
-In addition, in order to imitate @value{GDBN}'s behaviour with binary floating
+In addition, in order to imitate @value{GDBN}'s behavior with binary floating
point computations, error checking in decimal float operations ignores
underflow, overflow and divide by zero exceptions.
If a function called from @value{GDBN} is interrupted by a timeout,
then by default the inferior is left in the frame where the timeout
-occurred, this behaviour can be adjusted with @samp{set
+occurred, this behavior can be adjusted with @samp{set
unwind-on-timeout} (@pxref{set unwind-on-timeout}).
For targets that don't support asynchronous execution
@subsection Python comes first
Python was @value{GDBN}'s first extension language, and to avoid breaking
-existing behaviour Python comes first. This is generally solved by the
+existing behavior Python comes first. This is generally solved by the
``first one wins'' principle. @value{GDBN} maintains a list of enabled
extension languages, and when it makes a call to an extension language,
(say to pretty-print a value), it tries each in turn until an extension
thread the frontend wants to operate on. However, getting this
optimization right can be tricky. In particular, if the frontend
sends several commands to @value{GDBN}, and one of the commands changes the
-selected thread, then the behaviour of subsequent commands will
+selected thread, then the behavior of subsequent commands will
change. So, a frontend should either wait for response from such
problematic commands, or explicitly add @code{-thread-select} for
all subsequent commands. No frontend is known to do this exactly
@cindex @sc{gdb/mi}, compatibility with CLI
For the developers convenience CLI commands can be entered directly,
-but there may be some unexpected behaviour. For example, commands
+but there may be some unexpected behavior. For example, commands
that query the user will behave as if the user replied yes, breakpoint
command lists are not executed and some CLI commands, such as
@code{if}, @code{when} and @code{define}, prompt for further input with
@item "^running"
This result record is equivalent to @samp{^done}. Historically, it
was output instead of @samp{^done} if the command has resumed the
-target. This behaviour is maintained for backward compatibility, but
+target. This behavior is maintained for backward compatibility, but
all frontends should treat @samp{^done} and @samp{^running}
identically and rely on the @samp{*running} output record to determine
which threads are resumed.
When @value{GDBN} reports an internal problem (error or warning) it
gives the user the opportunity to both quit @value{GDBN} and create a
core file of the current @value{GDBN} session. These commands let you
-override the default behaviour for each particular @var{action},
+override the default behavior for each particular @var{action},
described in the table below.
@table @samp
@itemize @bullet
@item
-The user types @kbd{Ctrl-c}. The behaviour is as explained above, and the
+The user types @kbd{Ctrl-c}. The behavior is as explained above, and the
@code{read}
system call is treated as finished.
for the @code{print} command, references are not automatically expanded
when using the @code{format_string} method or the @code{str}
function. There is no global @code{print} setting to change the default
-behaviour.
+behavior.
@item actual_objects
@code{True} if the representation of a pointer to an object should
produces a hole in the frame info that gets filled by the
linker with zeros.
- The GCC behaviour is arguably a bug, but it's effectively now
+ The GCC behavior is arguably a bug, but it's effectively now
part of the ABI, so we're now stuck with it, at least at the
object file level. A smart linker may decide, in the process
of compressing duplicate CIE information, that it can rewrite
}
#endif
- /* If possible arrange for SIG to have its default behaviour (which
+ /* If possible arrange for SIG to have its default behavior (which
should be to terminate the current process), unblock SIG, and reraise
the signal. This ensures GDB terminates with the expected signal. */
if (signal (sig, SIG_DFL) != SIG_ERR
static const std::array<const extension_language_defn *, 2> extension_languages
{
- /* To preserve existing behaviour, python should always appear first. */
+ /* To preserve existing behavior, python should always appear first. */
&extension_language_python,
&extension_language_guile,
};
/* There was an error (e.g., Python error while printing a value).
When an error occurs no further extension languages are tried.
- This is to preserve existing behaviour, and because it's convenient
+ This is to preserve existing behavior, and because it's convenient
for Python developers.
Note: This is different than encountering a memory error trying to read
a value for pretty-printing. Here we're referring to, e.g., programming
/* A base class used by fortran_array_walker. There's no virtual methods
here, sub-classes should just override the functions they want in order
- to specialise the behaviour to their needs. The functionality
+ to specialise the behavior to their needs. The functionality
provided in these default implementations will visit every array
element, but do nothing for each element. */
- If the thread is running, then this field has its value removed by
calling stop_pc.reset() (see thread_info::set_executing()).
Attempting to read a std::optional with no value is undefined
- behaviour and will trigger an assertion error when _GLIBCXX_DEBUG is
+ behavior and will trigger an assertion error when _GLIBCXX_DEBUG is
defined, which should make error easier to track down. */
std::optional<CORE_ADDR> stop_pc;
};
{
add_setshow_boolean_cmd ("guile-scripts", class_support,
&auto_load_guile_scripts, _("\
-Set the debugger's behaviour regarding auto-loaded Guile scripts."), _("\
-Show the debugger's behaviour regarding auto-loaded Guile scripts."), _("\
+Set the debugger's behavior regarding auto-loaded Guile scripts."), _("\
+Show the debugger's behavior regarding auto-loaded Guile scripts."), _("\
If enabled, auto-loaded Guile scripts are loaded when the debugger reads\n\
an executable or shared library.\n\
This options has security implications for untrusted inferiors."),
case TYPE_CODE_ARRAY:
return realtype->target_type ();
default:
- /* This is done to preserve existing behaviour. PR 20769.
+ /* This is done to preserve existing behavior. PR 20769.
E.g., gdb.parse_and_eval("my_int_variable").lazy_string().type. */
return realtype;
}
ULONGEST eip = (pc - insn_offset) & 0xffffffffUL;
/* If we just stepped over a breakpoint insn, we don't backup
- the pc on purpose; this is to match behaviour without
+ the pc on purpose; this is to match behavior without
stepping. */
regcache_write_pc (regs, eip);
caused by an unhandled C++ exception. GDB blocked this call in order\n\
to prevent the program from being terminated, and has restored the\n\
context to its original state before the call.\n\
-To change this behaviour use \"set unwind-on-terminating-exception off\".\n\
+To change this behavior use \"set unwind-on-terminating-exception off\".\n\
Evaluation of the expression containing the function (%s)\n\
will be abandoned."),
name.c_str ());
we would wrongly adjust the PC to 0x08000000, since there's a
breakpoint at PC - 1. We'd then report a hit on B1, although
INSN1 hadn't been de-executed yet. Doing nothing is the correct
- behaviour. */
+ behavior. */
if (execution_direction == EXEC_REVERSE)
return;
const char *name);
\f
-/* These macros define the behaviour of the expression
+/* These macros define the behavior of the expression
evaluator. */
/* Should we range check values against the domain of their type? */
p = remove_trailing_whitespace (orig, *linespec);
/* If there is no valid linespec then this will leave the
- spec_string as nullptr. This behaviour is relied on in the
+ spec_string as nullptr. This behavior is relied on in the
breakpoint setting code, where spec_string being nullptr means
to use the default breakpoint location. */
if ((p - orig) > 0)
case btTypedef:
/* Follow a forward typedef. This might recursively
call cross_ref till we get a non typedef'ed type.
- FIXME: This is not correct behaviour, but gdb currently
+ FIXME: This is not correct behavior, but gdb currently
cannot handle typedefs without type copying. Type
copying is impossible as we might have mutual forward
references between two files and the copied type would not
{
/* Parse the type for a normal typedef. This might recursively call
cross_ref till we get a non typedef'ed type.
- FIXME: This is not correct behaviour, but gdb currently
+ FIXME: This is not correct behavior, but gdb currently
cannot handle typedefs without type copying. But type copying is
impossible as we might have mutual forward references between
two files and the copied type would not get filled in when
error (_("Invalid thread group for the --thread-group option"));
set_current_inferior (inf);
- /* This behaviour means that if --thread-group option identifies
+ /* This behavior means that if --thread-group option identifies
an inferior with multiple threads, then a random one will be
picked. This is not a problem -- frontend should always
provide --thread if it wishes to operate on a specific
/* Perform a cast of ARG into TYPE. There's sadly a lot of duplication in
here from valops.c:value_cast, opencl is different only in the
- behaviour of scalar to vector casting. As far as possibly we're going
+ behavior of scalar to vector casting. As far as possibly we're going
to try and delegate back to the standard value_cast function. */
struct value *
{
add_setshow_boolean_cmd ("python-scripts", class_support,
&auto_load_python_scripts, _("\
-Set the debugger's behaviour regarding auto-loaded Python scripts."), _("\
-Show the debugger's behaviour regarding auto-loaded Python scripts."), _("\
+Set the debugger's behavior regarding auto-loaded Python scripts."), _("\
+Show the debugger's behavior regarding auto-loaded Python scripts."), _("\
If enabled, auto-loaded Python scripts are loaded when the debugger reads\n\
an executable or shared library.\n\
This options has security implications for untrusted inferiors."),
set_show_commands auto_load_scripts_cmds
= add_setshow_boolean_cmd ("auto-load-scripts", class_support,
&auto_load_python_scripts, _("\
-Set the debugger's behaviour regarding auto-loaded Python scripts, "
+Set the debugger's behavior regarding auto-loaded Python scripts, "
"deprecated."),
_("\
-Show the debugger's behaviour regarding auto-loaded Python scripts, "
+Show the debugger's behavior regarding auto-loaded Python scripts, "
"deprecated."),
NULL, NULL, show_auto_load_python_scripts,
&setlist, &showlist);
It is important that the result is inspected immediately after sending
a packet to the remote, and any error fetched, calling any other
Python functions that might clear the error state, or rely on an error
- not being set will cause undefined behaviour. */
+ not being set will cause undefined behavior. */
gdbpy_ref<> result () const
{
NEXT is nullptr. */
Py_XDECREF ((PyObject *) obj->next);
- /* Now core deallocation behaviour. */
+ /* Now core deallocation behavior. */
Py_TYPE (self)->tp_free (self);
}
part in the gdbpy_disassembler is a text part in the same STYLE, then
the new string is appended to the previous part.
- The merging behaviour make the Python API a little more user friendly,
+ The merging behavior make the Python API a little more user friendly,
some disassemblers produce their output character at a time, there's no
particular reason for this, it's just how they are implemented. By
merging parts with the same style we make it easier for the user to
default value for the backtrace command (see the call to print_frame_info
in backtrace_command_1).
Having the same default ensures that 'bt' and 'bt no-filters'
- have the same behaviour when some filters exist but do not apply
+ have the same behavior when some filters exist but do not apply
to a frame. */
enum print_what print_what
= out->is_mi_like_p () ? LOC_AND_ADDRESS : LOCATION;
case TYPE_CODE_ARRAY:
return check_typedef (realtype->target_type ());
default:
- /* This is done to preserve existing behaviour. PR 20769.
+ /* This is done to preserve existing behavior. PR 20769.
E.g., gdb.parse_and_eval("my_int_variable").lazy_string().type. */
return realtype;
}
{
/* The test of is_stmt here was added when the is_stmt field was
introduced to the 'struct linetable_entry' structure. This
- ensured that this loop maintained the same behaviour as before we
+ ensured that this loop maintained the same behavior as before we
introduced is_stmt. That said, it might be that we would be
better off not checking is_stmt here, this would lead to us
possibly adding more line numbers to the range. At the time this
break;
default:
buffer = (gdb_byte *) xmalloc (length);
- /* POSIX defines EINTR behaviour of read in a weird way. It's allowed
+ /* POSIX defines EINTR behavior of read in a weird way. It's allowed
for read() to return -1 even if "some" bytes have been read. It
has been corrected in SUSv2 but that doesn't help us much...
Therefore a complete solution must check how many bytes have been
this might be a call to an initializer in main(), introduced by gcc2.
We'd like to skip over it as well. Fortunately, xlc does some extra
work before calling a function right after a prologue, thus we can
- single out such gcc2 behaviour. */
+ single out such gcc2 behavior. */
if ((op & 0xfc000001) == 0x48000001)
using mode MODE in the calls to open. You cannot use this function to
create files (O_CREAT).
- OPTS specifies the function behaviour in specific cases.
+ OPTS specifies the function behavior in specific cases.
If OPF_TRY_CWD_FIRST, try to open ./STRING before searching PATH.
(ie pretend the first element of PATH is "."). This also indicates
}
-/* This is essentially a convenience, for clients that want the behaviour
+/* This is essentially a convenience, for clients that want the behavior
of openp, using source_path, but that really don't want the file to be
opened but want instead just to know what the full pathname is (as
qualified against source_path).
/* Move to the last linetable entry of the current function. */
if (it == &linetable->item[0])
{
- /* Doing it-- would introduce undefined behaviour, avoid it by
+ /* Doing it-- would introduce undefined behavior, avoid it by
explicitly handling this case. */
return {};
}
if (it == &linetable->item[0])
{
/* No more entries in the current function.
- Doing it-- would introduce undefined behaviour, avoid it by
+ Doing it-- would introduce undefined behavior, avoid it by
explicitly handling this case. */
break;
}
void *baton;
};
-/* Enumeration specifying different flash preservation behaviour. */
+/* Enumeration specifying different flash preservation behavior. */
enum flash_preserve_mode
{
flash_preserve,
# in the same situation, we avoid invoking DejaGnu, and instead just call
# the check/no-matching-tests-found rule (which prints a helpful message).
#
-# To get the same behaviour for check-single we decide here, based on how
+# To get the same behavior for check-single we decide here, based on how
# TESTS expanded, whether check-single should redirect to do-check-single or
# to check/no-matching-tests-found.
ifeq ($(expanded_tests_or_none),no-matching-tests-found)
/* Finds and returns an invalid pointer, mmaps in a page, grabs a pointer
to it then unmaps the page again. This is almost certainly "undefined"
- behaviour, but should be good enough for this small test program. */
+ behavior, but should be good enough for this small test program. */
static void *
make_invalid_ptr (void)
# frame where the stack in unreadable.
#
# One interesting bug that has been observed is that gdb will sometime
-# exhibit different behaviour the first time a stack command is run
+# exhibit different behavior the first time a stack command is run
# compared to the second (and later) times a command is run. This is
# because the first time a command is run gdb actually tries to figure out
# the answer, while the second (and later) times gdb relies on the answer
/* Finds and returns an invalid pointer, mmaps in a page, grabs a pointer
to it then unmaps the page again. This is almost certainly "undefined"
- behaviour, but should be good enough for this small test program. */
+ behavior, but should be good enough for this small test program. */
static void *
make_invalid_ptr (void)
# frame where the stack in unreadable.
#
# One interesting bug that has been observed is that gdb will sometime
-# exhibit different behaviour the first time a stack command is run
+# exhibit different behavior the first time a stack command is run
# compared to the second (and later) times a command is run. This is
# because the first time a command is run gdb actually tries to figure out
# the answer, while the second (and later) times gdb relies on the answer
# You should have received a copy of the GNU General Public License
# along with this program. If not, see <http://www.gnu.org/licenses/>.
-# Test the 'maint set backtrace-on-fatal-signal' behaviour. Start up
+# Test the 'maint set backtrace-on-fatal-signal' behavior. Start up
# GDB, turn on backtrace-on-fatal-signal, then send fatal signals to
# GDB and ensure we see the backtrace.
# As before, delay so that at least one second has passed. GDB still
# will not spot that the source file has changed, as GDB doesn't do a
# time check unless the binary has also changed, this delay just
-# allows us to confirm this behaviour.
+# allows us to confirm this behavior.
sleep 1
# List the printf line again, we should not see the file changes yet
return 0
}
-# Verify set may-call-functions behaviour.
+# Verify set may-call-functions behavior.
gdb_test_no_output "set may-call-functions off"
gdb_test "call callexit()" \
"Cannot call functions in the program: may-call-functions is off." \
# as " - force - condition", that is, subtraction of the symbol
# "force" followed by subtraction of symbol "context". This is really
# just a quirk of how this used to be implemented, and should maybe be
-# changed in the future. However, for now GDB retains this behaviour.
+# changed in the future. However, for now GDB retains this behavior.
gdb_test "break *main if (1==1) -force-condition" \
"No symbol \"force\" in current context\\."
"use user command after redefining ghi-prefix-cmd: alternate-jkl-cmd"
####################
-# Check error behaviour.
+# Check error behavior.
gdb_test "define-prefix print" ".* is built-in.*"
gdb_test "print \$_exitcode" " = void" \
"\$_exitcode is still void after restarting the inferior"
-# Now we test the behaviour of $_exit{code,signal} during a normal
+# Now we test the behavior of $_exit{code,signal} during a normal
# inferior execution.
standard_testfile normal.c
# range. It is only when GDB exits the loop that we leave the stepping
# range, and the stepping finishes at address 0x114.
#
-# This test checks this behaviour using the DWARF assembler.
+# This test checks this behavior using the DWARF assembler.
load_lib dwarf.exp
require {!is_remote host}
# Test both ansi (no auto-wrap) and xterm (auto-wrap). Also test dumb, which
-# shows the effective behaviour on stub-termcap systems, regardless of the
+# shows the effective behavior on stub-termcap systems, regardless of the
# TERM setting.
set terms {ansi xterm dumb}
]
}
-### 2.2 None as filter. This resets the default behaviour.
+### 2.2 None as filter. This resets the default behavior.
with_test_prefix "None" {
gdb_test_multiline "register filter in python" \
"python" "" \
# (gdb) print enum_var
# $1 = 8
#
-# This test checks this behaviour.
+# This test checks this behavior.
standard_testfile .cc
# in-frame). The default handler calls std::terminate. This will kill
# the inferior. Assert that terminate should never be called in an
# inferior function call. These tests test the functionality around
-# unwinding that sequence and also tests the flag behaviour gating this
+# unwinding that sequence and also tests the flag behavior gating this
# functionality.
#
# PR c++/9600.
# See http://sourceware.org/gdb/bugs/2495
-# Test normal baseline behaviour. Call a function that
+# Test normal baseline behavior. Call a function that
# does not raise an exception.
gdb_test "p exceptions.no_throw_function()" " = 1"
# And one that does but handles it in-frame.
gdb_test "info breakpoints" \
"gdb2495\.cc.*"
-# Turn off this new behaviour.
+# Turn off this new behavior.
gdb_test_no_output "set unwind-on-terminating-exception off"
# Check that it is turned off.
"exception is unhandled while in a call dummy is off.*" \
"turn off unwind on terminating exception flag"
-# Check that the old behaviour is restored.
+# Check that the old behavior is restored.
gdb_test "p exceptions.throw_function()" \
"The program being debugged was signaled while in a function called .*" \
"call a function that raises an exception with unwinding off.."
}
-# Check to see if the new behaviour alters the unwind signal
+# Check to see if the new behavior alters the unwind signal
# behaviour; it should not. Test both on and off states.
-# Turn on unwind on signal behaviour.
+# Turn on unwind on signal behavior.
gdb_test_no_output "set unwind-on-signal on"
# Check that it is turned on.
"signal is received while in a call dummy is on.*" \
"turn on unwind on signal"
-# Check to see if new behaviour interferes with
+# Check to see if new behavior interferes with
# normal signal handling in inferior function calls.
gdb_test "p exceptions.raise_signal(1)" \
[multi_line \
"signal is received while in a call dummy is off.*" \
"turn off unwind on signal"
-# Check to see if new behaviour interferes with
+# Check to see if new behavior interferes with
# normal signal handling in inferior function calls.
gdb_test "p exceptions.raise_signal(1)" \
"To change this behavior use \"set unwind-on-signal on\".*" \
library_base_address
= mmap (NULL, buf.st_size, PROT_READ, MAP_PRIVATE, fd, 0);
- res = *ptr; /* Undefined behaviour here. */
+ res = *ptr; /* Undefined behavior here. */
return 0;
}
return
}
-gdb_breakpoint [gdb_get_line_number "Undefined behaviour here" $srcfile3]
+gdb_breakpoint [gdb_get_line_number "Undefined behavior here" $srcfile3]
gdb_continue_to_breakpoint "run to breakpoint"
set library_base_address \
}
proc test_d_expressions {} {
- # Test expression behaviour specific to D.
+ # Test expression behavior specific to D.
# Comparison and order expressions have same precedence.
gdb_test "print 1 == 2 > 0" "A syntax error in expression, near `> 0'\."
# third breakpoint will actually be placed at the same location as the
# second breakpoint.
#
-# This test is designed to test GDB's internal behaviour with respect
+# This test is designed to test GDB's internal behavior with respect
# to discarding particular line table entries. GCC and DWARF are
# starting to introduce the idea of line table views. As the views
# information becomes better supported within GDB it is likely that
along with this program. If not, see <http://www.gnu.org/licenses/>. */
/* This test relies on foo being inlined into main and bar not being
- inlined. The test is checking GDB's behaviour as we single step from
+ inlined. The test is checking GDB's behavior as we single step from
main through foo and into bar. */
volatile int global_var;
gdb_test_no_output "maint set dwarf synchronous on"
# This pattern is hit when GDB does not use -readnow (i.e. the default
-# behaviour).
+# behavior).
set pattern1 \
[multi_line \
"Reading symbols from \[^\r\n\]+" \
along with this program. If not, see <http://www.gnu.org/licenses/>. */
-/* Test the behaviour of gdb in the following situation, the dwarf debug
+/* Test the behavior of gdb in the following situation, the dwarf debug
information describes a parameter as being in a register but a more
recent (inner) frame marks the register as being undefined.
clobbering them.
The dwarf register numbering is different to the gdb register number.
- In some of the tests we rely on gdb behaviour of being able to specify a
+ In some of the tests we rely on gdb behavior of being able to specify a
struct using a single register location, the structure will then "flow"
into the next gdb register. The initial register is specified using a
dwarf register number, but the "next" register will depend on gdb
set dwarf_error "DWARF Error: DW_FORM_strp used without required section"
# This pattern is hit when GDB does not use -readnow (i.e. the default
-# behaviour).
+# behavior).
set pattern1 \
[multi_line \
$line1 \
# The goal here is to compare the sizes of the slice in show with
# the size of the slice extracted by GDB. So we can only compare
# sizes when GDB's repacking setting matches the repacking
- # behaviour we got from the compiler.
+ # behavior we got from the compiler.
if { ($addr_in_show < $start_addr || $addr_in_show >= $end_addr) \
== ($repack == "on") } {
gdb_assert {$size_in_show == $size_in_parent} \
# Currently referencing symbols using 'info',
# 'whatis' and 'ptype' before the program is
# started doesn't work. This is the same
- # behaviour we see in C++ so I don't think this
+ # behavior we see in C++ so I don't think this
# is a failure, just a limitation in current GDB.
if { ${with_nest_prefix_p} } {
gdb_test "info symbol ${nest_prefix}${function}" \
"&\"caused by an unhandled C\\+\\+ exception. GDB blocked this call in order\\\\n\"" \
"&\"to prevent the program from being terminated, and has restored the\\\\n\"" \
"&\"context to its original state before the call.\\\\n\"" \
- "&\"To change this behaviour use \\\\\"set unwind-on-terminating-exception off\\\\\"\\.\\\\n\"" \
+ "&\"To change this behavior use \\\\\"set unwind-on-terminating-exception off\\\\\"\\.\\\\n\"" \
"&\"Evaluation of the expression containing the function \\(cond_throw\\(\\)\\)\\\\n\"" \
"&\"will be abandoned.\\\\n\"" \
"=breakpoint-modified,bkpt={number=\"$bpnum\",type=\"breakpoint\",\[^\r\n\]+times=\"1\",\[^\r\n\]+}" \
"$real" "get children of pvla2_not_associated"
}
-re "580\\^error,msg=\"value contents too large \\(\[0-9\]+ bytes\\).*${mi_gdb_prompt}$" {
- # Undefined behaviour in gfortran.
+ # Undefined behavior in gfortran.
xfail $test
}
-re "${mi_gdb_prompt}$" {
exp_continue
}
# Likewise, but with startup-with-shell enabled, which is the
- # default behaviour.
+ # default behavior.
-re "stdin/stdout redirected.*exec: non-existing-program: not found\r\nDuring startup program exited with code 127\.\r\nExiting\r\n" {
set saw_exiting 1
exp_continue
}
gdb_assert { $expect_reread == $saw_reread } \
- "check symbol re-read behaviour"
+ "check symbol re-read behavior"
}
}
using the LD_PRELOAD technique.
The library intercepts calls to WAITPID and SIGSUSPEND in order to
- simulate the behaviour of a heavily loaded kernel.
+ simulate the behavior of a heavily loaded kernel.
When GDB wants to stop all threads in an inferior each thread is sent a
SIGSTOP, GDB will then wait for the signal to be received by the thread
The idea in this library is to rate limit calls to waitpid (where pid is
-1 and the WNOHANG option is set) so that only 1 per second can return
an answer. Any additional calls will report that no threads are
- currently ready. This should match the behaviour we see on a slow
+ currently ready. This should match the behavior we see on a slow
kernel.
However, given that usually when using this library, the kernel does
*log = fopen (env, "w");
}
-/* Wrap 'read', and modify it's behaviour using READ1 or READMORE style. */
+/* Wrap 'read', and modify it's behavior using READ1 or READMORE style. */
ssize_t
read (int fd, void *buf, size_t count)
init_readmore (&readmore_method, &readmore_sleep, &log);
}
- /* Only modify 'read' behaviour when reading from the terminal. */
+ /* Only modify 'read' behavior when reading from the terminal. */
if (isatty (fd) == 0)
goto fallback;
/* Run FN. Capture its output into the returned string, do not display it
to the screen. The global BATCH_FLAG will temporarily be set to true.
- When TERM_OUT is true the output is collected with terminal behaviour
+ When TERM_OUT is true the output is collected with terminal behavior
(e.g. with styling). When TERM_OUT is false raw output will be collected
(e.g. no styling). */
/* Helper for "tui reg next", returns the next register group after
CURRENT_GROUP in the register group list for GDBARCH, with wrap around
- behaviour.
+ behavior.
If CURRENT_GROUP is nullptr (e.g. if the tui register window has only
just been displayed and has no current group selected) or the currently
/* Helper for "tui reg prev", returns the register group previous to
CURRENT_GROUP in the register group list for GDBARCH, with wrap around
- behaviour.
+ behavior.
If CURRENT_GROUP is nullptr (e.g. if the tui register window has only
just been displayed and has no current group selected) or the currently
virtual bool isatty ()
{ return false; }
- /* true indicates terminal output behaviour such as cli_styling.
+ /* true indicates terminal output behavior such as cli_styling.
This default implementation indicates to do terminal output
- behaviour if the UI_FILE is a tty. A derived class can override
- TERM_OUT to have cli_styling behaviour without being a tty. */
+ behavior if the UI_FILE is a tty. A derived class can override
+ TERM_OUT to have cli_styling behavior without being a tty. */
virtual bool term_out ()
{ return isatty (); }
{
public:
/* Construct a string_file to collect 'raw' output, i.e. without
- 'terminal' behaviour such as cli_styling. */
+ 'terminal' behavior such as cli_styling. */
string_file () : m_term_out (false) {};
- /* If TERM_OUT, construct a string_file with terminal output behaviour
+ /* If TERM_OUT, construct a string_file with terminal output behavior
such as cli_styling)
else collect 'raw' output like the previous constructor. */
explicit string_file (bool term_out) : m_term_out (term_out) {};
changeable = varobj_value_is_changeable_p (var);
/* If the type has custom visualizer, we consider it to be always
- changeable. FIXME: need to make sure this behaviour will not
+ changeable. FIXME: need to make sure this behavior will not
mess up read-sensitive values. */
if (var->dynamic->pretty_printer != NULL)
changeable = true;
gdb_assert (options != nullptr);
/* Empty options means the "default" set. This exists mostly for
- backwards compatibility with gdbserver's legacy behaviour. */
+ backwards compatibility with gdbserver's legacy behavior. */
if (*options == '\0')
options = "+threads";
Your 'rm' program seems unable to run without file operands specified
on the command line, even when the '-f' option is present. This is contrary
-to the behaviour of most rm programs out there, and not conforming with
+to the behavior of most rm programs out there, and not conforming with
the upcoming POSIX standard: <http://austingroupbugs.net/view.php?id=542>
Please tell bug-automake@gnu.org about your system, including the value
Your 'rm' program seems unable to run without file operands specified
on the command line, even when the '-f' option is present. This is contrary
-to the behaviour of most rm programs out there, and not conforming with
+to the behavior of most rm programs out there, and not conforming with
the upcoming POSIX standard: <http://austingroupbugs.net/view.php?id=542>
Please tell bug-automake@gnu.org about your system, including the value
}
/* A sequential drop-in replacement of parallel_for_each. This can be useful
- when debugging multi-threading behaviour, and you want to limit
+ when debugging multi-threading behavior, and you want to limit
multi-threading in a fine-grained way. */
template<class RandomIt, class RangeFunction>
projects / thirdparty / binutils-gdb.git / commitdiff
