[libc] Fixed a number of typos

[GabrielRavier]

Summary

I went over the output of the following mess of a command:

(ulimit -m 2000000; ulimit -v 2000000; git ls-files -z | parallel --xargs -0 cat | aspell list --mode=none --ignore-case | grep -E '^[A-Za-z][a-z]*$' | sort | uniq -c | sort -n | grep -vE '.{25}' | aspell pipe -W3 | grep : | cut -d' ' -f2 | less)

and proceeded to spend a few days looking at it to find probable typos
and fixed a few hundred of them in all of the llvm project (note, the
ones I found are not anywhere near all of them, but it seems like a
good start).

libc/benchmarks/automemcpy/unittests/ResultAnalyzerTest.cpp

 namespace {
 
 TEST(AutomemcpyJsonResultsAnalyzer, getThroughputsOneSample) {
   static constexpr FunctionId Foo1 = {"memcpy1", FunctionType::MEMCPY};
   static constexpr DistributionId DistA = {{"A"}};
   static constexpr SampleId Id = {Foo1, DistA};
   static constexpr Sample kSamples[] = {
       Sample{Id, SampleType::ITERATION, 4},
-      Sample{Id, SampleType::AGGREGATE, -1}, // Aggegates gets discarded
+      Sample{Id, SampleType::AGGREGATE, -1}, // Aggregates gets discarded
   };
 
   const std::vector<FunctionData> Data = getThroughputs(kSamples);
   EXPECT_THAT(Data, SizeIs(1));
   EXPECT_THAT(Data[0].Id, Foo1);
   EXPECT_THAT(Data[0].PerDistributionData, SizeIs(1));
   // A single value is provided.
   const auto &DistributionData = Data[0].PerDistributionData.lookup(DistA.Name);

libc/cmake/modules/LLVMLibCObjectRules.cmake

if(LLVM_LIBC_ENABLE_LINTING)
     endif()
 
     # We only want a second invocation of clang-tidy to run
     # restrict-system-libc-headers if the compiler-resource-dir was set in
     # order to prevent false-positives due to a mismatch between the host
     # compiler and the compiled clang-tidy.
     if(COMPILER_RESOURCE_DIR)
       # We run restrict-system-libc-headers with --system-headers to prevent
-      # transitive inclusion through compler provided headers.
+      # transitive inclusion through compiler provided headers.
       set(restrict_system_headers_check_invocation
         COMMAND ${LLVM_LIBC_CLANG_TIDY} --system-headers
         --checks="-*,llvmlibc-restrict-system-libc-headers"
         # We explicitly set the resource dir here to match the
         # resource dir of the host compiler.
         "--extra-arg=-resource-dir=${COMPILER_RESOURCE_DIR}"
         --quiet
         -p ${PROJECT_BINARY_DIR}

libc/config/linux/app.h

struct TLSDescriptor {
   // The size of the TLS area.
   uintptr_t size = 0;
 
   // The address of the TLS area. This address can be passed to cleanup
   // functions like munmap.
   uintptr_t addr = 0;
 
   // The value the thread pointer register should be initialized to.
-  // Note that, dependending the target architecture ABI, it can be the
+  // Note that, depending on the target architecture ABI, it can be the
   // same as |addr| or something else.
   uintptr_t tp = 0;
 
   constexpr TLSDescriptor() = default;
 };
 
 // Create and initialize the TLS area for the current thread. Should not
 // be called before app.tls has been initialized.
 void init_tls(TLSDescriptor &tls);
 
 // Cleanup the TLS area as described in |tls_descriptor|.
 void cleanup_tls(uintptr_t tls_addr, uintptr_t tls_size);
 
 } // namespace __llvm_libc
 
 #endif // LLVM_LIBC_CONFIG_LINUX_APP_H

libc/test/src/__support/uint128_test.cpp

 
 TEST(LlvmLibcUInt128ClassTest, MultiplicationTests) {
   LL_UInt128 val1({5, 0});
   LL_UInt128 val2({10, 0});
   LL_UInt128 result1({50, 0});
   EXPECT_EQ((val1 * val2), result1);
   EXPECT_EQ((val1 * val2), (val2 * val1)); // multiplication is reciprocal
 
-  // Check that the multiplication works accross the whole number
+  // Check that the multiplication works across the whole number
   LL_UInt128 val3({0xf, 0});
   LL_UInt128 val4({0x1111111111111111, 0x1111111111111111});
   LL_UInt128 result2({0xffffffffffffffff, 0xffffffffffffffff});
   EXPECT_EQ((val3 * val4), result2);
   EXPECT_EQ((val3 * val4), (val4 * val3));
 
   // Check that multiplication doesn't reorder the bits.
   LL_UInt128 val5({2, 0});

libc/test/src/stdio/fileop_test.cpp

-//===-- Unittests for file operations like fopen, flcose etc --------------===//
+//===-- Unittests for file operations like fopen, fclose etc --------------===//
 //
 // 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/stdio/clearerr.h"

libc/test/src/stdio/unlocked_fileop_test.cpp

-//===-- Unittests for f operations like fopen, flcose etc --------------===//
+//===-- Unittests for f operations like fopen, fclose etc --------------===//
 //
 // 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/stdio/clearerr_unlocked.h"