typos

31 files changed, 42 insertions, 42 deletions

diff --git a/rts/Capability.c b/rts/Capability.c
index 7ebe51609f..abb3e5ed8c 100644
--- a/rts/Capability.c
+++ b/rts/Capability.c
@@ -7,7 +7,7 @@
  * A Capability represents the token required to execute STG code,
  * and all the state an OS thread/task needs to run Haskell code:
  * its STG registers, a pointer to its TSO, a nursery etc. During
- * STG execution, a pointer to the capabilitity is kept in a
+ * STG execution, a pointer to the capability is kept in a
  * register (BaseReg; actually it is a pointer to cap->r).
  *
  * Only in a THREADED_RTS build will there be multiple capabilities,
diff --git a/rts/Exception.cmm b/rts/Exception.cmm
index edbd657251..0ef74a8c57 100644
--- a/rts/Exception.cmm
+++ b/rts/Exception.cmm
@@ -524,7 +524,7 @@ retry_pop_stack:
             // we don't want any further exceptions to be caught,
             // until GHCi is ready to handle them.  This prevents
             // deadlock if an exception is raised in InteractiveUI,
-            // for exmplae.  Perhaps the stop_on_exception flag should
+            // for example.  Perhaps the stop_on_exception flag should
             // be per-thread.
             CInt[rts_stop_on_exception] = 0;
             ("ptr" ioAction) = ccall deRefStablePtr (W_[rts_breakpoint_io_action] "ptr");
diff --git a/rts/Hash.h b/rts/Hash.h
index 4f9d75d6be..3415a43174 100644
--- a/rts/Hash.h
+++ b/rts/Hash.h
@@ -91,7 +91,7 @@ INLINE_HEADER void freeStrHashTable ( StrHashTable *table, void (*freeDataFun)(v
 /*
  * Hash set API
  *
- * A hash set is bascially a hash table where values are NULL.
+ * A hash set is basically a hash table where values are NULL.
  */
 
 typedef struct hashtable HashSet;
diff --git a/rts/IOManager.c b/rts/IOManager.c
index 5551e2e2cd..e9bf3fa70c 100644
--- a/rts/IOManager.c
+++ b/rts/IOManager.c
@@ -75,7 +75,7 @@ initIOManagerAfterFork(Capability **pcap USED_IF_THREADS_AND_NOT_MINGW32)
      * No Windows impl since no forking.
      *
      * TODO: figure out if it is necessary for the threaded MIO case for the
-     * starting of the IO managager threads to be synchronous. It would be
+     * starting of the IO manager threads to be synchronous. It would be
      * simpler if it could start them asynchronously and thus not have to
      * have the pcap as an inout param, that could be modified. In practice it
      * cannot be modified anyway since in the contexts where it is called
diff --git a/rts/ProfHeap.c b/rts/ProfHeap.c
index ab65feab2b..0e3848d616 100644
--- a/rts/ProfHeap.c
+++ b/rts/ProfHeap.c
@@ -418,7 +418,7 @@ void freeHeapProfiling (void)
 }
 
 /* --------------------------------------------------------------------------
- * Initialize the heap profilier
+ * Initialize the heap profiler
  * ----------------------------------------------------------------------- */
 void
 initHeapProfiling(void)
@@ -1240,9 +1240,9 @@ heapCensusBlock(Census *census, bdescr *bd)
          * use this to scan for the next valid heap closure.
          *
          * Note that not all types of slop are relevant here, only the ones
-         * that can reman after major GC. So essentially just large objects
+         * that can remain after major GC. So essentially just large objects
          * and pinned objects. All other closures will have been packed nice
-         * and thight into fresh blocks.
+         * and tight into fresh blocks.
          */
     }
 }
diff --git a/rts/RetainerProfile.c b/rts/RetainerProfile.c
index 964cb99e9f..90d3c8c0f4 100644
--- a/rts/RetainerProfile.c
+++ b/rts/RetainerProfile.c
@@ -413,7 +413,7 @@ computeRetainerSet( traverseState *ts )
 
 /* -----------------------------------------------------------------------------
  * Perform retainer profiling.
- * N is the oldest generation being profilied, where the generations are
+ * N is the oldest generation being profiled, where the generations are
  * numbered starting at 0.
  * Invariants:
  * Note:
diff --git a/rts/RtsFlags.c b/rts/RtsFlags.c
index b99e315083..881b75be53 100644
--- a/rts/RtsFlags.c
+++ b/rts/RtsFlags.c
@@ -2613,7 +2613,7 @@ overwrite files. This would be bad in the context of CGI scripts or
 setuid binaries. So we introduced a system where +RTS processing is more
 or less disabled unless you pass the -rtsopts flag at link time.
 
-This scheme is safe enough but it also really annoyes users. They have
+This scheme is safe enough but it also really annoys users. They have
 to use -rtsopts in many circumstances: with -threaded to use -N, with
 -eventlog to use -l, with -prof to use any of the profiling flags. Many
 users just set -rtsopts globally or in project .cabal files. Apart from
diff --git a/rts/RtsSymbols.c b/rts/RtsSymbols.c
index 2818df6ff3..f695cbd041 100644
--- a/rts/RtsSymbols.c
+++ b/rts/RtsSymbols.c
@@ -96,7 +96,7 @@ extern char **environ;
  * if it is declared but not defined, allowing it to be defined by an object
  * which is loaded later. GHC generalizes this notion, allowing symbol
  * definitions to be declared as *strong*. A strong symbol is one which will
- * silently supercede definitions of the same name by later objects.
+ * silently supersede definitions of the same name by later objects.
  *
  * This is currently only used in the case of atexit() to workaround an
  * unfortunate interaction on musl systems (#20350). Specifically,
diff --git a/rts/STM.h b/rts/STM.h
index 69cee7b531..5ca57b9a49 100644
--- a/rts/STM.h
+++ b/rts/STM.h
@@ -21,7 +21,7 @@
   STM_FG_LOCKS -- per-TVar exclusion : each TVar can be owned by at
                   most one TRec at any time.  This allows dynamically
                   non-conflicting transactions to commit in parallel.
-                  The implementation treats reads optimisitcally --
+                  The implementation treats reads optimistically --
                   extra versioning information is retained in the 
                   saw_update_by field of the TVars so that they do not 
                   need to be locked for reading.
diff --git a/rts/Schedule.c b/rts/Schedule.c
index 9b1e98ea17..0a75bd1a55 100644
--- a/rts/Schedule.c
+++ b/rts/Schedule.c
@@ -1516,7 +1516,7 @@ static void acquireAllCapabilities(Capability *cap, Task *task)
 
     ASSERT(SEQ_CST_LOAD(&pending_sync) != NULL);
     for (i=0; i < n_capabilities; i++) {
-        debugTrace(DEBUG_sched, "grabbing all the capabilies (%d/%d)",
+        debugTrace(DEBUG_sched, "grabbing all the capabilities (%d/%d)",
                    i, n_capabilities);
         tmpcap = capabilities[i];
         if (tmpcap != cap) {
diff --git a/rts/Stats.c b/rts/Stats.c
index 8d020d53d6..794c67ebd5 100644
--- a/rts/Stats.c
+++ b/rts/Stats.c
@@ -437,7 +437,7 @@ stat_startGC (Capability *cap, gc_thread *gct)
     // (though converted from Time=StgInt64 to EventTimestamp=StgWord64).
     // Here, as opposed to other places, the event is emitted on the cap
     // that initiates the GC and external tools expect it to have the same
-    // timestamp as used in +RTS -s calculcations.
+    // timestamp as used in +RTS -s calculations.
     traceEventGcStartAtT(cap,
                          TimeToNS(gct->gc_start_elapsed - start_init_elapsed));
 
@@ -594,7 +594,7 @@ stat_endGC (Capability *cap, gc_thread *initiating_gct, W_ live, W_ copied, W_ s
         // (though converted from Time=StgInt64 to EventTimestamp=StgWord64).
         // Here, as opposed to other places, the event is emitted on the cap
         // that initiates the GC and external tools expect it to have the same
-        // timestamp as used in +RTS -s calculcations.
+        // timestamp as used in +RTS -s calculations.
         traceEventGcEndAtT(cap, TimeToNS(stats.elapsed_ns));
 
         if (gen == RtsFlags.GcFlags.generations-1) { // major GC?
@@ -643,7 +643,7 @@ stat_endGC (Capability *cap, gc_thread *initiating_gct, W_ live, W_ copied, W_ s
 }
 
 /* -----------------------------------------------------------------------------
-   Called at the beginning of each Retainer Profiliing
+   Called at the beginning of each Retainer Profiling
    -------------------------------------------------------------------------- */
 #if defined(PROFILING)
 void
@@ -660,7 +660,7 @@ stat_startRP(void)
 #endif /* PROFILING */
 
 /* -----------------------------------------------------------------------------
-   Called at the end of each Retainer Profiliing
+   Called at the end of each Retainer Profiling
    -------------------------------------------------------------------------- */
 
 #if defined(PROFILING)
diff --git a/rts/Threads.c b/rts/Threads.c
index 1972f14895..fdd7eeadf0 100644
--- a/rts/Threads.c
+++ b/rts/Threads.c
@@ -358,7 +358,7 @@ void
 migrateThread (Capability *from, StgTSO *tso, Capability *to)
 {
     // Sadly we can't assert this since migrateThread is called from
-    // scheduleDoGC, where we implicly own all capabilities.
+    // scheduleDoGC, where we implicitly own all capabilities.
     //ASSERT_FULL_CAPABILITY_INVARIANTS(from, getTask());
 
     traceEventMigrateThread (from, tso, to->no);
diff --git a/rts/TraverseHeap.c b/rts/TraverseHeap.c
index 43318541f8..60c88a278d 100644
--- a/rts/TraverseHeap.c
+++ b/rts/TraverseHeap.c
@@ -931,7 +931,7 @@ traverseSmallBitmap (traverseState *ts, StgPtr p, uint32_t size, StgWord bitmap,
  *
  *  Note:
  *
- *    This code was almost plagiarzied from GC.c! For each pointer,
+ *    This code was almost plagiarized from GC.c! For each pointer,
  *    traversePushClosure() is invoked instead of evacuate().
  */
 static void
diff --git a/rts/TraverseHeap.h b/rts/TraverseHeap.h
index 2ac20e9cc5..010b2f3025 100644
--- a/rts/TraverseHeap.h
+++ b/rts/TraverseHeap.h
@@ -112,7 +112,7 @@ typedef struct traverseState_ {
      * users for example by shifting the real data up by one bit.
      *
      * Since we don't want to have to scan the entire heap a second time just to
-     * reset the per-object visitied bit before/after the real traversal we make
+     * reset the per-object visited bit before/after the real traversal we make
      * the interpretation of this bit dependent on the value of a global
      * variable, 'flip' and "flip" this variable when we want to invalidate all
      * objects.
diff --git a/rts/eventlog/EventLog.c b/rts/eventlog/EventLog.c
index ff3229298c..ba05f31591 100644
--- a/rts/eventlog/EventLog.c
+++ b/rts/eventlog/EventLog.c
@@ -76,7 +76,7 @@ bool eventlog_enabled; // protected by state_change_mutex to ensure
  *  6. stop the writer
  *  7. release state_change_mutex
  *
- * Note that a corrollary of this is that !eventlog_enabled implies that the
+ * Note that a corollary of this is that !eventlog_enabled implies that the
  * eventlog buffers are all empty (modulo the block marker that all buffers
  * always have).
  *
@@ -302,7 +302,7 @@ postHeaderEvents(void)
     postInt32(&eventBuf, EVENT_DATA_BEGIN);
 }
 
-// These events will be reposted everytime we restart the eventlog
+// These events will be reposted every time we restart the eventlog
 void
 postInitEvent(EventlogInitPost post_init){
     ACQUIRE_LOCK(&state_change_mutex);
@@ -1341,7 +1341,7 @@ void postProfSampleCostCentre(Capability *cap,
 
 // This event is output at the start of profiling so the tick interval can
 // be reported. Once the tick interval is reported the total executation time
-// can be calculuated from how many samples there are.
+// can be calculated from how many samples there are.
 void postProfBegin(void)
 {
     ACQUIRE_LOCK(&eventBufMutex);
diff --git a/rts/ghc.mk b/rts/ghc.mk
index 0e56515a56..099e6531cd 100644
--- a/rts/ghc.mk
+++ b/rts/ghc.mk
@@ -381,7 +381,7 @@ WARNING_OPTS += -Wno-unused-label
 #WARNING_OPTS += -Wcast-qual
 
 # This one seems buggy on GCC 4.1.2, which is the only GCC version we
-# have that can bootstrap the SPARC build. We end up with lots of supurious
+# have that can bootstrap the SPARC build. We end up with lots of spurious
 # warnings of the form "cast increases required alignment of target type".
 # Some legitimate warnings can be fixed by adding an intermediate cast to
 # (void*), but we get others in rts/sm/GCUtils.c concerning the gct var
diff --git a/rts/include/RtsAPI.h b/rts/include/RtsAPI.h
index b6ea88623c..672673498f 100644
--- a/rts/include/RtsAPI.h
+++ b/rts/include/RtsAPI.h
@@ -141,7 +141,7 @@ typedef struct GCDetails_ {
   uint32_t threads;
     // Number of bytes allocated since the previous GC
   uint64_t allocated_bytes;
-    // Total amount of live data in the heap (incliudes large + compact data).
+    // Total amount of live data in the heap (includes large + compact data).
     // Updated after every GC. Data in uncollected generations (in minor GCs)
     // are considered live.
   uint64_t live_bytes;
diff --git a/rts/include/ghc.mk b/rts/include/ghc.mk
index 92a70538d1..074af66078 100644
--- a/rts/include/ghc.mk
+++ b/rts/include/ghc.mk
@@ -47,7 +47,7 @@ includes_H_FILES_GENERATED = \
     ghcplatform.h
 
 # Unlike above, include generated files. We still need the previous list
-# without the generated files separtely and not just as part of this due to
+# without the generated files separately and not just as part of this due to
 # lingering issues like the derived constants generation snooping the RTS
 # headers.
 includes_dist_H_FILES = \
diff --git a/rts/include/rts/TSANUtils.h b/rts/include/rts/TSANUtils.h
index 72f4541a89..ddcf108041 100644
--- a/rts/include/rts/TSANUtils.h
+++ b/rts/include/rts/TSANUtils.h
@@ -41,7 +41,7 @@
 
 #if defined(TSAN_ENABLED)
 #if !defined(HAVE_C11_ATOMICS)
-#error TSAN cannot be enabled without C11 atomics suppoort.
+#error TSAN cannot be enabled without C11 atomics support.
 #endif
 
 #define TSAN_ANNOTATE_HAPPENS_BEFORE(addr)                              \
diff --git a/rts/include/rts/storage/ClosureMacros.h b/rts/include/rts/storage/ClosureMacros.h
index d3ceca4805..34e07ae553 100644
--- a/rts/include/rts/storage/ClosureMacros.h
+++ b/rts/include/rts/storage/ClosureMacros.h
@@ -589,7 +589,7 @@ overwritingMutableClosureOfs (StgClosure *p, uint32_t offset)
     //   - shrinkSmallMutableArray# (SMALL_MUT_ARR_PTRS)
     //
     // we can safely omit the Ldv_recordDead call. Since these closures are
-    // considered inherenlty used we don't need to track their destruction.
+    // considered inherently used we don't need to track their destruction.
 #if defined(PROFILING)
     ASSERT(isInherentlyUsed(get_itbl(p)->type) == true);
 #endif
diff --git a/rts/include/stg/SMP.h b/rts/include/stg/SMP.h
index 696ec737ac..1bb6ca06a0 100644
--- a/rts/include/stg/SMP.h
+++ b/rts/include/stg/SMP.h
@@ -80,7 +80,7 @@ EXTERN_INLINE StgWord atomic_dec(StgVolatilePtr p);
 /*
  * Busy-wait nop: this is a hint to the CPU that we are currently in a
  * busy-wait loop waiting for another CPU to change something.  On a
- * hypertreaded CPU it should yield to another thread, for example.
+ * hyperthreaded CPU it should yield to another thread, for example.
  */
 EXTERN_INLINE void busy_wait_nop(void);
 
diff --git a/rts/linker/elf_compat.h b/rts/linker/elf_compat.h
index 424d1d25f8..9f2780203d 100644
--- a/rts/linker/elf_compat.h
+++ b/rts/linker/elf_compat.h
@@ -6,7 +6,7 @@
 // The files in ELFRelocs/ have been taken from
 // the LLVM project. See ELFRelocs/LICENSE-LLVM.TXT
 // for the University of Illinois Open Source License
-// under which it is distrubuted.
+// under which it is distributed.
 //
 
 #pragma once
diff --git a/rts/linker/elf_got.c b/rts/linker/elf_got.c
index 0f511e663f..4d0c97871e 100644
--- a/rts/linker/elf_got.c
+++ b/rts/linker/elf_got.c
@@ -17,7 +17,7 @@ needGotSlot(Elf_Sym * symbol) {
      * STB_WEAK.
      *
      * Any more restrictive filter here would result
-     * in a smaller GOT, which is preferrable.
+     * in a smaller GOT, which is preferable.
      */
     return ELF_ST_BIND(symbol->st_info) == STB_GLOBAL
         || ELF_ST_BIND(symbol->st_info) == STB_WEAK
@@ -87,7 +87,7 @@ fillGot(ObjectCode * oc) {
             if(needGotSlot(symbol->elf_sym)) {
 
                 /* no type are undefined symbols */
-                // Note STT_SECTION symbols should have their addres
+                // Note STT_SECTION symbols should have their address
                 // set prior to the fillGot call in ocResolve_ELF.
                 if(   STT_NOTYPE == ELF_ST_TYPE(symbol->elf_sym->st_info)
                    || STB_WEAK   == ELF_ST_BIND(symbol->elf_sym->st_info)) {
diff --git a/rts/posix/Signals.c b/rts/posix/Signals.c
index 2441f52016..5fab4e8984 100644
--- a/rts/posix/Signals.c
+++ b/rts/posix/Signals.c
@@ -561,7 +561,7 @@ empty_handler (int sig STG_UNUSED)
 /* -----------------------------------------------------------------------------
    SIGTSTP handling
 
-   When a process is suspeended with ^Z and resumed again, the shell
+   When a process is suspended with ^Z and resumed again, the shell
    makes no attempt to save and restore the terminal settings.  So on
    resume, any terminal setting modifications we made (e.g. turning off
    ICANON due to hSetBuffering NoBuffering) may well be lost.  Hence,
diff --git a/rts/posix/TTY.c b/rts/posix/TTY.c
index 52ade92374..0c7eaf0ea4 100644
--- a/rts/posix/TTY.c
+++ b/rts/posix/TTY.c
@@ -46,7 +46,7 @@ resetTerminalSettings (void)
 #if HAVE_TERMIOS_H
     // Reset the terminal settings on the standard file descriptors,
     // if we changed them.  See System.Posix.Internals.tcSetAttr for
-    // more details, including the reason we termporarily disable
+    // more details, including the reason we temporarily disable
     // SIGTTOU here.
     {
         int fd;
diff --git a/rts/rts.cabal.in b/rts/rts.cabal.in
index 96989ee750..6324829903 100644
--- a/rts/rts.cabal.in
+++ b/rts/rts.cabal.in
@@ -466,7 +466,7 @@ library
       if arch(ia64)
         c-sources: adjustor/NativeIA64.c
 
-    -- Use assembler STG entrypoint on archictures where it is used
+    -- Use assembler STG entrypoint on architectures where it is used
     if arch(ppc) || arch(ppc64) || arch(s390x) || arch(riscv64)
       asm-sources: StgCRunAsm.S
 
diff --git a/rts/sm/GC.c b/rts/sm/GC.c
index 71c1ecbfeb..24aeef8bef 100644
--- a/rts/sm/GC.c
+++ b/rts/sm/GC.c
@@ -2269,7 +2269,7 @@ bool doIdleGCWork(Capability *cap STG_UNUSED, bool all)
  * usage when the live data size is much more reasonable (for example ghcide)
  *
  * Therefore we have a new (2021) strategy which starts by retaining up to 4 * live_bytes
- * of blocks before gradually returning uneeded memory back to the OS on subsequent
+ * of blocks before gradually returning unneeded memory back to the OS on subsequent
  * major GCs which are NOT caused by a heap overflow.
  *
  * Each major GC which is NOT caused by heap overflow increases the consec_idle_gcs
diff --git a/rts/sm/MBlock.c b/rts/sm/MBlock.c
index ffd4f41266..84dc6a2bc0 100644
--- a/rts/sm/MBlock.c
+++ b/rts/sm/MBlock.c
@@ -46,8 +46,8 @@ W_ mpc_misses = 0;
       that was committed, after the given one
 
   For both these calls, @state is an in-out parameter that points to
-  an opaque state threading the calls togheter. The calls should only
-  be used in an interation fashion. Pass NULL if @state is not
+  an opaque state threading the calls together. The calls should only
+  be used in an iteration fashion. Pass NULL if @state is not
   interesting,or pass a pointer to NULL if you don't have a state.
 
   void *getCommittedMBlocks(uint32_t n)
diff --git a/rts/win32/AsyncWinIO.c b/rts/win32/AsyncWinIO.c
index fa397c343d..2c15dbad5a 100644
--- a/rts/win32/AsyncWinIO.c
+++ b/rts/win32/AsyncWinIO.c
@@ -373,7 +373,7 @@ void registerAlertableWait (bool has_timeout, DWORD mssec)
 }
 
 /* Exported callback function that will be called by the RTS to collect the
-   finished overlapped entried belonging to the completed I/O requests.  The
+   finished overlapped entries belonging to the completed I/O requests.  The
    number of read entries will be returned in NUM.
 
    NOTE: This function isn't thread safe, but is intended to be called only
diff --git a/rts/win32/veh_excn.c b/rts/win32/veh_excn.c
index 749f3720ce..ec992bb211 100644
--- a/rts/win32/veh_excn.c
+++ b/rts/win32/veh_excn.c
@@ -56,7 +56,7 @@
   software exceptions Which means previously when we registered VEH handlers
   we would also trap software exceptions. Which means when haskell code was
   loaded in a C++ or C# context we would swallow exceptions and terminate in
-  contexes that normally the runtime should be able to continue on, e.g. you
+  contexts that normally the runtime should be able to continue on, e.g. you
   could be handling the segfault in your C++ code, or the div by 0.
 
   We could not handle these exceptions, but GHCi would just die a horrible death
@@ -65,7 +65,7 @@
   So instead, we'll move to Continue handler, to run as late as possible, and
   also register a filter which calls any existing filter, and then runs the
   continue handlers, we then also only run as the last continue handler so we
-  don't supercede any other VCH handlers.
+  don't supersede any other VCH handlers.
 
   Lastly we'll also provide a way for users to disable the exception handling
   entirely so even if the new approach doesn't solve the issue they can work
diff --git a/rts/xxhash.h b/rts/xxhash.h
index 2d56d23c5d..68fe10f6d4 100644
--- a/rts/xxhash.h
+++ b/rts/xxhash.h
@@ -299,7 +299,7 @@ XXH_PUBLIC_API XXH32_hash_t XXH32 (const void* input, size_t length, XXH32_hash_
 /*******   Streaming   *******/
 
 /*
- * Streaming functions generate the xxHash value from an incrememtal input.
+ * Streaming functions generate the xxHash value from an incremental input.
  * This method is slower than single-call functions, due to state management.
  * For small inputs, prefer `XXH32()` and `XXH64()`, which are better optimized.
  *
@@ -835,7 +835,7 @@ XXH_PUBLIC_API XXH128_hash_t XXH128(const void* data, size_t len, XXH64_hash_t s
  *
  * The check costs one initial branch per hash, which is generally negligible, but not zero.
  * Moreover, it's not useful to generate binary for an additional code path
- * if memory access uses same instruction for both aligned and unaligned adresses.
+ * if memory access uses same instruction for both aligned and unaligned addresses.
  *
  * In these cases, the alignment check can be removed by setting this macro to 0.
  * Then the code will always use unaligned memory access.