if VGCONF_OS_IS_SOLARIS
# Make sure that all test programs have threaded errno.
-# Disable largefile support as there are test cases explictly enabling it.
+# Disable largefile support as there are test cases explicitly enabling it.
AM_CFLAGS += -D_REENTRANT @SOLARIS_UNDEF_LARGESOURCE@
endif
== 368864 WARNING: unhandled arm64-linux syscall: 262 (fanotify_init)
373555 Rename BBPTR to GSPTR as it denotes guest state pointer only
373938 const IRExpr arguments for matchIRExpr()
+374719 some spelling fixes
375514 valgrind_get_tls_addr() does not work in case of static TLS
375772 +1 error in get_elf_symbol_info() when computing value of 'hi' address
for ML_(find_rx_mapping)()
- A working combination of autotools is required: aclocal, autoheader,
automake and autoconf have to be found in the PATH. You should be able to
install pkg:/developer/build/automake and pkg:/developer/build/autoconf
- packages to fullfil this requirement.
+ packages to fulfil this requirement.
- System header files are required. On Solaris, these can be installed with:
# pkg install system/header
- GNU make is also required. On Solaris, this can be quickly achieved with:
LINX_, LINXY, PLAX_, PLAXY.
GEN* for generic syscalls (in syswrap-generic.c), LIN* for linux
specific ones (in syswrap-linux.c) and PLA* for the platform
- dependant ones (in syswrap-$(PLATFORM)-linux.c).
+ dependent ones (in syswrap-$(PLATFORM)-linux.c).
The *XY variant if it requires a PRE() and POST() function, and
the *X_ variant if it only requires a PRE()
function.
* As this can be detected at instrumentation time, and results
* in faster simulation, special-casing is benefical.
*
- * Abbrevations used in var/function names:
+ * Abbreviations used in var/function names:
* IrNoX - instruction read does not cross cache lines
* IrGen - generic instruction read; not detected as IrNoX
* Ir - not known / not important whether it is an IrNoX
njn@valgrind.org
AVL tree code derived from
- ANSI C Library for maintainance of AVL Balanced Trees
+ ANSI C Library for maintenance of AVL Balanced Trees
(C) 2000 Daniel Nagy, Budapest University of Technology and Economics
Released under GNU General Public License (GPL) version 2
/* forward */
static Bool avl_removeroot_wrk(AvlNode** t, Word(*kCmp)(Word,Word));
-/* Swing to the left. Warning: no balance maintainance. */
+/* Swing to the left. Warning: no balance maintenance. */
static void avl_swl ( AvlNode** root )
{
AvlNode* a = *root;
b->left = a;
}
-/* Swing to the right. Warning: no balance maintainance. */
+/* Swing to the right. Warning: no balance maintenance. */
static void avl_swr ( AvlNode** root )
{
AvlNode* a = *root;
b->right = a;
}
-/* Balance maintainance after especially nasty swings. */
+/* Balance maintenance after especially nasty swings. */
static void avl_nasty ( AvlNode* root )
{
switch (root->balance) {
/* Start full callgrind instrumentation if not already switched on.
When cache simulation is done, it will flush the simulated cache;
- this will lead to an artifical cache warmup phase afterwards with
+ this will lead to an artificial cache warmup phase afterwards with
cache misses which would not have happened in reality. */
#define CALLGRIND_START_INSTRUMENTATION \
VALGRIND_DO_CLIENT_REQUEST_STMT(VG_USERREQ__START_INSTRUMENTATION, \
what is happening within a given function or starting from a given
program phase. To this end, you can disable event aggregation for
uninteresting program parts. While attribution of events to
- functions as well as producing seperate output per program phase
+ functions as well as producing separate output per program phase
can be done by other means (see previous section), there are two
benefits by disabling aggregation. First, this is very
fine-granular (e.g. just for a loop within a function). Second,
cycles, this does not hold true: callees of a function in a cycle include
the function itself. Therefore, KCachegrind does cycle detection
and skips visualization of any inclusive cost for calls inside
- of cycles. Further, all functions in a cycle are collapsed into artifical
+ of cycles. Further, all functions in a cycle are collapsed into artificial
functions called like <computeroutput>Cycle 1</computeroutput>.</para>
<para>Now, when a program exposes really big cycles (as is
<listitem>
<para>Start full Callgrind instrumentation if not already enabled.
When cache simulation is done, this will flush the simulated cache
- and lead to an artifical cache warmup phase afterwards with
+ and lead to an artificial cache warmup phase afterwards with
cache misses which would not have happened in reality. See also
option <option><xref linkend="opt.instr-atstart"/></option>.</para>
</listitem>
/* _ld_runtime_resolve, located in ld.so, needs special handling:
* The jump at end into the resolved function should not be
* represented as a call (as usually done in callgrind with jumps),
- * but as a return + call. Otherwise, the repeated existance of
+ * but as a return + call. Otherwise, the repeated existence of
* _ld_runtime_resolve in call chains will lead to huge cycles,
* making the profile almost worthless.
*
* Basic Block Cost Center
*
* On demand, multiple BBCCs will be created for the same BB
- * dependend on command line options and:
+ * dependent on command line options and:
* - current function (it's possible that a BB is executed in the
* context of different functions, e.g. in manual assembler/PLT)
* - current thread ID
VG_(message)(Vg_UserMsg,
"callgrind only works with --vex-iropt-unroll-thresh=0\n"
"=> resetting it back to 0\n");
- VG_(clo_vex_control).iropt_unroll_thresh = 0; // cannot be overriden.
+ VG_(clo_vex_control).iropt_unroll_thresh = 0; // cannot be overridden.
}
if (VG_(clo_vex_control).guest_chase_thresh != 0) {
VG_(message)(Vg_UserMsg,
"callgrind only works with --vex-guest-chase-thresh=0\n"
"=> resetting it back to 0\n");
- VG_(clo_vex_control).guest_chase_thresh = 0; // cannot be overriden.
+ VG_(clo_vex_control).guest_chase_thresh = 0; // cannot be overridden.
}
CLG_DEBUG(1, " dump threads: %s\n", CLG_(clo).separate_threads ? "Yes":"No");
= VG_(clo_px_file_backed)
= VexRegUpdSpAtMemAccess; // overridable by the user.
- VG_(clo_vex_control).iropt_unroll_thresh = 0; // cannot be overriden.
- VG_(clo_vex_control).guest_chase_thresh = 0; // cannot be overriden.
+ VG_(clo_vex_control).iropt_unroll_thresh = 0; // cannot be overridden.
+ VG_(clo_vex_control).guest_chase_thresh = 0; // cannot be overridden.
VG_(basic_tool_funcs) (CLG_(post_clo_init),
CLG_(instrument),
# Power PC returns powerpc for Big Endian. This was not changed when Little
# Endian support was added to the 64-bit architecture. The 64-bit Little
# Endian systems explicitly state le in the host_cpu. For clarity in the
-# Valgrind code, the ARCH_MAX name will state LE or BE for the endianess of
+# Valgrind code, the ARCH_MAX name will state LE or BE for the endianness of
# the 64-bit system. Big Endian is the only mode supported on 32-bit Power PC.
# The abreviation PPC or ppc refers to 32-bit and 64-bit systems with either
-# Endianess. The name PPC64 or ppc64 to 64-bit systems of either Endianess.
+# Endianness. The name PPC64 or ppc64 to 64-bit systems of either Endianness.
# The names ppc64be or PPC64BE refer to only 64-bit systems that are Big
# Endian. Similarly, ppc64le or PPC64LE refer to only 64-bit systems that are
# Little Endian.
CFLAGS=$safe_CFLAGS
# If the linker only supports -Ttext (not -Ttext-segment) then we will
-# have to strip any build-id ELF NOTEs from the staticly linked tools.
+# have to strip any build-id ELF NOTEs from the statically linked tools.
# Otherwise the build-id NOTE might end up at the default load address.
# (Pedantically if the linker is gold then -Ttext is fine, but newer
# gold versions also support -Ttext-segment. So just assume that unless
/* Figure out the name of this executable (viz, the launcher), so
we can tell stage2. stage2 will use the name for recursive
- invokations of valgrind on child processes. */
+ invocations of valgrind on child processes. */
memset(launcher_name, 0, PATH_MAX+1);
for (i = 0; envp[i]; i++)
; /* executable path is after last envp item */
}
new_argv[new_argc++] = NULL;
- /* Build the stage2 invokation, and execve it. Bye! */
+ /* Build the stage2 invocation, and execve it. Bye! */
asprintf(&toolfile, "%s/%s-%s-darwin", valgrind_lib, toolname, arch);
if (access(toolfile, R_OK|X_OK) != 0) {
barf("tool '%s' not installed (%s) (%s)", toolname, toolfile, strerror(errno));
# first arg
# the alternative load address
# all the rest of the args
-# the gcc invokation to do the final link, that
+# the gcc invocation to do the final link, that
# the build system would have done, left to itself
#
# We just let the script 'die' if something is wrong, rather than do
#
# So: what we actually do is:
#
-# Look at the specified gcc invokation. Ignore all parts of it except
+# Look at the specified gcc invocation. Ignore all parts of it except
# the *.a, *.o and -o outfile parts. Wrap them up in a new command
# which looks (eg) as follows:
#
# executable for which we are linking. We need to know this because
# we must tell the linker that, by handing it either "-arch x86_64" or
# "-arch i386". Fortunately we can figure this out by scanning the
-# gcc invokation, which itself must contain either "-arch x86_64" or
+# gcc invocation, which itself must contain either "-arch x86_64" or
# "-arch i386".
use warnings;
# first arg
# the alternative load address
# all the rest of the args
-# the gcc invokation to do the final link, that
+# the gcc invocation to do the final link, that
# the build system would have done, left to itself
#
# We just let the script 'die' if something is wrong, rather than do
die "Bogus alt-load address"
if (length($ala) < 3 || index($ala, "0x") != 0);
-# the cc invokation to do the final link
+# the cc invocation to do the final link
my $cc = $ARGV[1];
# and the 'restargs' are argv[2 ..]
ThreadId tid;
StackPos stackPos = StackPos_stacked;
// Default init to StackPos_stacked, to silence gcc warning.
- // We assert this value is overriden if a stack descr is produced.
+ // We assert this value is overridden if a stack descr is produced.
// First try to find a tid with stack containing a
tid = find_tid_with_stack_containing (a);
Loss of pointercheck
~~~~~~~~~~~~~~~~~~~~
Up to and including Valgrind 2.4.1, x86 segmentation was used to
- enforce seperation of V and C, so that wild writes by C could not
+ enforce separation of V and C, so that wild writes by C could not
trash V. This got called "pointercheck". Unfortunately, the new
more flexible memory layout, plus the need to be portable across
different architectures, means doing this in hardware is no longer
the outcome of the search and the kind of request made, decide
whether the request is allowable and what address to advise.
- The Default Policy is overriden by Policy Exception #1:
+ The Default Policy is overridden by Policy Exception #1:
If the request is for a fixed client map, we are prepared to
grant it providing all areas inside the request are either
other words we are prepared to let the client trash its own
mappings if it wants to.
- The Default Policy is overriden by Policy Exception #2:
+ The Default Policy is overridden by Policy Exception #2:
If the request is for a hinted client map, we are prepared to
grant it providing all areas inside the request are either
in the stated order.
VG_(args_for_valgrind_noexecpass) is set to be the number of items
- in the first three categories. They are not passed to child invokations
+ in the first three categories. They are not passed to child invocations
at exec, whereas the last group is.
If the last group contains --command-line-only=yes, then the
static vki_priv_impl_info_t *create_priv_info(SizeT *size)
{
- /* Size of the returned priv_impl_info_t is apriori unkown. */
+ /* Size of the returned priv_impl_info_t is apriori unknown. */
vki_priv_impl_info_t first_cut[100];
SysRes sres = VG_(do_syscall5)(SYS_privsys, VKI_PRIVSYS_GETIMPLINFO,
0, 0, (UWord) first_cut,
cfsi_m_ix as in many case, one byte is good enough. For big
objects, 2 bytes are needed. No object has yet been found where
4 bytes are needed (but the code is ready to handle this case).
- Not covered ranges ('cfi holes') are stored explicitely in
+ Not covered ranges ('cfi holes') are stored explicitly in
cfsi_base/cfsi_m_ix as this is more memory efficient than storing
a length for each covered range : on x86 or amd64, we typically have
a hole every 8 covered ranges. On arm64, we have very few holes
if ( acode != abcode ) {
/* This isn't illegal, but somewhat unlikely. Normally the
* first abbrev describes the first DIE, the compile_unit.
- * But maybe this abbrevation data is shared with another
+ * But maybe this abbreviation data is shared with another
* or it is a NULL entry used for padding. See para 7.5.3. */
abbrev_img = lookup_abbrev( ML_(cur_plus)(debugabbrev_img, atoffs),
acode );
Int data_a_f;
Addr initloc;
Int ra_reg;
- /* The rest of these fields can be modifed by
+ /* The rest of these fields can be modified by
run_CF_instruction. */
/* The LOC entry */
Addr loc;
http://gcc.gnu.org/ml/gcc-patches/2004-08/msg00557.html
*/
# if defined(VGP_ppc64be_linux)
- /* Host and guest may have different Endianess, used by BE only */
+ /* Host and guest may have different Endianness, used by BE only */
is_in_opd = False;
# endif
di->symtab[r].sec_names = NULL;
}
/* Completely zap the entry -- paranoia to make it more
- likely we'll notice if we inadvertantly use it
+ likely we'll notice if we inadvertently use it
again. */
VG_(memset)(&di->symtab[r], 0, sizeof(DiSym));
} else {
-/* ANSI and traditional C compatability macros
+/* ANSI and traditional C compatibility macros
Copyright (C) 1991-2017 Free Software Foundation, Inc.
This file is part of the GNU C Library.
goto unknown;
/* Most of the demangling will trivially remove chars. Operator names
- may add one char but because they are always preceeded by '__' which is
+ may add one char but because they are always preceded by '__' which is
replaced by '.', they eventually never expand the size.
A few special names such as '___elabs' add a few chars (at most 7), but
they occur only once. */
string_append (s, buf);
/* Numbers not otherwise delimited, might have an underscore
- appended as a delimeter, which we should skip.
+ appended as a delimiter, which we should skip.
??? This used to always remove a following underscore, which
is wrong. If other (arbitrary) cases are followed by an
#define TOUPPER(c) _sch_toupper[(c) & 0xff]
#define TOLOWER(c) _sch_tolower[(c) & 0xff]
-/* Prevent the users of safe-ctype.h from accidently using the routines
+/* Prevent the users of safe-ctype.h from accidentally using the routines
from ctype.h. Initially, the approach was to produce an error when
detecting that ctype.h has been included. But this was causing
trouble as ctype.h might get indirectly included as a result of
before modifying the value. gdb checks that the value has not changed
and so "does not believe" the information that the write watchpoint
was triggered, and continues the execution. At the next watchpoint
-occurence, gdb sees the value has changed. But the watchpoints are all
+occurrence, gdb sees the value has changed. But the watchpoints are all
reported "off by one". To avoid this, Valgrind gdbserver must
terminate the current instruction before reporting the write watchpoint.
Terminating precisely the current instruction implies to have
/* When all threads are blocked in a system call, the Valgrind
scheduler cannot poll the shared memory for gdbserver activity. In
- such a case, vgdb will force the invokation of gdbserver using
+ such a case, vgdb will force the invocation of gdbserver using
ptrace. To do that, vgdb 'pushes' a call to invoke_gdbserver
on the stack using ptrace. invoke_gdbserver must not return.
Instead, it must call give_control_back_to_vgdb.
}
/* Convert a OURSIG (an enum target_signal) to the form used by the
- target operating system (refered to as the ``host'') or zero if the
+ target operating system (referred to as the ``host'') or zero if the
equivalent host signal is not available. Set/clear OURSIG_OK
accordingly. */
if (! sr_isError(res)) return 0;
- /* Make sure, argument values are determinstic upon failure */
+ /* Make sure, argument values are deterministic upon failure */
if (tv) *tv = (struct vki_timeval){ .tv_sec = 0, .tv_usec = 0 };
if (tz) *tz = (struct vki_timezone){ .tz_minuteswest = 0, .tz_dsttime = 0 };
whatever we were provided with. This is OK because all the
sigaction requests come from m_signals, and are not directly
what the client program requested, so there is no chance that we
- will inadvertantly ignore the sa_tramp field requested by the
+ will inadvertently ignore the sa_tramp field requested by the
client. (In fact m_signals does ignore it when building signal
frames for the client, but that's a completely different
matter).
// 8-bytes on 32-bit machines with an 8-byte VG_MIN_MALLOC_SZB -- because
// it's too hard to make a constant expression that works perfectly in all
// cases.
-// 'unsplittable' is set to NULL if superblock can be splitted, otherwise
+// 'unsplittable' is set to NULL if superblock can be split, otherwise
// it is set to the address of the superblock. An unsplittable superblock
// will contain only one allocated block. An unsplittable superblock will
// be unmapped when its (only) allocated block is freed.
SizeT min_unsplittable_sblock_szB;
// Minimum unsplittable superblock size in bytes. To be marked as
// unsplittable, a superblock must have a
- // size >= min_unsplittable_sblock_szB and cannot be splitted.
+ // size >= min_unsplittable_sblock_szB and cannot be split.
// So, to avoid big overhead, superblocks used to provide aligned
// blocks on big alignments are splittable.
// Unsplittable superblocks will be reclaimed when their (only)
}
// Initialise an arena. rz_szB is the (default) minimum redzone size;
-// It might be overriden by VG_(clo_redzone_size) or VG_(clo_core_redzone_size).
+// It might be overridden by VG_(clo_redzone_size) or VG_(clo_core_redzone_size).
// it might be made bigger to ensure that VG_MIN_MALLOC_SZB is observed.
static
void arena_init ( ArenaId aid, const HChar* name, SizeT rz_szB,
vg_assert(b_bszB >= req_bszB);
// Could we split this block and still get a useful fragment?
- // A block in an unsplittable superblock can never be splitted.
+ // A block in an unsplittable superblock can never be split.
frag_bszB = b_bszB - req_bszB;
if (frag_bszB >= min_useful_bszB(a)
&& (NULL == new_sb || ! new_sb->unsplittable)) {
/* b must be a free block, of size b_bszB.
If b is followed by another free block, merge them.
- If b is preceeded by another free block, merge them.
+ If b is preceded by another free block, merge them.
If the merge results in the superblock being fully free,
deferred_reclaimSuperblock the superblock. */
static void mergeWithFreeNeighbours (Arena* a, Superblock* sb,
{
/* As we will split the block given back by VG_(arena_malloc),
we have to (temporarily) disable unsplittable for this arena,
- as unsplittable superblocks cannot be splitted. */
+ as unsplittable superblocks cannot be split. */
const SizeT save_min_unsplittable_sblock_szB
= a->min_unsplittable_sblock_szB;
a->min_unsplittable_sblock_szB = MAX_PSZB;
//----------------------------------------------------------------------
// This file is based on:
//
-// ANSI C Library for maintainance of AVL Balanced Trees
+// ANSI C Library for maintenance of AVL Balanced Trees
// (C) 2000 Daniel Nagy, Budapest University of Technology and Economics
// Released under GNU General Public License (GPL) version 2
//----------------------------------------------------------------------
}
-// Swing to the left. Warning: no balance maintainance.
+// Swing to the left. Warning: no balance maintenance.
static void avl_swl ( AvlNode** root )
{
AvlNode* a = *root;
b->left = a;
}
-// Swing to the right. Warning: no balance maintainance.
+// Swing to the right. Warning: no balance maintenance.
static void avl_swr ( AvlNode** root )
{
AvlNode* a = *root;
b->right = a;
}
-// Balance maintainance after especially nasty swings.
+// Balance maintenance after especially nasty swings.
static void avl_nasty ( AvlNode* root )
{
switch (root->balance) {
}
POST(getdirentries64)
{
- /* Disabled; see coments in the PRE wrapper.
+ /* Disabled; see comments in the PRE wrapper.
POST_MEM_WRITE(ARG4, sizeof(vki_off_t));
*/
// GrP fixme be specific about d_name? (fixme copied from 32 bit version)
ARG4 = ARG3;
/* Fake the requested sigmask with a block-all mask. If the syscall
- suceeds then we will block "all" signals for a few instructions (in
+ succeeds then we will block "all" signals for a few instructions (in
syscall-x86-solaris.S) but the correct mask will be almost instantly set
again by a call to sigprocmask (also in syscall-x86-solaris.S). If the
syscall fails then the mask is not changed, so everything is ok too. */
case VKI_XEN_HVMOP_set_mem_type:
case VKI_XEN_HVMOP_set_mem_access:
case VKI_XEN_HVMOP_inject_trap:
- /* No output paramters */
+ /* No output parameters */
break;
case VKI_XEN_HVMOP_get_param:
.type VG_(s390x_linux_REDIR_FOR_index),@function
VG_(s390x_linux_REDIR_FOR_index):
#
-# %r2 = addess of string
+# %r2 = address of string
# %r3 = character to find
#
lghi %r0,255
/* Later .. it appears ppc32-linux tries to put [vdso] at 1MB,
which totally screws things up, because nothing else can go
there. The size of [vdso] is around 2 or 3 pages, so bump
- the hacky load addess along by 8 * VKI_PAGE_SIZE to be safe. */
+ the hacky load address along by 8 * VKI_PAGE_SIZE to be safe. */
/* Later .. on mips64 we can't use 0x108000, because mapelf will
fail. */
# if defined(VGP_mips64_linux)
/* forward */
static Bool avl_removeroot_wrk(AvlNode** t, Word(*kCmp)(UWord,UWord));
-/* Swing to the left. Warning: no balance maintainance. */
+/* Swing to the left. Warning: no balance maintenance. */
static void avl_swl ( AvlNode** root )
{
AvlNode* a = *root;
b->child[0] = a;
}
-/* Swing to the right. Warning: no balance maintainance. */
+/* Swing to the right. Warning: no balance maintenance. */
static void avl_swr ( AvlNode** root )
{
AvlNode* a = *root;
b->child[1] = a;
}
-/* Balance maintainance after especially nasty swings. */
+/* Balance maintenance after especially nasty swings. */
static void avl_nasty ( AvlNode* root )
{
switch (root->balance) {
/* True if some FPO information is loaded.
It is useless to call VG_(use_FPO_info) if this returns False.
- Note that the return value should preferrably be cached in
+ Note that the return value should preferably be cached in
the stack unwind code, and re-queried when the debug info generation
changes. */
extern Bool VG_(FPO_info_present)(void);
} VgdbShared64;
// The below typedef makes the life of valgrind easier.
-// vgdb must however work explicitely with the specific 32 or 64 bits version.
+// vgdb must however work explicitly with the specific 32 or 64 bits version.
#if VEX_HOST_WORDSIZE == 8
typedef VgdbShared64 VgdbShared;
#include "config.h" // Crucial: ensure we get ENABLE_INNER
#include "pub_tool_libcproc.h"
-/* The directory we look for all our auxillary files in. Useful for
+/* The directory we look for all our auxiliary files in. Useful for
running Valgrind out of a build tree without having to do "make
install". Inner valgrinds require a different lib variable, else
they end up picking up .so's etc intended for the outer
#define MIN_N_SECTORS 2
#define MAX_N_SECTORS 24
-/* Default for the nr of sectors, if not overriden by command line.
+/* Default for the nr of sectors, if not overridden by command line.
On Android, space is limited, so try to get by with fewer sectors.
On other platforms we can go to town. 16 sectors gives theoretical
capacity of about 440MB of JITted code in 1.05 million translations
if (!pid_found && pid) {
/* No threads are live. Process is busy stopping.
- We need to detach from pid explicitely. */
+ We need to detach from pid explicitly. */
DEBUG(1, "no thread live => PTRACE_DETACH pid %d\n", pid);
res = ptrace (PTRACE_DETACH, pid, NULL, NULL);
if (res != 0)
write_buf(to_pid, hexcommand, strlen(hexcommand),
"writing hex command to pid", /* notify */ True);
- /* we exit of the below loop explicitely when the command has
+ /* we exit of the below loop explicitly when the command has
been handled or because a signal handler will set
shutting_down. */
while (!shutting_down) {
using native Darwin semaphores.
Because the pipe-based semaphore intensively uses sys_read/sys_write,
-it is not surprising that it inadvertantly was eating up cancellation
+it is not surprising that it inadvertently was eating up cancellation
requests directed to client threads. With abovementioned change in
force the pipe-based semaphore appears to work correctly.
instruction must be discarded to have the SB re-instrumented for gdbserver.
At least at this moment (r2155/r11786), the extents for ARM/thumb blocks
contains addresses with the thumb bit set. It is not clear that this is
- a good thing: extents should preferrably reference the real address range of
- instructions, not an adress range which can be "off by one" due to the
+ a good thing: extents should preferably reference the real address range of
+ instructions, not an address range which can be "off by one" due to the
fact that the instruction is a thumb instruction.
Due to this "off by one", gdbserver is discarding a range of two bytes
* use the debug info : this solution was discarded as often debug
info does not allow a 100% correct solution. debug info is acceptable
for vg.translate (which is only for internal valgrind debugging),
- but is better not used for 'end user functionnality'.
+ but is better not used for 'end user functionality'.
* Derive the thumb bit for a SB from the extent address.
This was discarded as this implies that an SB cannot mix thumb
and ARM code. This implied to disable chasing at transition between
* the launcher, valgrind.c
* all the architecture-independent regression tests
* the performance tests
-* optionally, auxilary programs like hp2ps and valgrind-listener
+* optionally, auxiliary programs like hp2ps and valgrind-listener
In order to do that, we need to know what flags to use to build for
the primary target, and in particular whether to hand -m32 or -m64 to
This leads to the final complication: building the regression tests.
Most of them are architecture-neutral and so should be built for the
primary target. The /test/ Makefile.am's duly include
-AM_FLAG_M3264_PRI in the compilation invokations, and you should
+AM_FLAG_M3264_PRI in the compilation invocations, and you should
ensure you preserve that when adding more tests.
However, there are some arch-specific test directories (eg,
Redirection mechanism
~~~~~~~~~~~~~~~~~~~~~
How this works is difficult to understand. This should be fixed. The
-list of unresolved redirections should be a seperate data structure
+list of unresolved redirections should be a separate data structure
from the currently active (addr, addr) mapping.
There's a whole big #ifdef TEST section in vg_symtab2.c which has
Segments describe memory mapped into the address space, and so any
address-space chaging operation needs to update the Segment structure.
-After the process is initalized, this means one of:
+After the process is initialized, this means one of:
* mmap
* munmap
If the signal reason is not related to an address, the tag is omitted.
* STACK is defined above and shows where the thread was when it
- catched the signal. When sending the signal to itself using raise,
+ caught the signal. When sending the signal to itself using raise,
then raise is visible in this stack.
memcheck leak search can be requested from the client program
using VALGRIND_DO_LEAK_CHECK or via the monitor command "leak_search".
Note that the syntax of the command string is only verified at
- run-time. So, if it exists, it is preferrable to use a specific
+ run-time. So, if it exists, it is preferable to use a specific
client request to have better compile time verifications of the
arguments.
</para>
</listitem>
<listitem>
- <para><varname>v.info exectxt</varname> shows informations about
+ <para><varname>v.info exectxt</varname> shows information about
the "executable contexts" (i.e. the stack traces) recorded by
Valgrind. For some programs, Valgrind can record a very high
number of such stack traces, causing a high memory usage. This
knowledge of the glibc stack cache implementation and by
examining the debug information of the pthread
library. This technique is thus somewhat fragile and might
- not work for all glibc versions. This has been succesfully
+ not work for all glibc versions. This has been successfully
tested with various glibc versions (e.g. 2.11, 2.16, 2.18)
on various platforms.</para>
</listitem>
|| (VG_USERREQ__GDB_MONITOR_COMMAND == arg[0]
&& vg_tid == VG_INVALID_THREADID));
/* Check the consistency of vg_tid and drd_tid, unless
- vgdb has forced the invokation of a gdb monitor cmd
+ vgdb has forced the invocation of a gdb monitor cmd
when no threads was running (i.e. all threads blocked
in a syscall. In such a case, vg_tid is invalid,
its conversion to a drd thread id gives also an invalid
* a corresponding OS thread that is detached.
*/
Bool detached_posix_thread;
- /** Wether recording of memory load accesses is currently enabled. */
+ /** Whether recording of memory load accesses is currently enabled. */
Bool is_recording_loads;
- /** Wether recording of memory load accesses is currently enabled. */
+ /** Whether recording of memory load accesses is currently enabled. */
Bool is_recording_stores;
/** pthread_create() nesting level. */
Int pthread_create_nesting_level;
* - whether or not the smart pointer objects are shared over threads.
* - whether or not the smart pointer object itself is thread-safe.
*
- * Most smart pointer implemenations are not thread-safe
+ * Most smart pointer implementations are not thread-safe
* (e.g. boost::shared_ptr<>, tr1::shared_ptr<> and the smart_ptr<>
* implementation below). This means that it is not safe to modify a shared
* pointer object that is shared over threads without proper synchronization.
</variablelist>
<para>One important point to note is that each allocation stack counts
-as a seperate allocation point. Because stacks by default have 12
+as a separate allocation point. Because stacks by default have 12
frames, this tends to spread data out over multiple allocation points.
You may want to use the flag --num-callers=4 or some such small
number, to reduce the spreading.</para>
$dir/filter_gdb |
# Filter the number of real-time signal SIGRTMIN which
-# varies accross systems.
+# varies across systems.
sed 's/Program received signal SIG[0-9]*, Real-time event [0-9]*./Program received signal SIGxx, Real-time event xx./'
# We detect this two ways:
# the gdb output will not contain the signal handling
# faultstatus C code will report a failure for the signal not passed
-# (i.e. SIGBUG, Test 3). Other tests will be succesful, because signals
+# (i.e. SIGBUG, Test 3). Other tests will be successful, because signals
# are eventually passed.
prereq: test -e gdb
prog: ../none/tests/faultstatus
# reproduces a bug triggered by translation chaining and gdbserver
-# invalidation due to breakpoint, when there is a jump from a tranlation
+# invalidation due to breakpoint, when there is a jump from a translation
# block into itself.
prog: self_invalidate
vgopts: --tool=none --vgdb=yes --vgdb-error=0 --vgdb-prefix=./vgdb-prefix-nlself_invalidate
# send_signal sends signal $1 to the Valgrind process using prefix $2 in $3 seconds
# If there are some args after $3, the rest of these args is a command and its arg
-# which is run every second. When this command is succesful, then the sleep and
+# which is run every second. When this command is successful, then the sleep and
# the signal sending is done
SIG=$1
shift
# simulate control_c by sending SIGUSR1 to the vgdb using prefix $1 in $2 seconds
# If there are some args after $2, the rest of these args is a command and its arg
-# which is run every second. When this command is succesful, then the sleep and
+# which is run every second. When this command is successful, then the sleep and
# the control c simul is done.
PREFIX=$1
shift
the same thing implicitly. This is necessary because for example
Solaris libc caches many objects and reuses them for different threads
and that confuses Helgrind. With libvki it would be possible to
- explictly use VG_USERREQ__HG_CLEAN_MEMORY on such objects.
+ explicitly use VG_USERREQ__HG_CLEAN_MEMORY on such objects.
Also mutex activity is ignored so that they do not impose false
ordering between creator and created thread. */
Int pthread_create_nesting_level;
The common case is that some thread T holds (eg) L1 L2 and L3 and
is repeatedly acquiring and releasing Ln, and there is no ordering
- error in what it is doing. Hence it repeatly:
+ error in what it is doing. Hence it repeatedly:
(1) searches laog to see if Ln --*--> {L1,L2,L3}, which always
produces the answer No (because there is no error).
// blocks and Arena blocks.
// alloc_tinfo identifies the thread that has allocated the block.
// This is used by tools such as helgrind that maintain
- // more detailed informations about client blocks.
+ // more detailed information about client blocks.
struct {
BlockKind block_kind;
const HChar* block_desc; // "block","mempool","user-defined",arena
}
static inline Bool sr_EQ ( UInt sysno, SysRes sr1, SysRes sr2 ) {
/* This uglyness of hardcoding syscall numbers is necessary to
- avoid having this header file be dependant on
+ avoid having this header file be dependent on
include/vki/vki-scnums-mips{32,64}-linux.h. It seems pretty
safe given that it is inconceivable that the syscall numbers
for such simple syscalls would ever change. To make it
// Apply a function to every element in the StackTrace. The parameter
// 'n' gives the index of the passed ip. 'opaque' is an arbitrary
-// pointer provided to each invokation of 'action' (a poor man's
+// pointer provided to each invocation of 'action' (a poor man's
// closure). Doesn't go below main() unless --show-below-main=yes is
// set.
extern void VG_(apply_StackTrace)(
* SIGBUS si_codes
*/
#define VKI_BUS_ADRALN (__VKI_SI_FAULT|1) /* invalid address alignment */
-#define VKI_BUS_ADRERR (__VKI_SI_FAULT|2) /* non-existant physical address */
+#define VKI_BUS_ADRERR (__VKI_SI_FAULT|2) /* non-existent physical address */
#define VKI_BUS_OBJERR (__VKI_SI_FAULT|3) /* object specific hardware error */
/*
#define VKI_SIOCSIWPOWER 0x8B2C /* set Power Management settings */
#define VKI_SIOCGIWPOWER 0x8B2D /* get Power Management settings */
-/* WPA : Generic IEEE 802.11 informatiom element (e.g., for WPA/RSN/WMM). */
+/* WPA : Generic IEEE 802.11 information element (e.g., for WPA/RSN/WMM). */
#define VKI_SIOCSIWGENIE 0x8B30 /* set generic IE */
#define VKI_SIOCGIWGENIE 0x8B31 /* get generic IE */
__vki_s32 value; /* The value of the parameter itself */
__vki_u8 fixed; /* Hardware should not use auto select */
__vki_u8 disabled; /* Disable the feature */
- __vki_u16 flags; /* Various specifc flags (if any) */
+ __vki_u16 flags; /* Various specific flags (if any) */
};
struct vki_iw_point
#error Unsupported repcache protocol version
#endif
-/* The following definitions are currently stable accross all repcache protocol
+/* The following definitions are currently stable across all repcache protocol
versions. If there is any change to them, they need to be versioned
properly so that Valgrind works on older versions. */
#define VKI_F_GETXFL F_GETXFL
#define VKI_F_SETFL F_SETFL
-/* SVR3 rfs compability const, declared only if _KERNEL or _KMEMUSER is
+/* SVR3 rfs compatibility const, declared only if _KERNEL or _KMEMUSER is
defined. */
#if 0
#define VKI_F_O_GETLK F_O_GETLK
/* Signal handler runs with the signal masked.
Unmask the handled signal before longjmp-ing or return-ing.
Note that during leak search, we expect only SIGSEGV or SIGBUS
- and we do not expect another occurence until we longjmp-ed!return-ed
+ and we do not expect another occurrence until we longjmp-ed!return-ed
to resume the leak search. So, it is safe to unmask the signal
here. */
/* First get current mask (by passing NULL as first arg) */
// As for the portability of all this:
//
// sbrk and brk are not POSIX. However, any system that is a derivative
- // of *nix has sbrk and brk because there are too many softwares (such as
+ // of *nix has sbrk and brk because there are too many software (such as
// the Bourne shell) which rely on the traditional memory map (.text,
// .data+.bss, stack) and the existence of sbrk/brk.
//
static __attribute__((noinline))
void vector_copy ( void* dst, void* src )
{
- /* Note: Verions of GCC through 4.8.1 do not allow "ymm7" in the
+ /* Note: Versions of GCC through 4.8.1 do not allow "ymm7" in the
clobber list. (See http://stackoverflow.com/a/15767111/768469).
Simulate it with "xmm7". */
__asm__ __volatile__(
// if the superblock is used to provide a big aligned block
// (see bug 250101, comment #14).
// Valgrind m_mallocfree.c will allocate a big superblock for the memalign
- // call and will split it in two. This splitted superblock was
+ // call and will split it in two. This split superblock was
// wrongly marked as reclaimable, which was then causing
- // assert failures (as reclaimable blocks cannot be splitted).
+ // assert failures (as reclaimable blocks cannot be split).
p = memalign(1024 * 1024, 4 * 1024 * 1024 + 1); assert(0 == (long)p % (1024 * 1024));
// We allocate (and then free) a piece of memory smaller than
// the hole created in the big superblock.
prog: new_override
# Don't override the user defined somalloc functions in this test.
# The test depends on some side effects and initializing memory done by
-# the user overidden operator new.
+# the user overridden operator new.
vgopts: --soname-synonyms=somalloc=nouseroverride
stderr_filter: filter_allocs
# this test the case of two errors, one considered not dangerous and
# suppressed, the other considered dangerous, and the user does
-# not want to supress it.
+# not want to suppress it.
# The suppression entry only match the non dangerous error.
# However, when a medium resolution is used to compare 2 errors,
# only the last 4 calls are used to determine that two errors are similar
assert( v1_num_bits == v2_num_bits);
/* Comparison only produces 32-bit or 64-bit value where
- * the lower 3 bits are set to indicate, less than, equal and greater then.
+ * the lower 3 bits are set to indicate, less than, equal and greater than.
*/
switch (v1_num_bits) {
case 32:
# We replace the last 5 numbers to allow for a wide range of possible times.
# It's not a great test, but it will catch some breakage (eg. if the times
# don't start near 0, as happened in bug 200990, or if the space following
-# the time is omitted, as happend in r10465).
+# the time is omitted, as happened in r10465).
#
perl -p -e "s/^00:00:00:\d\d\.\d\d\d $/00:00:00:XX:YYY/"
#elif __BYTE_ORDER == __BIG_ENDIAN
return VexEndnessBE;
#else
- fprintf(stderr, "cannot determine endianess\n");
+ fprintf(stderr, "cannot determine endianness\n");
exit(1);
#endif
}
case VexArchMIPS64:
/* mips32/64 supports BE or LE, but at compile time.
If mips64 is compiled on a non mips system, the VEX lib
- is missing bit and pieces of code related to endianess.
+ is missing bit and pieces of code related to endianness.
The mandatory code for this test is then compiled as BE.
So, if this test runs on a mips system, returns the
- running endianess. Otherwise, returns BE as this one
+ running endianness. Otherwise, returns BE as this one
has the more chances to work. */
{
VexArch ga;
// endness(host) != endness(guest) (not well supported)
// wordsize (host) != wordsize (guest) (not well supported)
// The not well supported combinations are not run, unless requested
- // explicitely via command line arguments.
+ // explicitly via command line arguments.
if (multiarch) {
VexArch va;
for (va = VexArchX86; va <= VexArchTILEGX; va++) {
* I always get the result in r17 and also save XER and CCR for fixed-point
* operations. I also check FPSCR for floating points operations.
*
- * Improvments:
+ * Improvements:
* a more clever FPSCR management is needed: for now, I always test
* the round-to-zero case. Other rounding modes also need to be tested.
*/
* }
*
*
- * Details of intruction patching for immediate operands
+ * Details of instruction patching for immediate operands
* -----------------------------------------------------
* All the immediate insn test functions are of the form {imm_insn, blr}
* In order to patch one of these functions, we simply copy both insns
/* Power ISA 2.03 support dcbtct and dcbtstct with valid hint values b00000 - 0b00111.
* The ISA 2.06 added support for more valid hint values, but rather than tie ourselves
- * in knots trying to test all permuations of ISAs and valid hint values, we'll just
+ * in knots trying to test all permutations of ISAs and valid hint values, we'll just
* verify some of the base hint values from ISA 2.03.
*
* In a similar vein, in ISA 2.03, dcbtds had valid values of 0b01000 - 0b01010, whereas
suppressing. That means that the program check old psw will point to
the instruction after the illegal one (according to the calculated length).
There are some programs out there that use this mechanism to detect available
-intruction (sigh).
+instruction (sigh).
This patch checks, that valgrind makes forard progress. */
#include <signal.h>
#include <stdio.h>
expected final value for x is -2 + 1 + 1 = 0.
If instead the shift clears CC_NDEP (as it would legally do if
- the shift amount were non-zero), this will be interpeted as
+ the shift amount were non-zero), this will be interpreted as
clearing the carry bit, so the adc will be a no-op and the final
value of %x will instead be -1.
*/
static int nr_thr; // nr of threads (hardcoded to 1 currently)
static int nr_repeat; // nr of times we will allocate, use, then free total+ws
-// Note: the total nr of MB is what is explicitely allocated.
+// Note: the total nr of MB is what is explicitly allocated.
// On top of that, we have the stacks, local vars, lib vars, ...
// The working set is just the first nr_b_ws blocks of nr_b.
static int ch, tok;
static CValue tokc;
static CString tokcstr; /* current parsed string, if any */
-/* additional informations about token */
+/* additional information about token */
static int tok_flags;
#define TOK_FLAG_BOL 0x0001 /* beginning of line before */
#define TOK_FLAG_BOF 0x0002 /* beginning of file before */
Section *plt;
unsigned long *got_offsets;
int nb_got_offsets;
- /* give the correspondance from symtab indexes to dynsym indexes */
+ /* give the correspondence from symtab indexes to dynsym indexes */
int *symtab_to_dynsym;
/* temporary dynamic symbol sections (for dll loading) */
#define MAX_ASM_OPERANDS 30
typedef struct ASMOperand {
- int id; /* GCC 3 optionnal identifier (0 if number only supported */
+ int id; /* GCC 3 optional identifier (0 if number only supported */
char *constraint;
char asm_str[16]; /* computed asm string for operand */
SValue *vt; /* C value of the expression */
c = (int)vtop->c.i;
/* constant: simpler */
/* NOTE: all comments are for SHL. the other cases are
- done by swaping words */
+ done by swapping words */
vpop();
if (op != TOK_SHL)
vswap();
goto type_ok;
}
type1 = pointed_type(dt);
- /* a function is implicitely a function pointer */
+ /* a function is implicitly a function pointer */
if (sbt == VT_FUNC) {
if ((type1->t & VT_BTYPE) != VT_VOID &&
!is_compatible_types(pointed_type(dt), st))
}
/* put a got entry corresponding to a symbol in symtab_section. 'size'
- and 'info' can be modifed if more precise info comes from the DLL */
+ and 'info' can be modified if more precise info comes from the DLL */
static void put_got_entry(TCCState *s1,
int reloc_type, unsigned long size, int info,
int sym_index)
}
}
- /* if interpreter, then add corresponing program header */
+ /* if interpreter, then add corresponding program header */
if (interp) {
ph = &phdr[0];
ph->p_align = interp->sh_addralign;
}
- /* if dynamic section, then add corresponing program header */
+ /* if dynamic section, then add corresponding program header */
if (dynamic) {
Elf32_Sym *sym_end;
projects / thirdparty / valgrind.git / commitdiff
