[compiler-rt] NFC: Fix trivial typo

[xgupta]

LGTM, Thank you very much!

[xgupta]

I rebase and commit this patch.

compiler-rt/cmake/Modules/BuiltinTests.cmake

foreach(substitution ${substitutions})
     else()
       string(REPLACE "${substitution}" "" test_compile_command
              ${test_compile_command})
     endif()
   endforeach()
 
   # Strip quotes from the compile command, as the compiler is not expecting
   # quoted arguments (see discussion on D62063 for when this can come up). If
-  # the quotes were there for arugments with spaces in them, the quotes were
+  # the quotes were there for arguments with spaces in them, the quotes were
   # not going to help since the string gets split on spaces below.
   string(REPLACE "\"" "" test_compile_command "${test_compile_command}")
 
   string(REPLACE " " ";" test_compile_command "${test_compile_command}")
 
   execute_process(
     COMMAND ${test_compile_command}
     RESULT_VARIABLE result

compiler-rt/cmake/config-ix.cmake

foreach(platform ${DARWIN_EMBEDDED_PLATFORMS})
         foreach(arch ${DARWIN_${platform}_ARCHS})
           list(APPEND COMPILER_RT_SUPPORTED_ARCH ${arch})
           set(CAN_TARGET_${arch} 1)
         endforeach()
       endif()
     endforeach()
   endif()
 
-  # Explictly disable unsupported Sanitizer configurations.
+  # Explicitly disable unsupported Sanitizer configurations.
   list(REMOVE_ITEM FUZZER_SUPPORTED_OS "watchos")
   list(REMOVE_ITEM FUZZER_SUPPORTED_OS "watchossim")
 
   # for list_intersect
   include(CompilerRTUtils)
 
   list_intersect(SANITIZER_COMMON_SUPPORTED_ARCH
     ALL_SANITIZER_COMMON_SUPPORTED_ARCH

compiler-rt/include/sanitizer/asan_interface.h

 /// Performs shadow memory cleanup of the current thread's stack before a
 /// function marked with the <c>[[noreturn]]</c> attribute is called.
 ///
 /// To avoid false positives on the stack, must be called before no-return
 /// functions like <c>_exit()</c> and <c>execl()</c>.
 void __asan_handle_no_return(void);
 
 /// Update allocation stack trace for the given allocation to the current stack
-/// trace. Returns 1 if successfull, 0 if not.
+/// trace. Returns 1 if successful, 0 if not.
 int __asan_update_allocation_context(void* addr);
 
 #ifdef __cplusplus
 }  // extern "C"
 #endif
 
 #endif  // SANITIZER_ASAN_INTERFACE_H

compiler-rt/include/sanitizer/common_interface_defs.h

 #ifdef __cplusplus
 extern "C" {
 #endif
 // Arguments for __sanitizer_sandbox_on_notify() below.
 typedef struct {
   // Enable sandbox support in sanitizer coverage.
   int coverage_sandboxed;
   // File descriptor to write coverage data to. If -1 is passed, a file will
-  // be pre-opened by __sanitizer_sandobx_on_notify(). This field has no
+  // be pre-opened by __sanitizer_sandbox_on_notify(). This field has no
   // effect if coverage_sandboxed == 0.
   intptr_t coverage_fd;
   // If non-zero, split the coverage data into well-formed blocks. This is
   // useful when coverage_fd is a socket descriptor. Each block will contain
   // a header, allowing data from multiple processes to be sent over the same
   // socket.
   unsigned int coverage_max_block_size;
 } __sanitizer_sandbox_arguments;

compiler-rt/lib/asan/asan_interceptors.cpp

 #endif  // ASAN_INTERCEPT___CXA_ATEXIT
 
 #if ASAN_INTERCEPT_ATEXIT
 INTERCEPTOR(int, atexit, void (*func)()) {
   ENSURE_ASAN_INITED();
 #if CAN_SANITIZE_LEAKS
   __lsan::ScopedInterceptorDisabler disabler;
 #endif
-  // Avoid calling real atexit as it is unrechable on at least on Linux.
+  // Avoid calling real atexit as it is unreachable on at least on Linux.
   int res = REAL(__cxa_atexit)((void (*)(void *a))func, nullptr, nullptr);
   REAL(__cxa_atexit)(AtCxaAtexit, nullptr, nullptr);
   return res;
 }
 #endif
 
 #if ASAN_INTERCEPT_PTHREAD_ATFORK
 extern "C" {

compiler-rt/lib/asan/asan_report.cpp

~ScopedInErrorReport() {
 
     if (common_flags()->print_cmdline)
       PrintCmdline();
 
     if (common_flags()->print_module_map == 2)
       DumpProcessMap();
 
     // Copy the message buffer so that we could start logging without holding a
-    // lock that gets aquired during printing.
+    // lock that gets acquired during printing.
     InternalMmapVector<char> buffer_copy(kErrorMessageBufferSize);
     {
       Lock l(&error_message_buf_mutex);
       internal_memcpy(buffer_copy.data(),
                       error_message_buffer, kErrorMessageBufferSize);
       // Clear error_message_buffer so that if we find other errors
       // we don't re-log this error.
       error_message_buffer_pos = 0;

compiler-rt/lib/asan/tests/asan_interface_test.cpp

TEST(AddressSanitizerInterface, GetCurrentAllocatedBytesTest) {
   free(array);
   after_free = __sanitizer_get_current_allocated_bytes();
   EXPECT_EQ(before_malloc, after_free);
 }
 
 TEST(AddressSanitizerInterface, GetHeapSizeTest) {
   // ASan allocator does not keep huge chunks in free list, but unmaps them.
   // The chunk should be greater than the quarantine size,
-  // otherwise it will be stuck in quarantine instead of being unmaped.
+  // otherwise it will be stuck in quarantine instead of being unmapped.
   static const size_t kLargeMallocSize = (1 << 28) + 1;  // 256M
   free(Ident(malloc(kLargeMallocSize)));  // Drain quarantine.
   size_t old_heap_size = __sanitizer_get_heap_size();
   for (int i = 0; i < 3; i++) {
     // fprintf(stderr, "allocating %zu bytes:\n", kLargeMallocSize);
     free(Ident(malloc(kLargeMallocSize)));
     EXPECT_EQ(old_heap_size, __sanitizer_get_heap_size());
   }

compiler-rt/lib/builtins/README.txt

 // are only needed by Thumb1 code for efficient switch table generation.
 switch16
 switch32
 switch8
 switchu8
 
 // There is no C interface to the *_vfp_d8_d15_regs functions.  There are
 // called in the prolog and epilog of Thumb1 functions.  When the C++ ABI use
-// SJLJ for exceptions, each function with a catch clause or destuctors needs
-// to save and restore all registers in it prolog and epliog.  But there is 
+// SJLJ for exceptions, each function with a catch clause or destructors needs
+// to save and restore all registers in it prolog and epilog.  But there is
 // no way to access vector and high float registers from thumb1 code, so the 
 // compiler must add call outs to these helper functions in the prolog and 
 // epilog.
 restore_vfp_d8_d15_regs
 save_vfp_d8_d15_regs
 
 
 // Note: long ago ARM processors did not have floating point hardware support.
unsigned int __fixunssfsivfp(float a);  // Appears to convert from
                                         //     float to unsigned int.
 unsigned int __fixunsdfsivfp(double a); // Appears to convert from
                                         //     double to unsigned int.
 double __floatsidfvfp(int a);           // Appears to convert from
                                         //     int to double.
 float __floatsisfvfp(int a);            // Appears to convert from
                                         //     int to float.
 double __floatunssidfvfp(unsigned int a); // Appears to convert from
-                                        //     unisgned int to double.
+                                        //     unsigned int to double.
 float __floatunssisfvfp(unsigned int a); // Appears to convert from
-                                        //     unisgned int to float.
+                                        //     unsigned int to float.
 int __gedf2vfp(double a, double b);     // Appears to return __gedf2
                                         //     (a >= b)
 int __gesf2vfp(float a, float b);       // Appears to return __gesf2
                                         //     (a >= b)
 int __gtdf2vfp(double a, double b);     // Appears to return __gtdf2
                                         //     (a > b)
 int __gtsf2vfp(float a, float b);       // Appears to return __gtsf2
                                         //     (a > b)

compiler-rt/lib/builtins/arm/truncdfsf2vfp.S

 //===-- truncdfsf2vfp.S - Implement truncdfsf2vfp -------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "../assembly.h"
 
 //
 // extern float __truncdfsf2vfp(double a);
 //
-// Converts double precision float to signle precision result.
+// Converts double precision float to single precision result.
 // Uses Darwin calling convention where a double precision parameter is
-// passed in a R0/R1 pair and a signle precision result is returned in R0.
+// passed in a R0/R1 pair and a single precision result is returned in R0.
 //
   .syntax unified
   .p2align 2
 DEFINE_COMPILERRT_FUNCTION(__truncdfsf2vfp)
 #if defined(COMPILER_RT_ARMHF_TARGET)
   vcvt.f32.f64 s0, d0
 #else
   vmov   d7, r0, r1   // load double from r0/r1 pair
   vcvt.f32.f64 s15, d7 // convert double to single (trucate precision)
   vmov  r0, s15      // return result in r0
 #endif
   bx  lr
 END_COMPILERRT_FUNCTION(__truncdfsf2vfp)
 
 NO_EXEC_STACK_DIRECTIVE
 

compiler-rt/lib/builtins/emutls.c

 static void win_error(DWORD last_err, const char *hint) {
   char *buffer = NULL;
   if (FormatMessageA(FORMAT_MESSAGE_ALLOCATE_BUFFER |
                          FORMAT_MESSAGE_FROM_SYSTEM |
                          FORMAT_MESSAGE_MAX_WIDTH_MASK,
                      NULL, last_err, 0, (LPSTR)&buffer, 1, NULL)) {
     fprintf(stderr, "Windows error: %s\n", buffer);
   } else {
-    fprintf(stderr, "Unkown Windows error: %s\n", hint);
+    fprintf(stderr, "Unknown Windows error: %s\n", hint);
   }
   LocalFree(buffer);
 }
 
 static __inline void win_abort(DWORD last_err, const char *hint) {
   win_error(last_err, hint);
   abort();
 }

compiler-rt/lib/builtins/fixunsxfdi.c

 // bytes du_int is a 64 bit integral type value in long double is representable
 // in du_int or is negative (no range checking performed)
 
 // gggg gggg gggg gggg gggg gggg gggg gggg | gggg gggg gggg gggg seee eeee eeee
 // eeee | 1mmm mmmm mmmm mmmm mmmm mmmm mmmm mmmm | mmmm mmmm mmmm mmmm mmmm
 // mmmm mmmm mmmm
 
 #if defined(_MSC_VER) && !defined(__clang__)
-// MSVC throws a warning about 'unitialized variable use' here,
+// MSVC throws a warning about 'uninitialized variable use' here,
 // disable it for builds that warn-as-error
 #pragma warning(push)
 #pragma warning(disable : 4700)
 #endif
 
 COMPILER_RT_ABI du_int __fixunsxfdi(long double a) {
   long_double_bits fb;
   fb.f = a;

compiler-rt/lib/builtins/fixunsxfsi.c

 // bytes su_int is a 32 bit integral type value in long double is representable
 // in su_int or is negative
 
 // gggg gggg gggg gggg gggg gggg gggg gggg | gggg gggg gggg gggg seee eeee eeee
 // eeee | 1mmm mmmm mmmm mmmm mmmm mmmm mmmm mmmm | mmmm mmmm mmmm mmmm mmmm
 // mmmm mmmm mmmm
 
 #if defined(_MSC_VER) && !defined(__clang__)
-// MSVC throws a warning about 'unitialized variable use' here,
+// MSVC throws a warning about 'uninitialized variable use' here,
 // disable it for builds that warn-as-error
 #pragma warning(push)
 #pragma warning(disable : 4700)
 #endif
 
 COMPILER_RT_ABI su_int __fixunsxfsi(long double a) {
   long_double_bits fb;
   fb.f = a;

compiler-rt/lib/builtins/fixxfdi.c

 // bytes di_int is a 64 bit integral type value in long double is representable
 // in di_int (no range checking performed)
 
 // gggg gggg gggg gggg gggg gggg gggg gggg | gggg gggg gggg gggg seee eeee eeee
 // eeee | 1mmm mmmm mmmm mmmm mmmm mmmm mmmm mmmm | mmmm mmmm mmmm mmmm mmmm
 // mmmm mmmm mmmm
 
 #if defined(_MSC_VER) && !defined(__clang__)
-// MSVC throws a warning about 'unitialized variable use' here,
+// MSVC throws a warning about 'uninitialized variable use' here,
 // disable it for builds that warn-as-error
 #pragma warning(push)
 #pragma warning(disable : 4700)
 #endif
 
 COMPILER_RT_ABI di_int __fixxfdi(long double a) {
   const di_int di_max = (di_int)((~(du_int)0) / 2);
   const di_int di_min = -di_max - 1;

compiler-rt/lib/dfsan/done_abilist.txt

 fun:strlen=custom
 fun:strncasecmp=custom
 fun:strncmp=custom
 fun:strpbrk=custom
 fun:strrchr=custom
 fun:strstr=custom
 
 # Functions which take action based on global state, such as running a callback
-# set by a sepperate function.
+# set by a separate function.
 fun:write=custom
 
 # Functions that take a callback (wrap the callback manually).
 fun:dl_iterate_phdr=custom
 
 fun:getpwuid_r=custom
 fun:poll=custom
 fun:sched_getaffinity=custom

compiler-rt/lib/fuzzer/CMakeLists.txt

 append_list_if(COMPILER_RT_HAS_OMIT_FRAME_POINTER_FLAG -fno-omit-frame-pointer LIBFUZZER_CFLAGS)
 
 if (CMAKE_CXX_FLAGS MATCHES "fsanitize-coverage")
   list(APPEND LIBFUZZER_CFLAGS -fno-sanitize-coverage=trace-pc-guard,edge,trace-cmp,indirect-calls,8bit-counters)
 endif()
 
 if(MSVC)
   # Silence warnings by turning off exceptions in MSVC headers and avoid an
-  # error by unecessarily defining thread_local when it isn't even used on
+  # error by unnecessarily defining thread_local when it isn't even used on
   # Windows.
   list(APPEND LIBFUZZER_CFLAGS -D_HAS_EXCEPTIONS=0)
 else()
   if(NOT HAS_THREAD_LOCAL)
     list(APPEND LIBFUZZER_CFLAGS -Dthread_local=__thread)
   endif()
 endif()
 

compiler-rt/lib/fuzzer/FuzzerDataFlowTrace.cpp

 bool BlockCoverage::AppendCoverage(const std::string &S) {
   std::stringstream SS(S);
   return AppendCoverage(SS);
 }
 
 // Coverage lines have this form:
 // CN X Y Z T
 // where N is the number of the function, T is the total number of instrumented
-// BBs, and X,Y,Z, if present, are the indecies of covered BB.
+// BBs, and X,Y,Z, if present, are the indices of covered BB.
 // BB #0, which is the entry block, is not explicitly listed.
 bool BlockCoverage::AppendCoverage(std::istream &IN) {
   std::string L;
   while (std::getline(IN, L, '\n')) {
     if (L.empty())
       continue;
     std::stringstream SS(L.c_str() + 1);
     size_t FunctionId  = 0;

compiler-rt/lib/fuzzer/FuzzerFork.cpp

if (ExitCode == Options.InterruptExitCode) {
       Printf("==%lu== libFuzzer: a child was interrupted; exiting\n", GetPid());
       StopJobs();
       break;
     }
     Fuzzer::MaybeExitGracefully();
 
     Env.RunOneMergeJob(Job.get());
 
-    // Continue if our crash is one of the ignorred ones.
+    // Continue if our crash is one of the ignored ones.
     if (Options.IgnoreTimeouts && ExitCode == Options.TimeoutExitCode)
       Env.NumTimeouts++;
     else if (Options.IgnoreOOMs && ExitCode == Options.OOMExitCode)
       Env.NumOOMs++;
     else if (ExitCode != 0) {
       Env.NumCrashes++;
       if (Options.IgnoreCrashes) {
         std::ifstream In(Job->LogPath);

compiler-rt/lib/fuzzer/FuzzerMerge.cpp

for (size_t Attempt = 1; Attempt <= NumAttempts; Attempt++) {
     Cmd.addFlag("merge_control_file", CFPath);
     Cmd.addFlag("merge_inner", "1");
     if (!V) {
       Cmd.setOutputFile(getDevNull());
       Cmd.combineOutAndErr();
     }
     auto ExitCode = ExecuteCommand(Cmd);
     if (!ExitCode) {
-      VPrintf(V, "MERGE-OUTER: succesfull in %zd attempt(s)\n", Attempt);
+      VPrintf(V, "MERGE-OUTER: successful in %zd attempt(s)\n", Attempt);
       break;
     }
   }
   // Read the control file and do the merge.
   Merger M;
   std::ifstream IF(CFPath);
   IF.seekg(0, IF.end);
   VPrintf(V, "MERGE-OUTER: the control file has %zd bytes\n",

compiler-rt/lib/fuzzer/FuzzerTracePC.cpp

 
 static size_t InternalStrnlen(const char *S, size_t MaxLen) {
   size_t Len = 0;
   for (; Len < MaxLen && S[Len]; Len++) {}
   return Len;
 }
 
 // Finds min of (strlen(S1), strlen(S2)).
-// Needed bacause one of these strings may actually be non-zero terminated.
+// Needed because one of these strings may actually be non-zero terminated.
 static size_t InternalStrnlen2(const char *S1, const char *S2) {
   size_t Len = 0;
   for (; S1[Len] && S2[Len]; Len++)  {}
   return Len;
 }
 
 void TracePC::ClearInlineCounters() {
   IterateCounterRegions([](const Module::Region &R){

compiler-rt/lib/interception/interception_win.cpp

 //
 //        func:  jmp <label>     -->     func:  jmp <tramp>
 //                                              [...]
 //
 //                                   [trampoline]
 //                                      tramp:  jmp QWORD [addr]
 //                                       addr:  .bytes <hook>
 //
-//    Note: <real> is equilavent to <label>.
+//    Note: <real> is equivalent to <label>.
 //
 // 3) HotPatch
 //
 //    The HotPatch hooking is assuming the presence of an header with padding
 //    and a first instruction with at least 2-bytes.
 //
 //    The reason to enforce the 2-bytes limitation is to provide the minimal
 //    space to encode a short jump. HotPatch technique is only rewriting one

compiler-rt/lib/msan/msan.h

const MappingDesc kMemoryLayout[] = {
     {0x3B000000000ULL, 0x3C000000000ULL, MappingDesc::APP, "app-8"},
     {0x3C000000000ULL, 0x3D000000000ULL, MappingDesc::INVALID, "invalid"},
     {0x3D000000000ULL, 0x3E000000000ULL, MappingDesc::SHADOW, "shadow-8"},
     {0x3E000000000ULL, 0x3F000000000ULL, MappingDesc::ORIGIN, "origin-8"},
     {0x3F000000000ULL, 0x40000000000ULL, MappingDesc::APP, "app-9"},
     // The mappings below are used only for 48-bits VMA.
     // TODO(unknown): 48-bit mapping ony covers the usual PIE, non-PIE
     // segments and some more segments totalizing 262144GB of VMA (which cover
-    // only 0.32% of all 48-bit VMA). Memory avaliability can be increase by
+    // only 0.32% of all 48-bit VMA). Memory availability can be increase by
     // adding multiple application segments like 39 and 42 mapping.
     {0x0040000000000ULL, 0x0041000000000ULL, MappingDesc::INVALID, "invalid"},
     {0x0041000000000ULL, 0x0042000000000ULL, MappingDesc::APP, "app-10"},
     {0x0042000000000ULL, 0x0047000000000ULL, MappingDesc::INVALID, "invalid"},
     {0x0047000000000ULL, 0x0048000000000ULL, MappingDesc::SHADOW, "shadow-10"},
     {0x0048000000000ULL, 0x0049000000000ULL, MappingDesc::ORIGIN, "origin-10"},
     {0x0049000000000ULL, 0x0050000000000ULL, MappingDesc::INVALID, "invalid"},
     {0x0050000000000ULL, 0x0051000000000ULL, MappingDesc::APP, "app-11"},

 #define LINEARIZE_MEM(mem) \
   (((uptr)(mem) & ~0xc00000000000ULL) ^ 0x200000000000ULL)
 #define MEM_TO_SHADOW(mem) (LINEARIZE_MEM((mem)) + 0x100000000000ULL)
 #define SHADOW_TO_ORIGIN(shadow) (((uptr)(shadow)) + 0x280000000000)
 
 #elif SANITIZER_NETBSD || (SANITIZER_LINUX && SANITIZER_WORDSIZE == 64)
 
 #ifdef MSAN_LINUX_X86_64_OLD_MAPPING
-// Requries PIE binary and ASLR enabled.
+// Requires PIE binary and ASLR enabled.
 // Main thread stack and DSOs at 0x7f0000000000 (sometimes 0x7e0000000000).
 // Heap at 0x600000000000.
 const MappingDesc kMemoryLayout[] = {
     {0x000000000000ULL, 0x200000000000ULL, MappingDesc::INVALID, "invalid"},
     {0x200000000000ULL, 0x400000000000ULL, MappingDesc::SHADOW, "shadow"},
     {0x400000000000ULL, 0x600000000000ULL, MappingDesc::ORIGIN, "origin"},
     {0x600000000000ULL, 0x800000000000ULL, MappingDesc::APP, "app"}};
 

compiler-rt/lib/msan/msan_interceptors.cpp

 INTERCEPTOR(int, __cxa_atexit, void (*func)(void *), void *arg,
             void *dso_handle) {
   if (msan_init_is_running) return REAL(__cxa_atexit)(func, arg, dso_handle);
   return setup_at_exit_wrapper((void(*)())func, arg, dso_handle);
 }
 
 // Unpoison argument shadow for C++ module destructors.
 INTERCEPTOR(int, atexit, void (*func)()) {
-  // Avoid calling real atexit as it is unrechable on at least on Linux.
+  // Avoid calling real atexit as it is unreachable on at least on Linux.
   if (msan_init_is_running)
     return REAL(__cxa_atexit)((void (*)(void *a))func, 0, 0);
   return setup_at_exit_wrapper((void(*)())func, 0, 0);
 }
 
 static int setup_at_exit_wrapper(void(*f)(), void *arg, void *dso) {
   ENSURE_MSAN_INITED();
   MSanAtExitRecord *r =

compiler-rt/lib/msan/msan_interface_internal.h

 void __msan_init();
 
 // Print a warning and maybe return.
 // This function can die based on common_flags()->exitcode.
 SANITIZER_INTERFACE_ATTRIBUTE
 void __msan_warning();
 
 // Print a warning and die.
-// Intrumentation inserts calls to this function when building in "fast" mode
+// Instrumentation inserts calls to this function when building in "fast" mode
 // (i.e. -mllvm -msan-keep-going)
 SANITIZER_INTERFACE_ATTRIBUTE __attribute__((noreturn))
 void __msan_warning_noreturn();
 
 using __sanitizer::uptr;
 using __sanitizer::sptr;
 using __sanitizer::uu64;
 using __sanitizer::uu32;

compiler-rt/lib/profile/InstrProfiling.h

  * or if that's not set, the last name set to INSTR_PROF_PROFILE_NAME_VAR,
  * or if that's not set,  \c "default.profraw".
  */
 int __llvm_profile_write_file(void);
 
 int __llvm_orderfile_write_file(void);
 /*!
  * \brief this is a wrapper interface to \c __llvm_profile_write_file.
- * After this interface is invoked, a arleady dumped flag will be set
+ * After this interface is invoked, an already dumped flag will be set
  * so that profile won't be dumped again during program exit.
  * Invocation of interface __llvm_profile_reset_counters will clear
  * the flag. This interface is designed to be used to collect profile
  * data from user selected hot regions. The use model is
  *      __llvm_profile_reset_counters();
  *      ... hot region 1
  *      __llvm_profile_dump();
  *      .. some other code

compiler-rt/lib/profile/InstrProfilingInternal.h

typedef struct VPDataReaderType {
    * If there is nothing left, it returns NULL.
    */
   struct ValueProfNode *(*GetValueData)(uint32_t ValueKind, uint32_t Site,
                                         struct InstrProfValueData *Dst,
                                         struct ValueProfNode *StartNode,
                                         uint32_t N);
 } VPDataReaderType;
 
-/* Write profile data to destinitation. If SkipNameDataWrite is set to 1,
-   the name data is already in destintation, we just skip over it. */
+/* Write profile data to destination. If SkipNameDataWrite is set to 1,
+   the name data is already in destination, we just skip over it. */
 int lprofWriteData(ProfDataWriter *Writer, VPDataReaderType *VPDataReader,
                    int SkipNameDataWrite);
 int lprofWriteDataImpl(ProfDataWriter *Writer,
                        const __llvm_profile_data *DataBegin,
                        const __llvm_profile_data *DataEnd,
                        const uint64_t *CountersBegin,
                        const uint64_t *CountersEnd,
                        VPDataReaderType *VPDataReader, const char *NamesBegin,

compiler-rt/lib/profile/InstrProfilingValue.c

__llvm_profile_instrument_memop(uint64_t TargetValue, void *Data,
   // Map the target value to the representative value of its range.
   uint64_t RepValue = InstrProfGetRangeRepValue(TargetValue);
   __llvm_profile_instrument_target(RepValue, Data, CounterIndex);
 }
 
 /*
  * A wrapper struct that represents value profile runtime data.
  * Like InstrProfRecord class which is used by profiling host tools,
- * ValueProfRuntimeRecord also implements the abstract intefaces defined in
+ * ValueProfRuntimeRecord also implements the abstract interfaces defined in
  * ValueProfRecordClosure so that the runtime data can be serialized using
  * shared C implementation.
  */
 typedef struct ValueProfRuntimeRecord {
   const __llvm_profile_data *Data;
   ValueProfNode **NodesKind[IPVK_Last + 1];
   uint8_t **SiteCountArray;
 } ValueProfRuntimeRecord;

compiler-rt/lib/profile/InstrProfilingWriter.c

 #define VP_BUFFER_SIZE 8 * 1024
 static uint8_t BufferIOBuffer[VP_BUFFER_SIZE];
 static InstrProfValueData VPDataArray[16];
 static uint32_t VPDataArraySize = sizeof(VPDataArray) / sizeof(*VPDataArray);
 
 COMPILER_RT_VISIBILITY uint8_t *DynamicBufferIOBuffer = 0;
 COMPILER_RT_VISIBILITY uint32_t VPBufferSize = 0;
 
-/* The buffer writer is reponsponsible in keeping writer state
+/* The buffer writer is responsible in keeping writer state
  * across the call.
  */
 COMPILER_RT_VISIBILITY uint32_t lprofBufferWriter(ProfDataWriter *This,
                                                   ProfDataIOVec *IOVecs,
                                                   uint32_t NumIOVecs) {
   uint32_t I;
   char **Buffer = (char **)&This->WriterCtx;
   for (I = 0; I < NumIOVecs; I++) {

compiler-rt/lib/sanitizer_common/sancov_flags.inc

 //===-- sancov_flags.inc ----------------------------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
 // Sanitizer Coverage runtime flags.
 //
 //===----------------------------------------------------------------------===//
 #ifndef SANCOV_FLAG
 #error "Defnine SANCOV_FLAG prior to including this file!"
 #endif
 
 SANCOV_FLAG(bool, symbolize, true,
-            "If set, converage information will be symbolized by sancov tool "
+            "If set, coverage information will be symbolized by sancov tool "
             "after dumping.")
 
 SANCOV_FLAG(bool, help, false, "Print flags help.")

compiler-rt/lib/sanitizer_common/sanitizer_allocator_primary64.h

 
  private:
   friend class MemoryMapper<ThisT>;
 
   ReservedAddressRange address_range;
 
   static const uptr kRegionSize = kSpaceSize / kNumClassesRounded;
   // FreeArray is the array of free-d chunks (stored as 4-byte offsets).
-  // In the worst case it may reguire kRegionSize/SizeClassMap::kMinSize
+  // In the worst case it may require kRegionSize/SizeClassMap::kMinSize
   // elements, but in reality this will not happen. For simplicity we
   // dedicate 1/8 of the region's virtual space to FreeArray.
   static const uptr kFreeArraySize = kRegionSize / 8;
 
   static const bool kUsingConstantSpaceBeg = kSpaceBeg != ~(uptr)0;
   uptr NonConstSpaceBeg;
   uptr SpaceBeg() const {
     return kUsingConstantSpaceBeg ? kSpaceBeg : NonConstSpaceBeg;

compiler-rt/lib/sanitizer_common/sanitizer_asm.h

 //===-- sanitizer_asm.h -----------------------------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
-// Various support for assemebler.
+// Various support for assembler.
 //
 //===----------------------------------------------------------------------===//
 
 // Some toolchains do not support .cfi asm directives, so we have to hide
 // them inside macros.
 #if defined(__clang__) ||                                                      \
     (defined(__GNUC__) && defined(__GCC_HAVE_DWARF2_CFI_ASM))
   // GCC defined __GCC_HAVE_DWARF2_CFI_ASM if it supports CFI.

compiler-rt/lib/sanitizer_common/sanitizer_atomic_clang_mips.h

 
 #ifndef SANITIZER_ATOMIC_CLANG_MIPS_H
 #define SANITIZER_ATOMIC_CLANG_MIPS_H
 
 namespace __sanitizer {
 
 // MIPS32 does not support atomics > 4 bytes. To address this lack of
 // functionality, the sanitizer library provides helper methods which use an
-// internal spin lock mechanism to emulate atomic oprations when the size is
+// internal spin lock mechanism to emulate atomic operations when the size is
 // 8 bytes.
 static void __spin_lock(volatile int *lock) {
   while (__sync_lock_test_and_set(lock, 1))
     while (*lock) {
     }
 }
 
 static void __spin_unlock(volatile int *lock) { __sync_lock_release(lock); }

compiler-rt/lib/sanitizer_common/sanitizer_local_address_space_view.h

 // out-of-process)
 //
 // The `AddressSpaceView` interface requires that the type can be used as a
 // template parameter to objects that wish to be able to operate in an
 // out-of-process manner. In normal usage, objects are in-process and are thus
 // instantiated with the `LocalAddressSpaceView` type. This type is used to
 // load any pointers in instance methods. This implementation is effectively
 // a no-op. When an object is to be used in an out-of-process manner it is
-// instansiated with the `RemoteAddressSpaceView` type.
+// instantiated with the `RemoteAddressSpaceView` type.
 //
 // By making `AddressSpaceView` a template parameter of an object, it can
 // change its implementation at compile time which has no run time overhead.
 // This also allows unifying in-process and out-of-process code which avoids
 // code duplication.
 //
 //===----------------------------------------------------------------------===//
 #ifndef SANITIZER_LOCAL_ADDRES_SPACE_VIEW_H

compiler-rt/lib/sanitizer_common/sanitizer_stacktrace.cpp

void BufferedStackTrace::Init(const uptr *pcs, uptr cnt, uptr extra_top_pc) {
   size = cnt + !!extra_top_pc;
   CHECK_LE(size, kStackTraceMax);
   internal_memcpy(trace_buffer, pcs, cnt * sizeof(trace_buffer[0]));
   if (extra_top_pc)
     trace_buffer[cnt] = extra_top_pc;
   top_frame_bp = 0;
 }
 
-// Sparc implemention is in its own file.
+// Sparc implementation is in its own file.
 #if !defined(__sparc__)
 
 // In GCC on ARM bp points to saved lr, not fp, so we should check the next
 // cell in stack to be a saved frame pointer. GetCanonicFrame returns the
 // pointer to saved frame pointer in any case.
 static inline uhwptr *GetCanonicFrame(uptr bp,
                                       uptr stack_top,
                                       uptr stack_bottom) {

compiler-rt/lib/sanitizer_common/sanitizer_stacktrace_sparc.cpp

 //===-- sanitizer_stacktrace_sparc.cpp ------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
 // This file is shared between AddressSanitizer and ThreadSanitizer
 // run-time libraries.
 //
-// Implemention of fast stack unwinding for Sparc.
+// Implementation of fast stack unwinding for Sparc.
 //===----------------------------------------------------------------------===//
 
 #if defined(__sparc__)
 
 #if defined(__arch64__) || defined(__sparcv9)
 #define STACK_BIAS 2047
 #else
 #define STACK_BIAS 0

compiler-rt/lib/sanitizer_common/sanitizer_symbolizer_internal.h

 #include "sanitizer_symbolizer.h"
 #include "sanitizer_file.h"
 #include "sanitizer_vector.h"
 
 namespace __sanitizer {
 
 // Parsing helpers, 'str' is searched for delimiter(s) and a string or uptr
 // is extracted. When extracting a string, a newly allocated (using
-// InternalAlloc) and null-terminataed buffer is returned. They return a pointer
+// InternalAlloc) and null-terminated buffer is returned. They return a pointer
 // to the next characted after the found delimiter.
 const char *ExtractToken(const char *str, const char *delims, char **result);
 const char *ExtractInt(const char *str, const char *delims, int *result);
 const char *ExtractUptr(const char *str, const char *delims, uptr *result);
 const char *ExtractTokenUpToDelimiter(const char *str, const char *delimiter,
                                       char **result);
 
 const char *DemangleSwiftAndCXX(const char *name);

compiler-rt/lib/scudo/CMakeLists.txt

 if(ANDROID)
 # Put most Sanitizer shared libraries in the global group. For more details, see
 # android-changes-for-ndk-developers.md#changes-to-library-search-order
   if (COMPILER_RT_HAS_Z_GLOBAL)
     list(APPEND SCUDO_DYNAMIC_LINK_FLAGS -Wl,-z,global)
   endif()
 endif()
 
-# The minimal Scudo runtime does not inlude the UBSan runtime.
+# The minimal Scudo runtime does not include the UBSan runtime.
 set(SCUDO_MINIMAL_OBJECT_LIBS
   RTSanitizerCommonNoTermination
   RTSanitizerCommonLibc
   RTInterception)
 
 if (COMPILER_RT_HAS_GWP_ASAN)
   list(APPEND SCUDO_MINIMAL_OBJECT_LIBS
        RTGwpAsan RTGwpAsanOptionsParser RTGwpAsanBacktraceLibc

compiler-rt/lib/tsan/rtl/tsan_clock.h

private:
   // Namely, thread 3 will not trust any own clock values up to global_acquire_
   // for the purposes of the last_acquire_ optimization.
   atomic_uint64_t global_acquire_;
 
   // Cached SyncClock (without dirty entries and release_store_tid_).
   // We reuse it for subsequent store-release operations without intervening
   // acquire operations. Since it is shared (and thus constant), clock value
   // for the current thread is then stored in dirty entries in the SyncClock.
-  // We host a refernece to the table while it is cached here.
+  // We host a reference to the table while it is cached here.
   u32 cached_idx_;
   u16 cached_size_;
   u16 cached_blocks_;
 
   // Number of active elements in the clk_ table (the rest is zeros).
   uptr nclk_;
   u64 clk_[kMaxTidInClock];  // Fixed size vector clock.
 

compiler-rt/lib/tsan/rtl/tsan_clock.cpp

 // a shared lock; all non-const operations on SyncClock's are conducted under
 // an exclusive lock; ThreadClock's are private to respective threads and so
 // do not need any protection.
 //
 // Description of SyncClock state:
 // clk_ - variable size vector clock, low kClkBits hold timestamp,
 //   the remaining bits hold "acquired" flag (the actual value is thread's
 //   reused counter);
-//   if acquried == thr->reused_, then the respective thread has already
+//   if acquired == thr->reused_, then the respective thread has already
 //   acquired this clock (except possibly for dirty elements).
-// dirty_ - holds up to two indeces in the vector clock that other threads
+// dirty_ - holds up to two indices in the vector clock that other threads
 //   need to acquire regardless of "acquired" flag value;
 // release_store_tid_ - denotes that the clock state is a result of
 //   release-store operation by the thread with release_store_tid_ index.
 // release_store_reused_ - reuse count of release_store_tid_.
 
 namespace __tsan {
 
 static atomic_uint32_t *ref_ptr(ClockBlock *cb) {
void ThreadClock::ReleaseStore(ClockCache *c, SyncClock *dst) {
   DCHECK_LE(dst->size_, kMaxTid);
 
   if (dst->size_ == 0 && cached_idx_ != 0) {
     // Reuse the cached clock.
     // Note: we could reuse/cache the cached clock in more cases:
     // we could update the existing clock and cache it, or replace it with the
     // currently cached clock and release the old one. And for a shared
     // existing clock, we could replace it with the currently cached;
-    // or unshare, update and cache. But, for simplicity, we currnetly reuse
+    // or unshare, update and cache. But, for simplicity, we currently reuse
     // cached clock only when the target clock is empty.
     dst->tab_ = ctx->clock_alloc.Map(cached_idx_);
     dst->tab_idx_ = cached_idx_;
     dst->size_ = cached_size_;
     dst->blocks_ = cached_blocks_;
     CHECK_EQ(dst->dirty_[0].tid(), kInvalidTid);
     // The cached clock is shared (immutable),
     // so this is where we store the current clock.
     dst->dirty_[0].set_tid(tid_);
     dst->dirty_[0].epoch = clk_[tid_];
     dst->release_store_tid_ = tid_;
     dst->release_store_reused_ = reused_;
-    // Rememeber that we don't need to acquire it in future.
+    // Remember that we don't need to acquire it in future.
     dst->elem(tid_).reused = reused_;
     // Grab a reference.
     atomic_fetch_add(ref_ptr(dst->tab_), 1, memory_order_relaxed);
     return;
   }
 
   // Check if we need to resize dst.
   if (dst->size_ < nclk_)
void ThreadClock::ReleaseStore(ClockCache *c, SyncClock *dst) {
   for (ClockElem &ce : *dst) {
     ce.epoch = clk_[i];
     ce.reused = 0;
     i++;
   }
   for (uptr i = 0; i < kDirtyTids; i++) dst->dirty_[i].set_tid(kInvalidTid);
   dst->release_store_tid_ = tid_;
   dst->release_store_reused_ = reused_;
-  // Rememeber that we don't need to acquire it in future.
+  // Remember that we don't need to acquire it in future.
   dst->elem(tid_).reused = reused_;
 
   // If the resulting clock is cachable, cache it for future release operations.
   // The clock is always cachable if we released to an empty sync object.
   if (cached_idx_ == 0 && dst->Cachable()) {
     // Grab a reference to the ClockBlock.
     atomic_uint32_t *ref = ref_ptr(dst->tab_);
     if (atomic_load(ref, memory_order_acquire) == 1)

compiler-rt/lib/tsan/rtl/tsan_interceptors_mac.cpp

TSAN_INTERCEPTOR(int, objc_sync_exit, id obj) {
   if (result != OBJC_SYNC_SUCCESS) MutexInvalidAccess(thr, pc, addr);
   return result;
 }
 
 TSAN_INTERCEPTOR(int, swapcontext, ucontext_t *oucp, const ucontext_t *ucp) {
   {
     SCOPED_INTERCEPTOR_RAW(swapcontext, oucp, ucp);
   }
-  // Bacause of swapcontext() semantics we have no option but to copy its
-  // impementation here
+  // Because of swapcontext() semantics we have no option but to copy its
+  // implementation here
   if (!oucp || !ucp) {
     errno = EINVAL;
     return -1;
   }
   ThreadState *thr = cur_thread();
   const int UCF_SWAPPED = 0x80000000;
   oucp->uc_onstack &= ~UCF_SWAPPED;
   thr->ignore_interceptors++;

compiler-rt/lib/tsan/rtl/tsan_interceptors_posix.cpp

 static void CallUserSignalHandler(ThreadState *thr, bool sync, bool acquire,
                                   int sig, __sanitizer_siginfo *info,
                                   void *uctx) {
   __sanitizer_sigaction *sigactions = interceptor_ctx()->sigactions;
   if (acquire)
     Acquire(thr, 0, (uptr)&sigactions[sig]);
   // Signals are generally asynchronous, so if we receive a signals when
   // ignores are enabled we should disable ignores. This is critical for sync
-  // and interceptors, because otherwise we can miss syncronization and report
+  // and interceptors, because otherwise we can miss synchronization and report
   // false races.
   int ignore_reads_and_writes = thr->ignore_reads_and_writes;
   int ignore_interceptors = thr->ignore_interceptors;
   int ignore_sync = thr->ignore_sync;
   // For symbolizer we only process SIGSEGVs synchronously
   // (bug in symbolizer or in tsan). But we want to reset
   // in_symbolizer to fail gracefully. Symbolizer and user code
   // use different memory allocators, so if we don't reset

compiler-rt/lib/tsan/rtl/tsan_platform_linux.cpp

#if SANITIZER_LINUX && !SANITIZER_ANDROID
   }
   return cnt;
 #else
   return 0;
 #endif
 }
 
 // Extract file descriptors passed via UNIX domain sockets.
-// This is requried to properly handle "open" of these fds.
+// This is required to properly handle "open" of these fds.
 // see 'man recvmsg' and 'man 3 cmsg'.
 int ExtractRecvmsgFDs(void *msgp, int *fds, int nfd) {
   int res = 0;
   msghdr *msg = (msghdr*)msgp;
   struct cmsghdr *cmsg = CMSG_FIRSTHDR(msg);
   for (; cmsg; cmsg = CMSG_NXTHDR(msg, cmsg)) {
     if (cmsg->cmsg_level != SOL_SOCKET || cmsg->cmsg_type != SCM_RIGHTS)
       continue;

compiler-rt/lib/tsan/rtl/tsan_rtl.cpp

void MapShadow(uptr addr, uptr size) {
   meta_end = RoundUpTo(meta_end, 64 << 10);
   if (!data_mapped) {
     // First call maps data+bss.
     data_mapped = true;
     if (!MmapFixedSuperNoReserve(meta_begin, meta_end - meta_begin,
                                  "meta shadow"))
       Die();
   } else {
-    // Mapping continous heap.
+    // Mapping continuous heap.
     // Windows wants 64K alignment.
     meta_begin = RoundDownTo(meta_begin, 64 << 10);
     meta_end = RoundUpTo(meta_end, 64 << 10);
     if (meta_end <= mapped_meta_end)
       return;
     if (meta_begin < mapped_meta_end)
       meta_begin = mapped_meta_end;
     if (!MmapFixedSuperNoReserve(meta_begin, meta_end - meta_begin,

compiler-rt/lib/xray/tests/unit/function_call_trie_test.cpp

TEST(FunctionCallTrieTest, MergeInto) {
   T1.enterFunction(2, 1, 0);
   T1.enterFunction(3, 2, 0);
   T1.exitFunction(3, 3, 0);
   T1.exitFunction(2, 4, 0);
   T1.exitFunction(1, 5, 0);
 
   // We use a different allocator here to make sure that we're able to transfer
   // data into a FunctionCallTrie which uses a different allocator. This
-  // reflects the inteded usage scenario for when we're collecting profiles that
-  // aggregate across threads.
+  // reflects the intended usage scenario for when we're collecting profiles
+  // that aggregate across threads.
   auto B = FunctionCallTrie::InitAllocators();
   FunctionCallTrie Merged(B);
 
   T0.mergeInto(Merged);
   T1.mergeInto(Merged);
 
   ASSERT_EQ(Merged.getRoots().size(), 1u);
   const auto &R0 = *Merged.getRoots()[0];

compiler-rt/lib/xray/xray_basic_flags.h

 //===-- xray_basic_flags.h -------------------------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
-// This file is a part of XRay, a dynamic runtime instruementation system.
+// This file is a part of XRay, a dynamic runtime instrumentation system.
 //
 // XRay Basic Mode runtime flags.
 //===----------------------------------------------------------------------===//
 
 #ifndef XRAY_BASIC_FLAGS_H
 #define XRAY_BASIC_FLAGS_H
 
 #include "sanitizer_common/sanitizer_flag_parser.h"

compiler-rt/lib/xray/xray_buffer_queue.cpp

 //===-- xray_buffer_queue.cpp ----------------------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
-// This file is a part of XRay, a dynamic runtime instruementation system.
+// This file is a part of XRay, a dynamic runtime instrumentation system.
 //
 // Defines the interface for a buffer queue implementation.
 //
 //===----------------------------------------------------------------------===//
 #include "xray_buffer_queue.h"
 #include "sanitizer_common/sanitizer_atomic.h"
 #include "sanitizer_common/sanitizer_common.h"
 #include "sanitizer_common/sanitizer_libc.h"

compiler-rt/lib/xray/xray_flags.h

 //===-- xray_flags.h -------------------------------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
-// This file is a part of XRay, a dynamic runtime instruementation system.
+// This file is a part of XRay, a dynamic runtime instrumentation system.
 //
 // XRay runtime flags.
 //===----------------------------------------------------------------------===//
 
 #ifndef XRAY_FLAGS_H
 #define XRAY_FLAGS_H
 
 #include "sanitizer_common/sanitizer_flag_parser.h"

compiler-rt/lib/xray/xray_interface.cpp

XRayPatchingStatus mprotectAndPatchFunction(int32_t FuncId,
   const size_t PageSize = flags()->xray_page_size_override > 0
                               ? flags()->xray_page_size_override
                               : GetPageSizeCached();
   if ((PageSize == 0) || ((PageSize & (PageSize - 1)) != 0)) {
     Report("Provided page size is not a power of two: %lld\n", PageSize);
     return XRayPatchingStatus::FAILED;
   }
 
-  // Here we compute the minumum sled and maximum sled associated with a
+  // Here we compute the minimum sled and maximum sled associated with a
   // particular function ID.
   auto SledRange = InstrMap.SledsIndex ? InstrMap.SledsIndex[FuncId - 1]
                                        : findFunctionSleds(FuncId, InstrMap);
   auto *f = SledRange.Begin;
   auto *e = SledRange.End;
   auto *MinSled = f;
   auto *MaxSled = (SledRange.End - 1);
   while (f != e) {

compiler-rt/lib/xray/xray_profiling.cpp

if (!Success) {
       if (Verbosity())
         Report("Failed to initialize preallocated memory buffers!");
       atomic_store(&ProfilerLogStatus,
                    XRayLogInitStatus::XRAY_LOG_UNINITIALIZED,
                    memory_order_release);
       return XRayLogInitStatus::XRAY_LOG_UNINITIALIZED;
     }
 
-    // If we've succeded, set the global pointer to the initialised storage.
+    // If we've succeeded, set the global pointer to the initialised storage.
     BQ = reinterpret_cast<BufferQueue *>(&BufferQueueStorage);
   } else {
     BQ->finalize();
     auto InitStatus = BQ->init(profilingFlags()->per_thread_allocator_max,
                                profilingFlags()->buffers_max);
 
     if (InitStatus != BufferQueue::ErrorCode::Ok) {
       if (Verbosity())

compiler-rt/test/BlocksRuntime/recursiveassign.c

 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 
 /*
  *  recursiveassign.c
  *  testObjects
  *
  *  Created by Blaine Garst on 12/3/08.
  *
  */
 
 // CONFIG  rdar://6639533
 
-// The compiler is prefetching x->forwarding before evaluting code that recomputes forwarding and so the value goes to a place that is never seen again.
+// The compiler is prefetching x->forwarding before evaluating code that recomputes forwarding and so the value goes to a place that is never seen again.
 
 #include <stdio.h>
 #include <stdlib.h>
 #include <Block.h>
 
 
 int main(int argc, char* argv[]) {
     

compiler-rt/test/asan/TestCases/Linux/malloc_delete_mismatch.cpp

-// Check that we detect malloc/delete mismatch only if the approptiate flag
+// Check that we detect malloc/delete mismatch only if the appropriate flag
 // is set.
 
 // RUN: %clangxx_asan -g %s -o %t 2>&1
 
 // Find error and provide malloc context.
 // RUN: %env_asan_opts=alloc_dealloc_mismatch=1 not %run %t 2>&1 | FileCheck %s --check-prefix=CHECK --check-prefix=ALLOC-STACK
 
 // No error here.

compiler-rt/test/asan/TestCases/Windows/dll_host.cpp

 // The exception handlers differ in 32-bit and 64-bit, so we ignore them:
 // RUN: grep '[E]XPORT:' %s | sed -e 's/.*[E]XPORT: //' > %t.exports2
 // EXPORT: __asan_wrap__except_handler3
 // EXPORT: __asan_wrap__except_handler4
 // EXPORT: __asan_wrap___C_specific_handler
 //
 // Get the list of ASan wrappers imported by the DLL RTL:
 // [BEWARE: be really careful with the sed commands, as this test can be run
-//  from different environemnts with different shells and seds]
+//  from different environments with different shells and seds]
 // RUN: grep INTERCEPT_LIBRARY_FUNCTION %p/../../../../lib/asan/asan_win_dll_thunk.cpp \
 // RUN:  | grep -v define | sed -e s/.*(/__asan_wrap_/ -e s/).*//              \
 // RUN:  > %t.imports1
 //
 // Add functions interecepted in asan_malloc.win.cpp and asan_win.cpp.
 // RUN: grep '[I]MPORT:' %s | sed -e 's/.*[I]MPORT: //' > %t.imports2
 // IMPORT: __asan_wrap_HeapAlloc
 // IMPORT: __asan_wrap_HeapFree

compiler-rt/test/asan/TestCases/Windows/interface_symbols_windows.cpp

 // Check that the interface exported by asan static lib matches the list of
 // functions mentioned in sanitizer_interface.inc.
 //
 // Just make sure we can compile this.
 // RUN: %clang_cl_asan -Od %s -Fe%t
 //
 // note: The mangling decoration (i.e. @4 )is removed because calling convention
 //       differ from 32-bit and 64-bit.
 //
 // RUN: dumpbin /EXPORTS %t | sed "s/=.*//"                                    \
 // RUN:   | grep -o "\(__asan_\|__ubsan_\|__sanitizer_\|__sancov_\)[^ ]*"      \
 // RUN:   | grep -v "__asan_wrap"                                              \
 // RUN:   | sed -e s/@.*// > %t.exports
 //
 // [BEWARE: be really careful with the sed commands, as this test can be run
-//  from different environemnts with different shells and seds]
+//  from different environments with different shells and seds]
 //
 // RUN: grep -e "INTERFACE_FUNCTION"                                           \
 // RUN:  %p/../../../../lib/asan/asan_interface.inc                            \
 // RUN:  %p/../../../../lib/ubsan/ubsan_interface.inc                          \
 // RUN:  %p/../../../../lib/sanitizer_common/sanitizer_common_interface.inc    \
 // RUN:  %p/../../../../lib/sanitizer_common/sanitizer_coverage_interface.inc  \
 // RUN:  | sed -e "s/.*(//" -e "s/).*//" > %t.imports1
 //

compiler-rt/test/asan/TestCases/contiguous_container.cpp

for (int i = 0; i < 10000; i++) {
     }
     if (mid != end) {
       assert(!__sanitizer_verify_contiguous_container(beg, mid + 1, end));
       assert(mid == __sanitizer_contiguous_container_find_bad_address(
                         beg, mid + 1, end));
     }
   }
 
-  // Don't forget to unpoison the whole thing before destroing/reallocating.
+  // Don't forget to unpoison the whole thing before destroying/reallocating.
   __sanitizer_annotate_contiguous_container(beg, end, mid, end);
   for (size_t idx = 0; idx < capacity; idx++)
     assert(!__asan_address_is_poisoned(beg + idx));
   delete[] beg;
 }
 
 __attribute__((noinline))
 void Throw() { throw 1; }

compiler-rt/test/asan/TestCases/initialization-bug.cpp

 // Test to make sure basic initialization order errors are caught.
 
 // RUN: %clangxx_asan %min_macos_deployment_target=10.11 -O0 %s %p/Helpers/initialization-bug-extra2.cpp -o %t-INIT-ORDER-EXE
 // RUN: %env_asan_opts=check_initialization_order=true not %run %t-INIT-ORDER-EXE 2>&1 | FileCheck %s
 
 // Do not test with optimization -- the error may be optimized away.
 
 // FIXME: https://code.google.com/p/address-sanitizer/issues/detail?id=186
 // XFAIL: windows-msvc
 
 #include <cstdio>
 
 // The structure of the test is:
 // "x", "y", "z" are dynamically initialized globals.
 // Value of "x" depends on "y", value of "y" depends on "z".
 // "x" and "z" are defined in this TU, "y" is defined in another one.
-// Thus we shoud stably report initialization order fiasco independently of
+// Thus we should stably report initialization order fiasco independently of
 // the translation unit order.
 
 int initZ() {
   return 5;
 }
 int z = initZ();
 
 // 'y' is a dynamically initialized global residing in a different TU.  This

compiler-rt/test/builtins/Unit/clear_cache_test.c

 typedef int (*pfunc)(void);
 
 // Make these static to avoid ILT jumps for incremental linking on Windows.
 static int func1() { return 1; }
 static int func2() { return 2; }
 
 void __attribute__((noinline))
 memcpy_f(void *dst, const void *src, size_t n) {
-// ARM and MIPS nartually align functions, but use the LSB for ISA selection
+// ARM and MIPS naturally align functions, but use the LSB for ISA selection
 // (THUMB, MIPS16/uMIPS respectively).  Ensure that the ISA bit is ignored in
 // the memcpy
 #if defined(__arm__) || defined(__mips__)
   memcpy(dst, (void *)((uintptr_t)src & ~1), n);
 #else
   memcpy(dst, (void *)((uintptr_t)src), n);
 #endif
 }

compiler-rt/test/builtins/Unit/enable_execute_stack_test.c

 typedef int (*pfunc)(void);
 
 // Make these static to avoid ILT jumps for incremental linking on Windows.
 static int func1() { return 1; }
 static int func2() { return 2; }
 
 void *__attribute__((noinline))
 memcpy_f(void *dst, const void *src, size_t n) {
-// ARM and MIPS nartually align functions, but use the LSB for ISA selection
+// ARM and MIPS naturally align functions, but use the LSB for ISA selection
 // (THUMB, MIPS16/uMIPS respectively).  Ensure that the ISA bit is ignored in
 // the memcpy
 #if defined(__arm__) || defined(__mips__)
   return (void *)((uintptr_t)memcpy(dst, (void *)((uintptr_t)src & ~1), n) |
                   ((uintptr_t)src & 1));
 #else
   return memcpy(dst, (void *)((uintptr_t)src), n);
 #endif

compiler-rt/test/builtins/Unit/fp_test.h

else if (expected == 0x7ff8000000000000UL){
             return 0;
         }
     }
     return 1;
 }
 
 #if __LDBL_MANT_DIG__ == 113
 // return 0 if equal
-// use two 64-bit integers intead of one 128-bit integer
+// use two 64-bit integers instead of one 128-bit integer
 // because 128-bit integer constant can't be assigned directly
 static inline int compareResultLD(long double result,
                                   uint64_t expectedHi,
                                   uint64_t expectedLo)
 {
     __uint128_t rep = toRep128(result);
     uint64_t hi = rep >> 64;
     uint64_t lo = rep;

compiler-rt/test/fuzzer/CustomCrossOverTest.cpp

 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 
-// Simple test for a cutom crossover.
+// Simple test for a custom crossover.
 #include <assert.h>
 #include <cstddef>
 #include <cstdint>
 #include <cstdlib>
 #include <iostream>
 #include <ostream>
 #include <random>
 #include <string.h>

compiler-rt/test/fuzzer/CustomMutatorTest.cpp

 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 
-// Simple test for a cutom mutator.
+// Simple test for a custom mutator.
 #include <assert.h>
 #include <cstddef>
 #include <cstdint>
 #include <cstdlib>
 #include <iostream>
 #include <ostream>
 
 #include "FuzzerInterface.h"

compiler-rt/test/fuzzer/merge.test

 MCF: MERGE-OUTER: 3 new files
 
 
 # Check that merge tolerates failures.
 RUN: rm %t/T1/*
 RUN: cp %t/T0/* %t/T1/
 RUN: echo 'FUZZER' > %t/T2/FUZZER
 RUN: %run %t-FullCoverageSetTest -merge=1 %t/T1 %t/T2 2>&1 | FileCheck %s --check-prefix=MERGE_WITH_CRASH
-MERGE_WITH_CRASH: MERGE-OUTER: succesfull in 2 attempt(s)
+MERGE_WITH_CRASH: MERGE-OUTER: successful in 2 attempt(s)
 MERGE_WITH_CRASH: MERGE-OUTER: 3 new files
 
 # Check that we actually limit the size with max_len
 RUN: rm %t/T1/* %t/T2/*
 RUN: echo 'FUZZER' > %t/T2/FUZZER
 RUN: %run %t-FullCoverageSetTest -merge=1 %t/T1 %t/T2  -max_len=5 2>&1 | FileCheck %s --check-prefix=MERGE_LEN5
 RUN: not grep FUZZER %t/T1/*
 RUN: grep FUZZE %t/T1/*
-MERGE_LEN5: MERGE-OUTER: succesfull in 1 attempt(s)
+MERGE_LEN5: MERGE-OUTER: successful in 1 attempt(s)
 

compiler-rt/test/lit.common.cfg.py

elif config.host_os == 'SunOS':
     config.substitutions.append( ("%ld_flags_rpath_exe" + postfix, "-Wl,-R\$ORIGIN -L%T -l%xdynamiclib_namespec" + postfix) )
     config.substitutions.append( ("%ld_flags_rpath_so" + postfix, '') )
 
   # Must be defined after the substitutions that use %dynamiclib.
   config.substitutions.append( ("%dynamiclib" + postfix, '%T/%xdynamiclib_filename' + postfix) )
   config.substitutions.append( ("%xdynamiclib_filename" + postfix, 'lib%xdynamiclib_namespec{}.so'.format(postfix)) )
   config.substitutions.append( ("%xdynamiclib_namespec", '%basename_t.dynamic') )
 
-# Provide a substituion that can be used to tell Clang to use a static libstdc++.
+# Provide a substitution that can be used to tell Clang to use a static libstdc++.
 # The substitution expands to nothing on non Linux platforms.
 # FIXME: This should check the target OS, not the host OS.
 if config.host_os == 'Linux':
   config.substitutions.append( ("%linux_static_libstdcplusplus", "-stdlib=libstdc++ -static-libstdc++") )
 else:
   config.substitutions.append( ("%linux_static_libstdcplusplus", "") )
 
 config.default_sanitizer_opts = []

compiler-rt/test/msan/param_tls_limit.cpp

 
 // This test passes poisoned values through function argument list.
 // In case of overflow, argument is unpoisoned.
 #define OVERFLOW(x) assert(__msan_test_shadow(&x, sizeof(x)) == -1)
 // In case of no overflow, it is still poisoned.
 #define NO_OVERFLOW(x) assert(__msan_test_shadow(&x, sizeof(x)) == 0)
 
 #if defined(__x86_64__)
-// In x86_64, if argument is partially outside tls, it is considered completly
+// In x86_64, if argument is partially outside tls, it is considered completely
 // unpoisoned
 #define PARTIAL_OVERFLOW(x) OVERFLOW(x)
 #else
 // In other archs, bigger arguments are splitted in multiple IR arguments, so
 // they are considered poisoned till tls limit. Checking last byte of such arg:
 #define PARTIAL_OVERFLOW(x) assert(__msan_test_shadow((char *)(&(x) + 1) - 1, 1) == -1)
 #endif
 

compiler-rt/test/sanitizer_common/CMakeLists.txt

if ("${CMAKE_SYSTEM_NAME}" STREQUAL "Linux" AND NOT ANDROID)
       list(APPEND SANITIZER_COMMON_TEST_TARGET_CFLAGS -funwind-tables)
       string(REPLACE ";" " " SANITIZER_COMMON_TEST_TARGET_CFLAGS
                              "${SANITIZER_COMMON_TEST_TARGET_CFLAGS}")
     endif()
 
     configure_lit_site_cfg(
       ${CMAKE_CURRENT_SOURCE_DIR}/lit.site.cfg.py.in
       ${CMAKE_CURRENT_BINARY_DIR}/${CONFIG_NAME}/lit.site.cfg.py)
-    # FIXME(dliew): LSan i386 on Darwin is completly broken right now.
+    # FIXME(dliew): LSan i386 on Darwin is completely broken right now.
     # so don't run the tests by default.
     if (NOT (CMAKE_SYSTEM_NAME MATCHES "Darwin" AND
              ${tool} STREQUAL "lsan" AND
              ${arch} STREQUAL "i386"))
       list(APPEND SANITIZER_COMMON_TESTSUITES
            ${CMAKE_CURRENT_BINARY_DIR}/${CONFIG_NAME})
     endif()
   endforeach()

compiler-rt/test/sanitizer_common/TestCases/Linux/new_delete_test.cpp

 // RUN: %clangxx -std=c++1z -faligned-allocation -O0 %s -o %t && %run %t
 // RUN: %clangxx -std=c++1z -faligned-allocation -fsized-deallocation -O0 %s -o %t && %run %t
 
 // ubsan does not intercept new/delete.
 // UNSUPPORTED: ubsan
 
 // Check that all new/delete variants are defined and work with supported
 // sanitizers. Sanitizer-specific failure modes tests are supposed to go to
-// the particular sanitizier's test suites.
+// the particular sanitizer's test suites.
 
 #include <cstddef>
 
 // Define all new/delete to do not depend on the version provided by the
 // platform. The implementation is provided by the sanitizer anyway.
 
 namespace std {
 struct nothrow_t {};

compiler-rt/test/tsan/custom_mutex0.cpp

 // RUN: %clangxx_tsan -O1 --std=c++11 %s -o %t && %run %t 2>&1 | FileCheck %s
 #include "custom_mutex.h"
 
-// Test that custom annoations provide normal mutex synchronization
+// Test that custom annotations provide normal mutex synchronization
 // (no race reports for properly protected critical sections).
 
 Mutex mu(true, 0);
 long data;
 
 void *thr(void *arg) {
   barrier_wait(&barrier);
   mu.Lock();

compiler-rt/test/tsan/deep_stack1.cpp

#ifdef ORDER1
   barrier_wait(&barrier);
 #endif
 
   pthread_join(t, 0);
 }
 
 // CHECK: WARNING: ThreadSanitizer: data race
 // CHECK:    #100 foo
-// We must output suffucuently large stack (at least 100 frames)
+// We must output sufficiently large stack (at least 100 frames)
 

compiler-rt/test/tsan/fd_dup_norace2.cpp

 // 2. Some daemons dup /dev/null in place of stdin/stdout.
 
 int fd;
 
 void *Thread(void *x) {
   char buf;
   int n = read(fd, &buf, 1);
   if (n != 1) {
-    // This read can "legitimately" fail regadless of the fact that glibc claims
+    // This read can "legitimately" fail regardless of the fact that glibc claims
     // that "there is no instant in the middle of calling dup2 at which new is
     // closed and not yet a duplicate of old". Strace of the failing runs
     // looks as follows:
     //
     //    [pid 122196] open("/dev/urandom", O_RDONLY) = 3
     //    [pid 122196] open("/dev/urandom", O_RDONLY) = 4
     //    Process 122382 attached
     //    [pid 122382] read(3,  <unfinished ...>

compiler-rt/utils/generate_netbsd_ioctls.awk

 # This script will emit compat code for the older releases.
 #
 # NetBSD minimal version supported 9.0.
 # NetBSD current version supported 9.99.26.
 #
 #===------------------------------------------------------------------------===#
 
 BEGIN {
-  # harcode the script name
+  # hardcode the script name
   script_name = "generate_netbsd_ioctls.awk"
   outputinc = "../lib/sanitizer_common/sanitizer_interceptors_ioctl_netbsd.inc"
 
   # assert that we are in the directory with scripts
   in_utils = system("test -f " script_name " && exit 1 || exit 0")
   if (in_utils == 0) {
     usage()
   }

compiler-rt/utils/generate_netbsd_syscalls.awk

 # This script will emit compat code for the older releases.
 #
 # NetBSD minimal version supported 9.0.
 # NetBSD current version supported 9.99.30.
 #
 #===------------------------------------------------------------------------===#
 
 BEGIN {
-  # harcode the script name
+  # hardcode the script name
   script_name = "generate_netbsd_syscalls.awk"
   outputh = "../include/sanitizer/netbsd_syscall_hooks.h"
   outputinc = "../lib/sanitizer_common/sanitizer_syscalls_netbsd.inc"
 
   # assert that we are in the directory with scripts
   in_utils = system("test -f " script_name " && exit 1 || exit 0")
   if (in_utils == 0) {
     usage()