[lldb] Fixed a number of typos

[GabrielRavier]

Summary

I went over the output of the following mess of a command:

(ulimit -m 2000000; ulimit -v 2000000; git ls-files -z | parallel --xargs -0 cat | aspell list --mode=none --ignore-case | grep -E '^[A-Za-z][a-z]*$' | sort | uniq -c | sort -n | grep -vE '.{25}' | aspell pipe -W3 | grep : | cut -d' ' -f2 | less)

and proceeded to spend a few days looking at it to find probable typos
and fixed a few hundred of them in all of the llvm project (note, the
ones I found are not anywhere near all of them, but it seems like a
good start).

[Michael137]

FYI, there's a couple of instances of sythetic (instead of synthetic) around LLDB that could be included in this

[JDevlieghere]

Thanks, these all look good. LGTM.

[GabrielRavier]

Btw just so you know, I do not have commit access to LLVM so I cannot land this revision myself (I've also been told I should tell you my usual handle on git is Gabriel Ravier <[e-mail]> w.r.t. that)

lldb/bindings/interface/SBProcess.i

use IsValid() to check if the info returned is valid. ::
         process_info = process.GetProcessInfo()
         if process_info.IsValid():
             process_info.GetProcessID()") GetProcessInfo;
     lldb::SBProcessInfo
     GetProcessInfo();
 
     %feature("autodoc", "
     Allocates a block of memory within the process, with size and
-    access permissions specified in the arguments. The permisssions
+    access permissions specified in the arguments. The permissions
     argument is an or-combination of zero or more of
     lldb.ePermissionsWritable, lldb.ePermissionsReadable, and
     lldb.ePermissionsExecutable. Returns the address
     of the allocated buffer in the process, or
     lldb.LLDB_INVALID_ADDRESS if the allocation failed.") AllocateMemory;
 
     lldb::addr_t
     AllocateMemory(size_t size, uint32_t permissions, lldb::SBError &error);

lldb/bindings/interface/SBType.i

public:
     ") GetVectorElementType;
     lldb::SBType
     GetVectorElementType ();
 
     %feature("docstring",
     "Returns the `BasicType` value that is most appropriate to this type.
 
     Returns `eBasicTypeInvalid` if no appropriate `BasicType` was found or this
-    type is invalid. See the `BasicType` documentation for the language-specific m
-    aning of each `BasicType` value.
+    type is invalid. See the `BasicType` documentation for the language-specific
+    meaning of each `BasicType` value.
 
     **Overload behaviour:** When called with a `BasicType` parameter, the
     following behaviour applies:
 
     Returns the `SBType` that represents the passed `BasicType` value. Returns
     an invalid `SBType` if no fitting `SBType` could be created.
 
     Language-specific behaviour:
public:
     "Returns the number of template arguments of this type.
 
     Returns ``0`` if this type is not a template.
 
     Language-specific behaviour:
 
     * C: Always returns ``0``.
     * C++: If this type is a class template instantiation then this returns the
-      number of template parameters that were used in this instantiation. This i
-      cludes both explicit and implicit template parameters.
+      number of template parameters that were used in this instantiation. This
+      includes both explicit and implicit template parameters.
     * Objective-C: Always returns ``0``.
     ") GetNumberOfTemplateArguments;
     uint32_t
     GetNumberOfTemplateArguments ();
 
     %feature("docstring",
     "Returns the type of the template argument with the given index.
 

lldb/docs/use/python-reference.rst

if __name__ == '__main__':
       # lldb.debugger, so we can just create it if it will be needed
       debugger = lldb.SBDebugger.Create()
 
       # Next, do whatever work this module should do when run as a command.
       # ...
 
       # Finally, dispose of the debugger you just made.
       lldb.SBDebugger.Destroy(debugger)
-      # Terminate the debug sesssion
+      # Terminate the debug session
       lldb.SBDebugger.Terminate()
 
 
 Now we can create a module called ls.py in the file ~/ls.py that will implement
 a function that can be used by LLDB's python command code:
 
 ::
 

lldb/examples/python/armv7_cortex_m_target_defintion.py

 # to change and add new registers without requiring a new LLDB build
 # just so we can see new registers.
 #
 # This file implements the x86_64 registers for the darwin version of
 # GDB and allows you to connect to servers that use this register set. 
 # 
 # USAGE
 #
-# (lldb) settings set plugin.process.gdb-remote.target-definition-file /path/to/armv7_cortex_m_target_defintion.py
+# (lldb) settings set plugin.process.gdb-remote.target-definition-file /path/to/armv7_cortex_m_target_definition.py
 # (lldb) gdb-remote other.baz.com:1234
 #
 # The target definition file will get used if and only if the 
 # qRegisterInfo packets are not supported when connecting to a remote
 # GDB server.
 #----------------------------------------------------------------------
 
 from lldb import *

lldb/examples/python/lldb_module_utils.py

 #!/usr/bin/env python
 
 import lldb
 import optparse
 import shlex
 import string
 import sys
 
 
 class DumpLineTables:
     command_name = "dump-line-tables"
-    short_decription = "Dumps full paths to compile unit files and optionally all line table files."
+    short_description = "Dumps full paths to compile unit files and optionally all line table files."
     description = 'Dumps all line tables from all compile units for any modules specified as arguments. Specifying the --verbose flag will output address ranges for each line entry.'
     usage = "usage: %prog [options] MODULE1 [MODULE2 ...]"
     def create_options(self):
         self.parser = optparse.OptionParser(
             description=self.description,
             prog=self.command_name,
             usage=self.usage)
 
         self.parser.add_option(
             '-v',
             '--verbose',
             action='store_true',
             dest='verbose',
             help='Display verbose output.',
             default=False)
 
     def get_short_help(self):
-        return self.short_decription
+        return self.short_description
 
     def get_long_help(self):
         return self.help_string
 
     def __init__(self, debugger, unused):
         self.create_options()
         self.help_string = self.parser.format_help()
 

lldb/include/lldb/Core/Debugger.h

public:
   ///   debugger identifier that this progress should be delivered to. If this
   ///   optional parameter does not have a value, the progress will be
   ///   delivered to all debuggers.
   ///
   /// \param [in] once
   ///   If a pointer is passed to a std::once_flag, then it will be used to
   ///   ensure the given warning is only broadcast once.
   static void
-  ReportWarning(std::string messsage,
+  ReportWarning(std::string message,
                 llvm::Optional<lldb::user_id_t> debugger_id = llvm::None,
                 std::once_flag *once = nullptr);
 
   /// Report error events.
   ///
   /// Progress events will be delivered to any debuggers that have listeners
   /// for the eBroadcastBitError.
   ///
   /// \param[in] message
   ///   The error message to be reported.
   ///
   /// \param [in] debugger_id
   ///   If this optional parameter has a value, it indicates the unique
   ///   debugger identifier that this progress should be delivered to. If this
   ///   optional parameter does not have a value, the progress will be
   ///   delivered to all debuggers.
   ///
   /// \param [in] once
   ///   If a pointer is passed to a std::once_flag, then it will be used to
   ///   ensure the given error is only broadcast once.
   static void
-  ReportError(std::string messsage,
+  ReportError(std::string message,
               llvm::Optional<lldb::user_id_t> debugger_id = llvm::None,
               std::once_flag *once = nullptr);
 
   static void ReportSymbolChange(const ModuleSpec &module_spec);
 
 protected:
   friend class CommandInterpreter;
   friend class REPL;

lldb/include/lldb/Core/Mangled.h

 
 namespace lldb_private {
 
 /// \class Mangled Mangled.h "lldb/Core/Mangled.h"
 /// A class that handles mangled names.
 ///
 /// Designed to handle mangled names. The demangled version of any names will
 /// be computed when the demangled name is accessed through the Demangled()
-/// acccessor. This class can also tokenize the demangled version of the name
+/// accessor. This class can also tokenize the demangled version of the name
 /// for powerful searches. Functions and symbols could make instances of this
 /// class for their mangled names. Uniqued string pools are used for the
 /// mangled, demangled, and token string values to allow for faster
 /// comparisons and for efficient memory use.
 class Mangled {
 public:
   enum NamePreference {
     ePreferMangled,

lldb/include/lldb/Symbol/Type.h

public:
   /// Since Type instances only keep a "SymbolFile *" internally, other classes
   /// like TypeImpl need make sure the module is still around before playing
   /// with
   /// Type instances. They can store a weak pointer to the Module;
   lldb::ModuleSP GetModule();
 
   /// GetModule may return module for compile unit's object file.
   /// GetExeModule returns module for executable object file that contains
-  /// compile unit where type was actualy defined.
+  /// compile unit where type was actually defined.
   /// GetModule and GetExeModule may return the same value.
   lldb::ModuleSP GetExeModule();
 
   void GetDescription(Stream *s, lldb::DescriptionLevel level, bool show_name,
                       ExecutionContextScope *exe_scope);
 
   SymbolFile *GetSymbolFile() { return m_symbol_file; }
   const SymbolFile *GetSymbolFile() const { return m_symbol_file; }

lldb/packages/Python/lldbsuite/test/lldbbench.py

 from __future__ import absolute_import
 
 # System modules
 import time
 
 # Third-party modules
 
 # LLDB modules
 from .lldbtest import *
 
 
 class Stopwatch(object):
     """Stopwatch provides a simple utility to start/stop your stopwatch multiple
     times.  Each start/stop is equal to a lap, with its elapsed time accumulated
-    while measurment is in progress.
+    while measurement is in progress.
 
     When you're ready to start from scratch for another round of measurements,
     be sure to call the reset() method.
 
     For example,
 
     sw = Stopwatch()
     for i in range(1000):

lldb/source/Core/DynamicLoader.cpp

for (uint32_t idx = 0;
         return instance_up.release();
     }
   }
   return nullptr;
 }
 
 DynamicLoader::DynamicLoader(Process *process) : m_process(process) {}
 
-// Accessosors to the global setting as to whether to stop at image (shared
+// Accessors to the global setting as to whether to stop at image (shared
 // library) loading/unloading.
 
 bool DynamicLoader::GetStopWhenImagesChange() const {
   return m_process->GetStopOnSharedLibraryEvents();
 }
 
 void DynamicLoader::SetStopWhenImagesChange(bool stop) {
   m_process->SetStopOnSharedLibraryEvents(stop);

lldb/source/Core/IOHandlerCursesGUI.cpp

void UpdateFieldsVisibility() override {
     }
   }
 
   static constexpr const char *kLoadDependentFilesNo = "No";
   static constexpr const char *kLoadDependentFilesYes = "Yes";
   static constexpr const char *kLoadDependentFilesExecOnly = "Executable only";
 
   std::vector<std::string> GetLoadDependentFilesChoices() {
-    std::vector<std::string> load_depentents_options;
-    load_depentents_options.push_back(kLoadDependentFilesExecOnly);
-    load_depentents_options.push_back(kLoadDependentFilesYes);
-    load_depentents_options.push_back(kLoadDependentFilesNo);
-    return load_depentents_options;
+    std::vector<std::string> load_dependents_options;
+    load_dependents_options.push_back(kLoadDependentFilesExecOnly);
+    load_dependents_options.push_back(kLoadDependentFilesYes);
+    load_dependents_options.push_back(kLoadDependentFilesNo);
+    return load_dependents_options;
   }
 
   LoadDependentFiles GetLoadDependentFiles() {
     std::string choice = m_load_dependent_files_field->GetChoiceContent();
     if (choice == kLoadDependentFilesNo)
       return eLoadDependentsNo;
     if (choice == kLoadDependentFilesYes)
       return eLoadDependentsYes;

lldb/source/Expression/DWARFExpression.cpp

case DW_OP_const8u:
       break;
 
     case DW_OP_form_tls_address:
     case DW_OP_GNU_push_tls_address:
       // DW_OP_form_tls_address and DW_OP_GNU_push_tls_address must be preceded
       // by a file address on the stack. We assume that DW_OP_const4u or
       // DW_OP_const8u is used for these values, and we check that the last
       // opcode we got before either of these was DW_OP_const4u or
-      // DW_OP_const8u. If so, then we can link the value accodingly. For
+      // DW_OP_const8u. If so, then we can link the value accordingly. For
       // Darwin, the value in the DW_OP_const4u or DW_OP_const8u is the file
       // address of a structure that contains a function pointer, the pthread
       // key and the offset into the data pointed to by the pthread key. So we
       // must link this address and also set the module of this expression to
       // the new_module_sp so we can resolve the file address correctly
       if (const_byte_size > 0) {
         lldb::addr_t linked_file_addr = link_address_callback(const_value);
         if (linked_file_addr == LLDB_INVALID_ADDRESS)
enum LocationDescriptionKind {
   /* Composite*/
 };
 /// Adjust value's ValueType according to the kind of location description.
 void UpdateValueTypeFromLocationDescription(Log *log, const DWARFUnit *dwarf_cu,
                                             LocationDescriptionKind kind,
                                             Value *value = nullptr) {
   // Note that this function is conflating DWARF expressions with
   // DWARF location descriptions. Perhaps it would be better to define
-  // a wrapper for DWARFExpresssion::Eval() that deals with DWARF
+  // a wrapper for DWARFExpression::Eval() that deals with DWARF
   // location descriptions (which consist of one or more DWARF
   // expressions). But doing this would mean we'd also need factor the
   // handling of DW_OP_(bit_)piece out of this function.
   if (dwarf_cu && dwarf_cu->GetVersion() >= 4) {
     const char *log_msg = "DWARF location description kind: %s";
     switch (kind) {
     case Empty:
       LLDB_LOGF(log, log_msg, "Empty");

 /// into a load address.
 ///
 /// \param exe_ctx Pointer to the execution context
 /// \param module_sp shared_ptr contains the module if we have one
 /// \param error_ptr pointer to Status object if we have one
 /// \param dw_op_type C-style string used to vary the error output
 /// \param file_addr the file address we are trying to resolve and turn into a
 ///                  load address
-/// \param so_addr out parameter, will be set to load addresss or section offset
+/// \param so_addr out parameter, will be set to load address or section offset
 /// \param check_sectionoffset bool which determines if having a section offset
 ///                            but not a load address is considerd a success
 /// \returns llvm::Optional containing the load address if resolving and getting
 ///          the load address succeed or an empty Optinal otherwise. If
 ///          check_sectionoffset is true we consider LLDB_INVALID_ADDRESS a
 ///          success if so_addr.IsSectionOffset() is true.
 static llvm::Optional<lldb::addr_t>
 ResolveLoadAddress(ExecutionContext *exe_ctx, lldb::ModuleSP &module_sp,

lldb/source/Plugins/DynamicLoader/POSIX-DYLD/DynamicLoaderPOSIXDYLD.cpp

if (ModuleSP module_sp = DynamicLoader::LoadModuleAtAddress(
           file, link_map_addr, base_addr, base_addr_is_offset))
     return module_sp;
 
   // This works around an dynamic linker "bug" on android <= 23, where the
   // dynamic linker would report the application name
   // (e.g. com.example.myapplication) instead of the main process binary
   // (/system/bin/app_process(32)). The logic is not sound in general (it
   // assumes base_addr is the real address, even though it actually is a load
-  // bias), but it happens to work on adroid because app_process has a file
+  // bias), but it happens to work on android because app_process has a file
   // address of zero.
   // This should be removed after we drop support for android-23.
   if (m_process->GetTarget().GetArchitecture().GetTriple().isAndroid()) {
     MemoryRegionInfo memory_info;
     Status error = m_process->GetMemoryRegionInfo(base_addr, memory_info);
     if (error.Success() && memory_info.GetMapped() &&
         memory_info.GetRange().GetRangeBase() == base_addr &&
         !(memory_info.GetName().IsEmpty())) {

lldb/source/Plugins/ExpressionParser/Clang/ClangExpressionDeclMap.cpp

if (copied_function_type) {
                  function_type->GetName(), function_type->GetID());
 
         return;
       }
     } else {
       // We failed to copy the type we found
       LLDB_LOG(log,
                "  Failed to import the function type '{0}' ({1:x})"
-               " into the expression parser AST contenxt",
+               " into the expression parser AST context",
                function_type->GetName(), function_type->GetID());
 
       return;
     }
   } else if (symbol) {
     fun_address = symbol->GetAddress();
     function_decl = context.AddGenericFunDecl();
     is_indirect_function = symbol->IsIndirect();

lldb/source/Plugins/Platform/gdb-server/PlatformRemoteGDBServer.cpp

 size_t PlatformRemoteGDBServer::ConnectToWaitingProcesses(Debugger &debugger,
                                                           Status &error) {
   std::vector<std::string> connection_urls;
   GetPendingGdbServerList(connection_urls);
 
   for (size_t i = 0; i < connection_urls.size(); ++i) {
     ConnectProcess(connection_urls[i].c_str(), "gdb-remote", debugger, nullptr, error);
     if (error.Fail())
-      return i; // We already connected to i process succsessfully
+      return i; // We already connected to i process successfully
   }
   return connection_urls.size();
 }
 
 size_t PlatformRemoteGDBServer::GetPendingGdbServerList(
     std::vector<std::string> &connection_urls) {
   std::vector<std::pair<uint16_t, std::string>> remote_servers;
   if (!IsConnected())

lldb/source/Plugins/Process/gdb-remote/ProcessGDBRemote.cpp

if (remote_process_arch.IsValid()) {
     process_arch = m_gdb_comm.GetHostArchitecture();
     LLDB_LOG(log,
              "gdb-remote did not have process architecture, using gdb-remote "
              "host architecture {0} {1}",
              process_arch.GetArchitectureName(),
              process_arch.GetTriple().getTriple());
   }
 
-  if (int addresssable_bits = m_gdb_comm.GetAddressingBits()) {
-    lldb::addr_t address_mask = ~((1ULL << addresssable_bits) - 1);
+  if (int addressable_bits = m_gdb_comm.GetAddressingBits()) {
+    lldb::addr_t address_mask = ~((1ULL << addressable_bits) - 1);
     SetCodeAddressMask(address_mask);
     SetDataAddressMask(address_mask);
   }
 
   if (process_arch.IsValid()) {
     const ArchSpec &target_arch = GetTarget().GetArchitecture();
     if (target_arch.IsValid()) {
       LLDB_LOG(log, "analyzing target arch, currently {0} {1}",

lldb/source/Plugins/Process/minidump/MinidumpParser.cpp

std::vector<const minidump::Module *> MinidumpParser::GetFilteredModuleList() {
   if (!ExpectedModules) {
     LLDB_LOG_ERROR(log, ExpectedModules.takeError(),
                    "Failed to read module list: {0}");
     return {};
   }
 
   // Create memory regions from the linux maps only. We do this to avoid issues
   // with breakpad generated minidumps where if someone has mmap'ed a shared
-  // library into memory to accesss its data in the object file, we can get a
+  // library into memory to access its data in the object file, we can get a
   // minidump with two mappings for a binary: one whose base image points to a
   // memory region that is read + execute and one that is read only.
   MemoryRegionInfos linux_regions;
   if (CreateRegionsCacheFromLinuxMaps(*this, linux_regions))
     llvm::sort(linux_regions);
 
   // map module_name -> filtered_modules index
   typedef llvm::StringMap<size_t> MapType;

lldb/source/Plugins/Process/scripted/ScriptedThread.cpp

bool ScriptedThread::LoadArtificialStackFrames() {
 
   size_t arr_size = arr_sp->GetSize();
   if (arr_size > std::numeric_limits<uint32_t>::max())
     return ScriptedInterface::ErrorWithMessage<bool>(
         LLVM_PRETTY_FUNCTION,
         llvm::Twine(
             "StackFrame array size (" + llvm::Twine(arr_size) +
             llvm::Twine(
-                ") is greater than maximum autorized for a StackFrameList."))
+                ") is greater than maximum authorized for a StackFrameList."))
             .str(),
         error, LLDBLog::Thread);
 
   StackFrameListSP frames = GetStackFrameList();
 
   for (size_t idx = 0; idx < arr_size; idx++) {
 
     StructuredData::Dictionary *dict;

lldb/source/Plugins/SymbolFile/Breakpad/SymbolFileBreakpad.cpp

 
 size_t SymbolFileBreakpad::ParseBlocksRecursive(Function &func) {
   std::lock_guard<std::recursive_mutex> guard(GetModuleMutex());
   CompileUnit *comp_unit = func.GetCompileUnit();
   lldbassert(comp_unit);
   ParseInlineOriginRecords();
   // A vector of current each level's parent block. For example, when parsing
   // "INLINE 0 ...", the current level is 0 and its parent block is the
-  // funciton block at index 0.
+  // function block at index 0.
   std::vector<Block *> blocks;
   Block &block = func.GetBlock(false);
   block.AddRange(Block::Range(0, func.GetAddressRange().GetByteSize()));
   blocks.push_back(&block);
 
   size_t blocks_added = 0;
   addr_t func_base = func.GetAddressRange().GetBaseAddress().GetOffset();
   CompUnitData &data = m_cu_data->GetEntryRef(comp_unit->GetID()).data;

lldb/source/Plugins/SymbolFile/PDB/PDBASTParser.cpp

case PDB_SymType::ArrayType: {
 
     CompilerType element_ast_type = element_type->GetForwardCompilerType();
     // If element type is UDT, it needs to be complete.
     if (TypeSystemClang::IsCXXClassType(element_ast_type) &&
         !element_ast_type.GetCompleteType()) {
       if (TypeSystemClang::StartTagDeclarationDefinition(element_ast_type)) {
         TypeSystemClang::CompleteTagDeclarationDefinition(element_ast_type);
       } else {
-        // We are not able to start defintion.
+        // We are not able to start definition.
         return nullptr;
       }
     }
     CompilerType array_ast_type = m_ast.CreateArrayType(
         element_ast_type, num_elements, /*is_gnu_vector*/ false);
     TypeSP type_sp = std::make_shared<lldb_private::Type>(
         array_type->getSymIndexId(), m_ast.GetSymbolFile(), ConstString(),
         bytes, nullptr, LLDB_INVALID_UID, lldb_private::Type::eEncodingIsUID,

lldb/source/Plugins/SymbolFile/PDB/SymbolFilePDB.cpp

if (result_up) {
           }
         }
       }
     }
   }
   if (!func_decorated_name.empty()) {
     mangled.SetMangledName(ConstString(func_decorated_name));
 
-    // For MSVC, format of C funciton's decorated name depends on calling
+    // For MSVC, format of C function's decorated name depends on calling
     // convention. Unfortunately none of the format is recognized by current
     // LLDB. For example, `_purecall` is a __cdecl C function. From PDB,
     // `__purecall` is retrieved as both its decorated and undecorated name
     // (using PDBSymbolFunc::getUndecoratedName method). However `__purecall`
     // string is not treated as mangled in LLDB (neither `?` nor `_Z` prefix).
     // Mangled::GetDemangledName method will fail internally and caches an
     // empty string as its undecorated name. So we will face a contradiction
     // here for the same symbol:

lldb/source/Symbol/Type.cpp

if (type_name) {
       *s << ", name = \"" << type_name << '"';
       ConstString qualified_type_name(GetQualifiedName());
       if (qualified_type_name != type_name) {
         *s << ", qualified = \"" << qualified_type_name << '"';
       }
     }
   }
 
-  // Call the get byte size accesor so we resolve our byte size
+  // Call the get byte size accessor so we resolve our byte size
   if (GetByteSize(exe_scope))
     s->Printf(", byte-size = %" PRIu64, m_byte_size);
   bool show_fullpaths = (level == lldb::eDescriptionLevelVerbose);
   m_decl.Dump(s, show_fullpaths);
 
   if (m_compiler_type.IsValid()) {
     *s << ", compiler_type = \"";
     GetForwardCompilerType().DumpTypeDescription(s);

lldb/test/API/commands/expression/codegen-crash-import-def-arraytype-element/main.cpp

 // This is a reproducer for a crash during codegen. The base issue is when we
 // Import the DeclContext we force FieldDecl that are RecordType to be defined
 // since we need these to be defined in order to layout the class.
 // This case involves an array member whose ElementType are records. In this
 // case we need to check the ElementType of an ArrayType and if it is a record
 // we need to import the definition.
 struct A {
   int x;
 };
 
 struct B {
   // When we import the all the FieldDecl we need to check if we have an
   // ArrayType and then check if the ElementType is a RecordDecl and if so
-  // import the defintion. Otherwise during codegen we will attempt to layout A
+  // import the definition. Otherwise during codegen we will attempt to layout A
   // but won't be able to.
   A s1[2];
   A s2[2][2][3];
   char o;
 };
 
 class FB {
 public:

lldb/test/API/functionalities/breakpoint/debugbreak/TestDebugBreak.py

def test_asm_int_3(self):
         self.assertState(process.GetState(), lldb.eStateStopped)
         stop_reason = lldb.eStopReasonException if (lldbplatformutil.getPlatform(
         ) == "windows" or lldbplatformutil.getPlatform() == "macosx") else lldb.eStopReasonSignal
         thread = lldbutil.get_stopped_thread(process, stop_reason)
         self.assertIsNotNone(
             thread, "Unable to find thread stopped at the __debugbreak()")
         frame = thread.GetFrameAtIndex(0)
 
-        # We should be in funciton 'bar'.
+        # We should be in function 'bar'.
         self.assertTrue(frame.IsValid())
         function_name = frame.GetFunctionName()
         self.assertIn('bar', function_name,
                       "Unexpected function name {}".format(function_name))
 
         # We should be able to evaluate the parameter foo.
         value = frame.EvaluateExpression('*foo')
         self.assertEqual(value.GetValueAsSigned(), 42)

lldb/test/API/functionalities/load_unload/TestLoadUnload.py

def run_load_unload(self):
         self.expect("thread list", STOPPED_DUE_TO_BREAKPOINT,
                     substrs=['stopped',
                              'a_function',
                              'stop reason = breakpoint'])
 
         # The breakpoint should have a hit count of 1.
         lldbutil.check_breakpoint(self, bpno = 1, expected_hit_count = 1)
 
-        # Issue the 'continue' command.  We should stop agaian at a_function.
+        # Issue the 'continue' command.  We should stop again at a_function.
         # The stop reason of the thread should be breakpoint and at a_function.
         self.runCmd("continue")
 
         # rdar://problem/8508987
         # The a_function breakpoint should be encountered twice.
         self.expect("thread list", STOPPED_DUE_TO_BREAKPOINT,
                     substrs=['stopped',
                              'a_function',

lldb/test/API/functionalities/memory/tag/TestMemoryTag.py

def test_memory_tag_read_unsupported(self):
         self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET)
 
         lldbutil.run_break_set_by_file_and_line(self, "main.cpp",
                             line_number('main.cpp', '// Breakpoint here'),
                                         num_expected_locations=1)
         self.runCmd("run", RUN_SUCCEEDED)
 
         # If you're on AArch64 you could have MTE but the remote process
-        # must also support it. If you're on any other arhcitecture you
+        # must also support it. If you're on any other architecture you
         # won't have any tagging at all. So the error message is different.
         if self.isAArch64():
             expected = "error: Process does not support memory tagging"
         else:
             expected = "error: This architecture does not support memory tagging"
 
         self.expect("memory tag read 0 1", substrs=[expected], error=True)
         self.expect("memory tag write 0 1 2", substrs=[expected], error=True)

lldb/test/API/functionalities/module_cache/bsd/TestModuleCacheBSD.py

def test(self):
             We do this to test that we can correctly cache duplicate .o files
             that appear in .a files.
 
             This test only works on darwin because of the way DWARF is stored
             where the debug map will refer to .o files inside of .a files.
         """
         exe = self.getBuildArtifact("a.out")
 
-        # Create a module with no depedencies.
+        # Create a module with no dependencies.
         target = self.createTestTarget(load_dependent_modules=False)
 
         self.runCmd('breakpoint set -f a.c -l %d' % (self.line_a))
         self.runCmd('breakpoint set -f b.c -l %d' % (self.line_b))
         self.runCmd('breakpoint set -f c.c -l %d' % (self.line_c))
 
         # Get the executable module and get the number of symbols to make
         # sure the symbol table gets parsed and cached. The module cache is

lldb/test/API/functionalities/module_cache/simple_exe/TestModuleCacheSimple.py

def test(self):
             corresponding index cache entry for the symbol table for the
             executable. It also removes the executable, rebuilds so that the
             modification time of the binary gets updated, and then creates a new
             target and should cause the cache to get updated so the cache file
             should get an updated modification time.
         """
         exe = self.getBuildArtifact("a.out")
 
-        # Create a module with no depedencies.
+        # Create a module with no dependencies.
         target = self.createTestTarget(load_dependent_modules=False)
 
         # Get the executable module and get the number of symbols to make
         # sure the symbol table gets parsed and cached. The module cache is
         # enabled in the setUp() function.
         main_module = target.GetModuleAtIndex(0)
         self.assertTrue(main_module.IsValid())
         # Make sure the symbol table gets loaded and cached

lldb/test/API/functionalities/module_cache/universal/TestModuleCacheUniversal.py

def test(self):
         """
         exe_basename = "testit"
         src_dir = self.getSourceDir()
         yaml_path = os.path.join(src_dir, "universal.yaml")
         yaml_base, ext = os.path.splitext(yaml_path)
         exe = self.getBuildArtifact(exe_basename)
         self.yaml2obj(yaml_path, exe)
         self.assertTrue(os.path.exists(exe))
-        # Create a module with no depedencies.
+        # Create a module with no dependencies.
         self.runCmd('target create -d --arch x86_64 %s' % (exe))
         self.runCmd('image dump symtab %s' % (exe_basename))
         self.runCmd('target create -d --arch arm64 %s' % (exe))
         self.runCmd('image dump symtab %s' % (exe_basename))
 
         cache_files = self.get_module_cache_files(exe_basename)
 
         self.assertEqual(len(cache_files), 2,
                 "make sure there are two files in the module cache directory (%s) for %s" % (self.cache_dir, exe_basename))

lldb/test/API/functionalities/postmortem/elf-core/TestLinuxCore.py

def test_aarch64_sve_regs_full(self):
         for regname, value in values.items():
             self.expect("register read {}".format(regname),
                         substrs=["{} = {}".format(regname, value)])
 
         self.expect("register read --all")
 
     @skipIfLLVMTargetMissing("AArch64")
     def test_aarch64_pac_regs(self):
-        # Test AArch64/Linux Pointer Authenication register read
+        # Test AArch64/Linux Pointer Authentication register read
         target = self.dbg.CreateTarget(None)
         self.assertTrue(target, VALID_TARGET)
         process = target.LoadCore("linux-aarch64-pac.core")
 
         values = {"data_mask": "0x007f00000000000", "code_mask": "0x007f00000000000"}
 
         for regname, value in values.items():
             self.expect("register read {}".format(regname),

lldb/test/API/functionalities/postmortem/minidump-new/makefile.txt

 # This makefile aims to make the binaries as small as possible, for us not to
 # upload huge binary blobs in the repo.
 # The binary should have debug symbols because stack unwinding doesn't work
 # correctly using the information in the Minidump only. Also we want to evaluate
 # local variables, etc.
-# Breakpad compiles as a static library, so statically linking againts it
+# Breakpad compiles as a static library, so statically linking against it
 # makes the binary huge.
 # Dynamically linking to it does improve things, but we are still #include-ing
 # breakpad headers (which is a lot of source code for which we generate debug
 # symbols)
 # So, install_breakpad.cpp does the #include-ing and defines a global function
 # "InstallBreakpad" that does all the exception handler registration.
 # We compile install_breakpad to object file and then link it, alongside the
 # static libbreakpad, into a shared library.

lldb/tools/debugserver/source/DNBTimer.h

public:
   ~DNBTimer() {}
 
   bool IsThreadSafe() const { return m_mutexAP.get() != NULL; }
   // Reset the time value to now
   void Reset() {
     PTHREAD_MUTEX_LOCKER(locker, m_mutexAP.get());
     gettimeofday(&m_timeval, NULL);
   }
-  // Get the total mircoseconds since Jan 1, 1970
+  // Get the total microseconds since Jan 1, 1970
   uint64_t TotalMicroSeconds() const {
     PTHREAD_MUTEX_LOCKER(locker, m_mutexAP.get());
     return (uint64_t)(m_timeval.tv_sec) * 1000000ull +
            (uint64_t)m_timeval.tv_usec;
   }
 
   void GetTime(uint64_t &sec, uint32_t &usec) const {
     PTHREAD_MUTEX_LOCKER(locker, m_mutexAP.get());

lldb/tools/debugserver/source/JSON.h

private:
 
   std::string m_data;
 };
 
 class JSONNumber : public JSONValue {
 public:
   typedef std::shared_ptr<JSONNumber> SP;
 
-  // We cretae a constructor for all integer and floating point type with using
+  // We create a constructor for all integer and floating point type with using
   // templates and
   // SFINAE to avoid having ambiguous overloads because of the implicit type
   // promotion. If we
   // would have constructors only with int64_t, uint64_t and double types then
   // constructing a
   // JSONNumber from an int32_t (or any other similar type) would fail to
   // compile.
 

lldb/tools/debugserver/source/MacOSX/Genealogy.cpp

if (m_os_activity_diagnostic_for_pid(
                           bc.activity_id = breadcrumb->activity_id;
                           bc.timestamp = breadcrumb->timestamp;
                           if (breadcrumb->name)
                             bc.name = breadcrumb->name;
                           breadcrumbs.push_back(bc);
                           return true;
                         });
 
-                    // Collect all the Activites
+                    // Collect all the Activities
                     m_os_activity_iterate_activities(
                         process_info->activities, process_info,
                         ^bool(os_activity_entry_t activity) {
                           Activity ac;
                           ac.activity_start = activity->activity_start;
                           ac.activity_id = activity->activity_id;
                           ac.parent_id = activity->parent_id;
                           if (activity->activity_name)