[libunwind] 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).

libunwind/docs/conf.py

 
 # If false, no module index is generated.
 #texinfo_domain_indices = True
 
 # How to display URL addresses: 'footnote', 'no', or 'inline'.
 #texinfo_show_urls = 'footnote'
 
 
-# FIXME: Define intersphinx configration.
+# FIXME: Define intersphinx configuration.
 intersphinx_mapping = {}
 
 
 # -- Options for extensions ----------------------------------------------------
 
 # Enable this if you want TODOs to show up in the generated documentation.
 todo_include_todos = True

libunwind/include/mach-o/compact_unwind_encoding.h

 // DWARF unwind info, the __TEXT,__unwind_info section will contain the offset
 // of the FDE in the __TEXT,__eh_frame section in the final linked image.
 //
 // Note: Previously, the linker would transform some DWARF unwind infos into
 //       compact unwind info.  But that is fragile and no longer done.
 
 
 //
-// The compact unwind endoding is a 32-bit value which encoded in an
+// The compact unwind encoding is a 32-bit value which encoded in an
 // architecture specific way, which registers to restore from where, and how
 // to unwind out of the function.
 //
 typedef uint32_t compact_unwind_encoding_t;
 
 
 // architecture independent bits
 enum {

 //    A "frameless" (EBP not used as frame pointer) function with a small 
 //    constant stack size.  To return, a constant (encoded in the compact
 //    unwind encoding) is added to the ESP. Then the return is done by
 //    popping the stack into the pc.
 //    All non-volatile registers that need to be restored must have been saved
 //    on the stack immediately after the return address.  The stack_size/4 is
 //    encoded in the UNWIND_X86_FRAMELESS_STACK_SIZE (max stack size is 1024).
 //    The number of registers saved is encoded in UNWIND_X86_FRAMELESS_STACK_REG_COUNT.
-//    UNWIND_X86_FRAMELESS_STACK_REG_PERMUTATION constains which registers were
+//    UNWIND_X86_FRAMELESS_STACK_REG_PERMUTATION contains which registers were
 //    saved and their order.
 // UNWIND_X86_MODE_STACK_IND:
 //    A "frameless" (EBP not used as frame pointer) function large constant 
 //    stack size.  This case is like the previous, except the stack size is too
 //    large to encode in the compact unwind encoding.  Instead it requires that 
 //    the function contains "subl $nnnnnnnn,ESP" in its prolog.  The compact 
 //    encoding contains the offset to the nnnnnnnn value in the function in
 //    UNWIND_X86_FRAMELESS_STACK_SIZE.  

 //    A "frameless" (RBP not used as frame pointer) function with a small 
 //    constant stack size.  To return, a constant (encoded in the compact 
 //    unwind encoding) is added to the RSP. Then the return is done by 
 //    popping the stack into the pc.
 //    All non-volatile registers that need to be restored must have been saved
 //    on the stack immediately after the return address.  The stack_size/8 is
 //    encoded in the UNWIND_X86_64_FRAMELESS_STACK_SIZE (max stack size is 2048).
 //    The number of registers saved is encoded in UNWIND_X86_64_FRAMELESS_STACK_REG_COUNT.
-//    UNWIND_X86_64_FRAMELESS_STACK_REG_PERMUTATION constains which registers were
+//    UNWIND_X86_64_FRAMELESS_STACK_REG_PERMUTATION contains which registers were
 //    saved and their order.  
 // UNWIND_X86_64_MODE_STACK_IND:
 //    A "frameless" (RBP not used as frame pointer) function large constant 
 //    stack size.  This case is like the previous, except the stack size is too
 //    large to encode in the compact unwind encoding.  Instead it requires that 
 //    the function contains "subq $nnnnnnnn,RSP" in its prolog.  The compact 
 //    encoding contains the offset to the nnnnnnnn value in the function in
 //    UNWIND_X86_64_FRAMELESS_STACK_SIZE.  

libunwind/include/unwind.h

 
 #ifdef __USING_SJLJ_EXCEPTIONS__
 typedef struct _Unwind_FunctionContext *_Unwind_FunctionContext_t;
 extern void _Unwind_SjLj_Register(_Unwind_FunctionContext_t fc);
 extern void _Unwind_SjLj_Unregister(_Unwind_FunctionContext_t fc);
 #endif
 
 //
-// The following are semi-suppoted extensions to the C++ ABI
+// The following are semi-supported extensions to the C++ ABI
 //
 
 //
 //  called by __cxa_rethrow().
 //
 #ifdef __USING_SJLJ_EXCEPTIONS__
 extern _Unwind_Reason_Code
     _Unwind_SjLj_Resume_or_Rethrow(_Unwind_Exception *exception_object);

libunwind/src/DwarfInstructions.hpp

 #include "Registers.hpp"
 #include "DwarfParser.hpp"
 #include "config.h"
 
 
 namespace libunwind {
 
 
-/// DwarfInstructions maps abtract DWARF unwind instructions to a particular
+/// DwarfInstructions maps abstract DWARF unwind instructions to a particular
 /// architecture
 template <typename A, typename R>
 class DwarfInstructions {
 public:
   typedef typename A::pint_t pint_t;
   typedef typename A::sint_t sint_t;
 
   static int stepWithDwarf(A &addressSpace, pint_t pc, pint_t fdeStart,
if (CFI_Parser<A>::parseFDEInstructions(addressSpace, fdeInfo, cieInfo, pc,
           else if (registers.validRegister(i))
             newRegisters.setRegister(
                 i, getSavedRegister(addressSpace, registers, cfa,
                                     prolog.savedRegisters[i]));
           else
             return UNW_EBADREG;
         } else if (i == (int)cieInfo.returnAddressRegister) {
             // Leaf function keeps the return address in register and there is no
-            // explicit intructions how to restore it.
+            // explicit instructions how to restore it.
             returnAddress = registers.getRegister(cieInfo.returnAddressRegister);
         }
       }
 
       isSignalFrame = cieInfo.isSignalFrame;
 
 #if defined(_LIBUNWIND_TARGET_AARCH64)
       // If the target is aarch64 then the return address may have been signed
#define PPC64_ELFV2_R2_OFFSET 24
           break;
         }
         if (r2)
           newRegisters.setRegister(UNW_PPC64_R2, r2);
       }
 #endif
 
       // Return address is address after call site instruction, so setting IP to
-      // that does simualates a return.
+      // that does simulates a return.
       newRegisters.setIP(returnAddress);
 
       // Simulate the step by replacing the register set with the new ones.
       registers = newRegisters;
 
       return UNW_STEP_SUCCESS;
     }
   }
case DW_OP_shr:
         fprintf(stderr, "shift left\n");
       break;
 
     case DW_OP_shra:
       value = *sp--;
       svalue = (sint_t)*sp;
       *sp = (pint_t)(svalue >> value);
       if (log)
-        fprintf(stderr, "shift left arithmetric\n");
+        fprintf(stderr, "shift left arithmetic\n");
       break;
 
     case DW_OP_xor:
       value = *sp--;
       *sp ^= value;
       if (log)
         fprintf(stderr, "xor\n");
       break;

libunwind/src/DwarfParser.hpp

#endif
   if ((version != 1) && (version != 3))
     return "CIE version is not 1 or 3";
   ++p;
   // save start of augmentation string and find end
   pint_t strStart = p;
   while (addressSpace.get8(p) != 0)
     ++p;
   ++p;
-  // parse code aligment factor
+  // parse code alignment factor
   cieInfo->codeAlignFactor = (uint32_t)addressSpace.getULEB128(p, cieContentEnd);
   // parse data alignment factor
   cieInfo->dataAlignFactor = (int)addressSpace.getSLEB128(p, cieContentEnd);
   // parse return address register
   uint64_t raReg = (version == 1) ? addressSpace.get8(p++)
                                   : addressSpace.getULEB128(p, cieContentEnd);
   assert(raReg < 255 && "return address register too large");
   cieInfo->returnAddressRegister = (uint8_t)raReg;
#endif
     }
   }
   cieInfo->cieLength = cieContentEnd - cieInfo->cieStart;
   cieInfo->cieInstructions = p;
   return result;
 }
 
 
-/// "run" the DWARF instructions and create the abstact PrologInfo for an FDE
+/// "run" the DWARF instructions and create the abstract PrologInfo for an FDE
 template <typename A>
 bool CFI_Parser<A>::parseFDEInstructions(A &addressSpace,
                                          const FDE_Info &fdeInfo,
                                          const CIE_Info &cieInfo, pint_t upToPC,
                                          int arch, PrologInfo *results) {
   // Alloca is used for the allocation of the rememberStack entries. It removes
   // the dependency on new/malloc but the below for loop can not be refactored
   // into functions. Entry could be saved during the processing of a CIE and

libunwind/src/Registers.hpp

 #   if __riscv_flen == 64
 typedef double fp_t;
 #   elif __riscv_flen == 32
 typedef float fp_t;
 #   else
 #    error "Unsupported __riscv_flen"
 #   endif
 #  else
-// This is just for supressing undeclared error of fp_t.
+// This is just for suppressing undeclared error of fp_t.
 typedef double fp_t;
 #  endif
 # else
 // Use Max possible width when cross unwinding
 typedef uint64_t reg_t;
 typedef double fp_t;
 # define __riscv_xlen 64
 # define __riscv_flen 64

libunwind/src/Unwind-EHABI.cpp

if ((*data & 0x80000000) == 0) {
     // and ARM assembler, assume that the unwind opcodes come after the
     // personality rountine address.
     *off = 1; // First byte is size data.
     *len = (((data[1] >> 24) & 0xff) + 1) * 4;
     data++; // Skip the first word, which is the prel31 offset.
   } else {
     // 6.3: ARM Compact Model
     //
-    // EHT entries here correspond to the __aeabi_unwind_cpp_pr[012] PRs indeded
+    // EHT entries here correspond to the __aeabi_unwind_cpp_pr[012] PRs indeed
     // by format:
     Descriptor::Format format =
         static_cast<Descriptor::Format>((*data & 0x0f000000) >> 24);
     switch (format) {
       case Descriptor::SU16:
         *len = 4;
         *off = 1;
         break;
_LIBUNWIND_EXPORT void _Unwind_Complete(_Unwind_Exception* exception_object) {
   (void)exception_object;
 }
 
 /// When _Unwind_RaiseException() is in phase2, it hands control
 /// to the personality function at each frame.  The personality
 /// may force a jump to a landing pad in that function, the landing
 /// pad code may then call _Unwind_Resume() to continue with the
 /// unwinding.  Note: the call to _Unwind_Resume() is from compiler
-/// geneated user code.  All other _Unwind_* routines are called
+/// generated user code.  All other _Unwind_* routines are called
 /// by the C++ runtime __cxa_* routines.
 ///
 /// Note: re-throwing an exception (as opposed to continuing the unwind)
 /// is implemented by having the code call __cxa_rethrow() which
 /// in turn calls _Unwind_Resume_or_Rethrow().
 _LIBUNWIND_EXPORT void
 _Unwind_Resume(_Unwind_Exception *exception_object) {
   _LIBUNWIND_TRACE_API("_Unwind_Resume(ex_obj=%p)",

libunwind/src/Unwind-seh.cpp

case _URC_CONTINUE_UNWIND:
     // at the target frame, we're in real trouble.
     if (action & _UA_HANDLER_FRAME)
       _LIBUNWIND_ABORT("Personality continued unwind at the target frame!");
     return ExceptionContinueSearch;
   case _URC_HANDLER_FOUND:
     // If we were called by __libunwind_seh_personality(), indicate that
     // a handler was found; otherwise, initiate phase 2 by unwinding.
     if (ours && ms_exc->NumberParameters > 1)
-      return 4 /* ExecptionExecuteHandler in mingw */;
+      return 4 /* ExceptionExecuteHandler in mingw */;
     // This should never happen in phase 2.
     if (IS_UNWINDING(ms_exc->ExceptionFlags))
       _LIBUNWIND_ABORT("Personality indicated exception handler in phase 2!");
     exc->private_[1] = (ULONG_PTR)frame;
     if (ours) {
       ms_exc->NumberParameters = 4;
       ms_exc->ExceptionInformation[1] = (ULONG_PTR)frame;
     }
     // FIXME: Indicate target frame in foreign case!
     // phase 2: the clean up phase
     RtlUnwindEx(frame, (PVOID)disp->ControlPc, ms_exc, exc, ms_ctx, disp->HistoryTable);
     _LIBUNWIND_ABORT("RtlUnwindEx() failed");
   case _URC_INSTALL_CONTEXT: {
     // If we were called by __libunwind_seh_personality(), indicate that
     // a handler was found; otherwise, it's time to initiate a collided
     // unwind to the target.
     if (ours && !IS_UNWINDING(ms_exc->ExceptionFlags) && ms_exc->NumberParameters > 1)
-      return 4 /* ExecptionExecuteHandler in mingw */;
+      return 4 /* ExceptionExecuteHandler in mingw */;
     // This should never happen in phase 1.
     if (!IS_UNWINDING(ms_exc->ExceptionFlags))
       _LIBUNWIND_ABORT("Personality installed context during phase 1!");
 #ifdef __x86_64__
     exc->private_[2] = disp->TargetIp;
     __unw_get_reg(&cursor, UNW_X86_64_RAX, &retval);
     __unw_get_reg(&cursor, UNW_X86_64_RDX, &exc->private_[3]);
 #elif defined(__arm__)
_Unwind_RaiseException(_Unwind_Exception *exception_object) {
   return _URC_END_OF_STACK;
 }
 
 /// When \c _Unwind_RaiseException() is in phase2, it hands control
 /// to the personality function at each frame.  The personality
 /// may force a jump to a landing pad in that function; the landing
 /// pad code may then call \c _Unwind_Resume() to continue with the
 /// unwinding.  Note: the call to \c _Unwind_Resume() is from compiler
-/// geneated user code.  All other \c _Unwind_* routines are called
+/// generated user code.  All other \c _Unwind_* routines are called
 /// by the C++ runtime \c __cxa_* routines.
 ///
 /// Note: re-throwing an exception (as opposed to continuing the unwind)
 /// is implemented by having the code call \c __cxa_rethrow() which
 /// in turn calls \c _Unwind_Resume_or_Rethrow().
 _LIBUNWIND_EXPORT void
 _Unwind_Resume(_Unwind_Exception *exception_object) {
   _LIBUNWIND_TRACE_API("_Unwind_Resume(ex_obj=%p)", (void *)exception_object);

libunwind/src/Unwind-sjlj.c

 
 #if defined(_LIBUNWIND_BUILD_SJLJ_APIS)
 
 struct _Unwind_FunctionContext {
   // next function in stack of handlers
   struct _Unwind_FunctionContext *prev;
 
 #if defined(__ve__)
-  // VE requires to store 64 bit pointers in the buffer for SjLj execption.
+  // VE requires to store 64 bit pointers in the buffer for SjLj exception.
   // We expand the size of values defined here.  This size must be matched
   // to the size returned by TargetMachine::getSjLjDataSize().
 
   // set by calling function before registering to be the landing pad
   uint64_t                        resumeLocation;
 
   // set by personality handler to be parameters passed to landing pad function
   uint64_t                        resumeParameters[4];

 
 
 
 /// When _Unwind_RaiseException() is in phase2, it hands control
 /// to the personality function at each frame.  The personality
 /// may force a jump to a landing pad in that function, the landing
 /// pad code may then call _Unwind_Resume() to continue with the
 /// unwinding.  Note: the call to _Unwind_Resume() is from compiler
-/// geneated user code.  All other _Unwind_* routines are called
+/// generated user code.  All other _Unwind_* routines are called
 /// by the C++ runtime __cxa_* routines.
 ///
 /// Re-throwing an exception is implemented by having the code call
 /// __cxa_rethrow() which in turn calls _Unwind_Resume_or_Rethrow()
 _LIBUNWIND_EXPORT void
 _Unwind_SjLj_Resume(struct _Unwind_Exception *exception_object) {
   _LIBUNWIND_TRACE_API("_Unwind_SjLj_Resume(ex_obj=%p)",
                        (void *)exception_object);
_Unwind_SjLj_Resume_or_Rethrow(struct _Unwind_Exception *exception_object) {
   // re-throw.
   // Call _Unwind_RaiseException() as if this was a new exception.
   if (exception_object->private_1 == 0) {
     return _Unwind_SjLj_RaiseException(exception_object);
     // should return if there is no catch clause, so that __cxa_rethrow can call
     // std::terminate()
   }
 
-  // Call through to _Unwind_Resume() which distiguishes between forced and
+  // Call through to _Unwind_Resume() which distinguishes between forced and
   // regular exceptions.
   _Unwind_SjLj_Resume(exception_object);
   _LIBUNWIND_ABORT("__Unwind_SjLj_Resume_or_Rethrow() called "
                     "_Unwind_SjLj_Resume() which unexpectedly returned");
 }
 
 
 /// Called by personality handler during phase 2 to get LSDA for current frame.

libunwind/src/UnwindCursor.hpp

 #ifdef __arm__
   virtual void        saveVFPAsX();
 #endif
 
   DISPATCHER_CONTEXT *getDispatcherContext() { return &_dispContext; }
   void setDispatcherContext(DISPATCHER_CONTEXT *disp) { _dispContext = *disp; }
 
   // libunwind does not and should not depend on C++ library which means that we
-  // need our own defition of inline placement new.
+  // need our own definition of inline placement new.
   static void *operator new(size_t, UnwindCursor<A, R> *p) { return p; }
 
 private:
 
   pint_t getLastPC() const { return _dispContext.ControlPc; }
   void setLastPC(pint_t pc) { _dispContext.ControlPc = pc; }
   RUNTIME_FUNCTION *lookUpSEHUnwindInfo(pint_t pc, pint_t *base) {
 #ifdef __arm__
#ifdef _AIX
   virtual uintptr_t getDataRelBase();
 #endif
 
 #if defined(_LIBUNWIND_USE_CET)
   virtual void *get_registers() { return &_registers; }
 #endif
 
   // libunwind does not and should not depend on C++ library which means that we
-  // need our own defition of inline placement new.
+  // need our own definition of inline placement new.
   static void *operator new(size_t, UnwindCursor<A, R> *p) { return p; }
 
 private:
 
 #if defined(_LIBUNWIND_ARM_EHABI)
   bool getInfoFromEHABISection(pint_t pc, const UnwindInfoSections &sects);
 
   int stepWithEHABI() {
if (isSignalFrame) {
     }
   }
   _LIBUNWIND_TRACE_UNWINDING("lastStack=%p, returnAddress=%p, pc=%p\n",
                              reinterpret_cast<void *>(lastStack),
                              reinterpret_cast<void *>(returnAddress),
                              reinterpret_cast<void *>(pc));
 
   // The return address is the address after call site instruction, so
-  // setting IP to that simualates a return.
+  // setting IP to that simulates a return.
   newRegisters.setIP(reinterpret_cast<uintptr_t>(returnAddress));
 
   // Simulate the step by replacing the register set with the new ones.
   registers = newRegisters;
 
   // Check if the next frame is a signal frame.
   pint_t nextStack = *(reinterpret_cast<pint_t *>(registers.getSP()));
 

libunwind/src/UnwindLevel1-gcc-ext.c

_Unwind_Resume_or_Rethrow(_Unwind_Exception *exception_object) {
   // re-throw.
   // Call _Unwind_RaiseException() as if this was a new exception
   if (exception_object->PRIVATE_1 == 0) {
     return _Unwind_RaiseException(exception_object);
     // Will return if there is no catch clause, so that __cxa_rethrow can call
     // std::terminate().
   }
 
-  // Call through to _Unwind_Resume() which distiguishes between forced and
+  // Call through to _Unwind_Resume() which distinguishes between forced and
   // regular exceptions.
   _Unwind_Resume(exception_object);
   _LIBUNWIND_ABORT("_Unwind_Resume_or_Rethrow() called _Unwind_RaiseException()"
                    " which unexpectedly returned");
 }
 
 /// Called by personality handler during phase 2 to get base address for data
 /// relative encodings.

libunwind/src/UnwindLevel1.c

 #ifndef _LIBUNWIND_SUPPORT_SEH_UNWIND
 
 // When CET is enabled, each "call" instruction will push return address to
 // CET shadow stack, each "ret" instruction will pop current CET shadow stack
 // top and compare it with target address which program will return.
 // In exception handing, some stack frames will be skipped before jumping to
 // landing pad and we must adjust CET shadow stack accordingly.
 // _LIBUNWIND_POP_CET_SSP is used to adjust CET shadow stack pointer and we
-// directly jump to __libunwind_Registerts_x86/x86_64_jumpto instead of using
+// directly jump to __libunwind_Registers_x86/x86_64_jumpto instead of using
 // a regular function call to avoid pushing to CET shadow stack again.
 #if !defined(_LIBUNWIND_USE_CET)
 #define __unw_phase2_resume(cursor, fn)                                        \
   do {                                                                         \
     (void)fn;                                                                  \
     __unw_resume((cursor));                                                    \
   } while (0)
 #elif defined(_LIBUNWIND_TARGET_I386)

 
 
 
 /// When _Unwind_RaiseException() is in phase2, it hands control
 /// to the personality function at each frame.  The personality
 /// may force a jump to a landing pad in that function, the landing
 /// pad code may then call _Unwind_Resume() to continue with the
 /// unwinding.  Note: the call to _Unwind_Resume() is from compiler
-/// geneated user code.  All other _Unwind_* routines are called
+/// generated user code.  All other _Unwind_* routines are called
 /// by the C++ runtime __cxa_* routines.
 ///
 /// Note: re-throwing an exception (as opposed to continuing the unwind)
 /// is implemented by having the code call __cxa_rethrow() which
 /// in turn calls _Unwind_Resume_or_Rethrow().
 _LIBUNWIND_EXPORT void
 _Unwind_Resume(_Unwind_Exception *exception_object) {
   _LIBUNWIND_TRACE_API("_Unwind_Resume(ex_obj=%p)", (void *)exception_object);

libunwind/src/UnwindRegistersRestore.S

 DEFINE_LIBUNWIND_FUNCTION(_ZN9libunwind13Registers_ppc6jumptoEv)
 //
 // void libunwind::Registers_ppc::jumpto()
 //
 // On entry:
 //  thread_state pointer is in r3
 //
 
-  // restore integral registerrs
+  // restore integral registers
   // skip r0 for now
   // skip r1 for now
   lwz     2,  16(3)
   // skip r3 for now
   // skip r4 for now
   // skip r5 for now
   lwz     6,  32(3)
   lwz     7,  36(3)

libunwind/src/Unwind_AIXExtras.cpp

char *getFuncNameFromTBTable(uintptr_t Pc, uint16_t &NameLen,
 
   // Get to the name of the function.
   p = reinterpret_cast<uint32_t *>(&TBTable->tb_ext);
 
   // Skip field parminfo if it exists.
   if (TBTable->tb.fixedparms || TBTable->tb.floatparms)
     p++;
 
-  // If the tb_offset field exisits, get the offset from the start of
+  // If the tb_offset field exists, get the offset from the start of
   // the function to pc. Skip the field.
   if (TBTable->tb.has_tboff) {
     unw_word_t StartIp =
         reinterpret_cast<uintptr_t>(TBTable) - *p - sizeof(uint32_t);
     *Offset = Pc - StartIp;
     p++;
   }
 

libunwind/src/libunwind.cpp

_LIBUNWIND_HIDDEN int __unw_set_reg(unw_cursor_t *cursor, unw_regnum_t regNum,
                                     unw_word_t value) {
   _LIBUNWIND_TRACE_API("__unw_set_reg(cursor=%p, regNum=%d, value=0x%" PRIxPTR
                        ")",
                        static_cast<void *>(cursor), regNum, value);
   typedef LocalAddressSpace::pint_t pint_t;
   AbstractUnwindCursor *co = (AbstractUnwindCursor *)cursor;
   if (co->validReg(regNum)) {
     co->setReg(regNum, (pint_t)value);
-    // specical case altering IP to re-find info (being called by personality
+    // special case altering IP to re-find info (being called by personality
     // function)
     if (regNum == UNW_REG_IP) {
       unw_proc_info_t info;
       // First, get the FDE for the old location and then update it.
       co->getInfo(&info);
       co->setInfoBasedOnIPRegister(false);
       // If the original call expects stack adjustment, perform this now.
       // Normal frame unwinding would have included the offset already in the

libunwind/test/unwind_leaffunction.pass.cpp

 #include <sys/types.h>
 #include <unistd.h>
 #include <unwind.h>
 
 _Unwind_Reason_Code frame_handler(struct _Unwind_Context* ctx, void* arg) {
   (void)arg;
   Dl_info info = { 0, 0, 0, 0 };
 
-  // Unwind util the main is reached, above frames deeped on the platfrom and architecture.
+  // Unwind until the main is reached, above frames deeped on the platform and
+  // architecture.
   if (dladdr(reinterpret_cast<void *>(_Unwind_GetIP(ctx)), &info) &&
       info.dli_sname && !strcmp("main", info.dli_sname)) {
     _Exit(0);
   }
   return _URC_NO_REASON;
 }
 
 void signal_handler(int signum) {