[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/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 .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

 
 .Lunit3:
     .long .Lunit3_end - .Lunit3_start # unit length
 .Lunit3_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 /dev/null
 # RUN: not ld.lld --allow-multiple-definition --no-allow-multiple-definition %t1 %t2 -o /dev/null
 # 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 /dev/null 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 /dev/null --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 /dev/null --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, 0x10010204
 
-# 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,
       : Symbol(name, LazyKind, flags, file), archiveSymbol(sym) {}
 
   static bool classof(const Symbol *s) { return s->kind() == LazyKind; }
   void fetch();
   MemoryBufferRef getMemberBuffer();
 
   // 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;