[lld] Fix trivial typos in comments

[ruiu]

LGTM

[kiszk]

I do not have commit rights to the repository. Could someone commit this change if it is OK?
Kazuaki Ishizaki <[e-mail]>

[MaskRay]

lld/lib/Core/Resolver.cpp

438

Capitalize and add a period.

lld/wasm/InputFiles.cpp

302

I'll add a period for you.

lld/Common/Filesystem.cpp

 //
 // Determining whether a file is writable or not is amazingly hard,
 // and after all the only reliable way of doing that is to actually
 // create a file. But we don't want to do that in this function
 // because LLD shouldn't update any file if it will end in a failure.
 // We also don't want to reimplement heuristics to determine if a
 // file is writable. So we'll let FileOutputBuffer do the work.
 //
-// FileOutputBuffer doesn't touch a desitnation file until commit()
+// FileOutputBuffer doesn't touch a destination file until commit()
 // is called. We use that class without calling commit() to predict
 // if the given file is writable.
 std::error_code lld::tryCreateFile(StringRef path) {
   if (path.empty())
     return std::error_code();
   if (path == "-")
     return std::error_code();
   return errorToErrorCode(FileOutputBuffer::create(path, 1).takeError());
 }

lld/ELF/Arch/X86.cpp

case R_386_GOT32X:
     // we had to implement as the standard requires.
     //
     // x86 does not support PC-relative data access. Therefore, in order to
     // access GOT contents, a GOT address needs to be known at link-time
     // (which means non-PIC) or compilers have to emit code to get a GOT
     // address at runtime (which means code is position-independent but
     // compilers need to emit extra code for each GOT access.) This decision
     // is made at compile-time. In the latter case, compilers emit code to
-    // load an GOT address to a register, which is usually %ebx.
+    // load a GOT address to a register, which is usually %ebx.
     //
     // So, there are two ways to refer to symbol foo's GOT entry: foo@GOT or
     // foo@GOT(%ebx).
     //
     // foo@GOT is not usable in PIC. If we are creating a PIC output and if we
     // find such relocation, we should report an error. foo@GOT is resolved to
     // an *absolute* address of foo's GOT entry, because both GOT address and
     // foo's offset are known. In other words, it's G + A.

lld/ELF/ICF.cpp

 //    relocations. During this step, relocation targets are not taken into
 //    account. We just put sections that apparently differ into different
 //    equivalence classes.
 //
 // 2. Next, for each equivalence class, we visit sections to compare
 //    relocation targets. Relocation targets are considered equivalent if
 //    their targets are in the same equivalence class. Sections with
 //    different relocation targets are put into different equivalence
-//    clases.
+//    classes.
 //
 // 3. If we split an equivalence class in step 2, two relocations
 //    previously target the same equivalence class may now target
 //    different equivalence classes. Therefore, we repeat step 2 until a
 //    convergence is obtained.
 //
 // 4. For each equivalence class C, pick an arbitrary section in C, and
 //    merge all the other sections in C with it.

lld/ELF/InputFiles.cpp

Optional<DILineInfo> ObjFile<ELFT>::getDILineInfo(InputSectionBase *s,
   ArrayRef<InputSectionBase *> sections = s->file->getSections();
   for (uint64_t curIndex = 0; curIndex < sections.size(); ++curIndex) {
     if (s == sections[curIndex]) {
       sectionIndex = curIndex;
       break;
     }
   }
 
-  // Use fake address calcuated by adding section file offset and offset in
+  // Use fake address calculated by adding section file offset and offset in
   // section. See comments for ObjectInfo class.
   return dwarf->getDILineInfo(s->getOffsetInFile() + offset, sectionIndex);
 }
 
 ELFFileBase::ELFFileBase(Kind k, MemoryBufferRef mb) : InputFile(k, mb) {
   ekind = getELFKind(mb, "");
 
   switch (ekind) {

lld/ELF/InputSection.cpp

for (const RelTy &rel : rels) {
 
     auto *p = reinterpret_cast<typename ELFT::Rela *>(buf);
     buf += sizeof(RelTy);
 
     if (RelTy::IsRela)
       p->r_addend = getAddend<ELFT>(rel);
 
     // Output section VA is zero for -r, so r_offset is an offset within the
-    // section, but for --emit-relocs it is an virtual address.
+    // section, but for --emit-relocs it is a virtual address.
     p->r_offset = sec->getVA(rel.r_offset);
     p->setSymbolAndType(in.symTab->getSymbolIndex(&sym), type,
                         config->isMips64EL);
 
     if (sym.type == STT_SECTION) {
       // We combine multiple section symbols into only one per
       // section. This means we have to update the addend. That is
       // trivial for Elf_Rela, but for Elf_Rel we have to write to the

lld/ELF/OutputSections.cpp

 }
 
 // Record that isec will be placed in the OutputSection. isec does not become
 // permanent until finalizeInputSections() is called. The function should not be
 // used after finalizeInputSections() is called. If you need to add an
 // InputSection post finalizeInputSections(), then you must do the following:
 //
 // 1. Find or create an InputSectionDescription to hold InputSection.
-// 2. Add the InputSection to the InputSectionDesciption::sections.
+// 2. Add the InputSection to the InputSectionDescription::sections.
 // 3. Call commitSection(isec).
 void OutputSection::recordSection(InputSectionBase *isec) {
   partition = isec->partition;
   isec->parent = this;
   if (sectionCommands.empty() ||
       !isa<InputSectionDescription>(sectionCommands.back()))
     sectionCommands.push_back(make<InputSectionDescription>(""));
   auto *isd = cast<InputSectionDescription>(sectionCommands.back());

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 comatible with outputing
+  because it effects code offset, this option is not compatible with outputing
   debug information.
 
 .. option:: --allow-undefined
 
   Allow undefined symbols in linked binary.
 
 .. option:: --import-memory
 

lld/docs/windows_support.rst

 The current status is that LLD is used to link production builds of large
 real-world binaries such as Firefox and Chromium.
 
 Development status
 ==================
 
 Driver
   :good:`Mostly done`. Some exotic command line options that are not usually
-  used for application develompent, such as ``/DRIVER``, are not supported.
+  used for application development, such as ``/DRIVER``, are not supported.
 
 Linking against DLL
   :good:`Done`. LLD can read import libraries needed to link against DLL. Both
   export-by-name and export-by-ordinal are supported.
 
 Linking against static library
   :good:`Done`. The format of static library (.lib) on Windows is actually the
   same as on Unix (.a). LLD can read it.

lld/include/lld/Core/Atom.h

public:
   /// Whether this atom is defined or a proxy for an undefined symbol
   enum Definition {
     definitionRegular,      ///< Normal C/C++ function or global variable.
     definitionAbsolute,     ///< Asm-only (foo = 10). Not tied to any content.
     definitionUndefined,    ///< Only in .o files to model reference to undef.
     definitionSharedLibrary ///< Only in shared libraries to model export.
   };
 
-  /// The scope in which this atom is acessible to other atoms.
+  /// The scope in which this atom is accessible to other atoms.
   enum Scope {
     scopeTranslationUnit,  ///< Accessible only to atoms in the same translation
                            ///  unit (e.g. a C static).
     scopeLinkageUnit,      ///< Accessible to atoms being linked but not visible
                            ///  to runtime loader (e.g. visibility=hidden).
     scopeGlobal            ///< Accessible to all atoms and visible to runtime
                            ///  loader (e.g. visibility=default).
   };

lld/include/lld/Core/Instrumentation.h

public:
   operator __itt_string_handle *() const { return _handle; }
 };
 
 /// A task on a single thread. Nests within other tasks.
 ///
 /// Each thread has its own task stack and tasks nest recursively on that stack.
 /// A task cannot transfer threads.
 ///
-/// SBRM is used to ensure task starts and ends are ballanced. The lifetime of
+/// SBRM is used to ensure task starts and ends are balanced. The lifetime of
 /// a task is either the lifetime of this object, or until end is called.
 class ScopedTask {
   __itt_domain *_domain;
 
   ScopedTask(const ScopedTask &) = delete;
   ScopedTask &operator=(const ScopedTask &) = delete;
 
 public:

lld/include/lld/Core/Reference.h

 
 protected:
   /// Reference is an abstract base class.  Only subclasses can use constructor.
   Reference(KindNamespace ns, KindArch a, KindValue value)
       : _kindValue(value), _kindNamespace((uint8_t)ns), _kindArch((uint8_t)a) {}
 
   /// The memory for Reference objects is always managed by the owning File
   /// object.  Therefore, no one but the owning File object should call
-  /// delete on an Reference.  In fact, some File objects may bulk allocate
+  /// delete on a Reference.  In fact, some File objects may bulk allocate
   /// an array of References, so they cannot be individually deleted by anyone.
   virtual ~Reference() = default;
 
   KindValue  _kindValue;
   uint8_t    _kindNamespace;
   uint8_t    _kindArch;
 };
 
 } // end namespace lld
 
 #endif // LLD_CORE_REFERENCES_H

lld/include/lld/ReaderWriter/MachOLinkingContext.h

public:
   ///
   /// When building a dynamic library, this is the compatibility version that
   /// gets embedded into the result. Other Mach-O binaries that link against
   /// this library will store the compatibility version in its load command. At
   /// runtime, the loader will verify that the binary is compatible with the
   /// installed dynamic library.
   uint32_t compatibilityVersion() const { return _compatibilityVersion; }
 
-  /// The dylib's current version, in the the raw uint32 format.
+  /// The dylib's current version, in the raw uint32 format.
   ///
   /// When building a dynamic library, this is the current version that gets
   /// embedded into the result. Other Mach-O binaries that link against
   /// this library will store the compatibility version in its load command.
   uint32_t currentVersion() const { return _currentVersion; }
 
   /// The dylib's install name.
   ///

lld/lib/Core/Resolver.cpp

bool Resolver::checkUndefines() {
   }
   if (!foundUndefines)
     return false;
   if (_ctx.printRemainingUndefines())
     llvm::errs() << "symbol(s) not found\n";
   return true;
 }
 
-// remove from _atoms all coaleseced away atoms
+// Remove from _atoms all coalesced away atoms.
 void Resolver::removeCoalescedAwayAtoms() {
   DEBUG_WITH_TYPE("resolver",
                   llvm::dbgs() << "******** Removing coalesced away atoms:\n");
   ScopedTask task(getDefaultDomain(), "removeCoalescedAwayAtoms");
   _atoms.erase(std::remove_if(_atoms.begin(), _atoms.end(),
                               [&](OwningAtomPtr<Atom> &a) {
                  return _symbolTable.isCoalescedAway(a.get()) ||
                         _deadAtoms.count(a.get());

lld/lib/Driver/DarwinLdDriver.cpp

// Handle -version_load_command or -no_version_load_command
     // default to adding version load command for dynamic code,
     // static code must opt-in
     switch (ctx.outputMachOType()) {
       case llvm::MachO::MH_OBJECT:
         ctx.setGenerateVersionLoadCommand(false);
         break;
       case llvm::MachO::MH_EXECUTE:
         // dynamic executables default to generating a version load command,
-        // while static exectuables only generate it if required.
+        // while static executables only generate it if required.
         if (isStaticExecutable) {
           if (flagOn)
             ctx.setGenerateVersionLoadCommand(true);
         } else {
           if (!flagOff)
             ctx.setGenerateVersionLoadCommand(true);
         }
         break;
// Handle -function_starts or -no_function_starts
     // default to adding functions start for dynamic code, static code must
     // opt-in
     switch (ctx.outputMachOType()) {
       case llvm::MachO::MH_OBJECT:
         ctx.setGenerateFunctionStartsLoadCommand(false);
         break;
       case llvm::MachO::MH_EXECUTE:
         // dynamic executables default to generating a version load command,
-        // while static exectuables only generate it if required.
+        // while static executables only generate it if required.
         if (isStaticExecutable) {
           if (flagOn)
             ctx.setGenerateFunctionStartsLoadCommand(true);
         } else {
           if (!flagOff)
             ctx.setGenerateFunctionStartsLoadCommand(true);
         }
         break;
// Handle -data_in_code_info or -no_data_in_code_info
     // opt-in
     switch (ctx.outputMachOType()) {
       case llvm::MachO::MH_OBJECT:
         if (!flagOff)
           ctx.setGenerateDataInCodeLoadCommand(true);
         break;
       case llvm::MachO::MH_EXECUTE:
         // dynamic executables default to generating a version load command,
-        // while static exectuables only generate it if required.
+        // while static executables only generate it if required.
         if (isStaticExecutable) {
           if (flagOn)
             ctx.setGenerateDataInCodeLoadCommand(true);
         } else {
           if (!flagOff)
             ctx.setGenerateDataInCodeLoadCommand(true);
         }
         break;
if (llvm::opt::Arg *arg = parsedArgs.getLastArg(OPT_sdk_version)) {
     if (MachOLinkingContext::parsePackedVersion(arg->getValue(),
                                                 sdkVersion)) {
       error("malformed sdkVersion value");
       return false;
     }
     ctx.setSdkVersion(sdkVersion);
   } else if (ctx.generateVersionLoadCommand()) {
     // If we don't have an sdk version, but were going to emit a load command
-    // with min_version, then we need to give an warning as we have no sdk
+    // with min_version, then we need to give a warning as we have no sdk
     // version to put in that command.
     // FIXME: We need to decide whether to make this an error.
     warn("-sdk_version is required when emitting min version load command.  "
          "Setting sdk version to match provided min version");
     ctx.setSdkVersion(ctx.osMinVersion());
   }
 
   // Handle source_version

lld/lib/ReaderWriter/MachO/CompactUnwindPass.cpp

llvm::Error perform(SimpleFile &mergedFile) override {
     if (unwindLocs.empty() && dwarfFrames.empty())
       return llvm::Error::success();
 
     // FIXME: if there are more than 4 personality functions then we need to
     // defer to DWARF info for the ones we don't put in the list. They should
     // also probably be sorted by frequency.
     assert(personalities.size() <= 4);
 
-    // TODO: Find commmon encodings for use by compressed pages.
+    // TODO: Find common encodings for use by compressed pages.
     std::vector<uint32_t> commonEncodings;
 
     // Now sort the entries by final address and fixup the compact encoding to
     // its final form (i.e. set personality function bits & create DWARF
     // references where needed).
     std::vector<CompactUnwindEntry> unwindInfos = createUnwindInfoEntries(
         mergedFile, unwindLocs, personalities, dwarfFrames);
 

lld/lib/ReaderWriter/MachO/File.h

if (copyRefs) {
       name = name.copy(allocator());
     }
     auto *atom =
         new (allocator()) MachOTentativeDefAtom(*this, name, scope, size, align);
     addAtom(*atom);
     _undefAtoms[name] = atom;
   }
 
-  /// Search this file for an the atom from 'section' that covers
+  /// Search this file for the atom from 'section' that covers
   /// 'offsetInSect'.  Returns nullptr is no atom found.
   MachODefinedAtom *findAtomCoveringAddress(const Section &section,
                                             uint64_t offsetInSect,
                                             uint32_t *foundOffsetAtom=nullptr) {
     const auto &pos = _sectionAtoms.find(&section);
     if (pos == _sectionAtoms.end())
       return nullptr;
     const auto &vec = pos->second;

lld/lib/ReaderWriter/MachO/GOTPass.cpp

for (const DefinedAtom *atom : mergedFile.defined()) {
         // Look at instructions accessing the GOT.
         bool canBypassGOT;
         if (!_archHandler.isGOTAccess(*ref, canBypassGOT))
           continue;
         const Atom *target = ref->target();
         assert(target != nullptr);
 
         if (!shouldReplaceTargetWithGOTAtom(target, canBypassGOT)) {
-          // Update reference kind to reflect that target is a direct accesss.
+          // Update reference kind to reflect that target is a direct access.
           _archHandler.updateReferenceToGOT(ref, false);
         } else {
           // Replace the target with a reference to a GOT entry.
           const DefinedAtom *gotEntry = makeGOTEntry(target);
           const_cast<Reference *>(ref)->setTarget(gotEntry);
           // Update reference kind to reflect that target is now a GOT entry.
           _archHandler.updateReferenceToGOT(ref, true);
         }

lld/lib/ReaderWriter/MachO/MachOLinkingContext.cpp

 void MachOLinkingContext::addExportSymbol(StringRef sym) {
   // Support old crufty export lists with bogus entries.
   if (sym.endswith(".eh") || sym.startswith(".objc_category_name_")) {
     llvm::errs() << "warning: ignoring " << sym << " in export list\n";
     return;
   }
   // Only i386 MacOSX uses old ABI, so don't change those.
   if ((_os != OS::macOSX) || (_arch != arch_x86)) {
-    // ObjC has two differnent ABIs.  Be nice and allow one export list work for
+    // ObjC has two different ABIs.  Be nice and allow one export list work for
     // both ABIs by renaming symbols.
     if (sym.startswith(".objc_class_name_")) {
       std::string abi2className("_OBJC_CLASS_$_");
       abi2className += sym.substr(17);
       _exportedSymbols.insert(copy(abi2className));
       std::string abi2metaclassName("_OBJC_METACLASS_$_");
       abi2metaclassName += sym.substr(17);
       _exportedSymbols.insert(copy(abi2metaclassName));

lld/lib/ReaderWriter/MachO/MachONormalizedFileBinaryWriter.cpp

void TrieNode::addSymbol(const Export& entry,
   StringRef partialStr = entry.name.drop_front(_cummulativeString.size());
   for (TrieEdge &edge : _children) {
     StringRef edgeStr = edge._subString;
     if (partialStr.startswith(edgeStr)) {
       // Already have matching edge, go down that path.
       edge._child->addSymbol(entry, allocator, allNodes);
       return;
     }
-    // See if string has commmon prefix with existing edge.
+    // See if string has common prefix with existing edge.
     for (int n=edgeStr.size()-1; n > 0; --n) {
       if (partialStr.substr(0, n).equals(edgeStr.substr(0, n))) {
         // Splice in new node:  was A -> C,  now A -> B -> C
         StringRef bNodeStr = edge._child->_cummulativeString;
         bNodeStr = bNodeStr.drop_back(edgeStr.size()-n).copy(allocator);
         auto *bNode = new (allocator) TrieNode(bNodeStr);
         allNodes.push_back(bNode);
         TrieNode* cNode = edge._child;
if (_flags & EXPORT_SYMBOL_FLAGS_REEXPORT) {
       nodeSize = llvm::getULEB128Size(_flags) + llvm::getULEB128Size(_address);
       if (_flags & EXPORT_SYMBOL_FLAGS_STUB_AND_RESOLVER)
         nodeSize += llvm::getULEB128Size(_other);
     }
     // Overall node size so far is uleb128 of export info + actual export info.
     nodeSize += llvm::getULEB128Size(nodeSize);
   }
   // Compute size of all child edges.
-  ++nodeSize; // Byte for number of chidren.
+  ++nodeSize; // Byte for number of children.
   for (TrieEdge &edge : _children) {
     nodeSize += edge._subString.size() + 1 // String length.
               + llvm::getULEB128Size(edge._child->_trieOffset); // Offset len.
   }
   // On input, 'offset' is new prefered location for this node.
   bool result = (_trieOffset != offset);
   // Store new location in node object for use by parents.
   _trieOffset = offset;

lld/lib/ReaderWriter/MachO/MachONormalizedFileToAtoms.cpp

void atomFromSymbol(DefinedAtom::ContentType atomType, const Section &section,
   if (isZeroFillSection(section.type)) {
     file.addZeroFillDefinedAtom(symbolName, symbolScope, offset, size,
                                 noDeadStrip, copyRefs, &section);
   } else {
     DefinedAtom::Merge merge = (symbolDescFlags & N_WEAK_DEF)
                               ? DefinedAtom::mergeAsWeak : DefinedAtom::mergeNo;
     bool thumb = (symbolDescFlags & N_ARM_THUMB_DEF);
     if (atomType == DefinedAtom::typeUnknown) {
-      // Mach-O needs a segment and section name.  Concatentate those two
+      // Mach-O needs a segment and section name.  Concatenate those two
       // with a / separator (e.g. "seg/sect") to fit into the lld model
       // of just a section name.
       std::string segSectName = section.segmentName.str()
                                 + "/" + section.sectionName.str();
       file.addDefinedAtomInCustomSection(symbolName, symbolScope, atomType,
                                          merge, thumb, noDeadStrip, offset,
                                          size, segSectName, true, &section);
     } else {
llvm::Error processSymboledSection(DefinedAtom::ContentType atomType,
   //    << llvm::format("0x%08llx ", (uint64_t)sym->value)
   //    << ", " << sym->name << "\n";
 
   // If section has no symbols and no content, there are no atoms.
   if (symbols.empty() && section.content.empty())
     return llvm::Error::success();
 
   if (symbols.empty()) {
-    // Section has no symbols, put all content in one anoymous atom.
+    // Section has no symbols, put all content in one anonymous atom.
     atomFromSymbol(atomType, section, file, section.address, StringRef(),
                   0, Atom::scopeTranslationUnit,
                   section.address + section.content.size(),
                   scatterable, copyRefs);
   }
   else if (symbols.front()->value != section.address) {
     // Section has anonymous content before first symbol.
     atomFromSymbol(atomType, section, file, section.address, StringRef(),
for (unsigned int offset = 0, e = section.content.size(); offset != e;) {
       if (size == 0) {
         return llvm::make_error<GenericError>(Twine("Section ")
                                               + section.segmentName
                                               + "/" + section.sectionName
                                               + " is malformed.  The last atom "
                                               "is not zero terminated.");
       }
       if (customSectionName) {
-        // Mach-O needs a segment and section name.  Concatentate those two
+        // Mach-O needs a segment and section name.  Concatenate those two
         // with a / separator (e.g. "seg/sect") to fit into the lld model
         // of just a section name.
         std::string segSectName = section.segmentName.str()
                                   + "/" + section.sectionName.str();
         file.addDefinedAtomInCustomSection(StringRef(), scope, atomType,
                                            merge, false, false, offset,
                                            size, segSectName, true, &section);
       } else {
for (auto &sect : normalizedFile.sections) {
     DefinedAtom::ContentType atomType = atomTypeFromSection(sect,
                                                             customSectionName);
     if (auto ec =  processSection(atomType, sect, customSectionName,
                                   normalizedFile, *file, scatterable, copyRefs))
       return ec;
   }
   // Create atoms from undefined symbols.
   for (auto &sym : normalizedFile.undefinedSymbols) {
-    // Undefinded symbols with n_value != 0 are actually tentative definitions.
+    // Undefined symbols with n_value != 0 are actually tentative definitions.
     if (sym.value == Hex64(0)) {
       file->addUndefinedAtom(sym.name, copyRefs);
     } else {
       file->addTentativeDefAtom(sym.name, atomScope(sym.scope), sym.value,
                                 DefinedAtom::Alignment(1 << (sym.desc >> 8)),
                                 copyRefs);
     }
   }

lld/lib/ReaderWriter/YAML/ReaderWriterYAML.cpp

void buildDuplicateNameMap(const lld::Atom &atom) {
     if (pos != _nameMap.end()) {
       // Found name collision, give each a unique ref-name.
       std::string Storage;
       llvm::raw_string_ostream buffer(Storage);
       buffer << atom.name() << llvm::format(".%03d", ++_collisionCount);
       StringRef newName = copyString(buffer.str());
       _refNames[&atom] = newName;
       DEBUG_WITH_TYPE("WriterYAML",
-                      llvm::dbgs() << "name collsion: creating ref-name: '"
+                      llvm::dbgs() << "name collision: creating ref-name: '"
                                    << newName << "' ("
                                    << (const void *)newName.data()
                                    << ", " << newName.size() << ")\n");
       const lld::Atom *prevAtom = pos->second;
       AtomToRefName::iterator pos2 = _refNames.find(prevAtom);
       if (pos2 == _refNames.end()) {
         // Only create ref-name for previous if none already created.
         std::string Storage2;
         llvm::raw_string_ostream buffer2(Storage2);
         buffer2 << prevAtom->name() << llvm::format(".%03d", ++_collisionCount);
         StringRef newName2 = copyString(buffer2.str());
         _refNames[prevAtom] = newName2;
         DEBUG_WITH_TYPE("WriterYAML",
-                        llvm::dbgs() << "name collsion: creating ref-name: '"
+                        llvm::dbgs() << "name collision: creating ref-name: '"
                                      << newName2 << "' ("
                                      << (const void *)newName2.data() << ", "
                                      << newName2.size() << ")\n");
       }
     } else {
       // First time we've seen this name, just add it to map.
       _nameMap[atom.name()] = &atom;
       DEBUG_WITH_TYPE("WriterYAML", llvm::dbgs()

lld/test/ELF/aarch64-movw-tprel.s

 # REQUIRES: aarch64
 # RUN: llvm-mc -filetype=obj -triple=aarch64-linux-gnu %s -o %t.o
 # RUN: ld.lld %t.o -o %t
 # RUN: llvm-objdump --no-show-raw-insn -d %t | FileCheck %s
 # RUN: llvm-readobj --symbols %t | FileCheck --check-prefix=CHECK-SYM %s
 
-## Test the the local exec relocations that map to:
+## Test the local exec relocations that map to:
 ## R_AARCH64_TLSLE_MOVW_TPREL_G2
 ## R_AARCH64_TLSLE_MOVW_TPREL_G1
 ## R_AARCH64_TLSLE_MOVW_TPREL_G1_NC
 ## R_AARCH64_TLSLE_MOVW_TPREL_G0
 ## R_AARCH64_TLSLE_MOVW_TPREL_G0_NC
 ## They calculate the same value as the other TPREL relocations, namely the
 ## offset from the thread pointer TP. The G0, G1 and G2 refer to partitions
 ## of the result with G2 bits [47:32], G1 bits [31:16] and G0 bits [15:0]

lld/test/ELF/linkerscript/assert.s

 # RUN: llvm-readobj %t5 > /dev/null
 
 ## Even without SECTIONS block we still use section names
 ## in expressions
 # RUN: echo "ASSERT(SIZEOF(.foo) == 8, fail);" > %t5.script
 # RUN: ld.lld -shared -o %t5 --script %t5.script %t1.o
 # RUN: llvm-readobj %t5 > /dev/null
 
-## Test assertions inside of output section decriptions.
+## Test assertions inside of output section descriptions.
 # RUN: echo "SECTIONS { .foo : { *(.foo) ASSERT(SIZEOF(.foo) == 8, \"true\"); } }" > %t6.script
 # RUN: ld.lld -shared -o %t6 --script %t6.script %t1.o
 # RUN: llvm-readobj %t6 > /dev/null
 
 ## Unlike the GNU ld, we accept the ASSERT without the semicolon.
 ## It is consistent with how ASSERT can be written outside of the
 ## output section declaration.
 # RUN: echo "SECTIONS { .foo : { ASSERT(1, \"true\") } }" > %t7.script
 # RUN: ld.lld -shared -o /dev/null --script %t7.script %t1.o
 
 .section .foo, "a"
  .quad 0

lld/test/ELF/ppc64-bsymbolic-toc-restore.s

 # RUN: llvm-mc -filetype=obj -triple=powerpc64-unknown-linux %p/Inputs/ppc64-bsymbolic-local-def.s  -o %t2.o
 # RUN: ld.lld -Bsymbolic -shared %t1.o %t2.o -o %t
 # RUN: llvm-objdump -d -r %t | FileCheck %s
 # RUN: not ld.lld -shared %t1.o %t2.o -o %t 2>&1 | FileCheck --check-prefix=FAIL %s
 
 # FAIL: call to def lacks nop, can't restore toc
 
 # Test to document the toc-restore behavior with -Bsymbolic option. Since
-# -Bsymbolic causes the call to bind to the internal defintion we know the
+# -Bsymbolic causes the call to bind to the internal definition we know the
 # caller and callee share the same TOC base. This means branching to the
 # local entry point of the callee, and no need for a nop to follow the call
 # (since there is no need to restore the TOC-pointer after the call).
 
         .abiversion 2
         .section ".text"
 
         .p2align 2

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 explict --export of an lazy archive
+; 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*
 ; 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

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:
 ; %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"
 
-; Function declartion with incorrect signature.
+; Function declaration with incorrect signature.
 declare dso_local void @ret32()
 
 ; Simply taking the address of the function should *not* generate the
 ; the signature mismatch warning.
 @ptr = dso_local global i8* bitcast (void ()* @ret32 to i8*), align 8
 
 define hidden void @_start() local_unnamed_addr {
   %addr = load i32 ()*, i32 ()** bitcast (i8** @ptr to i32 ()**), align 8
   call i32 %addr()
   ret void
 }

lld/wasm/Config.h

struct Configuration {
 
   // The following config options do not directly correspond to any
   // particualr command line options.
 
   // True if we are creating position-independent code.
   bool isPic;
 
   // The table offset at which to place function addresses.  We reserve zero
-  // for the null function pointer.  This gets set to 1 for exectuables and 0
+  // for the null function pointer.  This gets set to 1 for executables and 0
   // for shared libraries (since they always added to a dynamic offset at
   // runtime).
   uint32_t tableBase = 0;
 };
 
 // The only instance of Configuration struct.
 extern Configuration *config;
 
 } // namespace wasm
 } // namespace lld
 
 #endif

lld/wasm/InputChunks.h

protected:
   void verifyRelocTargets() const;
 
   ArrayRef<WasmRelocation> relocations;
   Kind sectionKind;
 };
 
 // Represents a WebAssembly data segment which can be included as part of
 // an output data segments.  Note that in WebAssembly, unlike ELF and other
-// formats, used the term "data segment" to refer to the continous regions of
+// formats, used the term "data segment" to refer to the continuous regions of
 // memory that make on the data section. See:
 // https://webassembly.github.io/spec/syntax/modules.html#syntax-data
 //
 // For example, by default, clang will produce a separate data section for
 // each global variable.
 class InputSegment : public InputChunk {
 public:
   InputSegment(const WasmSegment &seg, ObjFile *f)
uint32_t getInputSectionOffset() const override {
     return function->CodeSectionOffset;
   }
   uint32_t getTableIndex() const { return tableIndex.getValue(); }
   bool hasTableIndex() const { return tableIndex.hasValue(); }
   void setTableIndex(uint32_t index);
 
   // The size of a given input function can depend on the values of the
   // LEB relocations within it.  This finalizeContents method is called after
-  // all the symbol values have be calcualted but before getSize() is ever
+  // all the symbol values have be calculated but before getSize() is ever
   // called.
   void calculateSize();
 
   const WasmSignature &signature;
 
 protected:
   ArrayRef<uint8_t> data() const override {
     assert(!config->compressRelocations);

lld/wasm/InputFiles.cpp

if (section.Type == WASM_SEC_CODE) {
       assert(!dataSection);
       dataSection = &section;
     } else if (section.Type == WASM_SEC_CUSTOM) {
       customSections.emplace_back(make<InputSection>(section, this));
       customSections.back()->setRelocations(section.Relocations);
       customSectionsByIndex[sectionIndex] = customSections.back();
     }
     sectionIndex++;
-    // Scans relocations to dermine determine if a function symbol is called
-    // directly
+    // Scans relocations to determine if a function symbol is called directly.
     for (const WasmRelocation &reloc : section.Relocations)
       if (reloc.Type == R_WASM_FUNCTION_INDEX_LEB)
         isCalledDirectly[reloc.Index] = true;
   }
 
   typeMap.resize(getWasmObj()->types().size());
   typeIsUsed.resize(getWasmObj()->types().size(), false);
 

lld/wasm/SymbolTable.cpp

DefinedFunction *SymbolTable::addSyntheticFunction(StringRef name,
   LLVM_DEBUG(dbgs() << "addSyntheticFunction: " << name << "\n");
   assert(!find(name));
   syntheticFunctions.emplace_back(function);
   return replaceSymbol<DefinedFunction>(insertName(name).first, name,
                                         flags, nullptr, function);
 }
 
 // Adds an optional, linker generated, data symbols.  The symbol will only be
-// added if there is an undefine reference to it, or if it is explictly exported
-// via the --export flag.  Otherwise we don't add the symbol and return nullptr.
+// added if there is an undefine reference to it, or if it is explicitly
+// exported via the --export flag.  Otherwise we don't add the symbol and return
+// nullptr.
 DefinedData *SymbolTable::addOptionalDataSymbol(StringRef name,
                                                 uint32_t value) {
   Symbol *s = find(name);
   if (!s && (config->exportAll || config->exportedSymbols.count(name) != 0))
     s = insertName(name).first;
   else if (!s || s->isDefined())
     return nullptr;
   LLVM_DEBUG(dbgs() << "addOptionalDataSymbol: " << name << "\n");
Symbol *SymbolTable::addDefinedEvent(StringRef name, uint32_t flags,
   if (shouldReplace(s, file, flags))
     replaceSym();
   return s;
 }
 
 // This function get called when an undefined symbol is added, and there is
 // already an existing one in the symbols table.  In this case we check that
 // custom 'import-module' and 'import-field' symbol attributes agree.
-// With LTO these attributes are not avialable when the bitcode is read and only
+// With LTO these attributes are not available when the bitcode is read and only
 // become available when the LTO object is read.  In this case we silently
 // replace the empty attributes with the valid ones.
 template <typename T>
 static void setImportAttributes(T *existing, StringRef importName,
                                 StringRef importModule, InputFile *file) {
   if (!importName.empty()) {
     if (existing->importName.empty())
       existing->importName = importName;
if (wasInserted) {
     replaceSymbol<LazySymbol>(s, name, 0, file, *sym);
     return;
   }
 
   if (!s->isUndefined())
     return;
 
   // The existing symbol is undefined, load a new one from the archive,
-  // unless the the existing symbol is weak in which case replace the undefined
+  // unless the existing symbol is weak in which case replace the undefined
   // symbols with a LazySymbol.
   if (s->isWeak()) {
     const WasmSignature *oldSig = nullptr;
     // In the case of an UndefinedFunction we need to preserve the expected
     // signature.
     if (auto *f = dyn_cast<UndefinedFunction>(s))
       oldSig = f->signature;
     LLVM_DEBUG(dbgs() << "replacing existing weak undefined symbol\n");
for (Symbol *sym : getSymbols()) {
     if (!sym->isUndefWeak())
       continue;
 
     const WasmSignature *sig = sym->getSignature();
     if (!sig) {
       // It is possible for undefined functions not to have a signature (eg. if
       // added via "--undefined"), but weak undefined ones do have a signature.
       // Lazy symbols may not be functions and therefore Sig can still be null
-      // in some circumstantce.
+      // in some circumstance.
       assert(!isa<FunctionSymbol>(sym));
       continue;
     }
 
     // Add a synthetic dummy for weak undefined functions.  These dummies will
     // be GC'd if not used as the target of any "call" instructions.
     StringRef debugName = saver.save("undefined:" + toString(*sym));
     InputFunction* func = replaceWithUnreachable(sym, *sig, debugName);

lld/wasm/Symbols.h

public:
   bool requiresGOT : 1;
 
   // True if the symbol was used for linking and thus need to be added to the
   // output file's symbol table. This is true for all symbols except for
   // unreferenced DSO symbols, lazy (archive) symbols, and bitcode symbols that
   // are unreferenced except by other bitcode objects.
   bool isUsedInRegularObj : 1;
 
-  // True if ths symbol is explicity marked for export (i.e. via the -e/--export
-  // command line flag)
+  // True if ths symbol is explicitly marked for export (i.e. via the
+  // -e/--export command line flag)
   bool forceExport : 1;
 
   // False if LTO shouldn't inline whatever this symbol points to. If a symbol
   // is overwritten after LTO, LTO shouldn't inline the symbol because it
   // doesn't know the final contents of the symbol.
   bool canInline : 1;
 
   // True if this symbol is specified by --trace-symbol option.