[WebAssembly] Fix typos

[sbc100]

Summary

Patch by Nicholas Wilson

[ruiu]

LGTM

wasm/Driver.cpp

static Optional<std::string> findFile(StringRef Path1, const Twine &Path2) {
   path::append(S, Path1, Path2);
   if (fs::exists(S))
     return S.str().str();
   return None;
 }
 
 // Inject a new wasm global into the output binary with the given value.
 // Wasm global are used in relocatable object files to model symbol imports
-// and exports.  In the final exectuable the only use of wasm globals is the
+// and exports.  In the final executable the only use of wasm globals is
 // for the exlicit stack pointer (__stack_pointer).
 static void addSyntheticGlobal(StringRef Name, int32_t Value) {
   log("injecting global: " + Name);
   Symbol *S = Symtab->addDefinedGlobal(Name);
   S->setOutputIndex(Config->SyntheticGlobals.size());
 
   WasmGlobal Global;
   Global.Mutable = true;

wasm/SymbolTable.cpp

if (WasInserted) {
     S->update(Kind, F, Sym, Segment, NewSig);
   } else if (S->isLazy()) {
     // The existing symbol is lazy. Replace it without checking types since
     // lazy symbols don't have any type information.
     DEBUG(dbgs() << "replacing existing lazy symbol: " << Sym->Name << "\n");
     S->update(Kind, F, Sym, Segment, NewSig);
   } else if (!S->isDefined()) {
     // The existing symbol table entry is undefined. The new symbol replaces
-    // it, after checkign the type matches
+    // it, after checking the type matches
     DEBUG(dbgs() << "resolving existing undefined symbol: " << Sym->Name
                  << "\n");
     checkSymbolTypes(*S, *F, *Sym, NewSig);
     S->update(Kind, F, Sym, Segment, NewSig);
   } else if (Sym->isWeak()) {
     // the new symbol is weak we can ignore it
-    DEBUG(dbgs() << "existing symbol takes precensence\n");
+    DEBUG(dbgs() << "existing symbol takes precedence\n");
   } else if (S->isWeak()) {
     // the new symbol is not weak and the existing symbol is, so we replace
     // it
     DEBUG(dbgs() << "replacing existing weak symbol\n");
     checkSymbolTypes(*S, *F, *Sym, NewSig);
     S->update(Kind, F, Sym, Segment, NewSig);
   } else {
-    // niether symbol is week. They conflict.
+    // neither symbol is week. They conflict.
     reportDuplicate(S, F);
   }
   return S;
 }
 
 Symbol *SymbolTable::addUndefinedFunction(StringRef Name,
                                           const WasmSignature *Type) {
   Symbol *S;

wasm/Writer.cpp

for (size_t i = 0; i < OrigSize; i++) {
     SyntheticSection *Section = createSyntheticSection(WASM_SEC_CUSTOM, name);
     raw_ostream &OS = Section->getStream();
     writeUleb128(OS, S->Type, "reloc section");
     writeUleb128(OS, Count, "reloc count");
     S->writeRelocations(OS);
   }
 }
 
-// Create the custome "linking" section containing linker metadata.
+// Create the custom "linking" section containing linker metadata.
 // This is only created when relocatable output is requested.
 void Writer::createLinkingSection() {
   SyntheticSection *Section =
       createSyntheticSection(WASM_SEC_CUSTOM, "linking");
   raw_ostream &OS = Section->getStream();
 
   SubSection DataSizeSubSection(WASM_DATA_SIZE);
   writeUleb128(DataSizeSubSection.getStream(), DataSize, "data size");

 }
 
 void Writer::writeSections() {
   uint8_t *Buf = Buffer->getBufferStart();
   parallelForEach(OutputSections, [Buf](OutputSection *S) { S->writeTo(Buf); });
 }
 
 // Fix the memory layout of the output binary.  This assigns memory offsets
-// to each of the intput data sections as well as the explicit stack region.
+// to each of the input data sections as well as the explicit stack region.
 void Writer::layoutMemory() {
   uint32_t MemoryPtr = 0;
   if (!Config->Relocatable) {
     MemoryPtr = Config->GlobalBase;
     debugPrint("mem: global base = %d\n", Config->GlobalBase);
   }
 
   createOutputSegments();