[libc] NFC: Fix trivial typo in comments, documents, and messages

libc/AOR_v20.02/math/math_config.h

/* Round x to nearest int in all rounding modes, ties have to be rounded
    would be outside of [-2^31, 2^31-1] then the semantics is unspecified.  */
 static inline double_t
 roundtoint (double_t x)
 {
   return round (x);
 }
 
 /* Convert x to nearest int in all rounding modes, ties have to be rounded
-   consistently with roundtoint.  If the result is not representible in an
+   consistently with roundtoint.  If the result is not representable in an
    int32_t then the semantics is unspecified.  */
 static inline int32_t
 converttoint (double_t x)
 {
 # if HAVE_FAST_LROUND
   return lround (x);
 # else
   return (long) round (x);

 
 
 #define EXP_TABLE_BITS 7
 #define EXP_POLY_ORDER 5
 /* Use polynomial that is optimized for a wider input range.  This may be
    needed for good precision in non-nearest rounding and !TOINT_INTRINSICS.  */
 #define EXP_POLY_WIDE 0
 /* Use close to nearest rounding toint when !TOINT_INTRINSICS.  This may be
-   needed for good precision in non-nearest rouning and !EXP_POLY_WIDE.  */
+   needed for good precision in non-nearest rounding and !EXP_POLY_WIDE.  */
 #define EXP_USE_TOINT_NARROW 0
 #define EXP2_POLY_ORDER 5
 #define EXP2_POLY_WIDE 0
 extern const struct exp_data
 {
   double invln2N;
   double shift;
   double negln2hiN;

libc/AOR_v20.02/math/pow.c

log_inline (uint64_t ix, double_t *tail)
   kd = (double_t) k;
 
   /* log(x) = k*Ln2 + log(c) + log1p(z/c-1).  */
   invc = T[i].invc;
   logc = T[i].logc;
   logctail = T[i].logctail;
 
   /* Note: 1/c is j/N or j/N/2 where j is an integer in [N,2N) and
-     |z/c - 1| < 1/N, so r = z/c - 1 is exactly representible.  */
+     |z/c - 1| < 1/N, so r = z/c - 1 is exactly representable.  */
 #if HAVE_FAST_FMA
   r = fma (z, invc, -1.0);
 #else
   /* Split z such that rhi, rlo and rhi*rhi are exact and |rlo| <= |r|.  */
   double_t zhi = asdouble ((iz + (1ULL << 31)) & (-1ULL << 32));
   double_t zlo = z - zhi;
   double_t rhi = zhi * invc - 1.0;
   double_t rlo = zlo * invc;
(|y| < 0x1p-65 or |y| >= 0x1p63 or nan).  */
     return 1.0;
       }
     return (ix > asuint64 (1.0)) == (topy < 0x800) ? __math_oflow (0)
                : __math_uflow (0);
   }
       if (topx == 0)
   {
     /* Normalize subnormal x so exponent becomes negative.  */
-    /* Without the barrier some versions of clang evalutate the mul
+    /* Without the barrier some versions of clang evaluate the mul
        unconditionally causing spurious overflow exceptions.  */
     ix = asuint64 (opt_barrier_double (x) * 0x1p52);
     ix &= 0x7fffffffffffffff;
     ix -= 52ULL << 52;
   }
     }
 
   double_t lo;

libc/AOR_v20.02/math/pow_log_data.c

 where z is in [0x1.69555p-1; 0x1.69555p0] which is split into N subintervals
 and z falls into the ith one, then table entries are computed as
 
   tab[i].invc = 1/c
   tab[i].logc = round(0x1p43*log(c))/0x1p43
   tab[i].logctail = (double)(log(c) - logc)
 
 where c is chosen near the center of the subinterval such that 1/c has only a
-few precision bits so z/c - 1 is exactly representible as double:
+few precision bits so z/c - 1 is exactly representable as double:
 
   1/c = center < 1 ? round(N/center)/N : round(2*N/center)/N/2
 
 Note: |z/c - 1| < 1/N for the chosen c, |log(c) - logc - logctail| < 0x1p-97,
 the last few bits of logc are rounded away so k*ln2hi + logc has no rounding
 error and the interval for z is selected such that near x == 1, where log(x)
 is tiny, large cancellation error is avoided in logc + poly(z/c - 1).  */
 .tab = {

libc/AOR_v20.02/math/powf.c

 */
 
 #define N (1 << POWF_LOG2_TABLE_BITS)
 #define T __powf_log2_data.tab
 #define A __powf_log2_data.poly
 #define OFF 0x3f330000
 
 /* Subnormal input is normalized so ix has negative biased exponent.
-   Output is multiplied by N (POWF_SCALE) if TOINT_INTRINICS is set.  */
+   Output is multiplied by N (POWF_SCALE) if TOINT_INTRINSICS is set.  */
 static inline double_t
 log2_inline (uint32_t ix)
 {
   /* double_t for better performance on targets with FLT_EVAL_METHOD==2.  */
   double_t z, r, r2, r4, p, q, y, y0, invc, logc;
   uint32_t iz, top, tmp;
   int k, i;
 

libc/AOR_v20.02/math/test/mathbench.c

 
 static void
 readtrace (const char *name)
 {
   int n = 0;
   FILE *f = strcmp (name, "-") == 0 ? stdin : fopen (name, "r");
   if (!f)
     {
-      printf ("openning \"%s\" failed: %m\n", name);
+      printf ("opening \"%s\" failed: %m\n", name);
       exit (1);
     }
   for (;;)
     {
       if (n >= trace_size)
         {
     trace_size += N;
     Trace = realloc (Trace, trace_size * sizeof (Trace[0]));

libc/AOR_v20.02/string/aarch64/memchr-sve.S

0:  whilelo  p1.b, x3, x2      /* make sure off < max */
 
   /* Found C.  */
 1:  brkb  p2.b, p1/z, p2.b  /* find the first c */
   add  x0, x0, x3    /* form partial pointer */
   incp  x0, p2.b    /* form final pointer to c */
   ret
 
   /* First fault failed: only some of the vector is valid.
-     Perform the comparision only on the valid bytes.  */
+     Perform the comparison only on the valid bytes.  */
 2:  cmpeq  p2.b, p0/z, z0.b, z1.b
   b.any 1b
 
   /* No C found.  Re-init FFR, increment, and loop.  */
   setffr
   incp  x3, p0.b
   b 0b
 
   /* Found end of count.  */
 9:  mov  x0, 0      /* return null */
   ret
 
   .size __memchr_aarch64_sve, . - __memchr_aarch64_sve
 #endif

libc/AOR_v20.02/string/aarch64/strchr-sve.S

1:  brka  p4.b, p1/z, p4.b  /* find first such */
   incp  x0, p4.b
 #ifndef BUILD_STRCHRNUL
   ptest  p4, p2.b    /* was first in c? */
   csel  x0, xzr, x0, none  /* if there was no c, return null */
 #endif
   ret
 
   /* First fault failed: only some of the vector is valid.
-     Perform the comparision only on the valid bytes.  */
+     Perform the comparison only on the valid bytes.  */
 2:  cmpeq  p2.b, p0/z, z0.b, z1.b    /* search for c */
   cmpeq  p3.b, p0/z, z0.b, 0    /* search for 0 */
   orrs  p4.b, p0/z, p2.b, p3.b    /* c | 0 */
   b.any 1b
 
   /* No C or 0 found.  Re-init FFR, increment, and loop.  */
   setffr
   incp  x0, p0.b
   b 0b
 
   .size FUNC, . - FUNC
 #endif

libc/AOR_v20.02/string/aarch64/strnlen.S

ENTRY_ALIGN (__strnlen_aarch64, 0)
   /* NUL detection works on the principle that (X - 1) & (~X) & 0x80
      (=> (X - 1) & ~(X | 0x7f)) is non-zero iff a byte is zero, and
      can be done in parallel across the entire word.  */
   /* The inner loop deals with two Dwords at a time.  This has a
      slightly higher start-up cost, but we should win quite quickly,
      especially on cores with a high number of issue slots per
      cycle, as we get much better parallelism out of the operations.  */
 
-  /* Start of critial section -- keep to one 64Byte cache line.  */
+  /* Start of critical section -- keep to one 64Byte cache line.  */
 L(loop):
   ldp data1, data2, [src], #16
 L(realigned):
   sub tmp1, data1, zeroones
   orr tmp2, data1, #REP8_7f
   sub tmp3, data2, zeroones
   orr tmp4, data2, #REP8_7f
   bic has_nul1, tmp1, tmp2

libc/AOR_v20.02/string/aarch64/strrchr-sve.S

0:  ldff1b  z0.b, p1/z, [x0, xzr]
   cmpeq  p3.b, p1/z, z0.b, z1.b  /* search for c; no eos */
   b.none  0b
 
   mov x2, x0      /* save advanced base */
   mov p2.b, p3.b    /* save current search */
   b 0b
 
   /* First fault failed: only some of the vector is valid.
-     Perform the comparisions only on the valid bytes.  */
+     Perform the comparisons only on the valid bytes.  */
 1:  cmpeq  p3.b, p0/z, z0.b, 0  /* search for 0 */
   b.any 2f
 
   cmpeq  p3.b, p0/z, z0.b, z1.b  /* search for c; no eos */
   mov x3, x0
   incp  x0, p0.b    /* skip bytes this round */
   setffr        /* re-init FFR */
   b.none  0b

libc/AOR_v20.02/string/arm/strcpy.c

# else
        "itet ne\n\t"
        "strneh r2, [ip], #2\n\t"
        "streqb r2, [ip]\n\t"
        "tstne  r2, #0xff00\n\t"
 # endif
        "bne  5b\n\t"
        "BX LR\n"
 
-       /* src and dst do not have a common word-alignement.  Fall back to
+       /* src and dst do not have a common word-alignment.  Fall back to
     byte copying.  */
   "4:\n\t"
        "ldrb r2, [r1], #1\n\t"
        "strb r2, [ip], #1\n\t"
        "cmp  r2, #0\n\t"
        "bne  4b\n\t"
        "BX LR");
 }
 /* For GLIBC: libc_hidden_builtin_def (strcpy) */
 
 #endif /* defined (__thumb2__) && !defined (__thumb__)  */

libc/docs/header_generation.rst

 Header configuration language consists of few special *commands*. The header
 generation mechanism takes an input file, which has an extension of
 ``.h.def``, and produces a header file with ``.h`` extension. The header
 configuration language commands are listed in the input ``.h.def`` file. While
 reading a ``.h.def`` file, the header generation tool does two things:
 
 1. Copy the lines not containing commands as is into the output ``.h`` file.
 2. Replace the line on which a command occurs with some other text as directed
-   by the command. The replacment text can span multiple lines.
+   by the command. The replacement text can span multiple lines.
 
 Command syntax
 ~~~~~~~~~~~~~~
 
 A command should be listed on a line by itself, and should not span more than
 one line. The first token to appear on the line is the command name prefixed
 with ``%%``. For example, a line with the ``include_file`` command should start
 with ``%%include_file``. There can be indentation spaces before the ``%%``

 ```
 %%include_file(a/b/c) <!> Path to c in b of a.  !!! WRONG SYNTAX
 ```
 
 Available Commands
 ------------------
 
 Sub-sections below describe the commands currently available. Under each command
-is the discription of the arugments to the command, and the action taken by the
+is the description of the arguments to the command, and the action taken by the
 header generation tool when processing a command.
 
 ``include_file``
 ~~~~~~~~~~~~~~~~
 
 This is a replacement command which should be listed in an input ``.h.def``
 file.
 

libc/docs/implementation_standard.rst

 Implementation of entrypoints can span multiple ``.cpp`` and ``.h`` files, but
 there will be atleast one header file with name of the form
 ``<entrypoint name>.h`` for every entrypoint. This header file is called as the
 implementation header file. For the ``round`` function, the path to the
 implementation header file will be ``src/math/round/round.h``. The rest of this
 document explains the structure of implementation header files and ``.cpp``
 files.
 
-Implementaion Header File Structure
------------------------------------
+Implementation Header File Structure
+------------------------------------
 
 We will use the ``round`` function from the public ``math.h`` header file as an
 example. The ``round`` function will be declared in an internal header file
 ``src/math/round/round.h`` as follows::
 
     // --- round.h --- //
     #ifndef LLVM_LIBC_SRC_MATH_ROUND_ROUND_H
     #define LLVM_LIBC_SRC_MATH_ROUND_ROUND_H

 a post build step. For example, for the ``round`` function, one can use
 ``objcopy`` to add an alias symbol as follows::
 
     objcopy --add-symbol round=.llvm.libc.entrypoint.round:0,function round.o
 
 NOTE: We use a post build ``objcopy`` step to add an alias instead of using
 the ``__attribute__((alias))``. For C++, this ``alias`` attribute requires
 mangled names of the referees. Using the post build ``objcopy`` step helps
-us avoid putting mangled names with ``alias`` atttributes.
+us avoid putting mangled names with ``alias`` attributes.

libc/include/__posix-types.h

 //===----------------- Definitions of common POSIX types ------------------===//
 //
 // 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 header file does not have a header guard. It is internal to LLVM libc
 // and intended to be used to pick specific definitions without polluting the
-// public headers with unneccesary definitions.
+// public headers with unnecessary definitions.
 
 #if defined(__need_off_t) && !defined(__llvm_libc_off_t_defined)
 typedef __INT64_TYPE__ off_t;
 #define __llvm_libc_off_t_defined
 #endif // __need_off_t

libc/src/signal/linux/CMakeLists.txt

add_object_library(
   SRCS
     __restore.cpp
   COMPILE_OPTIONS
     -fomit-frame-pointer
     -O3
     -Wframe-larger-than=0
     -Werror
     -Wno-attributes
-    # asan creates asan.module_ctor which uses stack space, causing warinngs.
+    # asan creates asan.module_ctor which uses stack space, causing warnings.
     -fno-sanitize=address
   DEPENDS
     linux_syscall_h
     sys_syscall_h
 )
 
 add_entrypoint_object(
   sigaction

libc/src/signal/linux/__restore.cpp

 //===----------------- Linux implementation of __restore_rt ---------------===//
 //
 // 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 implemented seperately from sigaction.cpp so that we can
+// This file is implemented separately from sigaction.cpp so that we can
 // strongly control the options this file is compiled with. __restore_rt cannot
 // make any stack allocations so we must ensure this.
 
 #include "config/linux/syscall.h"
 #include "include/sys/syscall.h"
 
 namespace __llvm_libc {
 
 extern "C" void __restore_rt()
     __attribute__((no_sanitize("thread", "memory", "undefined", "fuzzer"),
                    hidden));
 
 extern "C" void __restore_rt() { __llvm_libc::syscall(SYS_rt_sigreturn); }
 
 } // namespace __llvm_libc

libc/src/stdlib/abort.cpp

 
 namespace __llvm_libc {
 
 void LLVM_LIBC_ENTRYPOINT(abort)() {
   // TODO: When sigprocmask and sigaction land:
   // Unblock SIGABRT, raise it, if it was ignored or the handler returned,
   // change its action to SIG_DFL, raise it again.
   // TODO: When C11 mutexes land:
-  // Aquire recursive mutex (in case the current signal handler for SIGABRT
+  // Acquire recursive mutex (in case the current signal handler for SIGABRT
   // itself calls abort we don't want to deadlock on the same thread trying
-  // to aquire it's own mutex.)
+  // to acquire it's own mutex.)
   __llvm_libc::raise(SIGABRT);
   __llvm_libc::raise(SIGKILL);
   __llvm_libc::_Exit(127);
 }
 
 } // namespace __llvm_libc

libc/src/string/strlen.cpp

 //===-------------------- Implementation of strlen ------------------------===//
 //
 // 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 "src/string/strlen.h"
 
 #include "src/__support/common.h"
 
 namespace __llvm_libc {
 
 // TODO: investigate the performance of this function.
-// There might be potential for compiler optmization.
+// There might be potential for compiler optimization.
 size_t LLVM_LIBC_ENTRYPOINT(strlen)(const char *src) {
   const char *end = src;
   while (*end != '\0')
     ++end;
   return end - src;
 }
 
 } // namespace __llvm_libc

libc/src/string/x86/memcpy_arch_specific.h.inc

 #include "src/string/memory_utils/memcpy_utils.h"
 
 namespace __llvm_libc {
 
 static void CopyRepMovsb(char *__restrict dst, const char *__restrict src,
                          size_t count) {
-  // FIXME: Add MSVC suppport with
+  // FIXME: Add MSVC support with
   // #include <intrin.h>
   // __movsb(reinterpret_cast<unsigned char *>(dst),
   //         reinterpret_cast<const unsigned char *>(src), count);
   asm volatile("rep movsb" : "+D"(dst), "+S"(src), "+c"(count) : : "memory");
 }
 
 #if defined(__AVX__)
 #define BEST_SIZE 64

libc/src/threads/linux/thread_utils.h

 #include <stdatomic.h>
 #include <stdint.h>
 
 namespace __llvm_libc {
 
 // The futex data has to be exactly 4 bytes long. However, we use a uint type
 // here as we do not want to use `_Atomic uint32_t` as the _Atomic keyword which
 // is C only. The header stdatomic.h does not define an atomic type
-// corresponding to `uint32_t` or to something which is exaclty 4 bytes wide.
+// corresponding to `uint32_t` or to something which is exactly 4 bytes wide.
 using FutexData = atomic_uint;
 
 // We use a tri-state mutex because we want to avoid making syscalls
 // as much as possible. In `mtx_unlock` a syscall to wake waiting threads is
 // made only if the mutex status is `MutexStatus::Waiting`.
 enum MutexStatus : uint32_t { MS_Free, MS_Locked, MS_Waiting };
 
 static_assert(sizeof(atomic_uint) == 4,

libc/utils/HdrGen/Main.cpp

 llvm::cl::opt<std::string>
     HeaderDefFile("def", llvm::cl::desc("Path to the .h.def file."),
                   llvm::cl::value_desc("<filename>"), llvm::cl::Required);
 llvm::cl::opt<std::string> StandardHeader(
     "header",
     llvm::cl::desc("The standard header file which is to be generated."),
     llvm::cl::value_desc("<header file>"));
 llvm::cl::list<std::string> ReplacementValues(
-    "args", llvm::cl::desc("Command seperated <argument name>=<value> pairs."),
+    "args", llvm::cl::desc("Command separated <argument name>=<value> pairs."),
     llvm::cl::value_desc("<name=value>[,name=value]"));
 
 void ParseArgValuePairs(std::unordered_map<std::string, std::string> &Map) {
   for (std::string &R : ReplacementValues) {
     auto Pair = llvm::StringRef(R).split('=');
     Map[std::string(Pair.first)] = std::string(Pair.second);
   }
 }

libc/utils/UnitTest/README.md

 implementation of the C standard libraries) causes various kinds of
 mixup/conflict problems.
 
 ## How is it different from gtest?
 
 LLVM libc's unit test framework is much less featureful as compared to gtest.
 But, what is available strives to be exactly like gtest.
 
-## Will it be made as featurful as gtest in future?
+## Will it be made as featureful as gtest in future?
 
 It is not clear if LLVM libc needs/will need every feature of gtest. We only
 intend to extend it on an _as needed_ basis. Hence, it might never be as
 featureful as gtest.

libc/utils/UnitTest/Test.h

 namespace testing {
 
 class RunContext;
 
 // Only the following conditions are supported. Notice that we do not have
 // a TRUE or FALSE condition. That is because, C library funtions do not
 // return boolean values, but use integral return values to indicate true or
 // false conditions. Hence, it is more appropriate to use the other comparison
-// condtions for such cases.
+// conditions for such cases.
 enum TestCondition {
   Cond_None,
   Cond_EQ,
   Cond_NE,
   Cond_LT,
   Cond_LE,
   Cond_GT,
   Cond_GE,

libc/utils/benchmarks/LibcBenchmark.h

 // Measures the runtime of `foo` until conditions defined by `Options` are met.
 //
 // To avoid measurement's imprecisions we measure batches of `foo`.
 // The batch size is growing by `ScalingFactor` to minimize the effect of
 // measuring.
 //
 // Note: The benchmark is not responsible for serializing the executions of
 // `foo`. It is not suitable for measuring, very small & side effect free
-// functions, as the processor is free to execute serveral executions in
+// functions, as the processor is free to execute several executions in
 // parallel.
 //
 // - Options: A set of parameters controlling the stopping conditions for the
 //     benchmark.
 // - foo: The function under test. It takes one value and returns one value.
 //     The input value is used to randomize the execution of `foo` as part of a
 //     batch to mitigate the effect of the branch predictor. Signature:
 //     `ProductType foo(ParameterProvider::value_type value);`

libc/utils/buildbot/Dockerfile

 FROM debian:10
 
-# Installing dependecies.
+# Installing dependencies.
 RUN dpkg --add-architecture i386
 RUN apt-get update
 RUN apt-get install -y build-essential clang subversion git vim \
   zip libstdc++6:i386 file binutils-dev binutils-gold cmake python-pip \
   ninja-build
 RUN python -m pip install buildbot-slave==0.8.12
 
-# Temporary dependecies for AOR tests.
+# Temporary dependencies for AOR tests.
 RUN apt-get install -y libmpfr-dev libmpc-dev
 
 # Change linker to gold.
 RUN update-alternatives --install "/usr/bin/ld" "ld" "/usr/bin/ld.gold" 20
 
 # Create and switch to buildbot user.
 RUN useradd buildbot --create-home
 USER buildbot