Fix typos in comments of ExecutionEngine/

[sgraenitz]

Wow, that's a lot of typo fixes! Thanks!

Let's drop all the an <--> a changes, I think these are fine.

Everything else LGTM.

[Eymay]

In D157226#4564085, @sgraenitz wrote:

Let's drop all the an <--> a changes, I think these are fine.

Though it's a very minor thing, I wanted to remove all of the "a ELF " usage in the whole project including lldb https://reviews.llvm.org/D157214. I can revert them with no problem.

[Eymay]

Reverted a -> an changes for acronyms in comments

[sgraenitz]

LGTM, thanks! Should I land it on your behalf?

llvm/lib/ExecutionEngine/Orc/DebugUtils.cpp

79

I think we could keep this as well. Was it by accident?

[Eymay]

In D157226#4579993, @sgraenitz wrote:

LGTM, thanks! Should I land it on your behalf?

Yes please. You can use:
"Eymen Ünay <[e-mail]>"

llvm/lib/ExecutionEngine/Orc/DebugUtils.cpp

79

It is the only non-acronym pattern so I left it out.

[lhames]

Oh cool -- thanks very much for this @Eymay!

llvm/include/llvm-c/Orc.h

  * instance. Individual calls to this method may resolve a subset of the
  * symbols, but all symbols must have been resolved prior to calling emit.
  *
  * This method will return an error if any symbols being resolved have been
  * moved to the error state due to the failure of a dependency. If this
  * method returns an error then clients should log it and call
  * LLVMOrcMaterializationResponsibilityFailMaterialization. If no dependencies
  * have been registered for the symbols covered by this
- * MaterializationResponsibiility then this method is guaranteed to return
+ * MaterializationResponsibility then this method is guaranteed to return
  * LLVMErrorSuccess.
  */
 LLVMErrorRef LLVMOrcMaterializationResponsibilityNotifyResolved(
     LLVMOrcMaterializationResponsibilityRef MR, LLVMOrcCSymbolMapPairs Symbols,
     size_t NumPairs);
 
 /**
  * Notifies the target JITDylib (and any pending queries on that JITDylib)
  * that all symbols covered by this MaterializationResponsibility instance
  * have been emitted.
  *
  * This method will return an error if any symbols being resolved have been
  * moved to the error state due to the failure of a dependency. If this
  * method returns an error then clients should log it and call
  * LLVMOrcMaterializationResponsibilityFailMaterialization.
  * If no dependencies have been registered for the symbols covered by this
- * MaterializationResponsibiility then this method is guaranteed to return
+ * MaterializationResponsibility then this method is guaranteed to return
  * LLVMErrorSuccess.
  */
 LLVMErrorRef LLVMOrcMaterializationResponsibilityNotifyEmitted(
     LLVMOrcMaterializationResponsibilityRef MR);
 
 /**
  * Attempt to claim responsibility for new definitions. This method can be
  * used to claim responsibility for symbols that are added to a

  */
 LLVMErrorRef LLVMOrcMaterializationResponsibilityDefineMaterializing(
     LLVMOrcMaterializationResponsibilityRef MR,
     LLVMOrcCSymbolFlagsMapPairs Pairs, size_t NumPairs);
 
 /**
  * Notify all not-yet-emitted covered by this MaterializationResponsibility
  * instance that an error has occurred.
- * This will remove all symbols covered by this MaterializationResponsibilty
+ * This will remove all symbols covered by this MaterializationResponsibility
  * from the target JITDylib, and send an error to any queries waiting on
  * these symbols.
  */
 void LLVMOrcMaterializationResponsibilityFailMaterialization(
     LLVMOrcMaterializationResponsibilityRef MR);
 
 /**
  * Transfers responsibility to the given MaterializationUnit for all

llvm/include/llvm/ExecutionEngine/ExecutionEngine.h

public:
   }
 
   std::map<uint64_t, std::string> &getGlobalAddressReverseMap() {
     return GlobalAddressReverseMap;
   }
 
   /// Erase an entry from the mapping table.
   ///
-  /// \returns The address that \p ToUnmap was happed to.
+  /// \returns The address that \p ToUnmap was mapped to.
   uint64_t RemoveMapping(StringRef Name);
 };
 
 using FunctionCreator = std::function<void *(const std::string &)>;
 
 /// Abstract interface for implementation execution of LLVM modules,
 /// designed to support both interpreter and just-in-time (JIT) compiler
 /// implementations.
public:
   /// and all memory will be readable and writable but not executable.
   ///
   /// This function is primarily useful when generating code for an external
   /// target, allowing the client an opportunity to remap section addresses
   /// before relocations are applied.  Clients that intend to execute code
   /// locally can use the getFunctionAddress call, which will generate code
   /// and apply final preparations all in one step.
   ///
-  /// This method has no effect for the interpeter.
+  /// This method has no effect for the interpreter.
   virtual void generateCodeForModule(Module *M) {}
 
   /// finalizeObject - ensure the module is fully processed and is usable.
   ///
   /// It is the user-level function for completing the process of making the
   /// object usable for execution.  It should be called after sections within an
   /// object have been relocated using mapSectionAddress.  When this method is
   /// called the MCJIT execution engine will reapply relocations for a loaded
-  /// object.  This method has no effect for the interpeter.
+  /// object.  This method has no effect for the interpreter.
   ///
   /// Returns true on success, false on failure. Error messages can be retrieved
   /// by calling getError();
   virtual void finalizeObject() {}
 
   /// Returns true if an error has been recorded.
   bool hasError() const { return !ErrMsg.empty(); }
 

llvm/include/llvm/ExecutionEngine/JITEventListener.h

public:
   /// were loaded and with relocations performed in-place on debug sections.
   virtual void notifyObjectLoaded(ObjectKey K, const object::ObjectFile &Obj,
                                   const RuntimeDyld::LoadedObjectInfo &L) {}
 
   /// notifyFreeingObject - Called just before the memory associated with
   /// a previously emitted object is released.
   virtual void notifyFreeingObject(ObjectKey K) {}
 
-  // Get a pointe to the GDB debugger registration listener.
+  // Get a pointer to the GDB debugger registration listener.
   static JITEventListener *createGDBRegistrationListener();
 
 #if LLVM_USE_INTEL_JITEVENTS
   // Construct an IntelJITEventListener
   static JITEventListener *createIntelJITEventListener();
 
   // Construct an IntelJITEventListener with a test Intel JIT API implementation
   static JITEventListener *createIntelJITEventListener(

llvm/include/llvm/ExecutionEngine/JITLink/ELF_aarch64.h

 /// Create a LinkGraph from an ELF/aarch64 relocatable object
 ///
 /// Note: The graph does not take ownership of the underlying buffer, nor copy
 /// its contents. The caller is responsible for ensuring that the object buffer
 /// outlives the graph.
 Expected<std::unique_ptr<LinkGraph>>
 createLinkGraphFromELFObject_aarch64(MemoryBufferRef ObjectBuffer);
 
-/// jit-link the given object buffer, which must be a ELF aarch64 relocatable
+/// jit-link the given object buffer, which must be an ELF aarch64 relocatable
 /// object file.
 void link_ELF_aarch64(std::unique_ptr<LinkGraph> G,
                       std::unique_ptr<JITLinkContext> Ctx);
 
 } // end namespace jitlink
 } // end namespace llvm
 
 #endif // LLVM_EXECUTIONENGINE_JITLINK_ELF_AARCH64_H

llvm/include/llvm/ExecutionEngine/JITLink/ELF_i386.h

 /// Create a LinkGraph from an ELF/i386 relocatable object
 ///
 /// Note: The graph does not take ownership of the underlying buffer, nor copy
 /// its contents. The caller is responsible for ensuring that the object buffer
 /// outlives the graph.
 Expected<std::unique_ptr<LinkGraph>>
 createLinkGraphFromELFObject_i386(MemoryBufferRef ObjectBuffer);
 
-/// jit-link the given object buffer, which must be a ELF i386 relocatable
+/// jit-link the given object buffer, which must be an ELF i386 relocatable
 /// object file.
 void link_ELF_i386(std::unique_ptr<LinkGraph> G,
                    std::unique_ptr<JITLinkContext> Ctx);
 
 } // end namespace jitlink
 } // end namespace llvm
 
 #endif // LLVM_EXECUTIONENGINE_JITLINK_ELF_I386_H

llvm/include/llvm/ExecutionEngine/JITLink/ELF_ppc64.h

 /// Create a LinkGraph from an ELF/ppc64le relocatable object.
 ///
 /// Note: The graph does not take ownership of the underlying buffer, nor copy
 /// its contents. The caller is responsible for ensuring that the object buffer
 /// outlives the graph.
 Expected<std::unique_ptr<LinkGraph>>
 createLinkGraphFromELFObject_ppc64le(MemoryBufferRef ObjectBuffer);
 
-/// jit-link the given object buffer, which must be a ELF ppc64le object file.
+/// jit-link the given object buffer, which must be an ELF ppc64le object file.
 ///
 /// WARNING: The big-endian backend has not been tested yet.
 void link_ELF_ppc64(std::unique_ptr<LinkGraph> G,
                     std::unique_ptr<JITLinkContext> Ctx);
 
-/// jit-link the given object buffer, which must be a ELF ppc64le object file.
+/// jit-link the given object buffer, which must be an ELF ppc64le object file.
 void link_ELF_ppc64le(std::unique_ptr<LinkGraph> G,
                       std::unique_ptr<JITLinkContext> Ctx);
 
 } // end namespace llvm::jitlink
 
 #endif // LLVM_EXECUTIONENGINE_JITLINK_ELF_PPC64_H

llvm/include/llvm/ExecutionEngine/JITLink/ELF_riscv.h

 /// Create a LinkGraph from an ELF/riscv relocatable object
 ///
 /// Note: The graph does not take ownership of the underlying buffer, nor copy
 /// its contents. The caller is responsible for ensuring that the object buffer
 /// outlives the graph.
 Expected<std::unique_ptr<LinkGraph>>
 createLinkGraphFromELFObject_riscv(MemoryBufferRef ObjectBuffer);
 
-/// jit-link the given object buffer, which must be a ELF riscv object file.
+/// jit-link the given object buffer, which must be an ELF riscv object file.
 void link_ELF_riscv(std::unique_ptr<LinkGraph> G,
                     std::unique_ptr<JITLinkContext> Ctx);
 
 /// Returns a pass that performs linker relaxation. Should be added to
 /// PostAllocationPasses.
 LinkGraphPassFunction createRelaxationPass_ELF_riscv();
 
 } // end namespace jitlink
 } // end namespace llvm
 
 #endif // LLVM_EXECUTIONENGINE_JITLINK_ELF_RISCV_H

llvm/include/llvm/ExecutionEngine/JITLink/ELF_x86_64.h

 /// Create a LinkGraph from an ELF/x86-64 relocatable object.
 ///
 /// Note: The graph does not take ownership of the underlying buffer, nor copy
 /// its contents. The caller is responsible for ensuring that the object buffer
 /// outlives the graph.
 Expected<std::unique_ptr<LinkGraph>>
 createLinkGraphFromELFObject_x86_64(MemoryBufferRef ObjectBuffer);
 
-/// jit-link the given object buffer, which must be a ELF x86-64 object file.
+/// jit-link the given object buffer, which must be an ELF x86-64 object file.
 void link_ELF_x86_64(std::unique_ptr<LinkGraph> G,
                      std::unique_ptr<JITLinkContext> Ctx);
 
 } // end namespace jitlink
 } // end namespace llvm
 
 #endif // LLVM_EXECUTIONENGINE_JITLINK_ELF_X86_64_H

llvm/include/llvm/ExecutionEngine/JITLink/JITLink.h

public:
   void setScope(Scope S) {
     assert((!Name.empty() || S == Scope::Local) &&
            "Can not set anonymous symbol to non-local scope");
     assert((S != Scope::Local || Base->isDefined() || Base->isAbsolute()) &&
            "Invalid visibility for symbol type");
     this->S = static_cast<uint8_t>(S);
   }
 
-  /// Check wehther the given target flags are set for this Symbol.
+  /// Check whether the given target flags are set for this Symbol.
   bool hasTargetFlags(TargetFlagsType Flags) const {
     return static_cast<TargetFlagsType>(TargetFlags) & Flags;
   }
 
   /// Set the target flags for this Symbol.
   void setTargetFlags(TargetFlagsType Flags) {
     assert(Flags <= 1 && "Add more bits to store more than single flag");
     TargetFlags = Flags;

llvm/include/llvm/ExecutionEngine/JITSymbol.h

public:
   /// Construct a JITSymbolFlags instance from the given flags.
   JITSymbolFlags(FlagNames Flags) : Flags(Flags) {}
 
   /// Construct a JITSymbolFlags instance from the given flags and target
   ///        flags.
   JITSymbolFlags(FlagNames Flags, TargetFlagsType TargetFlags)
       : TargetFlags(TargetFlags), Flags(Flags) {}
 
-  /// Implicitly convert to bool. Returs true if any flag is set.
+  /// Implicitly convert to bool. Returns true if any flag is set.
   explicit operator bool() const { return Flags != None || TargetFlags != 0; }
 
   /// Compare for equality.
   bool operator==(const JITSymbolFlags &RHS) const {
     return Flags == RHS.Flags && TargetFlags == RHS.TargetFlags;
   }
 
   /// Bitwise AND-assignment for FlagNames.

llvm/include/llvm/ExecutionEngine/OProfileWrapper.h

 //===-- OProfileWrapper.h - OProfile JIT API Wrapper ------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
-// This file defines a OProfileWrapper object that detects if the oprofile
+// This file defines an OProfileWrapper object that detects if the oprofile
 // daemon is running, and provides wrappers for opagent functions used to
 // communicate with the oprofile JIT interface. The dynamic library libopagent
 // does not need to be linked directly as this object lazily loads the library
 // when the first op_ function is called.
 //
 // See http://oprofile.sourceforge.net/doc/devel/jit-interface.html for the
 // definition of the interface.
 //
public:
   // otherwise.
   bool isAgentAvailable();
 
 private:
   // Loads the libopagent library and initializes this wrapper if the oprofile
   // daemon is running
   bool initialize();
 
-  // Searches /proc for the oprofile daemon and returns true if the process if
+  // Searches /proc for the oprofile daemon and returns true if the process is
   // found, or false otherwise.
   bool checkForOProfileProcEntry();
 
   bool isOProfileRunning();
 };
 
 } // namespace llvm
 
 #endif // LLVM_EXECUTIONENGINE_OPROFILEWRAPPER_H

llvm/include/llvm/ExecutionEngine/Orc/COFFVCRuntimeSupport.h

 namespace orc {
 
 /// Bootstraps the vc runtime within jitdylibs.
 class COFFVCRuntimeBootstrapper {
 public:
   /// Try to create a COFFVCRuntimeBootstrapper instance. An optional
   /// RuntimePath can be given to specify the location of directory that
   /// contains all vc runtime library files such as ucrt.lib and msvcrt.lib. If
-  /// not path was given, it will try to search the MSVC toolchain and Windows
+  /// no path was given, it will try to search the MSVC toolchain and Windows
   /// SDK installation and use the found library files automatically.
   ///
   /// Note that depending on the build setting, a different library
   /// file must be used. In general, if vc runtime was statically linked to the
   /// object file that is to be jit-linked, LoadStaticVCRuntime and
   /// InitializeStaticVCRuntime must be used with libcmt.lib, libucrt.lib,
   /// libvcruntimelib. If vc runtime was dynamically linked LoadDynamicVCRuntime
   /// must be used along with msvcrt.lib, ucrt.lib, vcruntime.lib.
public:
 
   /// Runs the initializer of static version of msvc runtime libraries.
   /// This must be called before calling any functions requiring c runtime (e.g.
   /// printf) within the jit session. Note that proper initialization of vc
   /// runtime requires ability of running static initializers. Cosider setting
   /// up COFFPlatform.
   Error initializeStaticVCRuntime(JITDylib &JD);
 
-  /// Adds symbol definitions of dynamic versino of msvc runtie libraries.
+  /// Adds symbol definitions of dynamic version of msvc runtime libraries.
   Expected<std::vector<std::string>>
   loadDynamicVCRuntime(JITDylib &JD, bool DebugVersion = false);
 
 private:
   COFFVCRuntimeBootstrapper(ExecutionSession &ES,
                             ObjectLinkingLayer &ObjLinkingLayer,
                             const char *RuntimePath);
 

llvm/include/llvm/ExecutionEngine/Orc/CompileUtils.h

private:
   void notifyObjectCompiled(const Module &M, const MemoryBuffer &ObjBuffer);
 
   TargetMachine &TM;
   ObjectCache *ObjCache = nullptr;
 };
 
 /// A SimpleCompiler that owns its TargetMachine.
 ///
-/// This convenient for clients who don't want to own their TargetMachines,
+/// This is convenient for clients who don't want to own their TargetMachines,
 /// e.g. LLJIT.
 class TMOwningSimpleCompiler : public SimpleCompiler {
 public:
   TMOwningSimpleCompiler(std::unique_ptr<TargetMachine> TM,
                          ObjectCache *ObjCache = nullptr)
       : SimpleCompiler(*TM, ObjCache), TM(std::move(TM)) {}
 
 private:

llvm/include/llvm/ExecutionEngine/Orc/Core.h

public:
   /// symbols must be ones covered by this MaterializationResponsibility
   /// instance. Individual calls to this method may resolve a subset of the
   /// symbols, but all symbols must have been resolved prior to calling emit.
   ///
   /// This method will return an error if any symbols being resolved have been
   /// moved to the error state due to the failure of a dependency. If this
   /// method returns an error then clients should log it and call
   /// failMaterialize. If no dependencies have been registered for the
-  /// symbols covered by this MaterializationResponsibiility then this method
+  /// symbols covered by this MaterializationResponsibility then this method
   /// is guaranteed to return Error::success() and can be wrapped with cantFail.
   Error notifyResolved(const SymbolMap &Symbols);
 
   /// Notifies the target JITDylib (and any pending queries on that JITDylib)
   /// that all symbols covered by this MaterializationResponsibility instance
   /// have been emitted.
   ///
   /// This method will return an error if any symbols being resolved have been
   /// moved to the error state due to the failure of a dependency. If this
   /// method returns an error then clients should log it and call
   /// failMaterialize. If no dependencies have been registered for the
-  /// symbols covered by this MaterializationResponsibiility then this method
+  /// symbols covered by this MaterializationResponsibility then this method
   /// is guaranteed to return Error::success() and can be wrapped with cantFail.
   Error notifyEmitted();
 
   /// Attempt to claim responsibility for new definitions. This method can be
   /// used to claim responsibility for symbols that are added to a
   /// materialization unit during the compilation process (e.g. literal pool
   /// symbols). Symbol linkage rules are the same as for symbols that are
   /// defined up front: duplicate strong definitions will result in errors.
   /// Duplicate weak definitions will be discarded (in which case they will
   /// not be added to this responsibility instance).
   ///
   ///   This method can be used by materialization units that want to add
   /// additional symbols at materialization time (e.g. stubs, compile
   /// callbacks, metadata).
   Error defineMaterializing(SymbolFlagsMap SymbolFlags);
 
   /// Notify all not-yet-emitted covered by this MaterializationResponsibility
   /// instance that an error has occurred.
-  /// This will remove all symbols covered by this MaterializationResponsibilty
+  /// This will remove all symbols covered by this MaterializationResponsibility
   /// from the target JITDylib, and send an error to any queries waiting on
   /// these symbols.
   void failMaterialization();
 
   /// Transfers responsibility to the given MaterializationUnit for all
   /// symbols defined by that MaterializationUnit. This allows
   /// materializers to break up work based on run-time information (e.g.
   /// by introspecting which symbols have actually been looked up and
return [H = std::forward<HandlerT>(H)](
                const char *ArgData, size_t ArgSize) mutable {
       shared::WrapperFunction<SPSSignature>::handleAsync(ArgData, ArgSize, H,
                                                          std::move(SendResult));
     };
   }
 
   /// Wrap a class method that takes concrete argument types (and a sender for
   /// a concrete return type) to produce an AsyncHandlerWrapperFunction. Uses
-  /// SPS to unpack teh arguments and pack the result.
+  /// SPS to unpack the arguments and pack the result.
   ///
   /// This function is intended to support easy construction of
   /// AsyncHandlerWrapperFunctions that can be associated with a tag
   /// (using registerJITDispatchHandler) and called from the executor.
   template <typename SPSSignature, typename ClassT, typename... MethodArgTs>
   static JITDispatchHandlerFunction
   wrapAsyncWithSPS(ClassT *Instance, void (ClassT::*Method)(MethodArgTs...)) {
     return wrapAsyncWithSPS<SPSSignature>(

llvm/include/llvm/ExecutionEngine/Orc/DebugUtils.h

 
 /// Render a MaterializationUnit.
 raw_ostream &operator<<(raw_ostream &OS, const MaterializationUnit &MU);
 
 //// Render a JITDylibLookupFlags instance.
 raw_ostream &operator<<(raw_ostream &OS,
                         const JITDylibLookupFlags &JDLookupFlags);
 
-/// Rendar a SymbolLookupFlags instance.
+/// Render a SymbolLookupFlags instance.
 raw_ostream &operator<<(raw_ostream &OS, const SymbolLookupFlags &LookupFlags);
 
 /// Render a SymbolLookupSet entry.
 raw_ostream &operator<<(raw_ostream &OS, const SymbolLookupSet::value_type &KV);
 
 /// Render a SymbolLookupSet.
 raw_ostream &operator<<(raw_ostream &OS, const SymbolLookupSet &LookupSet);
 

llvm/include/llvm/ExecutionEngine/Orc/ELFNixPlatform.h

using ELFNixJITDylibInitializerSequence =
     std::vector<ELFNixJITDylibInitializers>;
 
 using ELFNixJITDylibDeinitializerSequence =
     std::vector<ELFNixJITDylibDeinitializers>;
 
 /// Mediates between ELFNix initialization and ExecutionSession state.
 class ELFNixPlatform : public Platform {
 public:
-  /// Try to create a ELFNixPlatform instance, adding the ORC runtime to the
+  /// Try to create an ELFNixPlatform instance, adding the ORC runtime to the
   /// given JITDylib.
   ///
   /// The ORC runtime requires access to a number of symbols in
-  /// libc++. It is up to the caller to ensure that the requried
+  /// libc++. It is up to the caller to ensure that the required
   /// symbols can be referenced by code added to PlatformJD. The
   /// standard way to achieve this is to first attach dynamic library
   /// search generators for either the given process, or for the
   /// specific required libraries, to PlatformJD, then to create the
   /// platform instance:
   ///
   /// \code{.cpp}
   ///   auto &PlatformJD = ES.createBareJITDylib("stdlib");

llvm/include/llvm/ExecutionEngine/Orc/EPCGenericJITLinkMemoryManager.h

private:
 
   ExecutorProcessControl &EPC;
   SymbolAddrs SAs;
 };
 
 namespace shared {
 
 /// FIXME: This specialization should be moved into TargetProcessControlTypes.h
-///        (or whereever those types get merged to) once ORC depends on JITLink.
+///        (or wherever those types get merged to) once ORC depends on JITLink.
 template <>
 class SPSSerializationTraits<SPSExecutorAddr,
                              jitlink::JITLinkMemoryManager::FinalizedAlloc> {
 public:
   static size_t size(const jitlink::JITLinkMemoryManager::FinalizedAlloc &FA) {
     return SPSArgList<SPSExecutorAddr>::size(ExecutorAddr(FA.getAddress()));
   }
 

llvm/include/llvm/ExecutionEngine/Orc/ExecutorProcessControl.h

public:
 
   /// Load the dynamic library at the given path and return a handle to it.
   /// If LibraryPath is null this function will return the global handle for
   /// the target process.
   virtual Expected<tpctypes::DylibHandle> loadDylib(const char *DylibPath) = 0;
 
   /// Search for symbols in the target process.
   ///
-  /// The result of the lookup is a 2-dimentional array of target addresses
+  /// The result of the lookup is a 2-dimensional array of target addresses
   /// that correspond to the lookup order. If a required symbol is not
   /// found then this method will return an error. If a weakly referenced
   /// symbol is not found then it be assigned a '0' value.
   virtual Expected<std::vector<tpctypes::LookupResult>>
   lookupSymbols(ArrayRef<LookupRequest> Request) = 0;
 
   /// Run function with a main-like signature.
   virtual Expected<int32_t> runAsMain(ExecutorAddr MainFnAddr,

llvm/include/llvm/ExecutionEngine/Orc/IndirectionUtils.h

 ///
 /// The given target triple will determine the ABI, and the given
 /// ErrorHandlerAddress will be used by the resulting compile callback
 /// manager if a compile callback fails.
 Expected<std::unique_ptr<JITCompileCallbackManager>>
 createLocalCompileCallbackManager(const Triple &T, ExecutionSession &ES,
                                   ExecutorAddr ErrorHandlerAddress);
 
-/// Create a local indriect stubs manager builder.
+/// Create a local indirect stubs manager builder.
 ///
 /// The given target triple will determine the ABI.
 std::function<std::unique_ptr<IndirectStubsManager>()>
 createLocalIndirectStubsManagerBuilder(const Triple &T);
 
 /// Build a function pointer of FunctionType with the given constant
 ///        address.
 ///

llvm/include/llvm/ExecutionEngine/Orc/MachOPlatform.h

using MachOJITDylibDepInfoMap =
       std::vector<std::pair<ExecutorAddr, MachOJITDylibDepInfo>>;
 
   /// Try to create a MachOPlatform instance, adding the ORC runtime to the
   /// given JITDylib.
   ///
   /// The ORC runtime requires access to a number of symbols in libc++, and
   /// requires access to symbols in libobjc, and libswiftCore to support
   /// Objective-C and Swift code. It is up to the caller to ensure that the
-  /// requried symbols can be referenced by code added to PlatformJD. The
+  /// required symbols can be referenced by code added to PlatformJD. The
   /// standard way to achieve this is to first attach dynamic library search
   /// generators for either the given process, or for the specific required
   /// libraries, to PlatformJD, then to create the platform instance:
   ///
   /// \code{.cpp}
   ///   auto &PlatformJD = ES.createBareJITDylib("stdlib");
   ///   PlatformJD.addGenerator(
   ///     ExitOnErr(EPCDynamicLibrarySearchGenerator

llvm/include/llvm/ExecutionEngine/RTDyldMemoryManager.h

public:
   RTDyldMemoryManager() = default;
   RTDyldMemoryManager(const RTDyldMemoryManager&) = delete;
   void operator=(const RTDyldMemoryManager&) = delete;
   ~RTDyldMemoryManager() override;
 
   /// Register EH frames in the current process.
   static void registerEHFramesInProcess(uint8_t *Addr, size_t Size);
 
-  /// Deregister EH frames in the current proces.
+  /// Deregister EH frames in the current process.
   static void deregisterEHFramesInProcess(uint8_t *Addr, size_t Size);
 
   void registerEHFrames(uint8_t *Addr, uint64_t LoadAddr, size_t Size) override;
   void deregisterEHFrames() override;
 
   /// This method returns the address of the specified function or variable in
   /// the current process.
   static uint64_t getSymbolAddressInProcess(const std::string &Name);

llvm/lib/ExecutionEngine/JITLink/COFFLinkGraphBuilder.cpp

 //=--------- COFFLinkGraphBuilder.cpp - COFF LinkGraph builder ----------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
-// Generic COFF LinkGraph buliding code.
+// Generic COFF LinkGraph building code.
 //
 //===----------------------------------------------------------------------===//
 #include "COFFLinkGraphBuilder.h"
 
 #define DEBUG_TYPE "jitlink"
 
 static const char *CommonSectionName = "__common";
 

 
 // Process the second symbol of COMDAT sequence.
 Expected<Symbol *>
 COFFLinkGraphBuilder::exportCOMDATSymbol(COFFSymbolIndex SymIndex,
                                          StringRef SymbolName,
                                          object::COFFSymbolRef Symbol) {
   Block *B = getGraphBlock(Symbol.getSectionNumber());
   auto &PendingComdatExport = PendingComdatExports[Symbol.getSectionNumber()];
-  // NOTE: ComdatDef->Legnth is the size of "section" not size of symbol.
+  // NOTE: ComdatDef->Length is the size of "section" not size of symbol.
   // We use zero symbol size to not reach out of bound of block when symbol
   // offset is non-zero.
   auto GSym = &G->addDefinedSymbol(
       *B, Symbol.getValue(), SymbolName, 0, PendingComdatExport->Linkage,
       Scope::Default, Symbol.getComplexType() == COFF::IMAGE_SYM_DTYPE_FUNCTION,
       false);
   LLVM_DEBUG({
     dbgs() << "    " << SymIndex

llvm/lib/ExecutionEngine/JITLink/ELFLinkGraphBuilder.h

 
 private:
   static StringRef CommonSectionName;
   static ArrayRef<const char *> DwarfSectionNames;
 
   Section *CommonSection = nullptr;
 };
 
-/// Ling-graph building code that's specific to the given ELFT, but common
+/// LinkGraph building code that's specific to the given ELFT, but common
 /// across all architectures.
 template <typename ELFT>
 class ELFLinkGraphBuilder : public ELFLinkGraphBuilderBase {
   using ELFFile = object::ELFFile<ELFT>;
 
 public:
   ELFLinkGraphBuilder(const object::ELFFile<ELFT> &Obj, Triple TT,
                       SubtargetFeatures Features, StringRef FileName,

llvm/lib/ExecutionEngine/JITLink/ELFLinkGraphBuilder.cpp

 //=----------- ELFLinkGraphBuilder.cpp - ELF LinkGraph builder ------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
-// Generic ELF LinkGraph buliding code.
+// Generic ELF LinkGraph building code.
 //
 //===----------------------------------------------------------------------===//
 
 #include "ELFLinkGraphBuilder.h"
 
 #define DEBUG_TYPE "jitlink"
 
 static const char *DWSecNames[] = {

llvm/lib/ExecutionEngine/JITLink/ELF_aarch64.cpp

return ELFLinkGraphBuilder_aarch64<object::ELF64LE>(
       .buildGraph();
 }
 
 void link_ELF_aarch64(std::unique_ptr<LinkGraph> G,
                       std::unique_ptr<JITLinkContext> Ctx) {
   PassConfiguration Config;
   const Triple &TT = G->getTargetTriple();
   if (Ctx->shouldAddDefaultTargetPasses(TT)) {
-    // Add eh-frame passses.
+    // Add eh-frame passes.
     Config.PrePrunePasses.push_back(DWARFRecordSectionSplitter(".eh_frame"));
     Config.PrePrunePasses.push_back(EHFrameEdgeFixer(
         ".eh_frame", 8, aarch64::Pointer32, aarch64::Pointer64,
         aarch64::Delta32, aarch64::Delta64, aarch64::NegDelta32));
     Config.PrePrunePasses.push_back(EHFrameNullTerminator(".eh_frame"));
 
     // Add a mark-live pass.
     if (auto MarkLive = Ctx->getMarkLivePass(TT))

llvm/lib/ExecutionEngine/JITLink/ELF_loongarch.cpp

return ELFLinkGraphBuilder_loongarch<object::ELF32LE>(
       .buildGraph();
 }
 
 void link_ELF_loongarch(std::unique_ptr<LinkGraph> G,
                         std::unique_ptr<JITLinkContext> Ctx) {
   PassConfiguration Config;
   const Triple &TT = G->getTargetTriple();
   if (Ctx->shouldAddDefaultTargetPasses(TT)) {
-    // Add eh-frame passses.
+    // Add eh-frame passes.
     Config.PrePrunePasses.push_back(DWARFRecordSectionSplitter(".eh_frame"));
     Config.PrePrunePasses.push_back(
         EHFrameEdgeFixer(".eh_frame", G->getPointerSize(), Pointer32, Pointer64,
                          Delta32, Delta64, NegDelta32));
     Config.PrePrunePasses.push_back(EHFrameNullTerminator(".eh_frame"));
 
     // Add a mark-live pass.
     if (auto MarkLive = Ctx->getMarkLivePass(TT))

llvm/lib/ExecutionEngine/JITLink/ELF_ppc64.cpp

 template <support::endianness Endianness>
 void link_ELF_ppc64(std::unique_ptr<LinkGraph> G,
                     std::unique_ptr<JITLinkContext> Ctx) {
   PassConfiguration Config;
 
   if (Ctx->shouldAddDefaultTargetPasses(G->getTargetTriple())) {
     // Construct a JITLinker and run the link function.
 
-    // Add eh-frame passses.
+    // Add eh-frame passes.
     Config.PrePrunePasses.push_back(DWARFRecordSectionSplitter(".eh_frame"));
     Config.PrePrunePasses.push_back(EHFrameEdgeFixer(
         ".eh_frame", G->getPointerSize(), ppc64::Pointer32, ppc64::Pointer64,
         ppc64::Delta32, ppc64::Delta64, ppc64::NegDelta32));
     Config.PrePrunePasses.push_back(EHFrameNullTerminator(".eh_frame"));
 
     // Add a mark-live pass.
     if (auto MarkLive = Ctx->getMarkLivePass(G->getTargetTriple()))

 }
 
 Expected<std::unique_ptr<LinkGraph>>
 createLinkGraphFromELFObject_ppc64le(MemoryBufferRef ObjectBuffer) {
   return createLinkGraphFromELFObject_ppc64<support::little>(
       std::move(ObjectBuffer));
 }
 
-/// jit-link the given object buffer, which must be a ELF ppc64 object file.
+/// jit-link the given object buffer, which must be an ELF ppc64 object file.
 void link_ELF_ppc64(std::unique_ptr<LinkGraph> G,
                     std::unique_ptr<JITLinkContext> Ctx) {
   return link_ELF_ppc64<support::big>(std::move(G), std::move(Ctx));
 }
 
-/// jit-link the given object buffer, which must be a ELF ppc64le object file.
+/// jit-link the given object buffer, which must be an ELF ppc64le object file.
 void link_ELF_ppc64le(std::unique_ptr<LinkGraph> G,
                       std::unique_ptr<JITLinkContext> Ctx) {
   return link_ELF_ppc64<support::little>(std::move(G), std::move(Ctx));
 }
 
 } // end namespace llvm::jitlink

llvm/lib/ExecutionEngine/JITLink/MachOLinkGraphBuilder.cpp

 //=--------- MachOLinkGraphBuilder.cpp - MachO LinkGraph builder ----------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
-// Generic MachO LinkGraph buliding code.
+// Generic MachO LinkGraph building code.
 //
 //===----------------------------------------------------------------------===//
 
 #include "MachOLinkGraphBuilder.h"
 #include <optional>
 
 #define DEBUG_TYPE "jitlink"
 

llvm/lib/ExecutionEngine/JITLink/MachO_arm64.cpp

if (auto MarkLive = Ctx->getMarkLivePass(G->getTargetTriple()))
       Config.PrePrunePasses.push_back(std::move(MarkLive));
     else
       Config.PrePrunePasses.push_back(markAllSymbolsLive);
 
     // Add compact unwind splitter pass.
     Config.PrePrunePasses.push_back(
         CompactUnwindSplitter("__LD,__compact_unwind"));
 
-    // Add eh-frame passses.
+    // Add eh-frame passes.
     // FIXME: Prune eh-frames for which compact-unwind is available once
     // we support compact-unwind registration with libunwind.
     Config.PrePrunePasses.push_back(createEHFrameSplitterPass_MachO_arm64());
     Config.PrePrunePasses.push_back(createEHFrameEdgeFixerPass_MachO_arm64());
 
     // Add an in-place GOT/Stubs pass.
     Config.PostPrunePasses.push_back(buildTables_MachO_arm64);
   }

llvm/lib/ExecutionEngine/JITLink/MachO_x86_64.cpp

 }
 
 void link_MachO_x86_64(std::unique_ptr<LinkGraph> G,
                        std::unique_ptr<JITLinkContext> Ctx) {
 
   PassConfiguration Config;
 
   if (Ctx->shouldAddDefaultTargetPasses(G->getTargetTriple())) {
-    // Add eh-frame passses.
+    // Add eh-frame passes.
     Config.PrePrunePasses.push_back(createEHFrameSplitterPass_MachO_x86_64());
     Config.PrePrunePasses.push_back(createEHFrameEdgeFixerPass_MachO_x86_64());
 
     // Add compact unwind splitter pass.
     Config.PrePrunePasses.push_back(
         CompactUnwindSplitter("__LD,__compact_unwind"));
 
     // Add a mark-live pass.

llvm/lib/ExecutionEngine/Orc/Core.cpp

if (Err) {
       // FIXME: Should this be reported / treated as failure to materialize?
       // Or should this be treated as a sanctioned bailing-out?
       ES.reportError(std::move(Err));
       R->failMaterialization();
       return;
     }
   }
 
-  // The OnResolveInfo struct will hold the aliases and responsibilty for each
+  // The OnResolveInfo struct will hold the aliases and responsibility for each
   // query in the list.
   struct OnResolveInfo {
     OnResolveInfo(std::unique_ptr<MaterializationResponsibility> R,
                   SymbolAliasMap Aliases)
         : R(std::move(R)), Aliases(std::move(Aliases)) {}
 
     std::unique_ptr<MaterializationResponsibility> R;
     SymbolAliasMap Aliases;
for (auto &KV : IPLS->SearchOrder) {
               auto FailedSymbolsMap = std::make_shared<SymbolDependenceMap>();
               (*FailedSymbolsMap)[&JD] = {Name};
               return make_error<FailedToMaterialize>(
                   getSymbolStringPool(), std::move(FailedSymbolsMap));
             }
 
             // Otherwise this is a match.
 
-            // If this symbol is already in the requried state then notify the
+            // If this symbol is already in the required state then notify the
             // query, remove the symbol and continue.
             if (SymI->second.getState() >= Q->getRequiredState()) {
               LLVM_DEBUG(dbgs()
                          << "matched, symbol already in required state\n");
               Q->notifySymbolMetRequiredState(Name, SymI->second.getSymbol());
               return true;
             }
 

llvm/lib/ExecutionEngine/Orc/DebugUtils.cpp

#ifndef NDEBUG
 
   // otherwise return false.
   return false;
 #else
   return false;
 #endif // NDEBUG
 }
 
-// Prints a sequence of items, filtered by an user-supplied predicate.
+// Prints a sequence of items, filtered by a user-supplied predicate.
 template <typename Sequence,
           typename Pred = PrintAll<typename Sequence::value_type>>
 class SequencePrinter {
 public:
   SequencePrinter(const Sequence &S, char OpenSeq, char CloseSeq,
                   Pred ShouldPrint = Pred())
       : S(S), OpenSeq(OpenSeq), CloseSeq(CloseSeq),
         ShouldPrint(std::move(ShouldPrint)) {}

llvm/lib/ExecutionEngine/Orc/RTDyldObjectLinkingLayer.cpp

Error RTDyldObjectLinkingLayer::onObjLoad(
   SymbolFlagsMap ExtraSymbolsToClaim;
   SymbolMap Symbols;
 
   // Hack to support COFF constant pool comdats introduced during compilation:
   // (See http://llvm.org/PR40074)
   if (auto *COFFObj = dyn_cast<object::COFFObjectFile>(&Obj)) {
     auto &ES = getExecutionSession();
 
-    // For all resolved symbols that are not already in the responsibilty set:
+    // For all resolved symbols that are not already in the responsibility set:
     // check whether the symbol is in a comdat section and if so mark it as
     // weak.
     for (auto &Sym : COFFObj->symbols()) {
       // getFlags() on COFF symbols can't fail.
       uint32_t SymFlags = cantFail(Sym.getFlags());
       if (SymFlags & object::BasicSymbolRef::SF_Undefined)
         continue;
       auto Name = Sym.getName();

llvm/lib/ExecutionEngine/Orc/SpeculateAnalyses.cpp

if (I.first == AtBB)
       SuccSkipNodes.insert(I.second);
 
   for (; PIt != EIt; ++PIt)
     if (BPI->isEdgeHot(AtBB, *PIt) && !SuccSkipNodes.count(*PIt))
       traverseToExitBlock(*PIt, CallerBlocks, BackEdgesInfo, BPI,
                           VisitedBlocks);
 }
 
-// Get Block frequencies for blocks and take most frquently executed block,
+// Get Block frequencies for blocks and take most frequently executed block,
 // walk towards the entry block from those blocks and discover the basic blocks
 // with call.
 SequenceBBQuery::BlockListTy
 SequenceBBQuery::queryCFG(Function &F, const BlockListTy &CallerBlocks) {
 
   BlockFreqInfoTy BBFreqs;
   VisitedBlocksInfoTy VisitedBlocks;
   BackEdgesInfoTy BackEdgesInfo;

llvm/lib/ExecutionEngine/PerfJITEvents/PerfJITEventListener.cpp

for (const std::pair<SymbolRef, uint64_t> &P : computeSymbolSizes(DebugObj)) {
     Address.Address = *AddrOrErr;
 
     uint64_t SectionIndex = object::SectionedAddress::UndefSection;
     if (auto SectOrErr = Sym.getSection())
         if (*SectOrErr != Obj.section_end())
             SectionIndex = SectOrErr.get()->getIndex();
 
     // According to spec debugging info has to come before loading the
-    // corresonding code load.
+    // corresponding code load.
     DILineInfoTable Lines = Context->getLineInfoForAddressRange(
         {*AddrOrErr, SectionIndex}, Size, FileLineInfoKind::AbsoluteFilePath);
 
     NotifyDebug(*AddrOrErr, Lines);
     NotifyCode(Name, *AddrOrErr, Size);
   }
 
   // avoid races with writes

llvm/lib/ExecutionEngine/RuntimeDyld/RTDyldMemoryManager.cpp

#endif
   // callee's(eg. tools/lli) one, to invoke wrong duplicated ctors
   // (and register wrong callee's dtors with atexit(3)).
   // We expect ExecutionEngine::runStaticConstructorsDestructors()
   // is called before ExecutionEngine::runFunctionAsMain() is called.
   if (Name == "__main") return (uint64_t)&jit_noop;
 
   const char *NameStr = Name.c_str();
 
-  // DynamicLibrary::SearchForAddresOfSymbol expects an unmangled 'C' symbol
+  // DynamicLibrary::SearchForAddressOfSymbol expects an unmangled 'C' symbol
   // name so ff we're on Darwin, strip the leading '_' off.
 #ifdef __APPLE__
   if (NameStr[0] == '_')
     ++NameStr;
 #endif
 
   return (uint64_t)sys::DynamicLibrary::SearchForAddressOfSymbol(NameStr);
 }

llvm/lib/ExecutionEngine/RuntimeDyld/RuntimeDyldChecker.cpp

std::tie(StubAddr, ErrorMsg) = Checker.getSectionAddr(
         FileName, SectionName, PCtx.IsInsideLoad);
 
     if (ErrorMsg != "")
       return std::make_pair(EvalResult(ErrorMsg), "");
 
     return std::make_pair(EvalResult(StubAddr), RemainingExpr);
   }
 
-  // Evaluate an identiefer expr, which may be a symbol, or a call to
+  // Evaluate an identifier expr, which may be a symbol, or a call to
   // one of the builtin functions: get_insn_opcode or get_insn_length.
   // Return the result, plus the expression remaining to be parsed.
   std::pair<EvalResult, StringRef> evalIdentifierExpr(StringRef Expr,
                                                       ParseContext PCtx) const {
     StringRef Symbol;
     StringRef RemainingExpr;
     std::tie(Symbol, RemainingExpr) = parseSymbol(Expr);
 
evalComplexExpr(const std::pair<EvalResult, StringRef> &LHSAndRemaining,
     StringRef RemainingExpr;
     std::tie(LHSResult, RemainingExpr) = LHSAndRemaining;
 
     // If there was an error, or there's nothing left to evaluate, return the
     // result.
     if (LHSResult.hasError() || RemainingExpr == "")
       return std::make_pair(LHSResult, RemainingExpr);
 
-    // Otherwise check if this is a binary expressioan.
+    // Otherwise check if this is a binary expression.
     BinOpToken BinOp;
     std::tie(BinOp, RemainingExpr) = parseBinOpToken(RemainingExpr);
 
     // If this isn't a recognized expression just return.
     if (BinOp == BinOpToken::Invalid)
       return std::make_pair(LHSResult, RemainingExpr);
 
     // This is a recognized bin-op. Evaluate the RHS, then evaluate the binop.

llvm/lib/ExecutionEngine/RuntimeDyld/RuntimeDyldELF.h

private:
 
   // Allocate no GOT entries for use in the given section.
   uint64_t allocateGOTEntries(unsigned no);
 
   // Find GOT entry corresponding to relocation or create new one.
   uint64_t findOrAllocGOTEntry(const RelocationValueRef &Value,
                                unsigned GOTRelType);
 
-  // Resolve the relvative address of GOTOffset in Section ID and place
+  // Resolve the relative address of GOTOffset in Section ID and place
   // it at the given Offset
   void resolveGOTOffsetRelocation(unsigned SectionID, uint64_t Offset,
                                   uint64_t GOTOffset, uint32_t Type);
 
   // For a GOT entry referenced from SectionID, compute a relocation entry
   // that will place the final resolved value in the GOT slot
   RelocationEntry computeGOTOffsetRE(uint64_t GOTOffset, uint64_t SymbolOffset,
                                      unsigned Type);
 
   // Compute the address in memory where we can find the placeholder
   void *computePlaceholderAddress(unsigned SectionID, uint64_t Offset) const;
 
-  // Split out common case for createing the RelocationEntry for when the relocation requires
-  // no particular advanced processing.
+  // Split out common case for creating the RelocationEntry for when the
+  // relocation requires no particular advanced processing.
   void processSimpleRelocation(unsigned SectionID, uint64_t Offset, unsigned RelType, RelocationValueRef Value);
 
   // Return matching *LO16 relocation (Mips specific)
   uint32_t getMatchingLoRelocation(uint32_t RelType,
                                    bool IsLocal = false) const;
 
   // The tentative ID for the GOT section
   unsigned GOTSectionID;

llvm/lib/ExecutionEngine/RuntimeDyld/Targets/RuntimeDyldCOFFAArch64.h

 
 #define DEBUG_TYPE "dyld"
 
 using namespace llvm::support::endian;
 
 namespace llvm {
 
 // This relocation type is used for handling long branch instruction
-// throught the Stub.
+// through the Stub.
 enum InternalRelocationType : unsigned {
   INTERNAL_REL_ARM64_LONG_BRANCH26 = 0x111,
 };
 
 static void add16(uint8_t *p, int16_t v) { write16le(p, read16le(p) + v); }
 static void or32le(void *P, int32_t V) { write32le(P, read32le(P) | V); }
 
 static void write32AArch64Imm(uint8_t *T, uint64_t imm, uint32_t rangeLimit) {