diff --git a/Makefile.tool-tests.am b/Makefile.tool-tests.am index 59c3b4202..b27724fbb 100644 --- a/Makefile.tool-tests.am +++ b/Makefile.tool-tests.am @@ -28,7 +28,7 @@ AM_CCASFLAGS = $(AM_CPPFLAGS) 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 diff --git a/NEWS b/NEWS index 286ac60b8..153ec4d53 100644 --- a/NEWS +++ b/NEWS @@ -134,6 +134,7 @@ where XXXXXX is the bug number as listed below. == 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)() diff --git a/README.solaris b/README.solaris index 6a52a5b5e..b9b122dac 100644 --- a/README.solaris +++ b/README.solaris @@ -11,7 +11,7 @@ Requirements - 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: diff --git a/README_MISSING_SYSCALL_OR_IOCTL b/README_MISSING_SYSCALL_OR_IOCTL index ab78902f2..24af45bf4 100644 --- a/README_MISSING_SYSCALL_OR_IOCTL +++ b/README_MISSING_SYSCALL_OR_IOCTL @@ -140,7 +140,7 @@ following: 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. diff --git a/cachegrind/cg_main.c b/cachegrind/cg_main.c index 26fef5131..5d44667f0 100644 --- a/cachegrind/cg_main.c +++ b/cachegrind/cg_main.c @@ -294,7 +294,7 @@ static LineCC* get_lineCC(Addr origAddr) * 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 diff --git a/cachegrind/cg_merge.c b/cachegrind/cg_merge.c index 13df3824b..b53cbe4c8 100644 --- a/cachegrind/cg_merge.c +++ b/cachegrind/cg_merge.c @@ -12,7 +12,7 @@ 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 @@ -1006,7 +1006,7 @@ struct _WordFM { /* 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; @@ -1016,7 +1016,7 @@ static void avl_swl ( AvlNode** 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; @@ -1026,7 +1026,7 @@ static void avl_swr ( AvlNode** 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) { diff --git a/callgrind/callgrind.h b/callgrind/callgrind.h index 35f3868c7..f078cc82b 100644 --- a/callgrind/callgrind.h +++ b/callgrind/callgrind.h @@ -109,7 +109,7 @@ typedef /* 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, \ diff --git a/callgrind/docs/cl-manual.xml b/callgrind/docs/cl-manual.xml index b5841aa05..a5f8c4b92 100644 --- a/callgrind/docs/cl-manual.xml +++ b/callgrind/docs/cl-manual.xml @@ -316,7 +316,7 @@ callgrind.out.pid.part-threa 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, @@ -432,7 +432,7 @@ callgrind.out.pid.part-threa 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 Cycle 1. Now, when a program exposes really big cycles (as is @@ -1194,7 +1194,7 @@ their arguments. 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 . diff --git a/callgrind/fn.c b/callgrind/fn.c index 157bb307b..d4c7b24c1 100644 --- a/callgrind/fn.c +++ b/callgrind/fn.c @@ -110,7 +110,7 @@ static Bool check_code(obj_node* obj, /* _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. * diff --git a/callgrind/global.h b/callgrind/global.h index dd3cdc4a2..7c5a59ce9 100644 --- a/callgrind/global.h +++ b/callgrind/global.h @@ -347,7 +347,7 @@ struct _JmpData { * 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 diff --git a/callgrind/main.c b/callgrind/main.c index 4c2476578..ab4927296 100644 --- a/callgrind/main.c +++ b/callgrind/main.c @@ -1998,13 +1998,13 @@ void CLG_(post_clo_init)(void) 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"); @@ -2057,8 +2057,8 @@ void CLG_(pre_clo_init)(void) = 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), diff --git a/configure.ac b/configure.ac index 26da68161..69d3bf646 100644 --- a/configure.ac +++ b/configure.ac @@ -192,10 +192,10 @@ AC_MSG_CHECKING([for a supported CPU]) # 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. @@ -2231,7 +2231,7 @@ AC_LINK_IFELSE( 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 diff --git a/coregrind/launcher-darwin.c b/coregrind/launcher-darwin.c index d458f08b0..5097b5894 100644 --- a/coregrind/launcher-darwin.c +++ b/coregrind/launcher-darwin.c @@ -357,7 +357,7 @@ int main(int argc, char** argv, char** envp) /* 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 */ @@ -410,7 +410,7 @@ int main(int argc, char** argv, char** envp) } 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)); diff --git a/coregrind/link_tool_exe_darwin.in b/coregrind/link_tool_exe_darwin.in index d0e3c3ec3..c11995414 100644 --- a/coregrind/link_tool_exe_darwin.in +++ b/coregrind/link_tool_exe_darwin.in @@ -19,7 +19,7 @@ # 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 @@ -30,7 +30,7 @@ # # 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: # @@ -65,7 +65,7 @@ # 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; diff --git a/coregrind/link_tool_exe_linux.in b/coregrind/link_tool_exe_linux.in index 521442031..9d4c90f83 100644 --- a/coregrind/link_tool_exe_linux.in +++ b/coregrind/link_tool_exe_linux.in @@ -19,7 +19,7 @@ # 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 diff --git a/coregrind/link_tool_exe_solaris.in b/coregrind/link_tool_exe_solaris.in index 795220fd8..f490e2203 100644 --- a/coregrind/link_tool_exe_solaris.in +++ b/coregrind/link_tool_exe_solaris.in @@ -31,7 +31,7 @@ my $ala = $ARGV[0]; 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 ..] diff --git a/coregrind/m_addrinfo.c b/coregrind/m_addrinfo.c index d56e1e602..c3edc13b6 100644 --- a/coregrind/m_addrinfo.c +++ b/coregrind/m_addrinfo.c @@ -222,7 +222,7 @@ void VG_(describe_addr) ( Addr a, /*OUT*/AddrInfo* ai ) 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); diff --git a/coregrind/m_aspacemgr/aspacemgr-linux.c b/coregrind/m_aspacemgr/aspacemgr-linux.c index b202d9479..7b141fabc 100644 --- a/coregrind/m_aspacemgr/aspacemgr-linux.c +++ b/coregrind/m_aspacemgr/aspacemgr-linux.c @@ -260,7 +260,7 @@ 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 @@ -1861,7 +1861,7 @@ Addr VG_(am_get_advisory) ( const MapRequest* req, 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 @@ -1869,7 +1869,7 @@ Addr VG_(am_get_advisory) ( const MapRequest* req, 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 diff --git a/coregrind/m_commandline.c b/coregrind/m_commandline.c index 3e1ce1a8a..9f5fff30e 100644 --- a/coregrind/m_commandline.c +++ b/coregrind/m_commandline.c @@ -123,7 +123,7 @@ static void add_args_from_string ( HChar* s ) 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 diff --git a/coregrind/m_coredump/coredump-solaris.c b/coregrind/m_coredump/coredump-solaris.c index cd5ac7d48..0539a8438 100644 --- a/coregrind/m_coredump/coredump-solaris.c +++ b/coregrind/m_coredump/coredump-solaris.c @@ -682,7 +682,7 @@ static vki_prpriv_t *create_prpriv(SizeT *size) 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, diff --git a/coregrind/m_debuginfo/priv_storage.h b/coregrind/m_debuginfo/priv_storage.h index 9f430894c..b4431ddd8 100644 --- a/coregrind/m_debuginfo/priv_storage.h +++ b/coregrind/m_debuginfo/priv_storage.h @@ -913,7 +913,7 @@ struct _DebugInfo { 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 diff --git a/coregrind/m_debuginfo/readdwarf.c b/coregrind/m_debuginfo/readdwarf.c index 32a363313..31585272c 100644 --- a/coregrind/m_debuginfo/readdwarf.c +++ b/coregrind/m_debuginfo/readdwarf.c @@ -853,7 +853,7 @@ void read_unitinfo_dwarf2( /*OUT*/UnitInfo* ui, 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 ); @@ -1899,7 +1899,7 @@ typedef 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; diff --git a/coregrind/m_debuginfo/readelf.c b/coregrind/m_debuginfo/readelf.c index 8c34d9e88..91e6d5258 100644 --- a/coregrind/m_debuginfo/readelf.c +++ b/coregrind/m_debuginfo/readelf.c @@ -524,7 +524,7 @@ Bool get_elf_symbol_info ( 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 diff --git a/coregrind/m_debuginfo/storage.c b/coregrind/m_debuginfo/storage.c index f3fd845ca..680abed52 100644 --- a/coregrind/m_debuginfo/storage.c +++ b/coregrind/m_debuginfo/storage.c @@ -1713,7 +1713,7 @@ static void canonicaliseSymtab ( struct _DebugInfo* di ) 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 { diff --git a/coregrind/m_demangle/ansidecl.h b/coregrind/m_demangle/ansidecl.h index 6c0c837bf..3822be0cb 100644 --- a/coregrind/m_demangle/ansidecl.h +++ b/coregrind/m_demangle/ansidecl.h @@ -1,4 +1,4 @@ -/* 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. diff --git a/coregrind/m_demangle/cplus-dem.c b/coregrind/m_demangle/cplus-dem.c index 9cdf40ba9..cf16f381d 100644 --- a/coregrind/m_demangle/cplus-dem.c +++ b/coregrind/m_demangle/cplus-dem.c @@ -983,7 +983,7 @@ ada_demangle (const char *mangled, int option ATTRIBUTE_UNUSED) 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. */ @@ -2004,7 +2004,7 @@ demangle_integral_value (struct work_stuff *work, 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 diff --git a/coregrind/m_demangle/safe-ctype.h b/coregrind/m_demangle/safe-ctype.h index 472c89782..66c8fe9d3 100644 --- a/coregrind/m_demangle/safe-ctype.h +++ b/coregrind/m_demangle/safe-ctype.h @@ -112,7 +112,7 @@ extern const unsigned char _sch_tolower[256]; #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 diff --git a/coregrind/m_gdbserver/README_DEVELOPERS b/coregrind/m_gdbserver/README_DEVELOPERS index eeba3f8b5..03eb76a45 100644 --- a/coregrind/m_gdbserver/README_DEVELOPERS +++ b/coregrind/m_gdbserver/README_DEVELOPERS @@ -113,7 +113,7 @@ to use --vgdb=full. This is because the error is detected by memcheck 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 diff --git a/coregrind/m_gdbserver/m_gdbserver.c b/coregrind/m_gdbserver/m_gdbserver.c index 9be02c17b..87fbce205 100644 --- a/coregrind/m_gdbserver/m_gdbserver.c +++ b/coregrind/m_gdbserver/m_gdbserver.c @@ -811,7 +811,7 @@ static int interrupts_non_interruptible = 0; /* 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. diff --git a/coregrind/m_gdbserver/signals.c b/coregrind/m_gdbserver/signals.c index a9128a6ea..ff5bfafb7 100644 --- a/coregrind/m_gdbserver/signals.c +++ b/coregrind/m_gdbserver/signals.c @@ -486,7 +486,7 @@ enum target_signal target_signal_from_host (int hostsig) } /* 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. */ diff --git a/coregrind/m_libcproc.c b/coregrind/m_libcproc.c index 5d2e1295d..49eb693b1 100644 --- a/coregrind/m_libcproc.c +++ b/coregrind/m_libcproc.c @@ -951,7 +951,7 @@ Int VG_(gettimeofday)(struct vki_timeval *tv, struct vki_timezone *tz) 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 }; diff --git a/coregrind/m_libcsignal.c b/coregrind/m_libcsignal.c index 46dc303e4..d5e5f4fd3 100644 --- a/coregrind/m_libcsignal.c +++ b/coregrind/m_libcsignal.c @@ -275,7 +275,7 @@ Int VG_(sigaction) ( Int signum, 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). diff --git a/coregrind/m_mallocfree.c b/coregrind/m_mallocfree.c index 8f1fa4773..968832131 100644 --- a/coregrind/m_mallocfree.c +++ b/coregrind/m_mallocfree.c @@ -154,7 +154,7 @@ typedef // 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. @@ -198,7 +198,7 @@ typedef 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) @@ -550,7 +550,7 @@ static ArenaId arenaP_to_ArenaId ( Arena *a ) } // 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, @@ -1859,7 +1859,7 @@ void* VG_(arena_malloc) ( ArenaId aid, const HChar* cc, SizeT req_pszB ) 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)) { @@ -2002,7 +2002,7 @@ void deferred_reclaimSuperblock ( Arena* a, Superblock* sb) /* 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, @@ -2248,7 +2248,7 @@ void* VG_(arena_memalign) ( ArenaId aid, const HChar* cc, { /* 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; diff --git a/coregrind/m_oset.c b/coregrind/m_oset.c index 24d325a66..5912134cf 100644 --- a/coregrind/m_oset.c +++ b/coregrind/m_oset.c @@ -31,7 +31,7 @@ //---------------------------------------------------------------------- // 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 //---------------------------------------------------------------------- @@ -200,7 +200,7 @@ inline Word slow_cmp(const AvlTree* t, const void* k, const AvlNode* n) } -// 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; @@ -210,7 +210,7 @@ static void avl_swl ( AvlNode** 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; @@ -220,7 +220,7 @@ static void avl_swr ( AvlNode** 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) { diff --git a/coregrind/m_syswrap/syswrap-darwin.c b/coregrind/m_syswrap/syswrap-darwin.c index 27ca2ef0c..f2199201f 100644 --- a/coregrind/m_syswrap/syswrap-darwin.c +++ b/coregrind/m_syswrap/syswrap-darwin.c @@ -4031,7 +4031,7 @@ PRE(getdirentries64) } 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) diff --git a/coregrind/m_syswrap/syswrap-solaris.c b/coregrind/m_syswrap/syswrap-solaris.c index 903a1e2ea..49cf933a0 100644 --- a/coregrind/m_syswrap/syswrap-solaris.c +++ b/coregrind/m_syswrap/syswrap-solaris.c @@ -5301,7 +5301,7 @@ PRE(sys_sigresend) 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. */ diff --git a/coregrind/m_syswrap/syswrap-xen.c b/coregrind/m_syswrap/syswrap-xen.c index 20341c4a6..05e0dbdb5 100644 --- a/coregrind/m_syswrap/syswrap-xen.c +++ b/coregrind/m_syswrap/syswrap-xen.c @@ -1986,7 +1986,7 @@ POST(hvm_op) 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: diff --git a/coregrind/m_trampoline.S b/coregrind/m_trampoline.S index 639656d4b..ebe20a8b8 100644 --- a/coregrind/m_trampoline.S +++ b/coregrind/m_trampoline.S @@ -1217,7 +1217,7 @@ VG_(s390x_linux_SUBST_FOR_rt_sigreturn): .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 diff --git a/coregrind/m_ume/elf.c b/coregrind/m_ume/elf.c index 0d3125459..21eb52bcb 100644 --- a/coregrind/m_ume/elf.c +++ b/coregrind/m_ume/elf.c @@ -578,7 +578,7 @@ Int VG_(load_ELF)(Int fd, const HChar* name, /*MOD*/ExeInfo* info) /* 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) diff --git a/coregrind/m_wordfm.c b/coregrind/m_wordfm.c index 4dfa170ea..323ac57f3 100644 --- a/coregrind/m_wordfm.c +++ b/coregrind/m_wordfm.c @@ -93,7 +93,7 @@ struct _WordFM { /* 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; @@ -103,7 +103,7 @@ static void avl_swl ( AvlNode** 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; @@ -113,7 +113,7 @@ static void avl_swr ( AvlNode** 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) { diff --git a/coregrind/pub_core_debuginfo.h b/coregrind/pub_core_debuginfo.h index 910551b5c..87486aa92 100644 --- a/coregrind/pub_core_debuginfo.h +++ b/coregrind/pub_core_debuginfo.h @@ -153,7 +153,7 @@ extern UInt VG_(debuginfo_generation) (void); /* 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); diff --git a/coregrind/pub_core_gdbserver.h b/coregrind/pub_core_gdbserver.h index 86ef869f2..ab9f755c9 100644 --- a/coregrind/pub_core_gdbserver.h +++ b/coregrind/pub_core_gdbserver.h @@ -230,7 +230,7 @@ typedef } 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; diff --git a/coregrind/pub_core_libcproc.h b/coregrind/pub_core_libcproc.h index 2a964a7d1..6ef5686ab 100644 --- a/coregrind/pub_core_libcproc.h +++ b/coregrind/pub_core_libcproc.h @@ -39,7 +39,7 @@ #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 diff --git a/coregrind/pub_core_transtab.h b/coregrind/pub_core_transtab.h index 1a2595f8d..62f2c5d23 100644 --- a/coregrind/pub_core_transtab.h +++ b/coregrind/pub_core_transtab.h @@ -68,7 +68,7 @@ extern void VG_(init_tt_tc) ( void ); #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 diff --git a/coregrind/vgdb-invoker-ptrace.c b/coregrind/vgdb-invoker-ptrace.c index d6d401050..5b804c05e 100644 --- a/coregrind/vgdb-invoker-ptrace.c +++ b/coregrind/vgdb-invoker-ptrace.c @@ -510,7 +510,7 @@ void detach_from_all_threads (pid_t pid) 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) diff --git a/coregrind/vgdb.c b/coregrind/vgdb.c index db607eaf7..12d2c7fae 100644 --- a/coregrind/vgdb.c +++ b/coregrind/vgdb.c @@ -1010,7 +1010,7 @@ void standalone_send_commands(int pid, 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) { diff --git a/docs/internals/Darwin-notes.txt b/docs/internals/Darwin-notes.txt index 85c9e8e48..8c320a35b 100644 --- a/docs/internals/Darwin-notes.txt +++ b/docs/internals/Darwin-notes.txt @@ -39,7 +39,7 @@ the entire Valgrind run mysteriously disappears, rather than spinning 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. diff --git a/docs/internals/arm_thumb_notes_gdbserver.txt b/docs/internals/arm_thumb_notes_gdbserver.txt index fc4028433..56ac68276 100644 --- a/docs/internals/arm_thumb_notes_gdbserver.txt +++ b/docs/internals/arm_thumb_notes_gdbserver.txt @@ -45,8 +45,8 @@ at several places in the gdbserver code. 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 @@ -77,7 +77,7 @@ at several places in the gdbserver code. * 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 diff --git a/docs/internals/multiple-architectures.txt b/docs/internals/multiple-architectures.txt index fee423fde..b0ddcfa38 100644 --- a/docs/internals/multiple-architectures.txt +++ b/docs/internals/multiple-architectures.txt @@ -129,7 +129,7 @@ for the primary architecture. These places are (at least): * 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 @@ -148,7 +148,7 @@ merely facilitates getting hold of it without the surrounding gunk. 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, diff --git a/docs/internals/notes.txt b/docs/internals/notes.txt index e15966ff9..5c7e7bceb 100644 --- a/docs/internals/notes.txt +++ b/docs/internals/notes.txt @@ -127,7 +127,7 @@ startup code, and should not be visible in generic core service code. 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 diff --git a/docs/internals/segments-seginfos.txt b/docs/internals/segments-seginfos.txt index c712e5c4a..fbf137cf2 100644 --- a/docs/internals/segments-seginfos.txt +++ b/docs/internals/segments-seginfos.txt @@ -9,7 +9,7 @@ the object file metadata (symbols, debug info, etc). 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 diff --git a/docs/internals/xml-output-protocol4.txt b/docs/internals/xml-output-protocol4.txt index 50828c0a1..65c055da8 100644 --- a/docs/internals/xml-output-protocol4.txt +++ b/docs/internals/xml-output-protocol4.txt @@ -791,5 +791,5 @@ Definition: 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. diff --git a/docs/xml/manual-core-adv.xml b/docs/xml/manual-core-adv.xml index 74d76ffce..d71b32483 100644 --- a/docs/xml/manual-core-adv.xml +++ b/docs/xml/manual-core-adv.xml @@ -233,7 +233,7 @@ tool-specific macros). 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. @@ -1448,7 +1448,7 @@ problems or bugs. - v.info exectxt shows informations about + v.info exectxt 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 diff --git a/docs/xml/manual-core.xml b/docs/xml/manual-core.xml index 627b7e3db..fb9512891 100644 --- a/docs/xml/manual-core.xml +++ b/docs/xml/manual-core.xml @@ -2115,7 +2115,7 @@ need to use them. 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. diff --git a/drd/drd_clientreq.c b/drd/drd_clientreq.c index f56e4ef53..ddce54eab 100644 --- a/drd/drd_clientreq.c +++ b/drd/drd_clientreq.c @@ -85,7 +85,7 @@ static Bool handle_client_request(ThreadId vg_tid, UWord* arg, UWord* ret) || (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 diff --git a/drd/drd_thread.h b/drd/drd_thread.h index 9e5bad760..b91caa924 100644 --- a/drd/drd_thread.h +++ b/drd/drd_thread.h @@ -88,9 +88,9 @@ typedef struct * 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; diff --git a/drd/tests/annotate_smart_pointer.cpp b/drd/tests/annotate_smart_pointer.cpp index 433430222..ccefc4735 100644 --- a/drd/tests/annotate_smart_pointer.cpp +++ b/drd/tests/annotate_smart_pointer.cpp @@ -7,7 +7,7 @@ * - 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. diff --git a/exp-dhat/docs/dh-manual.xml b/exp-dhat/docs/dh-manual.xml index 4836c398d..66b7c683c 100644 --- a/exp-dhat/docs/dh-manual.xml +++ b/exp-dhat/docs/dh-manual.xml @@ -389,7 +389,7 @@ to be the case, but it could happen. 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. diff --git a/gdbserver_tests/filter_passsigalrm b/gdbserver_tests/filter_passsigalrm index 6b86f381f..2a6719041 100755 --- a/gdbserver_tests/filter_passsigalrm +++ b/gdbserver_tests/filter_passsigalrm @@ -5,6 +5,6 @@ dir=`dirname $0` $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./' diff --git a/gdbserver_tests/mcsignopass.vgtest b/gdbserver_tests/mcsignopass.vgtest index 61992aab5..73def5e6b 100644 --- a/gdbserver_tests/mcsignopass.vgtest +++ b/gdbserver_tests/mcsignopass.vgtest @@ -2,7 +2,7 @@ # 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 diff --git a/gdbserver_tests/nlself_invalidate.vgtest b/gdbserver_tests/nlself_invalidate.vgtest index 3902538bc..203113035 100644 --- a/gdbserver_tests/nlself_invalidate.vgtest +++ b/gdbserver_tests/nlself_invalidate.vgtest @@ -1,5 +1,5 @@ # 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 diff --git a/gdbserver_tests/send_signal b/gdbserver_tests/send_signal index 3f4442f80..0657a7a6c 100755 --- a/gdbserver_tests/send_signal +++ b/gdbserver_tests/send_signal @@ -2,7 +2,7 @@ # 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 diff --git a/gdbserver_tests/simulate_control_c b/gdbserver_tests/simulate_control_c index d380d65cb..30428b2c3 100755 --- a/gdbserver_tests/simulate_control_c +++ b/gdbserver_tests/simulate_control_c @@ -2,7 +2,7 @@ # 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 diff --git a/helgrind/hg_lock_n_thread.h b/helgrind/hg_lock_n_thread.h index 8ee7dabba..30ee02b67 100644 --- a/helgrind/hg_lock_n_thread.h +++ b/helgrind/hg_lock_n_thread.h @@ -100,7 +100,7 @@ typedef 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; diff --git a/helgrind/hg_main.c b/helgrind/hg_main.c index e00f6dacb..5c302e56f 100644 --- a/helgrind/hg_main.c +++ b/helgrind/hg_main.c @@ -3459,7 +3459,7 @@ void evh__HG_RTLD_BIND_CLEAR(ThreadId tid, Int flags) 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). diff --git a/include/pub_tool_addrinfo.h b/include/pub_tool_addrinfo.h index 1650bd7eb..580887837 100644 --- a/include/pub_tool_addrinfo.h +++ b/include/pub_tool_addrinfo.h @@ -145,7 +145,7 @@ struct _AddrInfo { // 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 diff --git a/include/pub_tool_basics.h b/include/pub_tool_basics.h index 01772734f..f0c9b0036 100644 --- a/include/pub_tool_basics.h +++ b/include/pub_tool_basics.h @@ -242,7 +242,7 @@ static inline UWord sr_Err ( SysRes sr ) { } 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 diff --git a/include/pub_tool_stacktrace.h b/include/pub_tool_stacktrace.h index 33b4dbec4..c442d394d 100644 --- a/include/pub_tool_stacktrace.h +++ b/include/pub_tool_stacktrace.h @@ -66,7 +66,7 @@ extern UInt VG_(get_StackTrace) ( ThreadId tid, // 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)( diff --git a/include/vki/vki-linux.h b/include/vki/vki-linux.h index ab25f5bba..216194f44 100644 --- a/include/vki/vki-linux.h +++ b/include/vki/vki-linux.h @@ -527,7 +527,7 @@ typedef struct vki_siginfo { * 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 */ /* @@ -2794,7 +2794,7 @@ typedef vki_uint32_t vki_key_perm_t; #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 */ @@ -2821,7 +2821,7 @@ struct vki_iw_param __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 diff --git a/include/vki/vki-solaris-repcache.h b/include/vki/vki-solaris-repcache.h index b1557c9e0..57f031ee1 100644 --- a/include/vki/vki-solaris-repcache.h +++ b/include/vki/vki-solaris-repcache.h @@ -343,7 +343,7 @@ enum vki_rep_protocol_requestid { #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. */ diff --git a/include/vki/vki-solaris.h b/include/vki/vki-solaris.h index 13db6c052..5b7bb21c4 100644 --- a/include/vki/vki-solaris.h +++ b/include/vki/vki-solaris.h @@ -507,7 +507,7 @@ typedef struct vki_kcf_door_arg_s { #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 diff --git a/memcheck/mc_leakcheck.c b/memcheck/mc_leakcheck.c index 3505fde78..c026d27c2 100644 --- a/memcheck/mc_leakcheck.c +++ b/memcheck/mc_leakcheck.c @@ -714,7 +714,7 @@ void leak_search_fault_catcher ( Int sigNo, Addr addr, /* 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) */ diff --git a/memcheck/mc_main.c b/memcheck/mc_main.c index af83c2d7e..aff0b6140 100644 --- a/memcheck/mc_main.c +++ b/memcheck/mc_main.c @@ -7876,7 +7876,7 @@ static void mc_post_clo_init ( void ) // 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. // diff --git a/memcheck/tests/amd64/sh-mem-vec256.c b/memcheck/tests/amd64/sh-mem-vec256.c index 5a28e1579..d8eb5f141 100644 --- a/memcheck/tests/amd64/sh-mem-vec256.c +++ b/memcheck/tests/amd64/sh-mem-vec256.c @@ -8,7 +8,7 @@ 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__( diff --git a/memcheck/tests/memalign2.c b/memcheck/tests/memalign2.c index b35a70eaa..39069a6fb 100644 --- a/memcheck/tests/memalign2.c +++ b/memcheck/tests/memalign2.c @@ -36,9 +36,9 @@ int main ( void ) // 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. diff --git a/memcheck/tests/new_override.vgtest b/memcheck/tests/new_override.vgtest index 435e330f9..7febc1356 100644 --- a/memcheck/tests/new_override.vgtest +++ b/memcheck/tests/new_override.vgtest @@ -1,6 +1,6 @@ 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 diff --git a/memcheck/tests/suppfreecollision.vgtest b/memcheck/tests/suppfreecollision.vgtest index cda50aa7e..c2feebddf 100644 --- a/memcheck/tests/suppfreecollision.vgtest +++ b/memcheck/tests/suppfreecollision.vgtest @@ -1,6 +1,6 @@ # 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 diff --git a/memcheck/tests/vbit-test/vbits.c b/memcheck/tests/vbit-test/vbits.c index f7f382d16..8ba6532cc 100644 --- a/memcheck/tests/vbit-test/vbits.c +++ b/memcheck/tests/vbit-test/vbits.c @@ -1055,7 +1055,7 @@ cmpord_vbits(unsigned v1_num_bits, unsigned v2_num_bits) 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: diff --git a/none/tests/filter_timestamp b/none/tests/filter_timestamp index d524aef16..fe6bdd221 100755 --- a/none/tests/filter_timestamp +++ b/none/tests/filter_timestamp @@ -21,7 +21,7 @@ $dir/filter_stderr | # 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/" diff --git a/none/tests/libvex_test.c b/none/tests/libvex_test.c index 2c3986d26..52eeee826 100644 --- a/none/tests/libvex_test.c +++ b/none/tests/libvex_test.c @@ -48,7 +48,7 @@ static VexEndness running_endness (void) #elif __BYTE_ORDER == __BIG_ENDIAN return VexEndnessBE; #else - fprintf(stderr, "cannot determine endianess\n"); + fprintf(stderr, "cannot determine endianness\n"); exit(1); #endif } @@ -98,10 +98,10 @@ static VexEndness arch_endness (VexArch va) { 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; @@ -265,7 +265,7 @@ int main(int argc, char **argv) // 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++) { diff --git a/none/tests/ppc32/jm-insns.c b/none/tests/ppc32/jm-insns.c index 134d49ac0..e1a7da947 100644 --- a/none/tests/ppc32/jm-insns.c +++ b/none/tests/ppc32/jm-insns.c @@ -45,7 +45,7 @@ case I chased). * 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. */ @@ -98,7 +98,7 @@ case I chased). * } * * - * 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 @@ -3367,7 +3367,7 @@ static test_t tests_av_float_ops_spe[] = { /* 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 diff --git a/none/tests/s390x/op_exception.c b/none/tests/s390x/op_exception.c index 35c8602f7..f8dcb9deb 100644 --- a/none/tests/s390x/op_exception.c +++ b/none/tests/s390x/op_exception.c @@ -2,7 +2,7 @@ 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 #include diff --git a/none/tests/x86/shift_ndep.c b/none/tests/x86/shift_ndep.c index 7fc34c982..10f0a8d08 100644 --- a/none/tests/x86/shift_ndep.c +++ b/none/tests/x86/shift_ndep.c @@ -18,7 +18,7 @@ int shift_ndep( void ) 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. */ diff --git a/perf/memrw.c b/perf/memrw.c index 10b95989c..10b909c55 100644 --- a/perf/memrw.c +++ b/perf/memrw.c @@ -26,7 +26,7 @@ static int nr_loops; // nr of loops reading or writing the ws 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. diff --git a/perf/tinycc.c b/perf/tinycc.c index c08bdd1aa..ff757a0dc 100644 --- a/perf/tinycc.c +++ b/perf/tinycc.c @@ -2309,7 +2309,7 @@ static struct BufferedFile *file; 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 */ @@ -2435,7 +2435,7 @@ struct TCCState { 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) */ @@ -5508,7 +5508,7 @@ typedef struct ExprValue { #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 */ @@ -10846,7 +10846,7 @@ void gen_opl(int op) 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(); @@ -11821,7 +11821,7 @@ static void gen_assign_cast(CType *dt) 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)) @@ -18803,7 +18803,7 @@ static void build_got(TCCState *s1) } /* 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) @@ -19579,7 +19579,7 @@ int tcc_output_file(TCCState *s1, const char *filename) } } - /* if interpreter, then add corresponing program header */ + /* if interpreter, then add corresponding program header */ if (interp) { ph = &phdr[0]; @@ -19593,7 +19593,7 @@ int tcc_output_file(TCCState *s1, const char *filename) 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;