[lld] NFC: fix trivial typos in comments

[kiszk]

rebase with master

[dblaikie]

Super handy - thanks! (let me know if you need me to commit this for you, otherwise go ahead and commit it yourself)

[MaskRay]

LGTM

lld/ELF/Arch/PPC64.cpp

if (relas[index].r_offset < offset || index == 0)
       break;
     --index;
   }
   return {};
 }
 
 // When accessing a symbol defined in another translation unit, compilers
 // reserve a .toc entry, allocate a local label and generate toc-indirect
-// instuctions:
+// instructions:
 //
 //   addis 3, 2, .LC0@toc@ha  # R_PPC64_TOC16_HA
 //   ld    3, .LC0@toc@l(3)   # R_PPC64_TOC16_LO_DS, load the address from a .toc entry
 //   ld/lwa 3, 0(3)           # load the value from the address
 //
 //   .section .toc,"aw",@progbits
 //   .LC0: .tc var[TC],var
 //

lld/ELF/CallGraphSort.cpp

DenseMap<const InputSectionBase *, int> CallGraphSort::run() {
   }
 
   return orderMap;
 }
 
 // Sort sections by the profile data provided by -callgraph-profile-file
 //
 // This first builds a call graph based on the profile data then merges sections
-// according to the C³ huristic. All clusters are then sorted by a density
+// according to the C³ heuristic. All clusters are then sorted by a density
 // metric to further improve locality.
 DenseMap<const InputSectionBase *, int> computeCallGraphProfileOrder() {
   return CallGraphSort().run();
 }
 
 } // namespace elf
 } // namespace lld

lld/ELF/InputSection.cpp

case R_MIPS_GOT_GP:
     return in.mipsGot->getGp(file) + a;
   case R_MIPS_GOT_GP_PC: {
     // R_MIPS_LO16 expression has R_MIPS_GOT_GP_PC type iif the target
     // is _gp_disp symbol. In that case we should use the following
     // formula for calculation "AHL + GP - P + 4". For details see p. 4-19 at
     // ftp://www.linux-mips.org/pub/linux/mips/doc/ABI/mipsabi.pdf
     // microMIPS variants of these relocations use slightly different
     // expressions: AHL + GP - P + 3 for %lo() and AHL + GP - P - 1 for %hi()
-    // to correctly handle less-sugnificant bit of the microMIPS symbol.
+    // to correctly handle less-significant bit of the microMIPS symbol.
     uint64_t v = in.mipsGot->getGp(file) + a - p;
     if (type == R_MIPS_LO16 || type == R_MICROMIPS_LO16)
       v += 4;
     if (type == R_MICROMIPS_LO16 || type == R_MICROMIPS_HI16)
       v -= 1;
     return v;
   }
   case R_MIPS_GOT_LOCAL_PAGE:

lld/ELF/ScriptLexer.cpp

while (!s.empty()) {
     size_t e = s.find_first_of(ops);
 
     // No need to split if there is no operator.
     if (e == StringRef::npos) {
       ret.push_back(s);
       break;
     }
 
-    // Get a token before the opreator.
+    // Get a token before the operator.
     if (e != 0)
       ret.push_back(s.substr(0, e));
 
     // Get the operator as a token.
     // Keep !=, ==, >=, <=, << and >> operators as a single tokens.
     if (s.substr(e).startswith("!=") || s.substr(e).startswith("==") ||
         s.substr(e).startswith(">=") || s.substr(e).startswith("<=") ||
         s.substr(e).startswith("<<") || s.substr(e).startswith(">>")) {

lld/ELF/SyntheticSections.h

private:
   // holds primary and secondary GOT's.
   std::vector<FileGot> gots;
 
   // Return (and create if necessary) `FileGot`.
   FileGot &getGot(InputFile &f);
 
   // Try to merge two GOTs. In case of success the `Dst` contains
   // result of merging and the function returns true. In case of
-  // ovwerflow the `Dst` is unchanged and the function returns false.
+  // overflow the `Dst` is unchanged and the function returns false.
   bool tryMergeGots(FileGot & dst, FileGot & src, bool isPrimary);
 };
 
 class GotPltSection final : public SyntheticSection {
 public:
   GotPltSection();
   void addEntry(Symbol &sym);
   size_t getSize() const override;

lld/ELF/SyntheticSections.cpp

for (SymbolTableEntry &ent : symbols) {
     // get the exact same outputs for two sets of input files that differ only
     // in undefined symbol size in DSOs.
     if (eSym->st_shndx == SHN_UNDEF || !isDefinedHere)
       eSym->st_size = 0;
     else
       eSym->st_size = sym->getSize();
 
     // st_value is usually an address of a symbol, but that has a
-    // special meaining for uninstantiated common symbols (this can
+    // special meaning for uninstantiated common symbols (this can
     // occur if -r is given).
     if (BssSection *commonSec = getCommonSec(ent.sym))
       eSym->st_value = commonSec->alignment;
     else if (isDefinedHere)
       eSym->st_value = sym->getVA();
     else
       eSym->st_value = 0;
 

 // give the -hash-style=gnu or -hash-style=both option.
 //
 // The Unix semantics of resolving dynamic symbols is somewhat expensive.
 // Each ELF file has a list of DSOs that the ELF file depends on and a
 // list of dynamic symbols that need to be resolved from any of the
 // DSOs. That means resolving all dynamic symbols takes O(m)*O(n)
 // where m is the number of DSOs and n is the number of dynamic
 // symbols. For modern large programs, both m and n are large.  So
-// making each step faster by using hash tables substiantially
+// making each step faster by using hash tables substantially
 // improves time to load programs.
 //
 // (Note that this is not the only way to design the shared library.
 // For instance, the Windows DLL takes a different approach. On
 // Windows, each dynamic symbol has a name of DLL from which the symbol
 // has to be resolved. That makes the cost of symbol resolution O(n).
 // This disables some hacky techniques you can use on Unix such as
 // LD_PRELOAD, but this is arguably better semantics than the Unix ones.)

lld/docs/WebAssembly.rst

.. option:: --stack-first
 
   Place stack at start of linear memory rather than after data.
 
 .. option:: --compress-relocations
 
   Relocation targets in the code section 5-bytes wide in order to potentially
   occomate the largest LEB128 value.  This option will cause the linker to
   shirnk the code section to remove any padding from the final output.  However
-  because it effects code offset, this option is not compatible with outputing
+  because it effects code offset, this option is not compatible with outputting
   debug information.
 
 .. option:: --allow-undefined
 
   Allow undefined symbols in linked binary.
 
 .. option:: --import-memory
 

lld/include/lld/Core/Reference.h

public:
 
   /// During linking, the linker may merge graphs which coalesces some nodes
   /// (i.e. Atoms).  To switch the target of a reference, this method is called.
   virtual void setTarget(const Atom *) = 0;
 
   /// Some relocations require a symbol and a value (e.g. foo + 4).
   virtual Addend addend() const = 0;
 
-  /// During linking, some optimzations may change addend value.
+  /// During linking, some optimizations may change addend value.
   virtual void setAddend(Addend) = 0;
 
   /// Returns target specific attributes of the reference.
   virtual uint32_t tag() const { return 0; }
 
 protected:
   /// Reference is an abstract base class.  Only subclasses can use constructor.
   Reference(KindNamespace ns, KindArch a, KindValue value)

lld/lib/ReaderWriter/MachO/ArchHandler_arm64.cpp

case imageOffsetGot:
       return true;
     default:
       return false;
     }
   }
 
   /// Used by GOTPass to update GOT References.
   void updateReferenceToGOT(const Reference *ref, bool targetNowGOT) override {
-    // If GOT slot was instanciated, transform:
+    // If GOT slot was instantiated, transform:
     //   gotPage21/gotOffset12 -> page21/offset12scale8
     // If GOT slot optimized away, transform:
     //   gotPage21/gotOffset12 -> page21/addOffset12
     assert(ref->kindNamespace() == Reference::KindNamespace::mach_o);
     assert(ref->kindArch() == Reference::KindArch::AArch64);
     switch (ref->kindValue()) {
     case gotPage21:
       const_cast<Reference *>(ref)->setKindValue(page21);

lld/lib/ReaderWriter/MachO/CompactUnwindPass.cpp

private:
   bool _isBig;
 };
 
 void addCompactUnwindPass(PassManager &pm, const MachOLinkingContext &ctx) {
   assert(ctx.needsCompactUnwindPass());
   pm.add(std::make_unique<CompactUnwindPass>(ctx));
 }
 
-} // end namesapce mach_o
-} // end namesapce lld
+} // end namespace mach_o
+} // end namespace lld

lld/lib/ReaderWriter/MachO/GOTPass.cpp

private:
   llvm::DenseMap<const Atom*, const GOTEntryAtom*> _targetToGOT;
 };
 
 void addGOTPass(PassManager &pm, const MachOLinkingContext &ctx) {
   assert(ctx.needsGOTPass());
   pm.add(std::make_unique<GOTPass>(ctx));
 }
 
-} // end namesapce mach_o
-} // end namesapce lld
+} // end namespace mach_o
+} // end namespace lld

lld/lib/ReaderWriter/MachO/TLVPass.cpp

private:
   llvm::DenseMap<const Atom*, const TLVPEntryAtom*> _targetToTLVP;
 };
 
 void addTLVPass(PassManager &pm, const MachOLinkingContext &ctx) {
   assert(ctx.needsTLVPass());
   pm.add(std::make_unique<TLVPass>(ctx));
 }
 
-} // end namesapce mach_o
-} // end namesapce lld
+} // end namespace mach_o
+} // end namespace lld

lld/test/COFF/secidx-absolute.s

 # REQUIRES: x86
 # RUN: llvm-mc %s -filetype=obj -triple=x86_64-windows-msvc -o %t.obj
 # RUN: lld-link -entry:main -nodefaultlib %t.obj -out:%t.exe
 # RUN: llvm-readobj %t.exe -sections -section-data | FileCheck %s
 
-# Section relocations against absolute symbols resolve to the last real ouput
+# Section relocations against absolute symbols resolve to the last real output
 # section index plus one.
 
 .text
 .global main
 main:
 ret
 
 .section .rdata,"dr"

lld/test/ELF/Inputs/undef-bad-debug.s

 .section .text,"ax"
 sym:
     .quad zed6a
 sym2:
     .quad zed6b
 sym3:
     .quad zed7
 
 .section .debug_line,"",@progbits
 .Lunit:
     .long .Lunit_end - .Lunit_start # unit length
 .Lunit_start:
     .short 4                        # version
     .long .Lprologue_end - .Lprologue_start # prologue length
 .Lprologue_start:
     .byte 1                         # minimum instruction length
-    .byte 1                         # maximum operatiosn per instruction
+    .byte 1                         # maximum operations per instruction
     .byte 1                         # default is_stmt
     .byte -5                        # line base
     .byte 14                        # line range
     .byte 13                        # opcode base
     .byte 0, 1, 1, 1, 1, 0, 0, 0, 1, 0, 0, 1 # standard opcode lengths
     .asciz "dir"                    # include directories
     .byte 0
     .asciz "undef-bad-debug.s"      # file names

 
 .Lunit2:
     .long .Lunit2_end - .Lunit2_start # unit length
 .Lunit2_start:
     .short 4                        # version
     .long .Lprologue2_end - .Lprologue2_start # prologue length
 .Lprologue2_start:
     .byte 1                         # minimum instruction length
-    .byte 1                         # maximum operatiosn per instruction
+    .byte 1                         # maximum operations per instruction
     .byte 1                         # default is_stmt
     .byte -5                        # line base
     .byte 14                        # line range
     .byte 13                        # opcode base
     .byte 0, 1, 1, 1, 1, 0, 0, 0, 1, 0, 0, 1 # standard opcode lengths
     .asciz "dir2"                   # include directories
     .byte 0
     .asciz "undef-bad-debug2.s"     # file names

lld/test/ELF/allow-multiple-definition.s

 # REQUIRES: x86
 
 # RUN: llvm-mc -filetype=obj -triple=x86_64-unknown-linux %s -o %t1
 # RUN: llvm-mc -filetype=obj -triple=x86_64-unknown-linux %p/Inputs/allow-multiple-definition.s -o %t2
 # RUN: not ld.lld %t1 %t2 -o %t3
 # RUN: not ld.lld --allow-multiple-definition --no-allow-multiple-definition %t1 %t2 -o %t3
 # RUN: ld.lld --allow-multiple-definition --fatal-warnings %t1 %t2 -o %t3
 # RUN: ld.lld --allow-multiple-definition --fatal-warnings %t2 %t1 -o %t4
 # RUN: llvm-objdump -d %t3 | FileCheck %s
 # RUN: llvm-objdump -d %t4 | FileCheck -check-prefix=REVERT %s
 
 # RUN: ld.lld -z muldefs --fatal-warnings  %t1 %t2 -o %t3
 # RUN: ld.lld -z muldefs --fatal-warnings  %t2 %t1 -o %t4
 # RUN: llvm-objdump -d %t3 | FileCheck %s
 # RUN: llvm-objdump -d %t4 | FileCheck -check-prefix=REVERT %s
 
-# inputs contain different constants for instuction movl.
+# inputs contain different constants for instruction movl.
 # Tests below checks that order of files in command line
 # affects on what symbol will be used.
 # If flag allow-multiple-definition is enabled the first
 # meet symbol should be used.
 
 # CHECK: _bar:
 # CHECK-NEXT:  movl   $1, %eax
 

lld/test/ELF/arm-exidx-add-missing.s

 // REQUIRES: arm
 // RUN: llvm-mc -filetype=obj -triple=armv7a-none-linux-gnueabi --arm-add-build-attributes %s -o %t
 // RUN: ld.lld %t --no-merge-exidx-entries -o %t2
 // RUN: llvm-objdump -s %t2 | FileCheck %s
 // RUN: ld.lld %t -o %t3
 // RUN: llvm-objdump -s %t3 | FileCheck %s -check-prefix=CHECK-MERGE
 
 // The ARM.exidx section is a table of 8-byte entries of the form:
 // | PREL31 Relocation to start of function | Unwinding information |
 // The range of addresses covered by the table entry is terminated by the
 // next table entry. This means that an executable section without a .ARM.exidx
 // section does not terminate the range of addresses. To fix this the linker
-// synthesises an EXIDX_CANTUNWIND entry for each section wihout a .ARM.exidx
+// synthesises an EXIDX_CANTUNWIND entry for each section without a .ARM.exidx
 // section.
 
         .syntax unified
 
         // Expect inline unwind instructions
         .section .text.01, "ax", %progbits
         .global f1
 f1:

lld/test/ELF/executable-undefined-ignoreall.s

 # REQUIRES: x86
 
 ## --unresolved-symbols=ignore-all behaves similar to -shared:
-## for PLT relocations to undefined symbols, produce dynamic reloctions if we
+## for PLT relocations to undefined symbols, produce dynamic relocations if we
 ## emit .dynsym.
 
 # RUN: llvm-mc -filetype=obj -triple=x86_64-unknown-linux %s -o %t.o
 # RUN: ld.lld %t.o -o %t --unresolved-symbols=ignore-all -pie
 # RUN: llvm-readobj -r %t | FileCheck %s
 # RUN: ld.lld %t.o -o %t --unresolved-symbols=ignore-all --export-dynamic
 # RUN: llvm-readobj -r %t | FileCheck %s
 
 # CHECK:      Relocations [
 # CHECK-NEXT:   Section ({{.*}}) .rela.plt {
 # CHECK-NEXT:     R_X86_64_JUMP_SLOT foo 0x0
 # CHECK-NEXT:   }
 # CHECK-NEXT: ]
 
 _start:
 callq foo@PLT

lld/test/ELF/icf-absolute2.s

 # REQUIRES: x86
 
 # RUN: llvm-mc -filetype=obj -triple=x86_64-unknown-linux %s -o %t
 # RUN: llvm-mc -filetype=obj -triple=x86_64-unknown-linux %S/Inputs/icf-absolute2.s -o %t2
 # RUN: ld.lld %t %t2 -o /dev/null --icf=all --print-icf-sections | FileCheck -allow-empty %s
 
-## Test we do not crash and do not fold sections which relocations reffering to
+## Test we do not crash and do not fold sections which relocations referring to
 ## absolute symbols with a different values.
 # CHECK-NOT: selected
 
 .globl _start, f1, f2
 _start:
   ret
 
 .section .text.f1, "ax"
 f1:
   .byte a1
 
 .section .text.f2, "ax"
 f2:
   .byte a2

lld/test/ELF/invalid/broken-relaxation-x64.test

 # REQUIRES: x86
 
 # RUN: yaml2obj %s -o %t.o
 # RUN: not ld.lld %t.o -o %t.exe 2>&1 | FileCheck --check-prefix=ERR %s
 # ERR: R_X86_64_GOTTPOFF must be used in MOVQ or ADDQ instructions only
 # ERR: R_X86_64_GOTTPOFF must be used in MOVQ or ADDQ instructions only
 
 ## YAML below contains 2 relocations of type R_X86_64_GOTTPOFF, and a .text
 ## with fake content filled by 0xFF. That means instructions for relaxation are
 ## "broken", so they does not match any known valid relaxations. We also generate
-## .tls section because we need it for correct proccessing of STT_TLS symbol.
+## .tls section because we need it for correct processing of STT_TLS symbol.
 !ELF
 FileHeader:
   Class:           ELFCLASS64
   Data:            ELFDATA2LSB
   OSABI:           ELFOSABI_FREEBSD
   Type:            ET_REL
   Machine:         EM_X86_64
 Sections:
Relocations:
         Type:            R_X86_64_GOTTPOFF
 Symbols:
   - Name:     foo
     Type:     STT_TLS
     Section:  .text
     Value:    0x12345
     Size:     4
     Binding:  STB_GLOBAL
+ 
 
 

lld/test/ELF/linkerscript/align1.test

 # ZERO-NEXT:   0               00000000 0000000000000000
 # ZERO-NEXT:   1 .aaa          00000008 0000000000000123 DATA
 
 ## Check that ALIGN zero do nothing and does not crash #2.
 # RUN: echo "SECTIONS { . = 0x123; . = ALIGN(0); .aaa : { *(.aaa) } }" > %t.script
 # RUN: ld.lld -o %t5 --script %t.script %t.o
 # RUN: llvm-objdump -section-headers %t5 | FileCheck %s -check-prefix=ZERO
 
-## Test we fail gracefuly when alignment value is not a power of 2 (#1).
+## Test we fail gracefully when alignment value is not a power of 2 (#1).
 # RUN: echo "SECTIONS { . = 0x123; . = ALIGN(0x123, 3); .aaa : { *(.aaa) } }" > %t.script
 # RUN: not ld.lld -o %t6 --script %t.script %t.o 2>&1 | FileCheck -check-prefix=ERR %s
 
 # RUN: echo "SECTIONS { . = 0x123; . = ALIGN(3); .aaa : { *(.aaa) } }" > %t.script
 # RUN: not ld.lld -o %t7 --script %t.script %t.o 2>&1 | FileCheck -check-prefix=ERR %s
 
 # ERR: {{.*}}.script:1: alignment must be power of 2

lld/test/ELF/linkerscript/subalign.s

 # RUN: not ld.lld %t1.o --script %t3.script -o /dev/null 2>&1 | FileCheck --check-prefix=ERR1 %s
 # ERR1: {{.*}}.script:1: unable to get location counter value
 
 ## Test we are able to link with zero alignment, this is consistent with bfd 2.26.1.
 # RUN: echo "SECTIONS { .aaa : SUBALIGN(0) { *(.aaa*) } }" > %t4.script
 # RUN: ld.lld %t1.o --script %t4.script -o %t4
 # RUN: llvm-objdump -s %t4 | FileCheck -check-prefix=SUBALIGN %s
 
-## Test we fail gracefuly when alignment value is not a power of 2.
+## Test we fail gracefully when alignment value is not a power of 2.
 # RUN: echo "SECTIONS { .aaa : SUBALIGN(3) { *(.aaa*) } }" > %t5.script
 # RUN: not ld.lld %t1.o --script %t5.script -o /dev/null 2>&1 | FileCheck --check-prefix=ERR2 %s
 # ERR2: {{.*}}.script:1: alignment must be power of 2
 
 .global _start
 _start:
  nop
 

lld/test/ELF/lto/common4.ll

 ; REQUIRES: x86
 
 ;; Make sure that common symbols are properly internalized.
 ;; In this file, @a does not interpose any symbol in a DSO,
-;; so LTO should be able to internelize it.
+;; so LTO should be able to internalize it.
 
 ; RUN: llvm-mc -filetype=obj -triple=x86_64-unknown-linux /dev/null -o %t.so.o
 ; RUN: ld.lld -shared -o %t.so %t.so.o
 
 ; RUN: llvm-as %s -o %t.o
 ; RUN: ld.lld -o %t.exe -save-temps %t.o %t.so
 ; RUN: llvm-dis < %t.exe.0.2.internalize.bc | FileCheck %s
 
 ; RUN: ld.lld -pie -o %t.exe -save-temps %t.o
 ; RUN: llvm-dis < %t.exe.0.2.internalize.bc | FileCheck %s
 
 target datalayout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128"
 target triple = "x86_64-unknown-linux-gnu"
 
 @a = common dso_local local_unnamed_addr global i32 0, align 4
 ; CHECK-DAG: @a = internal global i32 0, align 4

lld/test/ELF/mips-sto-pic-flag.s

 # REQUIRES: mips
 # In case of linking PIC and non-PIC code together and generation
 # of a relocatable object, all PIC symbols should have STO_MIPS_PIC
-# flag in the symbol table of the ouput file.
+# flag in the symbol table of the output file.
 
 # RUN: llvm-mc -filetype=obj -triple=mips-unknown-linux %s -o %t-npic.o
 # RUN: llvm-mc -filetype=obj -triple=mips-unknown-linux \
 # RUN:   %p/Inputs/mips-pic.s -o %t-pic.o
 # RUN: ld.lld -r %t-npic.o %t-pic.o -o %t-rel.o
 # RUN: llvm-readobj --symbols %t-rel.o | FileCheck %s
 
 # CHECK:      Symbol {

lld/test/ELF/pack-dyn-relocs.s

 // ANDROID32-HEADERS-NEXT:  Link: 1
 // ANDROID32-HEADERS-NEXT:  Info: 0
 // ANDROID32-HEADERS-NEXT:  AddressAlignment: 4
 // ANDROID32-HEADERS-NEXT:  EntrySize: 1
 
 // ANDROID32-HEADERS: 0x6000000F ANDROID_REL          [[ADDR]]
 // ANDROID32-HEADERS: 0x60000010 ANDROID_RELSZ        [[SIZE]]
 
-// Packed should have the groups of non-relative reloations first, followed
+// Packed should have the groups of non-relative relocations first, followed
 // by the larger groups of relative relocations (i.e. the 8 and 9 followed
 // by the 7.)
 // ANDROID32:          Section ({{.+}}) .rel.dyn {
 // ANDROID32-NEXT:     0x324C R_ARM_RELATIVE - 0
 // ANDROID32-NEXT:     0x3250 R_ARM_RELATIVE - 0
 // ANDROID32-NEXT:     0x3254 R_ARM_RELATIVE - 0
 // ANDROID32-NEXT:     0x3258 R_ARM_RELATIVE - 0
 // ANDROID32-NEXT:     0x325C R_ARM_RELATIVE - 0

lld/test/ELF/ppc64-local-dynamic.s

 // address of a tls_index struct as the argument. However for local-dynamic
 // variables  all will have the same ti_module, and the offset field is left as
 // as 0, so the same struct can be used for every local-dynamic variable
 // used in the shared-object.
 // OutputRelocs:      Relocation section '.rela.dyn' at offset 0x{{[0-9a-f]+}} contains 1 entries:
 // OutputRelocs-NEXT: Offset Info Type Symbol's Value Symbol's Name + Addend
 // OutputRelocs-NEXT: R_PPC64_DTPMOD64
 
-// Check that the got has 3 entries, 1 for the TOC and 1 stucture of 2 entries
+// Check that the got has 3 entries, 1 for the TOC and 1 structure of 2 entries
 // for the tls variables. Also verify the address so we can check the offsets
 // we calculate for each relocation type.
 // CheckGot: got          00000018 0000000000020100
 
 // got starts at 0x20100 so .TOC. will be 0x28100, and the tls_index struct is
 // at 0x20108.
 
 // #ha(i@got@tlsld) --> (0x20108 - 0x28100 + 0x8000) >> 16 = 0

lld/test/ELF/ppc64-split-stack-prologue-adjust-success.s

 # RUN: llvm-objdump -d %t | FileCheck %s
 
         .abiversion 2
         .section    ".text"
 
 
 # A caller with a stack that is small enough that the addis instruction
 # from the split-stack prologue is unneeded, and after the prologue adjustment
-# the stack size still fits whithin 16 bits.
+# the stack size still fits within 16 bits.
         .p2align    2
         .global caller_small_stack
         .type caller_small_stack, @function
 caller_small_stack:
 .Lcss_gep:
     addis 2, 12, .TOC.-.Lcss_gep@ha
     addi 2, 2, .TOC.-.Lcss_gep@l
     .localentry caller_small_stack, .-caller_small_stack

 
 # CHECK-LABEL: caller_small_stack
 # CHECK:       ld 0, -28736(13)
 # CHECK-NEXT:  addi 12, 1, -16416
 # CHECK-NEXT:  nop
 # CHECK-NEXT:  cmpld 7, 12, 0
 # CHECK-NEXT:  bt-  28, .+36
 
-# A caller that has a stack size that fits whithin 16 bits, but the adjusted
+# A caller that has a stack size that fits within 16 bits, but the adjusted
 # stack size after prologue adjustment now overflows 16 bits needing both addis
 # and addi instructions.
         .p2align    2
         .global caller_med_stack
         .type caller_med_stack, @function
 caller_med_stack:
 .Lcms_gep:
     addis 2, 12, .TOC.-.Lcms_gep@ha

lld/test/ELF/warn-backrefs.s

 
 # RUN: not ld.lld --fatal-warnings --end-group 2>&1 | FileCheck -check-prefix=END %s
 # END: stray --end-group
 
 # RUN: echo ".globl bar; bar:" | llvm-mc -filetype=obj -triple=x86_64-unknown-linux - -o %t3.o
 # RUN: echo ".globl foo; foo: call bar" | llvm-mc -filetype=obj -triple=x86_64-unknown-linux - -o %t4.o
 # RUN: ld.lld --fatal-warnings --warn-backrefs %t1.o --start-lib %t3.o %t4.o --end-lib -o /dev/null
 
-# We don't report backward references to weak symbols as they can be overriden later.
+# We don't report backward references to weak symbols as they can be overridden later.
 # RUN: echo ".weak foo; foo:" | llvm-mc -filetype=obj -triple=x86_64-unknown-linux - -o %t5.o
 # RUN: ld.lld --fatal-warnings --warn-backrefs --start-lib %t5.o --end-lib %t1.o %t2.o -o /dev/null
 
 .globl _start, foo
 _start:
   call foo

lld/test/mach-o/error-simulator-vs-macosx.yaml

 # RUN: ld64.lld -arch i386 -macosx_version_min 10.8 %s %p/Inputs/hello-world-x86.yaml -o %t && llvm-nm -m %t | FileCheck %s
 # RUN: not ld64.lld -arch i386 -ios_simulator_version_min 5.0 %s %p/Inputs/hello-world-x86.yaml -o %t 2>&1 | FileCheck %s --check-prefix=ERROR
 #
-# Test that i386 can link with a macos version but gives an error with a simululator version.
+# Test that i386 can link with a macos version but gives an error with a simulator version.
 #
 
 --- !mach-o
 arch:            x86
 OS:              Mac OS X
 file-type:       MH_OBJECT
 flags:           [ MH_SUBSECTIONS_VIA_SYMBOLS ]
 sections:

lld/test/mach-o/parse-literals-error.yaml

 # RUN: not ld64.lld -arch x86_64 -r -print_atoms %s -o %t 2> %t.err
 # RUN: FileCheck %s < %t.err
 #
-# Test for error if literal section is not correct size mulitple.
+# Test for error if literal section is not correct size multiple.
 #
 
 --- !mach-o
 arch:            x86_64
 file-type:       MH_OBJECT
 flags:           [ MH_SUBSECTIONS_VIA_SYMBOLS ]
 has-UUID:        false
 OS:              unknown

lld/test/wasm/entry-signature.ll

-; Verify that the entry point signauture can be flexible.
+; Verify that the entry point signature can be flexible.
 ; RUN: llc -filetype=obj %s -o %t.o
 ; RUN: wasm-ld -o %t1.wasm %t.o
 
 target triple = "wasm32-unknown-unknown-wasm"
 
 define hidden i32 @_start(i32, i64) local_unnamed_addr #0 {
 entry:
   ret i32 0
 }

lld/test/wasm/export-optional-lazy.ll

 ; Optional linker-synthetic symbols are only created if they are undefined
 ; in the final output.
 ; This test is for a regression where an explicit --export of an lazy archive
-; symbol caused an undefined referece to an optional symbol to occur *after*
+; symbol caused an undefined reference to an optional symbol to occur *after*
 ; the optional symbols were created.
 
 ; RUN: llc -filetype=obj %s -o %t.o
 ; RUN: llc -filetype=obj %S/Inputs/optional-symbol.ll -o %t.a1.o
 ; RUN: rm -f %t.a
 ; RUN: llvm-ar rcs %t.a %t.a1.o
 ; RUN: wasm-ld --export=get_optional %t.o %t.a -o %t.wasm
 ; RUN: obj2yaml %t.wasm | FileCheck %s

lld/test/wasm/lto/signature-mismatch.ll

 ; RUN: llc -filetype=obj -o %t.o %s
 ; RUN: llvm-as %S/Inputs/archive.ll -o %t1.o
 ; RUN: not wasm-ld --fatal-warnings %t.o %t1.o -o %t.wasm 2>&1 | FileCheck %s
 
 ; Test that functions defined in bitcode correctly report signature
-; mistmaches with existing undefined sybmols in normal objects.
+; mismatches with existing undefined sybmols in normal objects.
 
 target triple = "wasm32-unknown-unknown"
 
 ; f is defined to take no argument in archive.ll which is compiled to bitcode
 declare void @f(i32);
 
 define void @_start() {
   call void @f(i32 0)
   ret void
 }
 
 ; CHECK: error: function signature mismatch: f
 ; CHECK: >>> defined as (i32) -> void in {{.*}}signature-mismatch.ll.tmp1.o
 ; CHECK: >>> defined as () -> void in lto.tmp

lld/test/wasm/lto/undef.ll

 ; RUN: llvm-as %s -o %t.o
 ; RUN: wasm-ld %t.o -o %t.wasm --allow-undefined
 ; RUN: obj2yaml %t.wasm | FileCheck %s
 
 target datalayout = "e-m:e-p:32:32-i64:64-n32:64-S128"
 target triple = "wasm32-unknown-unknown"
 
 declare i32 @bar()
 
 ; Symbols such as foo which are only called indirectly are handled slightly
-; differently with resepect to signature checking.
+; differently with respect to signature checking.
 declare i32 @foo()
 
 @ptr = global i8* bitcast (i32 ()* @foo to i8*), align 8
 ; Ensure access to ptr is not inlined below, even under LTO
 @llvm.used = appending global [1 x i8**] [i8** @ptr], section "llvm.metadata"
 
 define void @_start() {
   call i32 @bar()

lld/test/wasm/signature-mismatch-unknown.ll

 ; RUN: llc -filetype=obj %p/Inputs/ret32.ll -o %t.ret32.o
 ; RUN: llc -filetype=obj %s -o %t.main.o
 ; RUN: wasm-ld --fatal-warnings -o %t.wasm %t.ret32.o %t.main.o
 ; RUN: wasm-ld --fatal-warnings -o %t.wasm %t.main.o %t.ret32.o
 
 ; Also test the case where there are two different object files that contains
-; referneces ret32:
+; references ret32:
 ; %t.main.o: Does not call ret32 directly; used the wrong signature.
 ; %t.call-ret32.o: Calls ret32 directly; uses the correct signature.
 ; RUN: llc -filetype=obj %p/Inputs/call-ret32.ll -o %t.call-ret32.o
 ; RUN: wasm-ld --export=call_ret32 --fatal-warnings -o %t.wasm %t.main.o %t.call-ret32.o %t.ret32.o
 ; RUN: wasm-ld --export=call_ret32 --fatal-warnings -o %t.wasm %t.call-ret32.o %t.main.o %t.ret32.o
 
 target triple = "wasm32-unknown-unknown"
 

lld/test/wasm/undefined-entry.test

 RUN: llc -filetype=obj %p/Inputs/ret32.ll -o %t.ret32.o
 RUN: not wasm-ld -o %t.wasm %t.ret32.o 2>&1 | FileCheck %s
 RUN: not wasm-ld --allow-undefined -o %t.wasm %t.ret32.o 2>&1 | FileCheck %s
 RUN: not wasm-ld -entry=foo -o %t.wasm %t.ret32.o 2>&1 | FileCheck %s -check-prefix=CHECK-CUSTOM
 
-CHECK: error: entry symbol not defined (pass --no-entry to supress): _start
-CHECK-CUSTOM: error: entry symbol not defined (pass --no-entry to supress): foo
+CHECK: error: entry symbol not defined (pass --no-entry to suppress): _start
+CHECK-CUSTOM: error: entry symbol not defined (pass --no-entry to suppress): foo
 
 RUN: wasm-ld --no-entry -o %t.wasm %t.ret32.o

lld/test/wasm/visibility-hidden.ll

 ; RUN: llc -filetype=obj -o %t.o %s
 ; RUN: llc -filetype=obj %S/Inputs/hidden.ll -o %t2.o
 ; RUN: rm -f %t2.a
 ; RUN: llvm-ar rcs %t2.a %t2.o
 
-; Test that symbols with hidden visitiblity are not export, even with
+; Test that symbols with hidden visibility are not export, even with
 ; --export-dynamic
 ; RUN: wasm-ld --export-dynamic %t.o %t2.a -o %t.wasm
 ; RUN: obj2yaml %t.wasm | FileCheck %s
 
-; Test that symbols with default visitiblity are not exported without
+; Test that symbols with default visibility are not exported without
 ; --export-dynamic
 ; RUN: wasm-ld %t.o %t2.a -o %t.nodef.wasm
 ; RUN: obj2yaml %t.nodef.wasm | FileCheck %s -check-prefix=NO-DEFAULT
 
 
 target triple = "wasm32-unknown-unknown"
 
 define hidden i32 @objectHidden() {

lld/wasm/Driver.cpp

for (auto *arg : args.filtered(OPT_export))
     handleUndefined(arg->getValue());
 
   Symbol *entrySym = nullptr;
   if (!config->relocatable && !config->entry.empty()) {
     entrySym = handleUndefined(config->entry);
     if (entrySym && entrySym->isDefined())
       entrySym->forceExport = true;
     else
-      error("entry symbol not defined (pass --no-entry to supress): " +
+      error("entry symbol not defined (pass --no-entry to suppress): " +
             config->entry);
   }
 
   createOptionalSymbols();
 
   if (errorCount())
     return;
 

lld/wasm/SymbolTable.h

InputFunction *replaceWithUnreachable(Symbol *sym, const WasmSignature &sig,
                                         StringRef debugName);
 
   // Maps symbol names to index into the symVector.  -1 means that symbols
   // is to not yet in the vector but it should have tracing enabled if it is
   // ever added.
   llvm::DenseMap<llvm::CachedHashStringRef, int> symMap;
   std::vector<Symbol *> symVector;
 
-  // For certain symbols types, e.g. function symbols, we allow for muliple
+  // For certain symbols types, e.g. function symbols, we allow for multiple
   // variants of the same symbol with different signatures.
   llvm::DenseMap<llvm::CachedHashStringRef, std::vector<Symbol *>> symVariants;
 
   // Comdat groups define "link once" sections. If two comdat groups have the
   // same name, only one of them is linked, and the other is ignored. This set
   // is used to uniquify them.
   llvm::DenseSet<llvm::CachedHashStringRef> comdatGroups;
 

lld/wasm/SymbolTable.cpp

static void reportTypeError(const Symbol *existing, const InputFile *file,
                             llvm::wasm::WasmSymbolType type) {
   error("symbol type mismatch: " + toString(*existing) + "\n>>> defined as " +
         toString(existing->getWasmType()) + " in " +
         toString(existing->getFile()) + "\n>>> defined as " + toString(type) +
         " in " + toString(file));
 }
 
 // Check the type of new symbol matches that of the symbol is replacing.
-// Returns true if the function types match, false is there is a singature
+// Returns true if the function types match, false is there is a signature
 // mismatch.
 static bool signatureMatches(FunctionSymbol *existing,
                              const WasmSignature *newSig) {
   const WasmSignature *oldSig = existing->signature;
 
   // If either function is missing a signature (this happend for bitcode
   // symbols) then assume they match.  Any mismatch will be reported later
   // when the LTO objects are added.
Symbol *SymbolTable::addDefinedFunction(StringRef name, uint32_t flags,
   LLVM_DEBUG(dbgs() << "addDefinedFunction: " << name << " ["
                     << (function ? toString(function->signature) : "none")
                     << "]\n");
   Symbol *s;
   bool wasInserted;
   std::tie(s, wasInserted) = insert(name, file);
 
   auto replaceSym = [&](Symbol *sym) {
-    // If the new defined function doesn't have signture (i.e. bitcode
+    // If the new defined function doesn't have signature (i.e. bitcode
     // functions) but the old symbol does, then preserve the old signature
     const WasmSignature *oldSig = s->getSignature();
     auto* newSym = replaceSymbol<DefinedFunction>(sym, name, flags, file, function);
     if (!newSym->signature)
       newSym->signature = oldSig;
   };
 
   if (wasInserted || s->isLazy()) {

lld/wasm/Symbols.h

LazySymbol(StringRef name, uint32_t flags, InputFile *file,
              const llvm::object::Archive::Symbol &sym)
       : Symbol(name, LazyKind, flags, file), archiveSymbol(sym) {}
 
   static bool classof(const Symbol *s) { return s->kind() == LazyKind; }
   void fetch();
 
   // Lazy symbols can have a signature because they can replace an
   // UndefinedFunction which which case we need to be able to preserve the
-  // signture.
+  // signature.
   // TODO(sbc): This repetition of the signature field is inelegant.  Revisit
   // the use of class hierarchy to represent symbol taxonomy.
   const WasmSignature *signature = nullptr;
 
 private:
   llvm::object::Archive::Symbol archiveSymbol;
 };
 

lld/wasm/Symbols.cpp

void Symbol::setOutputSymbolIndex(uint32_t index) {
   assert(outputSymbolIndex == INVALID_INDEX);
   outputSymbolIndex = index;
 }
 
 void Symbol::setGOTIndex(uint32_t index) {
   LLVM_DEBUG(dbgs() << "setGOTIndex " << name << " -> " << index << "\n");
   assert(gotIndex == INVALID_INDEX);
   if (config->isPic) {
-    // Any symbol that is assigned a GOT entry must be exported othewise the
+    // Any symbol that is assigned a GOT entry must be exported otherwise the
     // dynamic linker won't be able create the entry that contains it.
     forceExport = true;
   }
   gotIndex = index;
 }
 
 bool Symbol::isWeak() const {
   return (flags & WASM_SYMBOL_BINDING_MASK) == WASM_SYMBOL_BINDING_WEAK;