[lldb] NFC: Fix trivial typo in comments, documents, and messages

[labath]

Thanks for doing this.

lldb/bindings/interface/SBBlock.i

%pythoncode %{
             return declaration(self.GetInlinedCallSiteFile(), self.GetInlinedCallSiteLine(), self.GetInlinedCallSiteColumn())
 
         parent = property(GetParent, None, doc='''A read only property that returns the same result as GetParent().''')
         first_child = property(GetFirstChild, None, doc='''A read only property that returns the same result as GetFirstChild().''')
         call_site = property(get_call_site, None, doc='''A read only property that returns a lldb.declaration object that contains the inlined call site file, line and column.''')
         sibling = property(GetSibling, None, doc='''A read only property that returns the same result as GetSibling().''')
         name = property(GetInlinedName, None, doc='''A read only property that returns the same result as GetInlinedName().''')
         inlined_block = property(GetContainingInlinedBlock, None, doc='''A read only property that returns the same result as GetContainingInlinedBlock().''')
-        range = property(get_ranges_access_object, None, doc='''A read only property that allows item access to the address ranges for a block by integer (range = block.range[0]) and by lldb.SBAdddress (find the range that contains the specified lldb.SBAddress like "pc_range = lldb.frame.block.range[frame.addr]").''')
+        range = property(get_ranges_access_object, None, doc='''A read only property that allows item access to the address ranges for a block by integer (range = block.range[0]) and by lldb.SBAddress (find the range that contains the specified lldb.SBAddress like "pc_range = lldb.frame.block.range[frame.addr]").''')
         ranges = property(get_ranges_array, None, doc='''A read only property that returns a list() object that contains all of the address ranges for the block.''')
         num_ranges = property(GetNumRanges, None, doc='''A read only property that returns the same result as GetNumRanges().''')
     %}
 #endif
 
 };
 
 } // namespace lldb

lldb/bindings/interface/SBExpressionOptions.i

public:
     %feature("docstring", "Sets whether to cast the expression result to its dynamic type.") SetFetchDynamicValue;
 
     void
     SetFetchDynamicValue (lldb::DynamicValueType dynamic = lldb::eDynamicCanRunTarget);
 
     uint32_t
     GetTimeoutInMicroSeconds () const;
 
-    %feature("docstring", "Sets the timeout in microseconds to run the expression for. If try all threads is set to true and the expression doesn't complete within the specified timeout, all threads will be resumed for the same timeout to see if the expresson will finish.") SetTimeoutInMicroSeconds;
+    %feature("docstring", "Sets the timeout in microseconds to run the expression for. If try all threads is set to true and the expression doesn't complete within the specified timeout, all threads will be resumed for the same timeout to see if the expression will finish.") SetTimeoutInMicroSeconds;
     void
     SetTimeoutInMicroSeconds (uint32_t timeout = 0);
 
     uint32_t
     GetOneThreadTimeoutInMicroSeconds () const;
 
     %feature("docstring", "Sets the timeout in microseconds to run the expression on one thread before either timing out or trying all threads.") SetTimeoutInMicroSeconds;
     void
     SetOneThreadTimeoutInMicroSeconds (uint32_t timeout = 0);
 
     bool
     GetTryAllThreads () const;
 
     %feature("docstring", "Sets whether to run all threads if the expression does not complete on one thread.") SetTryAllThreads;
     void
     SetTryAllThreads (bool run_others = true);
 
     bool
     GetStopOthers () const;
 
-    %feature("docstring", "Sets whether to stop other threads at all while running expressins.  If false, TryAllThreads does nothing.") SetTryAllThreads;
+    %feature("docstring", "Sets whether to stop other threads at all while running expressions.  If false, TryAllThreads does nothing.") SetTryAllThreads;
     void
     SetStopOthers (bool stop_others = true);
 
     bool
     GetTrapExceptions () const;
 
     %feature("docstring", "Sets whether to abort expression evaluation if an exception is thrown while executing.  Don't set this to false unless you know the function you are calling traps all exceptions itself.") SetTryAllThreads;
     void

lldb/bindings/interface/SBFile.i

#endif
     this will return that original object.
 
     The file returned from here should be considered borrowed,
     in the sense that you may read and write to it, and flush it,
     etc, but you should not close it.   If you want to close the
     SBFile, call SBFile.Close().
 
     If there is no underlying python file to unwrap, GetFile will
-    use the file descriptor, if availble to create a new python
+    use the file descriptor, if available to create a new python
     file object using `open(fd, mode=..., closefd=False)`
     ");
     FileSP GetFile();
 };
 
 } // namespace lldb

lldb/docs/lldb-platform-packets.txt

 //     2. flags passed to the open call, base 16.
 //        Note that these are not the oflags that open(2) takes, but
 //        are the constant values in enum OpenOptions from lldb's File.h
 //     3. mode bits, base 16
 //  
 //  response is F followed by the opened file descriptor in base 10.
 //  "F-1,errno" with the errno if an error occurs.
 //
-//  COMPATABILITY
+//  COMPATIBILITY
 //    The gdb-remote serial protocol documentatio defines a vFile:open:
 //    packet which uses incompatible flag values, e.g. 1 means O_WRONLY
 //    in gdb's vFile:open:, but it means eOpenOptionRead to lldb's
 //    implementation.
 
 //----------------------------------------------------------------------
 // vFile:close:
 //

lldb/examples/interposing/darwin/fd_interposing/FDInterposing.cpp

 typedef std::vector<void *> Frames;
 class FDEvent;
 typedef std::vector<void *> Frames;
 typedef std::tr1::shared_ptr<FDEvent> FDEventSP;
 typedef std::tr1::shared_ptr<String> StringSP;
 
 // FDEvent
 //
-// A class that describes a file desciptor event.
+// A class that describes a file descriptor event.
 //
 // File descriptor events fall into one of two categories: create events
 // and delete events.
 class FDEvent {
 public:
   FDEvent(int fd, int err, const StringSP &string_sp, bool is_create,
           const Frames &frames)
       : m_string_sp(string_sp), m_frames(frames.begin(), frames.end()),

 
 private:
   // A shared pointer to a String that describes this event in
   // detail (all args and return and error values)
   StringSP m_string_sp;
   // The frames for the stack backtrace for this event
   Frames m_frames;
   // If this is a file descriptor delete event, this might contain
-  // the correspoding file descriptor create event
+  // the corresponding file descriptor create event
   FDEventSP m_create_event_sp;
   // The file descriptor for this event
   int m_fd;
   // The error code (if any) for this event
   int m_err;
   // True if this event is a file descriptor create event, false
   // if it is a file descriptor delete event
   bool m_is_create;

 
 // Globals
 // Global event map that contains all file descriptor events. As file
 // descriptor create and close events come in, they will get filled
 // into this map (protected by g_mutex). When a file descriptor close
 // event is detected, the open event will be removed and placed into
 // the close event so if something tries to double close a file
 // descriptor we can show the previous close event and the file
-// desctiptor event that created it. When a new file descriptor create
+// descriptor event that created it. When a new file descriptor create
 // event comes in, we will remove the previous one for that file
-// desctiptor unless the environment variable
+// descriptor unless the environment variable
 // "FileDescriptorStackLoggingNoCompact"
-// is set. The file desctiptor history can be accessed using the
+// is set. The file descriptor history can be accessed using the
 // get_fd_history() function.
 static FDEventMap g_fd_event_map;
 // A mutex to protect access to our data structures in g_fd_event_map
 // and also our logging messages
 static pthread_mutex_t g_mutex = PTHREAD_MUTEX_INITIALIZER;
 // Log all file descriptor create and close events by default. Only log
-// warnings and erros if the "FileDescriptorMinimalLogging" environment
+// warnings and errors if the "FileDescriptorMinimalLogging" environment
 // variable is set.
 static int g_log_all_calls = 1;
 // We compact the file descriptor events by default. Set the environment
 // varible "FileDescriptorStackLoggingNoCompact" to keep a full history.
 static int g_compact = 1;
 // The current process ID
 static int g_pid = -1;
 static bool g_enabled = true;
if (fd_event_sp->IsCreateEvent()) {
         // Two fd create functions in a row, we missed
         // a function that closes a fd...
         log(log_fd, fd_event_sp.get(), "\nwarning: unmatched file descriptor "
                                        "create event fd=%i (we missed a file "
                                        "descriptor close event):\n",
             fd);
       } else if (g_compact) {
         // We are compacting so we remove previous create event
-        // when we get the correspinding delete event
+        // when we get the corresponding delete event
         event_array.pop_back();
       }
     } else {
       // The current fd event is a function that deletes
       // a descriptor, check in case last event for this
       // fd was a delete event (double close!)
       if (event_array.back()->IsDeleteEvent()) {
         const int log_fd = get_logging_fd();
         // Two fd delete functions in a row, we must
         // have missed some function that opened a descriptor
         log(log_fd, fd_event_sp.get(), "\nwarning: unmatched file descriptor "
                                        "close event for fd=%d (we missed the "
                                        "file descriptor create event):\n",
             fd);
       } else if (g_compact) {
         // Since this is a close event, we want to remember the open event
         // that this close if for...
         fd_event_sp->SetCreateEvent(event_array.back());
         // We are compacting so we remove previous create event
-        // when we get the correspinding delete event
+        // when we get the corresponding delete event
         event_array.pop_back();
       }
     }
 
     event_array.push_back(fd_event_sp);
   } else {
     g_fd_event_map[fd].push_back(fd_event_sp);
   }

lldb/examples/python/mach_o.py

class Skinny:
                             print('b) %s' % (rhs_section))
                             result = False
                         else:
                             print('ok')
                     else:
                         result = False
                         print('error: section %s is missing in %s' % (lhs_section.sectname, rhs.path))
             else:
-                print('error: comaparing a %s mach-o file with a %s mach-o file is not supported' % (self.type, rhs.type))
+                print('error: comparing a %s mach-o file with a %s mach-o file is not supported' % (self.type, rhs.type))
                 result = False
             if not result:
                 print('error: mach files differ')
             return result
 
         def dump_header(self, dump_description=True, options=None):
             if options.verbose:
                 print("MAGIC      CPU        SUBTYPE    FILETYPE   NUM CMDS SIZE CMDS  FLAGS")

lldb/include/lldb/Symbol/LineEntry.h

struct LineEntry {
   /// LineEntry (and it will include the range of the following LineEntries
   /// that match either 32 or 0.)
   ///
   /// When \b include_inlined_functions is \b true inlined functions with
   /// a call site at this LineEntry will also be included in the complete
   /// range.
   ///
   /// If the initial LineEntry this method is called on is a line #0, only the
-  /// range of contiuous LineEntries with line #0 will be included in the
+  /// range of continuous LineEntries with line #0 will be included in the
   /// complete range.
   ///
   /// @param[in] include_inlined_functions
   ///     Whether to include inlined functions at the same line or not.
   ///
   /// \return
   ///     The contiguous AddressRange for this source line.
   AddressRange

lldb/include/lldb/Symbol/SymbolFile.h

public:
   struct ArrayInfo {
     int64_t first_index = 0;
     llvm::SmallVector<uint64_t, 1> element_orders;
     uint32_t byte_stride = 0;
     uint32_t bit_stride = 0;
   };
   /// If \c type_uid points to an array type, return its characteristics.
   /// To support variable-length array types, this function takes an
-  /// optional \p ExtecutionContext. If \c exe_ctx is non-null, the
+  /// optional \p ExecutionContext. If \c exe_ctx is non-null, the
   /// dynamic characteristics for that context are returned.
   virtual llvm::Optional<ArrayInfo>
   GetDynamicArrayInfoForUID(lldb::user_id_t type_uid,
                             const lldb_private::ExecutionContext *exe_ctx) = 0;
 
   virtual bool CompleteType(CompilerType &compiler_type) = 0;
   virtual void ParseDeclsForContext(CompilerDeclContext decl_ctx) {}
   virtual CompilerDecl GetDeclForUID(lldb::user_id_t uid) {

lldb/include/lldb/Target/Platform.h

public:
   ///     If an error occurred during the connect then this object will
   ///     contain the error message.
   ///
   /// \return
   ///     The number of processes we are successfully connected to.
   virtual size_t ConnectToWaitingProcesses(lldb_private::Debugger &debugger,
                                            lldb_private::Status &error);
 
-  /// Gather all of crash informations into a structured data dictionnary.
+  /// Gather all of crash informations into a structured data dictionary.
   ///
   /// If the platform have a crashed process with crash information entries,
-  /// gather all the entries into an structured data dictionnary or return a
-  /// nullptr. This dictionnary is generic and extensible, as it contains an
+  /// gather all the entries into an structured data dictionary or return a
+  /// nullptr. This dictionary is generic and extensible, as it contains an
   /// array for each different type of crash information.
   ///
   /// \param[in] process
   ///     The crashed process.
   ///
   /// \return
-  ///     A structured data dictionnary containing at each entry, the crash
+  ///     A structured data dictionary containing at each entry, the crash
   ///     information type as the entry key and the matching  an array as the
   ///     entry value. \b nullptr if not implemented or  if the process has no
   ///     crash information entry. \b error if an error occured.
   virtual llvm::Expected<StructuredData::DictionarySP>
   FetchExtendedCrashInformation(lldb_private::Process &process) {
     return nullptr;
   }
 

lldb/include/lldb/Target/Process.h

private:
   ///     user, \b false otherwise.
   bool ShouldBroadcastEvent(Event *event_ptr);
 
   void ControlPrivateStateThread(uint32_t signal);
 
   DISALLOW_COPY_AND_ASSIGN(Process);
 };
 
-/// RAII guard that should be aquired when an utility function is called within
+/// RAII guard that should be acquired when an utility function is called within
 /// a given process.
 class UtilityFunctionScope {
   Process *m_process;
 
 public:
   UtilityFunctionScope(Process *p) : m_process(p) {
     if (m_process)
       m_process->SetRunningUtilityFunction(true);

lldb/include/lldb/Target/Target.h

public:
   /// won't be changed. If the input arch_spec is the same as the already set
   /// architecture, this is a no-op.
   ///
   /// \param[in] arch_spec
   ///     The new architecture.
   ///
   /// \param[in] set_platform
   ///     If \b true, then the platform will be adjusted if the currently
-  ///     selected platform is not compatible with the archicture being set.
+  ///     selected platform is not compatible with the architecture being set.
   ///     If \b false, then just the architecture will be set even if the
   ///     currently selected platform isn't compatible (in case it might be
   ///     manually set following this function call).
   ///
   /// \return
   ///     \b true if the architecture was successfully set, \bfalse otherwise.
   bool SetArchitecture(const ArchSpec &arch_spec, bool set_platform = false);
 

lldb/include/lldb/Target/ThreadPlan.h

 //  N.B. Don't wait to do clean up target state till the destructor, since that
 //  will usually get called when
 //  the target resumes, and you want to leave the target state correct for new
 //  plans in the time between when
 //  your plan gets unshipped and the next resume.
 //
 //  Thread State Checkpoint:
 //
 //  Note that calling functions on target process (ThreadPlanCallFunction) changes
 //  current thread state. The function can be called either by direct user demand or
 //  internally, for example lldb allocates memory on device to calculate breakpoint
 //  condition expression - on Linux it is performed by calling mmap on device.
 //  ThreadStateCheckpoint saves Thread state (stop info and completed
 //  plan stack) to restore it after completing function call.
 //
 //  Over the lifetime of the plan, various methods of the ThreadPlan are then
 //  called in response to changes of state in

 //  Master plans:
 //
 //  In the normal case, when we decide to stop, we will  collapse the plan stack
 //  up to the point of the plan that understood
 //  the stop reason.  However, if a plan wishes to stay on the stack after an
 //  event it didn't directly handle
 //  it can designate itself a "Master" plan by responding true to IsMasterPlan,
 //  and then if it wants not to be
 //  discarded, it can return false to OkayToDiscard, and it and all its dependent
 //  plans will be preserved when
 //  we resume execution.
 //
 //  The other effect of being a master plan is that when the Master plan is done
 //  , if it has set "OkayToDiscard" to false,
 //  then it will be popped & execution will stop and return to the user.
 //  Remember that if OkayToDiscard is false, the
 //  plan will be popped and control will be given to the next plan above it on

 //  When the process stops, the thread is given a StopReason, in the form of a
 //  StopInfo object.  If there is a completed
 //  plan corresponding to the stop, then the "actual" stop reason can be
 //  suppressed, and instead a StopInfoThreadPlan
 //  object will be cons'ed up from the top completed plan in the stack.
 //  However, if the plan doesn't want to be
 //  the stop reason, then it can call SetPlanComplete and pass in "false" for
 //  the "success" parameter.  In that case,
-//  the real stop reason will be used instead.  One exapmle of this is the
+//  the real stop reason will be used instead.  One example of this is the
 //  "StepRangeStepIn" thread plan.  If it stops
 //  because of a crash or breakpoint hit, it wants to unship itself, because it
 //  isn't so useful to have step in keep going
 //  after a breakpoint hit.  But it can't be the reason for the stop or no-one
 //  would see that they had hit a breakpoint.
 //
 //  Cleaning up the plan stack:
 //

lldb/include/lldb/Utility/Connection.h

virtual size_t Read(void *dst, size_t dst_len,
                       lldb::ConnectionStatus &status, Status *error_ptr) = 0;
 
   /// The actual write function that attempts to write to the communications
   /// protocol.
   ///
   /// Subclasses must override this function.
   ///
   /// \param[in] dst
-  ///     A desination buffer that must be at least \a dst_len bytes
+  ///     A destination buffer that must be at least \a dst_len bytes
   ///     long.
   ///
   /// \param[in] dst_len
   ///     The number of bytes to attempt to write, and also the
   ///     number of bytes are currently available in \a dst.
   ///
   /// \param[out] error_ptr
   ///     A pointer to an error object that should be given an

lldb/include/lldb/Utility/Reproducer.h

void SetVersion(std::string version) {
     assert(m_version.empty());
     m_version = std::move(version);
   }
   void Keep() override;
   std::string m_version;
   static char ID;
 };
 
-/// Provider for the LLDB current working directroy.
+/// Provider for the LLDB current working directory.
 ///
 /// When the reproducer is kept, it writes lldb's current working directory to
 /// a file named cwd.txt in the reproducer root.
 class WorkingDirectoryProvider : public Provider<WorkingDirectoryProvider> {
 public:
   WorkingDirectoryProvider(const FileSpec &directory) : Provider(directory) {
     llvm::SmallString<128> cwd;
     if (std::error_code EC = llvm::sys::fs::current_path(cwd))

lldb/include/lldb/Utility/Status.h

public:
   /// Access the error type.
   ///
   /// \return
   ///     The error type enumeration value.
   lldb::ErrorType GetType() const;
 
   /// Set accessor from a kern_return_t.
   ///
-  /// Set accesssor for the error value to \a err and the error type to \c
+  /// Set accessor for the error value to \a err and the error type to \c
   /// MachKernel.
   ///
   /// \param[in] err
   ///     A mach error code.
   void SetMachError(uint32_t err);
 
   void SetExpressionError(lldb::ExpressionResults, const char *mssg);
 
   int SetExpressionErrorWithFormat(lldb::ExpressionResults, const char *format,
                                    ...) __attribute__((format(printf, 3, 4)));
 
-  /// Set accesssor with an error value and type.
+  /// Set accessor with an error value and type.
   ///
-  /// Set accesssor for the error value to \a err and the error type to \a
+  /// Set accessor for the error value to \a err and the error type to \a
   /// type.
   ///
   /// \param[in] err
   ///     A mach error code.
   ///
   /// \param[in] type
   ///     The type for \a err.
   void SetError(ValueType err, lldb::ErrorType type);

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

def setPlatformWorkingDir(self):
                 remote_test_dir, 448)  # 448 = 0o700
             if error.Fail():
                 raise Exception("making remote directory '%s': %s" % (
                     remote_test_dir, error))
 
         lldb.remote_platform.SetWorkingDirectory(remote_test_dir)
 
         # This function removes all files from the current working directory while leaving
-        # the directories in place. The cleaup is required to reduce the disk space required
+        # the directories in place. The cleanup is required to reduce the disk space required
         # by the test suite while leaving the directories untouched is neccessary because
         # sub-directories might belong to an other test
         def clean_working_directory():
             # TODO: Make it working on Windows when we need it for remote debugging support
             # TODO: Replace the heuristic to remove the files with a logic what collects the
             # list of files we have to remove during test runs.
             shell_cmd = lldb.SBPlatformShellCommand(
                 "rm %s/*" % remote_test_dir)
def HideStdout(self):
             sys.stdout = old_stdout
         self.addTearDownHook(restore_stdout)
 
     # =======================================================================
     # Methods for customized teardown cleanups as well as execution of hooks.
     # =======================================================================
 
     def setTearDownCleanup(self, dictionary=None):
-        """Register a cleanup action at tearDown() time with a dictinary"""
+        """Register a cleanup action at tearDown() time with a dictionary"""
         self.dict = dictionary
         self.doTearDownCleanup = True
 
     def addTearDownCleanup(self, dictionary):
-        """Add a cleanup action at tearDown() time with a dictinary"""
+        """Add a cleanup action at tearDown() time with a dictionary"""
         self.dicts.append(dictionary)
         self.doTearDownCleanups = True
 
     def addTearDownHook(self, hook):
         """
         Add a function to be run during tearDown() time.
 
         Hooks are executed in a first come first serve manner.
def dumpSessionInfo(self):
         See also LLDBTestResult (dotest.py) which is a singlton class derived
         from TextTestResult and overwrites addError, addFailure, and
         addExpectedFailure methods to allow us to to mark the test instance as
         such.
         """
 
         # We are here because self.tearDown() detected that this test instance
         # either errored or failed.  The lldb.test_result singleton contains
-        # two lists (erros and failures) which get populated by the unittest
+        # two lists (errors and failures) which get populated by the unittest
         # framework.  Look over there for stack trace information.
         #
         # The lists contain 2-tuples of TestCase instances and strings holding
         # formatted tracebacks.
         #
         # See http://docs.python.org/library/unittest.html#unittest.TestResult.
 
         # output tracebacks into session

lldb/packages/Python/lldbsuite/test/test_runner/README.txt

 This directory contains source and tests for the lldb test runner
 architecture.  This directory is not for lldb python tests.  It
-is the test runner.  The tests under this diretory are test-runner
+is the test runner.  The tests under this directory are test-runner
 tests (i.e. tests that verify the test runner itself runs properly).
 

lldb/packages/Python/lldbsuite/test/tools/lldb-vscode/vscode.py

class DebugCommunication(object):
 
     def handle_recv_packet(self, packet):
         '''Called by the read thread that is waiting for all incoming packets
            to store the incoming packet in "self.recv_packets" in a thread safe
            way. This function will then signal the "self.recv_condition" to
            indicate a new packet is available. Returns True if the caller
            should keep calling this function for more packets.
         '''
-        # If EOF, notify the read thread by enqueing a None.
+        # If EOF, notify the read thread by enqueuing a None.
         if not packet:
             self.enqueue_recv_packet(None)
             return False
 
         # Check the packet to see if is an event packet
         keepGoing = True
         packet_type = packet['type']
         if packet_type == 'event':
def request_threads(self):
         body = response['body']
         # Fill in "self.threads" correctly so that clients that call
         # self.get_threads() or self.get_thread_id(...) can get information
         # on threads when the process is stopped.
         if 'threads' in body:
             self.threads = body['threads']
             for thread in self.threads:
                 # Copy the thread dictionary so we can add key/value pairs to
-                # it without affecfting the original info from the "threads"
+                # it without affecting the original info from the "threads"
                 # command.
                 tid = thread['id']
                 if tid in self.thread_stop_reasons:
                     thread_stop_info = self.thread_stop_reasons[tid]
                     copy_keys = ['reason', 'description', 'text']
                     for key in copy_keys:
                         if key in thread_stop_info:
                             thread[key] = thread_stop_info[key]
parser.add_option(
         default=None)
 
     parser.add_option(
         '--attach',
         action='store_true',
         dest='attach',
         default=False,
         help=('Specify this option to attach to a process by name. The '
-              'process name is the basanme of the executable specified with '
+              'process name is the basename of the executable specified with '
               'the --program option.'))
 
     parser.add_option(
         '-f', '--function-bp',
         type='string',
         action='append',
         dest='funcBreakpoints',
         help=('Specify the name of a function to break at. '

lldb/scripts/verify_api.py

parser.add_option(
         help='display verbose debug info',
         default=False)
     parser.add_option(
         '-a',
         '--arch',
         type='string',
         action='append',
         dest='archs',
-        help='architecure to use when checking the api')
+        help='architecture to use when checking the api')
     parser.add_option(
         '-r',
         '--api-regex',
         type='string',
         dest='api_regex_str',
         help='Exclude any undefined symbols that do not match this regular expression when searching for missing APIs.')
     parser.add_option(
         '-l',

lldb/source/Commands/CommandObjectWatchpoint.cpp

if (args.HasArgs())
       if (!ParseOptionsAndNotify(args.GetArgs(), result, m_option_group,
                                  exe_ctx))
         return false;
 
     // If no argument is present, issue an error message.  There's no way to
     // set a watchpoint.
     if (raw_command.trim().empty()) {
       result.GetErrorStream().Printf("error: required argument missing; "
-                                     "specify an expression to evaulate into "
+                                     "specify an expression to evaluate into "
                                      "the address to watch for\n");
       result.SetStatus(eReturnStatusFailed);
       return false;
     }
 
     // If no '-w' is specified, default to '-w write'.
     if (!m_option_watchpoint.watch_type_specified) {
       m_option_watchpoint.watch_type = OptionGroupWatchpoint::eWatchWrite;

lldb/source/Core/FormatEntity.cpp

if (close_pos != llvm::StringRef::npos)
     return;
 
   const size_t format_pos = str.find('%', dollar_pos + 2);
   if (format_pos != llvm::StringRef::npos)
     return;
 
   llvm::StringRef partial_variable(str.substr(dollar_pos + 2));
   if (partial_variable.empty()) {
-    // Suggest all top level entites as we are just past "${"
+    // Suggest all top level entities as we are just past "${"
     StringList new_matches;
     AddMatches(&g_root, str, llvm::StringRef(), new_matches);
     request.AddCompletions(new_matches);
     return;
   }
 
   // We have a partially specified variable, find it
   llvm::StringRef remainder;

lldb/source/Host/common/Editline.cpp

 using namespace lldb_private::line_editor;
 
 // Workaround for what looks like an OS X-specific issue, but other platforms
 // may benefit from something similar if issues arise.  The libedit library
 // doesn't explicitly initialize the curses termcap library, which it gets away
 // with until TERM is set to VT100 where it stumbles over an implementation
 // assumption that may not exist on other platforms.  The setupterm() function
 // would normally require headers that don't work gracefully in this context,
-// so the function declaraction has been hoisted here.
+// so the function declaration has been hoisted here.
 #if defined(__APPLE__)
 extern "C" {
 int setupterm(char *term, int fildes, int *errret);
 }
 #define USE_SETUPTERM_WORKAROUND
 #endif
 
 // Editline uses careful cursor management to achieve the illusion of editing a

lldb/source/Host/common/NativeProcessProtocol.cpp

Status NativeProcessProtocol::ReadMemoryWithoutTrap(lldb::addr_t addr,
 
   auto data =
       llvm::makeMutableArrayRef(static_cast<uint8_t *>(buf), bytes_read);
   for (const auto &pair : m_software_breakpoints) {
     lldb::addr_t bp_addr = pair.first;
     auto saved_opcodes = makeArrayRef(pair.second.saved_opcodes);
 
     if (bp_addr + saved_opcodes.size() < addr || addr + bytes_read <= bp_addr)
-      continue; // Breapoint not in range, ignore
+      continue; // Breakpoint not in range, ignore
 
     if (bp_addr < addr) {
       saved_opcodes = saved_opcodes.drop_front(addr - bp_addr);
       bp_addr = addr;
     }
     auto bp_data = data.drop_front(bp_addr - addr);
     std::copy_n(saved_opcodes.begin(),
                 std::min(saved_opcodes.size(), bp_data.size()),

lldb/source/Plugins/ABI/ARC/ABISysV_arc.cpp

ValueObjectSP ABISysV_arc::GetReturnValueObjectImpl(Thread &thread,
   Value value;
   // Void return type.
   if (retType.isVoidTy()) {
     value.GetScalar() = 0;
   }
   // Integer return type.
   else if (retType.isIntegerTy()) {
     size_t byte_size = retType.getPrimitiveSizeInBits();
-    if (1 != byte_size) // For boolian type.
+    if (1 != byte_size) // For boolean type.
       byte_size /= CHAR_BIT;
 
     auto raw_value = ReadRawValue(reg_ctx, byte_size);
 
     const bool is_signed = false; // IR Type doesn't provide this info.
     if (!SetSizedInteger(value.GetScalar(), raw_value, byte_size, is_signed))
       return ValueObjectSP();
   }

lldb/source/Plugins/DynamicLoader/MacOSX-DYLD/DynamicLoaderDarwin.cpp

if (image_module_sp) {
       // address. We need to check this so we don't mention that all loaded
       // shared libraries are newly loaded each time we hit out dyld breakpoint
       // since dyld will list all shared libraries each time.
       if (UpdateImageLoadAddress(image_module_sp.get(), image_infos[idx])) {
         target_images.AppendIfNeeded(image_module_sp);
         loaded_module_list.AppendIfNeeded(image_module_sp);
       }
 
-      // macCataylst support:
+      // macCatalyst support:
       // Update the module's platform with the DYLD info.
       ArchSpec dyld_spec = image_infos[idx].GetArchitecture();
       if (dyld_spec.GetTriple().getOS() == llvm::Triple::IOS &&
           dyld_spec.GetTriple().getEnvironment() == llvm::Triple::MacABI) {
         image_module_sp->MergeArchitecture(dyld_spec);
         const auto &target_triple = target.GetArchitecture().GetTriple();
         // If dyld reports the process as being loaded as MACCATALYST,
         // force-update the target's architecture to MACCATALYST.

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

EntryBreakpointHit(void *baton,
                      lldb::user_id_t break_id, lldb::user_id_t break_loc_id);
 
   /// Helper for the entry breakpoint callback.  Resolves the load addresses
   /// of all dependent modules.
   virtual void LoadAllCurrentModules();
 
   void LoadVDSO();
 
-  // Loading an interpreter module (if present) assumming m_interpreter_base
+  // Loading an interpreter module (if present) assuming m_interpreter_base
   // already points to its base address.
   lldb::ModuleSP LoadInterpreterModule();
 
   /// Computes a value for m_load_offset returning the computed address on
   /// success and LLDB_INVALID_ADDRESS on failure.
   lldb::addr_t ComputeLoadOffset();
 
   /// Computes a value for m_entry_point returning the computed address on

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

class CodeComplete : public CodeCompleteConsumer {
   /// Removes the last identifier token from the given cmd line.
   StringRef removeLastToken(StringRef cmd) {
     while (!cmd.empty() && IsIdChar(cmd.back())) {
       cmd = cmd.drop_back();
     }
     return cmd;
   }
 
-  /// Attemps to merge the given completion from the given position into the
+  /// Attempts to merge the given completion from the given position into the
   /// existing command. Returns the completion string that can be returned to
   /// the lldb completion API.
   std::string mergeCompletion(StringRef existing, unsigned pos,
                               StringRef completion) {
     StringRef existing_command = existing.substr(0, pos);
     // We rewrite the last token with the completion, so let's drop that
     // token from the command.
     existing_command = removeLastToken(existing_command);

lldb/source/Plugins/ExpressionParser/Clang/CppModuleConfiguration.h

class CppModuleConfiguration {
   std::vector<std::string> m_imported_modules;
 
   /// Analyze a given source file to build the current configuration.
   /// Returns false iff there was a fatal error that makes analyzing any
   /// further files pointless as the configuration is now invalid.
   bool analyzeFile(const FileSpec &f);
 
 public:
-  /// Creates a configuraiton by analyzing the given list of used source files.
+  /// Creates a configuration by analyzing the given list of used source files.
   ///
   /// Currently only looks at the used paths and doesn't actually access the
   /// files on the disk.
   explicit CppModuleConfiguration(const FileSpecList &support_files);
   /// Creates an empty and invalid configuration.
   CppModuleConfiguration() {}
 
   /// Returns true iff this is a valid configuration that can be used to

lldb/source/Plugins/Instruction/ARM/EmulateInstructionARM.cpp

if (ConditionPassed(opcode)) {
     {
       // R[t] = bits(32) UNKNOWN;
       WriteBits32Unknown(t);
     }
   }
   return true;
 }
 
-// LDRH (literal) caculates an address from the PC value and an immediate
+// LDRH (literal) calculates an address from the PC value and an immediate
 // offset, loads a halfword from memory,
 // zero-extends it to form a 32-bit word, and writes it to a register.
 bool EmulateInstructionARM::EmulateLDRHLiteral(const uint32_t opcode,
                                                const ARMEncoding encoding) {
 #if 0
     if ConditionPassed() then 
         EncodingSpecificOperations(); NullCheckIfThumbEE(15); 
         base = Align(PC,4); 
if (ConditionPassed(opcode)) {
     if (!WriteRegisterUnsigned(context, eRegisterKindDWARF, dwarf_r0 + d,
                                (uint64_t)data))
       return false;
   }
 
   return true;
 }
 
-// UXTB extracts an 8-bit value from a register, zero-extneds it to 32 bits, and
+// UXTB extracts an 8-bit value from a register, zero-extends it to 32 bits, and
 // writes the result to the destination
 // register.  You can specify a rotation by 0, 8, 16, or 24 bits before
 // extracting the 8-bit value.
 bool EmulateInstructionARM::EmulateUXTB(const uint32_t opcode,
                                         const ARMEncoding encoding) {
 #if 0
     if ConditionPassed() then 
         EncodingSpecificOperations(); 

lldb/source/Plugins/Instruction/MIPS/EmulateInstructionMIPS.h

protected:
   bool Emulate_JALRx16_MM(llvm::MCInst &insn);
 
   bool Emulate_JALx(llvm::MCInst &insn);
 
   bool Emulate_JALRS(llvm::MCInst &insn);
 
   bool nonvolatile_reg_p(uint32_t regnum);
 
-  const char *GetRegisterName(unsigned reg_num, bool altnernate_name);
+  const char *GetRegisterName(unsigned reg_num, bool alternate_name);
 
 private:
   std::unique_ptr<llvm::MCDisassembler> m_disasm;
   std::unique_ptr<llvm::MCDisassembler> m_alt_disasm;
   std::unique_ptr<llvm::MCSubtargetInfo> m_subtype_info;
   std::unique_ptr<llvm::MCSubtargetInfo> m_alt_subtype_info;
   std::unique_ptr<llvm::MCRegisterInfo> m_reg_info;
   std::unique_ptr<llvm::MCAsmInfo> m_asm_info;
   std::unique_ptr<llvm::MCContext> m_context;
   std::unique_ptr<llvm::MCInstrInfo> m_insn_info;
   uint32_t m_next_inst_size;
   bool m_use_alt_disaasm;
 };
 
 #endif // LLDB_SOURCE_PLUGINS_INSTRUCTION_MIPS_EMULATEINSTRUCTIONMIPS_H

lldb/source/Plugins/Instruction/MIPS64/EmulateInstructionMIPS64.h

protected:
   bool Emulate_BNZV(llvm::MCInst &insn);
 
   bool Emulate_BZV(llvm::MCInst &insn);
 
   bool Emulate_MSA_Branch_V(llvm::MCInst &insn, bool bnz);
 
   bool nonvolatile_reg_p(uint64_t regnum);
 
-  const char *GetRegisterName(unsigned reg_num, bool altnernate_name);
+  const char *GetRegisterName(unsigned reg_num, bool alternate_name);
 
 private:
   std::unique_ptr<llvm::MCDisassembler> m_disasm;
   std::unique_ptr<llvm::MCSubtargetInfo> m_subtype_info;
   std::unique_ptr<llvm::MCRegisterInfo> m_reg_info;
   std::unique_ptr<llvm::MCAsmInfo> m_asm_info;
   std::unique_ptr<llvm::MCContext> m_context;
   std::unique_ptr<llvm::MCInstrInfo> m_insn_info;
 };
 
 #endif // LLDB_SOURCE_PLUGINS_INSTRUCTION_MIPS64_EMULATEINSTRUCTIONMIPS64_H

lldb/source/Plugins/Language/CPlusPlus/CPlusPlusLanguage.cpp

static bool IsTrivialBasename(const llvm::StringRef &basename) {
   size_t idx = 0;
   if (basename.size() > 0 && basename[0] == '~')
     idx = 1;
 
   if (basename.size() <= idx)
     return false; // Empty string or "~"
 
   if (!std::isalpha(basename[idx]) && basename[idx] != '_')
-    return false; // First charater (after removing the possible '~'') isn't in
+    return false; // First character (after removing the possible '~'') isn't in
                   // [A-Za-z_]
 
   // Read all characters matching [A-Za-z_0-9]
   ++idx;
   while (idx < basename.size()) {
     if (!std::isalnum(basename[idx]) && basename[idx] != '_')
       break;
     ++idx;

lldb/source/Plugins/LanguageRuntime/CPlusPlus/CPPLanguageRuntime.h

public:
   bool GetObjectDescription(Stream &str, ValueObject &object) override;
 
   bool GetObjectDescription(Stream &str, Value &value,
                             ExecutionContextScope *exe_scope) override;
 
   /// Obtain a ThreadPlan to get us into C++ constructs such as std::function.
   ///
   /// \param[in] thread
-  ///     Curent thrad of execution.
+  ///     Current thrad of execution.
   ///
   /// \param[in] stop_others
   ///     True if other threads should pause during execution.
   ///
   /// \return
   ///      A ThreadPlan Shared pointer
   lldb::ThreadPlanSP GetStepThroughTrampolinePlan(Thread &thread,
                                                   bool stop_others) override;

lldb/source/Plugins/ObjectFile/ELF/ObjectFileELF.cpp

if (m_symtab_up == nullptr) {
     }
 
     // If we still don't have any symtab then create an empty instance to avoid
     // do the section lookup next time.
     if (m_symtab_up == nullptr)
       m_symtab_up.reset(new Symtab(this));
 
     // In the event that there's no symbol entry for the entry point we'll
-    // artifically create one. We delegate to the symtab object the figuring
+    // artificially create one. We delegate to the symtab object the figuring
     // out of the proper size, this will usually make it span til the next
     // symbol it finds in the section. This means that if there are missing
     // symbols the entry point might span beyond its function definition.
     // We're fine with this as it doesn't make it worse than not having a
     // symbol entry at all.
     if (CalculateType() == eTypeExecutable) {
       ArchSpec arch = GetArchitecture();
       auto entry_point_addr = GetEntryPointAddress();

 
 void ObjectFileELF::ParseUnwindSymbols(Symtab *symbol_table,
                                        DWARFCallFrameInfo *eh_frame) {
   SectionList *section_list = GetSectionList();
   if (!section_list)
     return;
 
   // First we save the new symbols into a separate list and add them to the
-  // symbol table after we colleced all symbols we want to add. This is
+  // symbol table after we collected all symbols we want to add. This is
   // neccessary because adding a new symbol invalidates the internal index of
   // the symtab what causing the next lookup to be slow because it have to
   // recalculate the index first.
   std::vector<Symbol> new_symbols;
 
   eh_frame->ForEachFDEEntries([this, symbol_table, section_list, &new_symbols](
       lldb::addr_t file_addr, uint32_t size, dw_offset_t) {
     Symbol *symbol = symbol_table->FindSymbolAtFileAddress(file_addr);

lldb/source/Plugins/Platform/MacOSX/PlatformDarwin.h

public:
   llvm::Expected<lldb_private::StructuredData::DictionarySP>
   FetchExtendedCrashInformation(lldb_private::Process &process) override;
 
   static llvm::StringRef GetSDKNameForType(SDKType type);
   static lldb_private::FileSpec GetXcodeSDK(SDKType type);
   static lldb_private::FileSpec GetXcodeContentsDirectory();
   static lldb_private::FileSpec GetXcodeDeveloperDirectory();
 
-  /// Return the toolchain directroy the current LLDB instance is located in.
+  /// Return the toolchain directory the current LLDB instance is located in.
   static lldb_private::FileSpec GetCurrentToolchainDirectory();
 
   /// Return the command line tools directory the current LLDB instance is
   /// located in.
   static lldb_private::FileSpec GetCurrentCommandLineToolsDirectory();
 
 protected:
   struct CrashInfoAnnotations {

lldb/source/Plugins/Process/Darwin/CFUtils.h

 
 #ifdef __cplusplus
 
 // Templatized CF helper class that can own any CF pointer and will
 // call CFRelease() on any valid pointer it owns unless that pointer is
 // explicitly released using the release() member function.
 template <class T> class CFReleaser {
 public:
-  // Type names for the avlue
+  // Type names for the value
   typedef T element_type;
 
   // Constructors and destructors
   CFReleaser(T ptr = NULL) : _ptr(ptr) {}
   CFReleaser(const CFReleaser &copy) : _ptr(copy.get()) {
     if (get())
       ::CFRetain(get());
   }

lldb/source/Plugins/Process/Linux/NativeRegisterContextLinux_arm.cpp

uint32_t NativeRegisterContextLinux_arm::SetHardwareWatchpoint(
   // Can't watch zero bytes
   // Can't watch more than 4 bytes per WVR/WCR pair
 
   if (size == 0 || size > 4)
     return LLDB_INVALID_INDEX32;
 
   // Check 4-byte alignment for hardware watchpoint target address. Below is a
   // hack to recalculate address and size in order to make sure we can watch
-  // non 4-byte alligned addresses as well.
+  // non 4-byte aligned addresses as well.
   if (addr & 0x03) {
     uint8_t watch_mask = (addr & 0x03) + size;
 
     if (watch_mask > 0x04)
       return LLDB_INVALID_INDEX32;
     else if (watch_mask <= 0x02)
       size = 2;
     else if (watch_mask <= 0x04)

 }
 
 Status NativeRegisterContextLinux_arm::DoReadRegisterValue(
     uint32_t offset, const char *reg_name, uint32_t size,
     RegisterValue &value) {
   // PTRACE_PEEKUSER don't work in the aarch64 linux kernel used on android
   // devices (always return "Bad address"). To avoid using PTRACE_PEEKUSER we
   // read out the full GPR register set instead. This approach is about 4 times
-  // slower but the performance overhead is negligible in comparision to
+  // slower but the performance overhead is negligible in comparison to
   // processing time in lldb-server.
   assert(offset % 4 == 0 && "Try to write a register with unaligned offset");
   if (offset + sizeof(uint32_t) > sizeof(m_gpr_arm))
     return Status("Register isn't fit into the size of the GPR area");
 
   Status error = ReadGPR();
   if (error.Fail())
     return error;
 
   value.SetUInt32(m_gpr_arm[offset / sizeof(uint32_t)]);
   return Status();
 }
 
 Status NativeRegisterContextLinux_arm::DoWriteRegisterValue(
     uint32_t offset, const char *reg_name, const RegisterValue &value) {
   // PTRACE_POKEUSER don't work in the aarch64 linux kernel used on android
   // devices (always return "Bad address"). To avoid using PTRACE_POKEUSER we
   // read out the full GPR register set, modify the requested register and
   // write it back. This approach is about 4 times slower but the performance
-  // overhead is negligible in comparision to processing time in lldb-server.
+  // overhead is negligible in comparison to processing time in lldb-server.
   assert(offset % 4 == 0 && "Try to write a register with unaligned offset");
   if (offset + sizeof(uint32_t) > sizeof(m_gpr_arm))
     return Status("Register isn't fit into the size of the GPR area");
 
   Status error = ReadGPR();
   if (error.Fail())
     return error;
 

lldb/source/Plugins/Process/Linux/NativeRegisterContextLinux_arm64.cpp

uint32_t NativeRegisterContextLinux_arm64::SetHardwareWatchpoint(
   }
 
   // Check if size has a valid hardware watchpoint length.
   if (size != 1 && size != 2 && size != 4 && size != 8)
     return LLDB_INVALID_INDEX32;
 
   // Check 8-byte alignment for hardware watchpoint target address. Below is a
   // hack to recalculate address and size in order to make sure we can watch
-  // non 8-byte alligned addresses as well.
+  // non 8-byte aligned addresses as well.
   if (addr & 0x07) {
     uint8_t watch_mask = (addr & 0x07) + size;
 
     if (watch_mask > 0x08)
       return LLDB_INVALID_INDEX32;
     else if (watch_mask <= 0x02)
       size = 2;
     else if (watch_mask <= 0x04)

lldb/source/Plugins/Process/Linux/NativeRegisterContextLinux_mips64.cpp

for (uint32_t index = 0; index < num_valid; index++) {
         } else {
           // It doesn't fit, but has the proper IRW capabilities
           vacant_watches++;
         }
       }
     }
 
     if (vacant_watches > 1) {
-      // Split this watchpoint accross several registers
+      // Split this watchpoint across several registers
       struct pt_watch_regs regs_copy;
       regs_copy = *regs;
       lldb::addr_t break_addr;
       uint32_t segment_size;
       for (uint32_t index = 0; index < num_valid; index++) {
         lo = GetWatchLo(&regs_copy, index);
         hi = GetRegMask(&regs_copy, index) | IRW;
         if (lo == 0 && irw == (hi & irw)) {

lldb/source/Plugins/Process/Linux/NativeRegisterContextLinux_ppc64le.cpp

uint32_t NativeRegisterContextLinux_ppc64le::SetHardwareWatchpoint(
   }
 
   // Check if size has a valid hardware watchpoint length.
   if (size != 1 && size != 2 && size != 4 && size != 8)
     return LLDB_INVALID_INDEX32;
 
   // Check 8-byte alignment for hardware watchpoint target address. Below is a
   // hack to recalculate address and size in order to make sure we can watch
-  // non 8-byte alligned addresses as well.
+  // non 8-byte aligned addresses as well.
   if (addr & 0x07) {
 
     addr_t begin = llvm::alignDown(addr, 8);
     addr_t end = llvm::alignTo(addr + size, 8);
     size = llvm::PowerOf2Ceil(end - begin);
 
     addr = addr & (~0x07);
   }

lldb/source/Plugins/Process/MacOSX-Kernel/CommunicationKDP.cpp

if (bytes_available >= 8) {
     case ePacketTypeReply | KDP_READMSR64:
     case ePacketTypeReply | KDP_WRITEMSR64:
     case ePacketTypeReply | KDP_DUMPINFO: {
       offset = 2;
       const uint16_t length = packet.GetU16(&offset);
       if (length <= bytes_available) {
         // We have an entire packet ready, we need to copy the data bytes into
         // a buffer that will be owned by the packet and erase the bytes from
-        // our communcation buffer "m_bytes"
+        // our communication buffer "m_bytes"
         packet.SetData(DataBufferSP(new DataBufferHeap(&m_bytes[0], length)));
         m_bytes.erase(0, length);
 
         if (log) {
           PacketStreamType log_strm;
           DumpPacket(log_strm, packet);
 
           LLDB_LOGF(log, "%.*s", (uint32_t)log_strm.GetSize(),

lldb/source/Plugins/Process/Utility/RegisterInfos_arm64.h

 // Defines a vector register with 16-byte size
 #define DEFINE_VREG(reg)                                                       \
   {                                                                            \
     #reg, nullptr, 16, FPU_OFFSET(fpu_##reg - fpu_v0), lldb::eEncodingVector,  \
         lldb::eFormatVectorOfUInt8, VREG_KIND(reg), nullptr, nullptr, nullptr, \
         0                                                                      \
   }
 
-// Defines S and D pseudo registers mapping over correspondig vector register
+// Defines S and D pseudo registers mapping over corresponding vector register
 #define DEFINE_FPU_PSEUDO(reg, size, offset, vreg)                             \
   {                                                                            \
     #reg, nullptr, size, FPU_OFFSET(fpu_##vreg - fpu_v0) + offset,             \
         lldb::eEncodingIEEE754, lldb::eFormatFloat, MISC_KIND(fpu_##reg),      \
         g_contained_##vreg, g_##reg##_invalidates, nullptr, 0                  \
   }
 
 // Defines miscellaneous status and control registers like cpsr, fpsr etc

lldb/source/Plugins/Process/Windows/Common/NativeProcessWindows.cpp

 }
 
 void NativeProcessWindows::OnDebuggerConnected(lldb::addr_t image_base) {
   Log *log = ProcessWindowsLog::GetLogIfAny(WINDOWS_LOG_PROCESS);
   LLDB_LOG(log, "Debugger connected to process {0}. Image base = {1:x}",
            GetDebuggedProcessId(), image_base);
 
   // This is the earliest chance we can resolve the process ID and
-  // architecutre if we don't know them yet.
+  // architecture if we don't know them yet.
   if (GetID() == LLDB_INVALID_PROCESS_ID)
     SetID(GetDebuggedProcessId());
 
   if (GetArchitecture().GetMachine() == llvm::Triple::UnknownArch) {
     ProcessInstanceInfo process_info;
     if (!Host::GetProcessInfo(GetDebuggedProcessId(), process_info)) {
       LLDB_LOG(log, "Cannot get process information during debugger connecting "
                     "to process");

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

for (const uint32_t *reg_num_p = reg_set_p->registers;
         LLDB_LOGF(log,
                   "GDBRemoteCommunicationServerLLGS::%s failed to get "
                   "register info for register set '%s', register index "
                   "%" PRIu32,
                   __FUNCTION__,
                   reg_set_p->name ? reg_set_p->name : "<unnamed-set>",
                   *reg_num_p);
       } else if (reg_info_p->value_regs == nullptr) {
-        // Only expediate registers that are not contained in other registers.
+        // Only expedite registers that are not contained in other registers.
         RegisterValue reg_value;
         Status error = reg_ctx.ReadRegister(reg_info_p, reg_value);
         if (error.Success()) {
           response.Printf("%.02x:", *reg_num_p);
           WriteRegisterValueInHexFixedWidth(response, reg_ctx, *reg_info_p,
                                             &reg_value, lldb::eByteOrderBig);
           response.PutChar(';');
         } else {

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

if (process->m_async_listener_sp->GetEvent(event_sp, llvm::None)) {
               }
 
               default:
                 process->SetPrivateState(stop_state);
                 break;
               } // switch(stop_state)
             }   // else // if in All-stop-mode
           }     // if (continue_packet)
-        }       // case eBroadcastBitAysncContinue
+        }       // case eBroadcastBitAsyncContinue
         break;
 
         case eBroadcastBitAsyncThreadShouldExit:
           LLDB_LOGF(log,
                     "ProcessGDBRemote::%s (arg = %p, pid = %" PRIu64
                     ") got eBroadcastBitAsyncThreadShouldExit...",
                     __FUNCTION__, arg, process->GetID());
           done = true;
root_element.ForEachChildElementWithName(
                   // the displacement as read from the field 'l_addr' of the
                   // link_map struct.
                   module.set_base(StringConvert::ToUInt64(
                       value.data(), LLDB_INVALID_ADDRESS, 0));
                   // base address is always a displacement, not an absolute
                   // value.
                   module.set_base_is_offset(true);
                 } else if (name == "l_ld") {
-                  // the memory address of the libraries PT_DYAMIC section.
+                  // the memory address of the libraries PT_DYNAMIC section.
                   module.set_dynamic(StringConvert::ToUInt64(
                       value.data(), LLDB_INVALID_ADDRESS, 0));
                 }
 
                 return true; // Keep iterating over all properties of "library"
               });
 
           if (log) {

lldb/source/Plugins/Process/mach-core/ProcessMachCore.cpp

if (GetCorefilePreference() == eKernelCorefile) {
     }
   }
 
   if (m_dyld_plugin_name != DynamicLoaderMacOSXDYLD::GetPluginNameStatic()) {
     // For non-user process core files, the permissions on the core file
     // segments are usually meaningless, they may be just "read", because we're
     // dealing with kernel coredumps or early startup coredumps and the dumper
     // is grabbing pages of memory without knowing what they are.  If they
-    // aren't marked as "exeuctable", that can break the unwinder which will
+    // aren't marked as "executable", that can break the unwinder which will
     // check a pc value to see if it is in an executable segment and stop the
     // backtrace early if it is not ("executable" and "unknown" would both be
     // fine, but "not executable" will break the unwinder).
     size_t core_range_infos_size = m_core_range_infos.GetSize();
     for (size_t i = 0; i < core_range_infos_size; i++) {
       VMRangeToPermissions::Entry *ent =
           m_core_range_infos.GetMutableEntryAtIndex(i);
       ent->data = lldb::ePermissionsReadable | lldb::ePermissionsExecutable;

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

void ProcessMinidump::RefreshStateAfterStop() {
   constexpr uint32_t BreakpadDumpRequested = 0xFFFFFFFF;
   if (m_active_exception->ExceptionRecord.ExceptionCode ==
       BreakpadDumpRequested) {
     // This "ExceptionCode" value is a sentinel that is sometimes used
     // when generating a dump for a process that hasn't crashed.
 
     // TODO: The definition and use of this "dump requested" constant
     // in Breakpad are actually Linux-specific, and for similar use
-    // cases on Mac/Windows it defines differnt constants, referring
+    // cases on Mac/Windows it defines different constants, referring
     // to them as "simulated" exceptions; consider moving this check
     // down to the OS-specific paths and checking each OS for its own
     // constant.
     return;
   }
 
   lldb::StopInfoSP stop_info;
   lldb::ThreadSP stop_thread;

lldb/source/Plugins/ScriptInterpreter/Python/PythonDataObjects.h

 // * Make all methods safe for exceptions.
 //
 // * Eliminate method signatures that must translate exceptions into
 //   empty objects or NULLs.   Almost everything here should return
 //   Expected<>.   It should be acceptable for certain operations that
 //   can never fail to assert instead, such as the creation of
 //   PythonString from a string literal.
 //
-// * Elimintate Reset(), and make all non-default constructors private.
+// * Eliminate Reset(), and make all non-default constructors private.
 //   Python objects should be created with Retain<> or Take<>, and they
 //   should be assigned with operator=
 //
 // * Eliminate default constructors, make python objects always
 //   nonnull, and use optionals where necessary.
 //
 
 
 #ifndef LLDB_PLUGINS_SCRIPTINTERPRETER_PYTHON_PYTHONDATAOBJECTS_H
 #define LLDB_PLUGINS_SCRIPTINTERPRETER_PYTHON_PYTHONDATAOBJECTS_H
 
 #include "lldb/Host/Config.h"
 
 #if LLDB_ENABLE_PYTHON
 
 // LLDB Python header must be included first

lldb/source/Plugins/ScriptInterpreter/Python/PythonDataObjects.cpp

std::string PythonException::ReadBacktrace() const {
   static PythonScript read_exception(read_exception_script);
 
   Expected<std::string> backtrace = As<std::string>(
       read_exception(m_exception_type, m_exception, m_traceback));
 
   if (!backtrace) {
     std::string message =
         std::string(toCString()) + "\n" +
-        "Traceback unavailble, an error occurred while reading it:\n";
+        "Traceback unavailable, an error occurred while reading it:\n";
     return (message + llvm::toString(backtrace.takeError()));
   }
 
   return std::move(backtrace.get());
 }
 
 char PythonException::ID = 0;
 

lldb/source/Plugins/StructuredData/DarwinLog/StructuredDataDarwinLog.h

public:
   static void Initialize();
 
   static void Terminate();
 
   static ConstString GetStaticPluginName();
 
   /// Return whether the DarwinLog functionality is enabled.
   ///
-  /// The DarwinLog functionality is enabled if the user expicitly enabled
+  /// The DarwinLog functionality is enabled if the user explicitly enabled
   /// it with the enable command, or if the user has the setting set
   /// that controls if we always enable it for newly created/attached
   /// processes.
   ///
   /// \return
   ///      True if DarwinLog support is/will be enabled for existing or
   ///      newly launched/attached processes.
   static bool IsEnabled();

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
-    // conventon. Unfortunately none of the format is recognized by current
+    // 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 contradition
+    // empty string as its undecorated name. So we will face a contradiction
     // here for the same symbol:
     //   non-empty undecorated name from PDB
     //   empty undecorated name from LLDB
     if (!func_undecorated_name.empty() && mangled.GetDemangledName().IsEmpty())
       mangled.SetDemangledName(ConstString(func_undecorated_name));
 
     // LLDB uses several flags to control how a C++ decorated name is
     // undecorated for MSVC. See `safeUndecorateName` in Class Mangled. So the

lldb/source/Plugins/TypeSystem/Clang/TypeSystemClang.cpp

TypeSystemClang::CreateTemplateTemplateParmDecl(const char *template_name) {
   llvm::SmallVector<NamedDecl *, 8> template_param_decls;
 
   TypeSystemClang::TemplateParameterInfos template_param_infos;
   TemplateParameterList *template_param_list = CreateTemplateParameterList(
       ast, template_param_infos, template_param_decls);
 
   // LLDB needs to create those decls only to be able to display a
   // type that includes a template template argument. Only the name matters for
-  // this purpose, so we use dummy values for the other characterisitcs of the
+  // this purpose, so we use dummy values for the other characteristics of the
   // type.
   return TemplateTemplateParmDecl::Create(
       ast, decl_ctx, SourceLocation(),
       /*Depth*/ 0, /*Position*/ 0,
       /*IsParameterPack*/ false, &identifier_info, template_param_list);
 }
 
 ClassTemplateSpecializationDecl *
const uint64_t enum_svalue = data.GetMaxS64Bitfield(
       &offset, byte_size, bitfield_bit_size, bitfield_bit_offset);
   bool can_be_bitfield = true;
   uint64_t covered_bits = 0;
   int num_enumerators = 0;
 
   // Try to find an exact match for the value.
   // At the same time, we're applying a heuristic to determine whether we want
   // to print this enum as a bitfield. We're likely dealing with a bitfield if
-  // every enumrator is either a one bit value or a superset of the previous
+  // every enumerator is either a one bit value or a superset of the previous
   // enumerators. Also 0 doesn't make sense when the enumerators are used as
   // flags.
   for (auto enumerator : enum_decl->enumerators()) {
     uint64_t val = enumerator->getInitVal().getSExtValue();
     val = llvm::SignExtend64(val, 8*byte_size);
     if (llvm::countPopulation(val) != 1 && (val & ~covered_bits) != 0)
       can_be_bitfield = false;
     covered_bits |= val;

lldb/source/Symbol/ArmUnwindInfo.cpp

  *     Document number: ARM IHI 0038A (current through ABI r2.09)
  *     Date of Issue: 25th January 2007, reissued 30th November 2012
  *     http://infocenter.arm.com/help/topic/com.arm.doc.ihi0038a/IHI0038A_ehabi.pdf
  */
 
 using namespace lldb;
 using namespace lldb_private;
 
-// Converts a prel31 avlue to lldb::addr_t with sign extension
+// Converts a prel31 value to lldb::addr_t with sign extension
 static addr_t Prel31ToAddr(uint32_t prel31) {
   addr_t res = prel31;
   if (prel31 & (1 << 30))
     res |= 0xffffffff80000000ULL;
   return res;
 }
 
 ArmUnwindInfo::ArmExidxEntry::ArmExidxEntry(uint32_t f, lldb::addr_t a,

lldb/source/Target/RegisterContextUnwind.cpp

 bool RegisterContextUnwind::CheckIfLoopingStack() {
   // If we have a bad stack setup, we can get the same CFA value multiple times
   // -- or even more devious, we can actually oscillate between two CFA values.
   // Detect that here and break out to avoid a possible infinite loop in lldb
   // trying to unwind the stack. To detect when we have the same CFA value
   // multiple times, we compare the
   // CFA of the current
   // frame with the 2nd next frame because in some specail case (e.g. signal
-  // hanlders, hand written assembly without ABI compiance) we can have 2
+  // hanlders, hand written assembly without ABI compliance) we can have 2
   // frames with the same
   // CFA (in theory we
   // can have arbitrary number of frames with the same CFA, but more then 2 is
   // very very unlikely)
 
   RegisterContextUnwind::SharedPtr next_frame = GetNextFrame();
   if (next_frame) {
     RegisterContextUnwind::SharedPtr next_next_frame =

 }
 
 bool RegisterContextUnwind::IsValid() const {
   return m_frame_type != eNotAValidFrame;
 }
 
 // After the final stack frame in a stack walk we'll get one invalid
 // (eNotAValidFrame) stack frame -- one past the end of the stack walk.  But
-// higher-level code will need to tell the differnece between "the unwind plan
+// higher-level code will need to tell the difference between "the unwind plan
 // below this frame failed" versus "we successfully completed the stack walk"
 // so this method helps to disambiguate that.
 
 bool RegisterContextUnwind::IsTrapHandlerFrame() const {
   return m_frame_type == eTrapHandlerFrame;
 }
 
 // A skip frame is a bogus frame on the stack -- but one where we're likely to

lldb/source/Target/StackFrame.cpp

lldb::ValueObjectSP DoGuessValueAt(StackFrame &frame, ConstString reg,
   // +22: addl   0x4(%rdi), %eax
   //
   // f, a pointer to a struct, is known to be at -0x8(%rbp).
   //
   // DoGuessValueAt(frame, rdi, 4, dis, vars, 0x22) finds the instruction at
   // +18 that assigns to rdi, and calls itself recursively for that dereference
   //   DoGuessValueAt(frame, rdi, 8, dis, vars, 0x18) finds the instruction at
   //   +14 that assigns to rdi, and calls itself recursively for that
-  //   derefernece
+  //   dereference
   //     DoGuessValueAt(frame, rbp, -8, dis, vars, 0x14) finds "f" in the
   //     variable list.
   //     Returns a ValueObject for f.  (That's what was stored at rbp-8 at +14)
   //   Returns a ValueObject for *(f+8) or f->b (That's what was stored at rdi+8
   //   at +18)
   // Returns a ValueObject for *(f->b+4) or f->b->a (That's what was stored at
   // rdi+4 at +22)
 

lldb/source/Target/StopInfo.cpp

if (thread_sp) {
                 LLDB_LOGF(log, "Error evaluating condition: \"%s\"\n", err_str);
 
                 error_sp->PutCString(err_str);
                 error_sp->EOL();
                 error_sp->Flush();
               } else {
                 LLDB_LOGF(log,
                           "Condition evaluated for breakpoint %s on thread "
-                          "0x%llx conditon_says_stop: %i.",
+                          "0x%llx condition_says_stop: %i.",
                           loc_desc.GetData(),
                           static_cast<unsigned long long>(thread_sp->GetID()),
                           condition_says_stop);
                 if (!condition_says_stop) {
                   // We don't want to increment the hit count of breakpoints if
                   // the condition fails. We've already bumped it by the time
                   // we get here, so undo the bump:
                   bp_loc_sp->UndoBumpHitCount();

lldb/test/API/benchmarks/turnaround/TestCompileRunToBreakpointTurnaround.py

-"""Benchmark the turnaround time starting a debugger and run to the breakpont with lldb vs. gdb."""
+"""Benchmark the turnaround time starting a debugger and run to the breakpoint with lldb vs. gdb."""
 
 from __future__ import print_function
 
 
 import sys
 import lldb
 from lldbsuite.test.lldbbench import *
 from lldbsuite.test.decorators import *

lldb/test/API/functionalities/breakpoint/breakpoint_names/TestBreakpointNames.py

def do_check_illegal_names(self):
             self.assertTrue(not retval.Succeeded(), "break set succeeded with: illegal name: %s"%(bad_name))
 
     def do_check_using_names(self):
         """Use Python APIs to check names work in place of breakpoint ID's."""
 
         # Create a dummy breakpoint to use up ID 1
         _ = self.target.BreakpointCreateByLocation(self.main_file_spec, 30)
 
-        # Create a breakpiont to test with
+        # Create a breakpoint to test with
         bkpt = self.target.BreakpointCreateByLocation(self.main_file_spec, 10)
         bkpt_name = "ABreakpoint"
         bkpt_id = bkpt.GetID()
         other_bkpt_name= "_AnotherBreakpoint"
 
         # Add a name and make sure we match it:
         success = bkpt.AddName(bkpt_name)
         self.assertTrue(success, "We couldn't add a legal name to a breakpoint.")

lldb/test/API/functionalities/breakpoint/step_over_breakpoint/TestStepOverBreakpoint.py

 """
 Test that breakpoints do not affect stepping.
 Check for correct StopReason when stepping to the line with breakpoint
-which chould be eStopReasonBreakpoint in general,
+which should be eStopReasonBreakpoint in general,
 and eStopReasonPlanComplete when breakpoint's condition fails.
 """
 
 
 import unittest2
 import lldb
 from lldbsuite.test.decorators import *
 from lldbsuite.test.lldbtest import *

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

def run_load_unload(self):
                     substrs=['stopped',
                              'a_function',
                              'stop reason = breakpoint'])
 
         # The breakpoint should have a hit count of 1.
         self.expect("breakpoint list -f", BREAKPOINT_HIT_ONCE,
                     substrs=[' resolved, hit count = 1'])
 
-        # Issue the 'contnue' command.  We should stop agaian at a_function.
+        # Issue the 'continue' command.  We should stop agaian 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/plugins/python_os_plugin/TestPythonOSPlugin.py

def run_python_os_funcionality(self):
         self.verify_os_thread_registers(thread)
         thread = process.GetThreadByID(0x333333333)
         self.assertTrue(
             thread.IsValid(),
             "Make sure there is a thread 0x333333333 after we load the python OS plug-in")
         self.verify_os_thread_registers(thread)
 
         # Now clear the OS plug-in path to make the OS plug-in created threads
-        # dissappear
+        # disappear
         self.dbg.HandleCommand(
             "settings clear target.process.python-os-plugin-path")
 
         # Verify the threads are gone after unloading the python OS plug-in
         thread = process.GetThreadByID(0x111111111)
         self.assertFalse(
             thread.IsValid(),
             "Make sure there is no thread 0x111111111 after we unload the python OS plug-in")

lldb/test/API/functionalities/process_crash_info/TestProcessCrashInfo.py

class PlatformProcessCrashInfoTestCase(TestBase):
     def tearDown(self):
         self.runCmd("settings clear auto-confirm")
         TestBase.tearDown(self)
 
     @skipIfAsan # The test process intentionally double-frees.
     @skipUnlessDarwin
     def test_cli(self):
         """Test that `process status --verbose` fetches the extended crash
-        information dictionnary from the command-line properly."""
+        information dictionary from the command-line properly."""
         self.build()
         exe = self.getBuildArtifact("a.out")
         self.expect("file " + exe,
                     patterns=["Current executable set to .*a.out"])
 
         self.expect('process launch',
                     patterns=["Process .* launched: .*a.out"])
 
         self.expect('process status --verbose',
                     patterns=["\"message\".*pointer being freed was not allocated"])
 
 
     @skipIfAsan # The test process intentionally hits a memory bug.
     @skipUnlessDarwin
     def test_api(self):
         """Test that lldb can fetch a crashed process' extended crash information
-        dictionnary from the api properly."""
+        dictionary from the api properly."""
         self.build()
         target = self.dbg.CreateTarget(self.getBuildArtifact("a.out"))
         self.assertTrue(target, VALID_TARGET)
 
         target.LaunchSimple(None, None, os.getcwd())
 
         stream = lldb.SBStream()
         self.assertTrue(stream)
def test_api(self):
         self.assertTrue(crash_info.IsValid())
 
         self.assertIn("pointer being freed was not allocated", stream.GetData())
 
     # dyld leaves permanent crash_info records when testing on device.
     @skipIfDarwinEmbedded
     def test_on_sane_process(self):
         """Test that lldb doesn't fetch the extended crash information
-        dictionnary from a 'sane' stopped process."""
+        dictionary from a 'sane' stopped process."""
         self.build()
         target, _, _, _ = lldbutil.run_to_line_breakpoint(self, lldb.SBFileSpec(self.source),
                                         self.line)
 
         stream = lldb.SBStream()
         self.assertTrue(stream)
 
         process = target.GetProcess()
         self.assertTrue(process)
 
         crash_info = process.GetExtendedCrashInformation()
 
         error = crash_info.GetAsJSON(stream)
         self.assertFalse(error.Success())
         self.assertIn("No structured data.", error.GetCString())

lldb/test/API/functionalities/target-new-solib-notifications/TestModuleLoadedNotifys.py

 from lldbsuite.test.lldbtest import *
 from lldbsuite.test import lldbutil
 
 class ModuleLoadedNotifysTestCase(TestBase):
 
     mydir = TestBase.compute_mydir(__file__)
     NO_DEBUG_INFO_TESTCASE = True
 
-    # DyanmicLoaderDarwin should batch up notifications about
+    # DynamicLoaderDarwin should batch up notifications about
     # newly added/removed libraries.  Other DynamicLoaders may
     # not be written this way.
     @skipUnlessDarwin
 
     def setUp(self):
         # Call super's setUp().
         TestBase.setUp(self)
         # Find the line number to break inside main().

lldb/test/API/lang/cpp/namespace/ns3.cpp

 #include "ns.h"
 extern int func();
 
 // Note: the following function must be before the using.
 void test_lookup_before_using_directive()
 {
   // BP_before_using_directive
   std::printf("before using directive: func() = %d\n", func()); // eval func(), exp: 1
 }
 using namespace A;
 void test_lookup_after_using_directive()
 {
   // BP_after_using_directive
-  //printf("func() = %d\n", func()); // eval func(), exp: error, amiguous
+  //printf("func() = %d\n", func()); // eval func(), exp: error, ambiguous
   std::printf("after using directive: func2() = %d\n", func2()); // eval func2(), exp: 3
   std::printf("after using directive: ::func() = %d\n", ::func()); // eval ::func(), exp: 1
   std::printf("after using directive: B::func() = %d\n", B::func()); // eval B::func(), exp: 4
 }

lldb/test/API/macosx/lc-note/kern-ver-str/TestKernVerStrLCNOTE.py

def test_lc_note(self):
         ###  and its dSYM when given self.test_exe's UUID.
         shell_cmds = [
                 '#! /bin/sh',
                 'ret=0',
                 'echo "<?xml version=\\"1.0\\" encoding=\\"UTF-8\\"?>"',
                 'echo "<!DOCTYPE plist PUBLIC \\"-//Apple//DTD PLIST 1.0//EN\\" \\"http://www.apple.com/DTDs/PropertyList-1.0.dtd\\">"',
                 'echo "<plist version=\\"1.0\\">"',
                 '',
-                '# the last arugment is probably the uuid',
+                '# the last argument is probably the uuid',
                 'while [ $# -gt 1 ]',
                 'do',
                 '  shift',
                 'done',
                 'echo "<dict><key>$1</key><dict>"',
                 '',
                 'if [ "$1" = "%s" ]' % aout_uuid,
                 'then',

lldb/test/API/macosx/lc-note/kern-ver-str/create-empty-corefile.cpp

int main (int argc, char **argv)
     add_lc_segment (load_commands, payload, 0);
 
     int size_of_load_commands = 0;
     for (const auto &lc : load_commands)
         size_of_load_commands += lc.size();
 
     int header_and_load_cmd_room = sizeof (struct mach_header_64) + size_of_load_commands;
 
-    // Erease the load commands / payload now that we know how much space is needed,
+    // Erase the load commands / payload now that we know how much space is needed,
     // redo it.
     load_commands.clear();
     payload.clear();
 
     load_commands.push_back (x86_lc_thread_load_command());
     add_lc_note_kern_ver_str_load_command (load_commands, payload, header_and_load_cmd_room, ident);
     add_lc_segment (load_commands, payload, header_and_load_cmd_room);
 

lldb/test/API/python_api/default-constructor/TestDefaultConstructorForAPIObjects.py

 """
 Test lldb Python API object's default constructor and make sure it is invalid
 after initial construction.
 
 There are also some cases of boundary condition testings sprinkled throughout
 the tests where None is passed to SB API which expects (const char *) in the
 C++ API counterpart.  Passing None should not crash lldb!
 
 There are three exceptions to the above general rules, though; API objects
-SBCommadnReturnObject, SBStream, and SBSymbolContextList, are all valid objects
+SBCommandReturnObject, SBStream, and SBSymbolContextList, are all valid objects
 after default construction.
 """
 
 from __future__ import print_function
 
 
 import lldb
 from lldbsuite.test.decorators import *

lldb/test/API/python_api/frame/TestFrames.py

def test_get_arg_vals_for_call_stack(self):
         self.assertTrue(callsOfA == 2,
                         "Expect to find 'a' on the call stacks two times")
         # By design, the 'a' call frame has the following arg vals:
         #     o a((int)val=1, (char)ch='A')
         #     o a((int)val=3, (char)ch='A')
         if self.TraceOn():
             print("Full stack traces when stopped on the breakpoint 'c':")
             print(session.getvalue())
-        self.expect(session.getvalue(), "Argugment values displayed correctly",
+        self.expect(session.getvalue(), "Argument values displayed correctly",
                     exe=False,
                     substrs=["a((int)val=1, (char)ch='A')",
                              "a((int)val=3, (char)ch='A')"])
 
     @add_test_categories(['pyapi'])
     def test_frame_api_boundary_condition(self):
         """Exercise SBFrame APIs with boundary condition inputs."""
         self.build()

lldb/test/API/python_api/function_symbol/main.c

 #include <stdio.h>
 
 // This simple program is to test the lldb Python APIs SBTarget, SBFrame,
 // SBFunction, SBSymbol, and SBAddress.
 //
-// When stopped on breakppint 1, we can get the line entry using SBFrame API
+// When stopped on breakpoint 1, we can get the line entry using SBFrame API
 // SBFrame.GetLineEntry().  We'll get the start address for the line entry
 // with the SBAddress type, resolve the symbol context using the SBTarget API
 // SBTarget.ResolveSymbolContextForAddress() in order to get the SBSymbol.
 //
 // We then stop at breakpoint 2, get the SBFrame, and the SBFunction object.
 //
 // The address from calling GetStartAddress() on the symbol and the function
 // should point to the same address, and we also verify that.

lldb/test/API/python_api/target/main.c

 #include <stdio.h>
 
 // This simple program is to test the lldb Python API SBTarget.
 //
-// When stopped on breakppint 1, and then 2, we can get the line entries using
+// When stopped on breakpoint 1, and then 2, we can get the line entries using
 // SBFrame API SBFrame.GetLineEntry().  We'll get the start addresses for the
 // two line entries; with the start address (of SBAddress type), we can then
 // resolve the symbol context using the SBTarget API
 // SBTarget.ResolveSymbolContextForAddress().
 //
 // The two symbol context should point to the same symbol, i.e., 'a' function.
 
 char my_global_var_of_char_type = 'X'; // Test SBTarget.FindGlobalVariables(...).

lldb/test/API/python_api/thread/TestThreadAPI.py

def setUp(self):
         # Find the line numbers within main2.cpp for
         # step_out_of_malloc_into_function_b() and step_over_3_times().
         self.step_out_of_malloc = line_number(
             "main2.cpp", "// thread step-out of malloc into function b.")
         self.after_3_step_overs = line_number(
             "main2.cpp", "// we should reach here after 3 step-over's.")
 
         # We'll use the test method name as the exe_name for executable
-        # comppiled from main2.cpp.
+        # compiled from main2.cpp.
         self.exe_name = self.testMethodName
 
     def get_process(self):
         """Test Python SBThread.GetProcess() API."""
         exe = self.getBuildArtifact("a.out")
 
         target = self.dbg.CreateTarget(exe)
         self.assertTrue(target, VALID_TARGET)

lldb/test/API/tools/lldb-server/main.cpp

if (std::strstr(argv[i], STDERR_PREFIX)) {
                            "swap_chars"))
         func_p = swap_chars;
 
       std::lock_guard<std::mutex> lock(g_print_mutex);
       printf("code address: %p\n", func_p);
     } else if (std::strstr(argv[i], CALL_FUNCTION_PREFIX)) {
       void (*func_p)() = nullptr;
 
-      // Defaut to providing the address of main.
+      // Default to providing the address of main.
       if (std::strcmp(argv[i] + strlen(CALL_FUNCTION_PREFIX), "hello") == 0)
         func_p = hello;
       else if (std::strcmp(argv[i] + strlen(CALL_FUNCTION_PREFIX),
                            "swap_chars") == 0)
         func_p = swap_chars;
       else {
         std::lock_guard<std::mutex> lock(g_print_mutex);
         printf("unknown function: %s\n",

lldb/test/API/tools/lldb-vscode/attach/TestVSCode_attach.py

 class TestVSCode_attach(lldbvscode_testcase.VSCodeTestCaseBase):
 
     mydir = TestBase.compute_mydir(__file__)
 
     def set_and_hit_breakpoint(self, continueToExit=True):
         source = 'main.c'
         breakpoint1_line = line_number(source, '// breakpoint 1')
         lines = [breakpoint1_line]
-        # Set breakoint in the thread function so we can step the threads
+        # Set breakpoint in the thread function so we can step the threads
         breakpoint_ids = self.set_source_breakpoints(source, lines)
         self.assertEqual(len(breakpoint_ids), len(lines),
                          "expect correct number of breakpoints")
         self.continue_to_breakpoints(breakpoint_ids)
         if continueToExit:
             self.continue_to_exit()
 
 

lldb/test/API/tools/lldb-vscode/breakpoint-events/TestVSCode_breakpointEvents.py

def test_breakpoint_events(self):
             This test sets a breakpoint in a shared library and runs and stops
             at the entry point of a program. When we stop at the entry point,
             the shared library won't be loaded yet. At this point the
             breakpoint should set itself, but not be verified because no
             locations are resolved. We will then continue and expect to get a
             breakpoint event that informs us that the breakpoint in the shared
             library is "changed" and the correct line number should be
             supplied. We also set a breakpoint using a LLDB command using the
-            "preRunCommands" when launching our program. Any breapoints set via
+            "preRunCommands" when launching our program. Any breakpoints set via
             the command interpreter should not be have breakpoint events sent
             back to VS Code as the UI isn't able to add new breakpoints to
             their UI. Code has been added that tags breakpoints set from VS Code
             DAP packets so we know the IDE knows about them. If VS Code is ever
             able to register breakpoints that aren't initially set in the GUI,
             then we will need to revise this.
         '''
         main_source_basename = 'main.cpp'
def test_breakpoint_events(self):
         # registered and marked with a special keyword to ensure we deliver
         # breakpoint events for these breakpoints but not for ones that are not
         # set via the command interpreter.
         bp_command = 'breakpoint set --file foo.cpp --line %u' % (foo_bp2_line)
         self.build_and_launch(program, stopOnEntry=True,
                               preRunCommands=[bp_command])
         main_bp_id = 0
         foo_bp_id = 0
-        # Set breakoints and verify that they got set correctly
+        # Set breakpoints and verify that they got set correctly
         vscode_breakpoint_ids = []
         response = self.vscode.request_setBreakpoints(main_source_path,
                                                       [main_bp_line])
         if response:
             breakpoints = response['body']['breakpoints']
             for breakpoint in breakpoints:
                 main_bp_id = breakpoint['id']
                 vscode_breakpoint_ids.append("%i" % (main_bp_id))

lldb/test/API/tools/lldb-vscode/breakpoint/TestVSCode_setBreakpoints.py

class TestVSCode_setBreakpoints(lldbvscode_testcase.VSCodeTestCaseBase):
     @skipIfWindows
     @skipIfRemote
     def test_set_and_clear(self):
         '''Tests setting and clearing source file and line breakpoints.
            This packet is a bit tricky on the debug adaptor side since there
            is no "clearBreakpoints" packet. Source file and line breakpoints
            are set by sending a "setBreakpoints" packet with a source file
            specified and zero or more source lines. If breakpoints have been
-           set in the source file before, any exising breakpoints must remain
+           set in the source file before, any existing breakpoints must remain
            set, and any new breakpoints must be created, and any breakpoints
            that were in previous requests and are not in the current request
            must be removed. This function tests this setting and clearing
            and makes sure things happen correctly. It doesn't test hitting
            breakpoints and the functionality of each breakpoint, like
            'conditions' and 'hitCondition' settings.'''
         source_basename = 'main.cpp'
         source_path = os.path.join(os.getcwd(), source_basename)
         first_line = line_number('main.cpp', 'break 12')
         second_line = line_number('main.cpp', 'break 13')
         third_line = line_number('main.cpp', 'break 14')
         lines = [first_line, third_line, second_line]
 
         # Visual Studio Code Debug Adaptors have no way to specify the file
         # without launching or attaching to a process, so we must start a
         # process in order to be able to set breakpoints.
         program = self.getBuildArtifact("a.out")
         self.build_and_launch(program)
 
-        # Set 3 breakoints and verify that they got set correctly
+        # Set 3 breakpoints and verify that they got set correctly
         response = self.vscode.request_setBreakpoints(source_path, lines)
         line_to_id = {}
         if response:
             breakpoints = response['body']['breakpoints']
             self.assertEquals(len(breakpoints), len(lines),
                             "expect %u source breakpoints" % (len(lines)))
             for (breakpoint, index) in zip(breakpoints, range(len(lines))):
                 line = breakpoint['line']
                 self.assertTrue(line, lines[index])
                 # Store the "id" of the breakpoint that was set for later
                 line_to_id[line] = breakpoint['id']
                 self.assertTrue(line in lines, "line expected in lines array")
                 self.assertTrue(breakpoint['verified'],
                                 "expect breakpoint verified")
 
         # There is no breakpoint delete packet, clients just send another
         # setBreakpoints packet with the same source file with fewer lines.
         # Below we remove the second line entry and call the setBreakpoints
         # function again. We want to verify that any breakpoints that were set
         # before still have the same "id". This means we didn't clear the
         # breakpoint and set it again at the same location. We also need to
         # verify that the second line location was actually removed.
         lines.remove(second_line)
-        # Set 2 breakoints and verify that the previous breakoints that were
+        # Set 2 breakpoints and verify that the previous breakpoints that were
         # set above are still set.
         response = self.vscode.request_setBreakpoints(source_path, lines)
         if response:
             breakpoints = response['body']['breakpoints']
             self.assertEquals(len(breakpoints), len(lines),
                             "expect %u source breakpoints" % (len(lines)))
             for (breakpoint, index) in zip(breakpoints, range(len(lines))):
                 line = breakpoint['line']
def test_functionality(self):
         new_breakpoint_ids = self.set_source_breakpoints(source_path,
                                                          [loop_line],
                                                          hitCondition="2")
 
         self.assertEquals(breakpoint_ids, new_breakpoint_ids,
                         "existing breakpoint should have its condition "
                         "updated")
 
-        # Continue with a hitContidtion of 2 and expect it to skip 1 value
+        # Continue with a hitCondition of 2 and expect it to skip 1 value
         self.continue_to_breakpoints(breakpoint_ids)
         i = int(self.vscode.get_local_variable_value('i'))
         self.assertEquals(i, 6,
                         'i != 6 showing hitCondition works')
 
         # continue after hitting our hitCondition and make sure it only goes
         # up by 1
         self.continue_to_breakpoints(breakpoint_ids)
         i = int(self.vscode.get_local_variable_value('i'))
         self.assertEquals(i, 7,
                         'i != 7 showing post hitCondition hits every time')

lldb/test/API/tools/lldb-vscode/breakpoint/TestVSCode_setExceptionBreakpoints.py

class TestVSCode_setExceptionBreakpoints(
     @expectedFailureNetBSD
     @skipIfRemote
     def test_functionality(self):
         '''Tests setting and clearing exception breakpoints.
            This packet is a bit tricky on the debug adaptor side since there
            is no "clear exception breakpoints" packet. Exception breakpoints
            are set by sending a "setExceptionBreakpoints" packet with zero or
            more exception filters. If exception breakpoints have been set
-           before, any exising breakpoints must remain set, and any new
+           before, any existing breakpoints must remain set, and any new
            breakpoints must be created, and any breakpoints that were in
            previous requests and are not in the current request must be
            removed. This exception tests this setting and clearing and makes
            sure things happen correctly. It doesn't test hitting breakpoints
            and the functionality of each breakpoint, like 'conditions' and
            x'hitCondition' settings.
         '''
         # Visual Studio Code Debug Adaptors have no way to specify the file

lldb/test/API/tools/lldb-vscode/breakpoint/TestVSCode_setFunctionBreakpoints.py

class TestVSCode_setFunctionBreakpoints(
     @skipIfWindows
     @skipIfRemote
     def test_set_and_clear(self):
         '''Tests setting and clearing function breakpoints.
            This packet is a bit tricky on the debug adaptor side since there
            is no "clearFunction Breakpoints" packet. Function breakpoints
            are set by sending a "setFunctionBreakpoints" packet with zero or
            more function names. If function breakpoints have been set before,
-           any exising breakpoints must remain set, and any new breakpoints
+           any existing breakpoints must remain set, and any new breakpoints
            must be created, and any breakpoints that were in previous requests
            and are not in the current request must be removed. This function
            tests this setting and clearing and makes sure things happen
            correctly. It doesn't test hitting breakpoints and the functionality
            of each breakpoint, like 'conditions' and 'hitCondition' settings.
         '''
         # Visual Studio Code Debug Adaptors have no way to specify the file
         # without launching or attaching to a process, so we must start a
def test_functionality(self):
                         'i != 4 showing conditional works')
         new_breakpoint_ids = self.set_function_breakpoints(functions,
                                                            hitCondition="2")
 
         self.assertEquals(breakpoint_ids, new_breakpoint_ids,
                         "existing breakpoint should have its condition "
                         "updated")
 
-        # Continue with a hitContidtion of 2 and expect it to skip 1 value
+        # Continue with a hitCondition of 2 and expect it to skip 1 value
         self.continue_to_breakpoints(breakpoint_ids)
         i = int(self.vscode.get_local_variable_value('i'))
         self.assertEquals(i, 6,
                         'i != 6 showing hitCondition works')
 
         # continue after hitting our hitCondition and make sure it only goes
         # up by 1
         self.continue_to_breakpoints(breakpoint_ids)
         i = int(self.vscode.get_local_variable_value('i'))
         self.assertEquals(i, 7,
                         'i != 7 showing post hitCondition hits every time')

lldb/test/API/tools/lldb-vscode/launch/TestVSCode_launch.py

def test_commands(self):
         # Verify all "preRunCommands" were found in console output
         self.verify_commands('preRunCommands', output, preRunCommands)
 
         source = 'main.c'
         first_line = line_number(source, '// breakpoint 1')
         second_line = line_number(source, '// breakpoint 2')
         lines = [first_line, second_line]
 
-        # Set 2 breakoints so we can verify that "stopCommands" get run as the
+        # Set 2 breakpoints so we can verify that "stopCommands" get run as the
         # breakpoints get hit
         breakpoint_ids = self.set_source_breakpoints(source, lines)
         self.assertEquals(len(breakpoint_ids), len(lines),
                         "expect correct number of breakpoints")
 
         # Continue after launch and hit the first breakpoint.
         # Get output from the console. This should contain both the
         # "stopCommands" that were run after the first breakpoint was hit
def test_extra_launch_commands(self):
             Tests the "luanchCommands" with extra launching settings
         '''
         self.build_and_create_debug_adaptor()
         program = self.getBuildArtifact("a.out")
 
         source = 'main.c'
         first_line = line_number(source, '// breakpoint 1')
         second_line = line_number(source, '// breakpoint 2')
-        # Set target binary and 2 breakoints
+        # Set target binary and 2 breakpoints
         # then we can varify the "launchCommands" get run
         # also we can verify that "stopCommands" get run as the
         # breakpoints get hit
         launchCommands = [
             'target create "%s"' % (program),
             'br s -f main.c -l %d' % first_line,
             'br s -f main.c -l %d' % second_line,
             'process launch --stop-at-entry'

lldb/test/API/tools/lldb-vscode/stackTrace/TestVSCode_stackTrace.py

def test_stackTrace(self):
         source = 'main.c'
         self.source_path = os.path.join(os.getcwd(), source)
         self.recurse_end = line_number(source, 'recurse end')
         self.recurse_call = line_number(source, 'recurse call')
         self.recurse_invocation = line_number(source, 'recurse invocation')
 
         lines = [self.recurse_end]
 
-        # Set breakoint at a point of deepest recuusion
+        # Set breakpoint at a point of deepest recuusion
         breakpoint_ids = self.set_source_breakpoints(source, lines)
         self.assertEquals(len(breakpoint_ids), len(lines),
                         "expect correct number of breakpoints")
 
         self.continue_to_breakpoints(breakpoint_ids)
         startFrame = 0
         # Verify we get all stack frames with no arguments
         (stackFrames, totalFrames) = self.get_stackFrames_and_totalFramesCount()

lldb/test/API/tools/lldb-vscode/step/TestVSCode_step.py

def test_step(self):
             Tests the stepping in/out/over in threads.
         '''
         program = self.getBuildArtifact("a.out")
         self.build_and_launch(program)
         source = 'main.cpp'
         # source_path = os.path.join(os.getcwd(), source)
         breakpoint1_line = line_number(source, '// breakpoint 1')
         lines = [breakpoint1_line]
-        # Set breakoint in the thread function so we can step the threads
+        # Set breakpoint in the thread function so we can step the threads
         breakpoint_ids = self.set_source_breakpoints(source, lines)
         self.assertEqual(len(breakpoint_ids), len(lines),
                         "expect correct number of breakpoints")
         self.continue_to_breakpoints(breakpoint_ids)
         threads = self.vscode.get_threads()
         for thread in threads:
             if 'reason' in thread:
                 reason = thread['reason']

lldb/test/Shell/SymbolFile/DWARF/anon_class_w_and_wo_export_symbols.ll

 ; UNSUPPORTED: system-windows
 ;
 ; This test verifies that we do the right thing with DIFlagExportSymbols which is the new
-; behavioir and without the DIFlagExportSymbols which is the old behavior for the given
+; behaviour and without the DIFlagExportSymbols which is the old behavior for the given
 ; definitions below.
 ;
 ;```
 ; struct A{
 ;   struct {
 ;    int x;
 ;   };
 ;   struct {

lldb/third_party/Python/module/pexpect-4.6/pexpect/spawnbase.py

class SpawnBase(object):
 
     def _get_buffer(self):
         return self._buffer.getvalue()
 
     def _set_buffer(self, value):
         self._buffer = self.buffer_type()
         self._buffer.write(value)
 
-    # This property is provided for backwards compatability (self.buffer used
+    # This property is provided for backwards compatibility (self.buffer used
     # to be a string/bytes object)
     buffer = property(_get_buffer, _set_buffer)
 
     def read_nonblocking(self, size=1, timeout=None):
         """This reads data from the file descriptor.
 
         This is a simple implementation suitable for a regular file. Subclasses using ptys or pipes should override it.
 

lldb/tools/debugserver/source/ChangeLog

2009-03-25  Greg Clayton  <[e-mail]>
   (RNBRemote::~RNBRemote): Ditto.
   (RNBRemote::SendPacket): Ditto.
   (RNBRemote::GetPacketPayload): Ditto.
   (RNBRemote::GetPacket): Ditto): Ditto.
   (RNBRemote::HandleAsyncPacket): Ditto.
   (RNBRemote::HandleReceivedPacket): Ditto.
   (RNBRemote::CommDataReceived): Ditto.
   * DNB.cpp (DNBProcessLaunch): Changed to take a eror string pointer with 
-  size for more desciptive error reporting (instead of a uint32_t pointer).
+  size for more descriptive error reporting (instead of a uint32_t pointer).
   * DNB.h (DNBProcessLaunch): Ditto.
   * DNBError.cpp (DNBError::AsString): Now returns NULL if there is no error.
   * DNBError.h (DNBError::SetErrorString): New accessor to allow custom error
   strings.
   * arm/DNBArchImpl.cpp (DNBArchMachARM::GetGPRState): Improved logging.
   * MachProcess.cpp (MachProcess::SBForkChildForPTraceDebugging): Improved
   error messages when a file doesn't exist, or when unable to extract the
   CFBundleIdentifier.
2009-01-12  Greg Clayton  <[e-mail]>
 
   * DNBArch.h (DNBArchProtocol::NumSupportedHardwareBreakpoints()): Removed
   the "const" qualifier to allow arches to auto detect how many hardware 
   breakpoints they have.
   (DNBArchProtocol::NumSupportedHardwareWatchpoints()): Removed the "const" 
   qualifier to allow arches to auto detect how many hardware watchpoints they 
   have.
   * DNBArchImpl.h (DNBArchMachARM::NumSupportedHardwareBreakpoints()): Auto
-  detect how many BRP pairs are avialable and disable for armv7 for the time
+  detect how many BRP pairs are available and disable for armv7 for the time
   being (rdar://problem/6372672).
   (DNBArchMachARM::NumSupportedHardwareWatchpoints()): Auto detect how many 
-  WRP pairs are avialable and disable for armv7 for the time being 
+  WRP pairs are available and disable for armv7 for the time being
   (rdar://problem/6372672).
 
 2009-01-09  Greg Clayton  <[e-mail]>
 
   * test-remotenub.cpp (main): Filled in short argument versions for 
   --applist (-t) and --lockdown (-k) options.
   * DNBArchImpl.h (DNBArchMachARM::ConditionPassed): New protected
   member function.
2008-10-22  Greg Clayton  <[e-mail]>
 
   * MacOSX/arm/DNBArchImpl.cpp (DNBArchMachARM::GetRegisterValue): Set
   register value to a uint32 value instead of a float64 value for s0 - 
   s31.
 
 2008-10-17  Greg Clayton  <[e-mail]>
 
   * test-remotenub.cpp (RNBRunLoopLaunchInferior): Don't listen for
-  the qLaunchSuccess if we aren't doing a lockdown connnection.
+  the qLaunchSuccess if we aren't doing a lockdown connection.
 
 2008-10-13  Greg Clayton  <[e-mail]>
 
   * RNBRemote.h (class RNBRemote): Added m_watchpoints member.
   * DNB.cpp (DNBBreakpointSet): Added boolean hardware parameter for
   requesting that a hardware breakpoint be set.
   (DNBWatchpointSet): New function.
   (DNBWatchpointClear): New function.

lldb/tools/debugserver/source/MacOSX/CFUtils.h

 
 #ifdef __cplusplus
 
 // Templatized CF helper class that can own any CF pointer and will
 // call CFRelease() on any valid pointer it owns unless that pointer is
 // explicitly released using the release() member function.
 template <class T> class CFReleaser {
 public:
-  // Type names for the avlue
+  // Type names for the value
   typedef T element_type;
 
   // Constructors and destructors
   CFReleaser(T ptr = NULL) : _ptr(ptr) {}
   CFReleaser(const CFReleaser &copy) : _ptr(copy.get()) {
     if (get())
       ::CFRetain(get());
   }

lldb/tools/debugserver/source/MacOSX/MachProcess.h

private:
   // to the inferior and only send the signal if we aren't already stopped.
   // If we end up sending a signal to stop the process we store it until we
   // receive an exception with this signal. This helps us to verify we got
   // the signal that interrupted the process. We might stop due to another
   // reason after an interrupt signal is sent, so this helps us ensure that
   // we don't report a spurious stop on the next resume.
   int m_auto_resume_signo; // If we resume the process and still haven't
                            // received our interrupt signal
-  // acknownledgement, we will shortly after the next resume. We store the
+  // acknowledgement, we will shortly after the next resume. We store the
   // interrupt signal in this variable so when we get the interrupt signal
   // as the sole reason for the process being stopped, we can auto resume
   // the process.
   bool m_did_exec;
 
   void *(*m_dyld_process_info_create)(task_t task, uint64_t timestamp,
                                       kern_return_t *kernelError);
   void (*m_dyld_process_info_for_each_image)(
       void *info, void (^callback)(uint64_t machHeaderAddress,
                                    const uuid_t uuid, const char *path));
   void (*m_dyld_process_info_release)(void *info);
   void (*m_dyld_process_info_get_cache)(void *info, void *cacheInfo);
   uint32_t (*m_dyld_process_info_get_platform)(void *info);
 };
 
 #endif // LLDB_TOOLS_DEBUGSERVER_SOURCE_MACOSX_MACHPROCESS_H

lldb/tools/lldb-test/lldb-test.cpp

cl::values(
         clEnumValN(FindType::Type, "type", "Find types."),
         clEnumValN(FindType::Variable, "variable", "Find global variables.")),
     cl::sub(SymbolsSubcommand));
 
 static cl::opt<std::string> Name("name", cl::desc("Name to find."),
                                  cl::sub(SymbolsSubcommand));
 static cl::opt<bool>
     Regex("regex",
-          cl::desc("Search using regular expressions (avaliable for variables "
+          cl::desc("Search using regular expressions (available for variables "
                    "and functions only)."),
           cl::sub(SymbolsSubcommand));
 static cl::opt<std::string>
     Context("context",
             cl::desc("Restrict search to the context of the given variable."),
             cl::value_desc("variable"), cl::sub(SymbolsSubcommand));
 
 static cl::opt<std::string> CompilerContext(
Error opts::symbols::verify(lldb_private::Module &Module) {
 
   uint32_t comp_units_count = symfile->GetNumCompileUnits();
 
   outs() << "Found " << comp_units_count << " compile units.\n";
 
   for (uint32_t i = 0; i < comp_units_count; i++) {
     lldb::CompUnitSP comp_unit = symfile->GetCompileUnitAtIndex(i);
     if (!comp_unit)
-      return make_string_error("Connot parse compile unit {0}.", i);
+      return make_string_error("Cannot parse compile unit {0}.", i);
 
     outs() << "Processing '"
            << comp_unit->GetPrimaryFile().GetFilename().AsCString()
            << "' compile unit.\n";
 
     LineTable *lt = comp_unit->GetLineTable();
     if (!lt)
       return make_string_error("Can't get a line table of a compile unit.");

lldb/tools/lldb-vscode/JSONUtils.h

 ///     A "Event" JSON object with that follows the formal JSON
 ///     definition outlined by Microsoft.
 llvm::json::Object CreateEventObject(const llvm::StringRef event_name);
 
 /// Create a "ExceptionBreakpointsFilter" JSON object as described in
 /// the Visual Studio Code debug adaptor definition.
 ///
 /// \param[in] bp
-///     The exception breakppoint object to use
+///     The exception breakpoint object to use
 ///
 /// \return
 ///     A "ExceptionBreakpointsFilter" JSON object with that follows
 ///     the formal JSON definition outlined by Microsoft.
 llvm::json::Value
 CreateExceptionBreakpointFilter(const ExceptionBreakpoint &bp);
 
 /// Create a "Scope" JSON object as described in the Visual Studio Code

lldb/tools/lldb-vscode/package.json

"debuggers": [
                 "default": false
               },
               "sourcePath": {
                 "type": "string",
                 "description": "Specify a source path to remap \"./\" to allow full paths to be used when setting breakpoints in binaries that have relative source paths."
               },
               "sourceMap": {
                 "type": "array",
-                "description": "Specify an array of path remappings; each element must itself be a two element array containing a source and desination pathname. Overrides sourcePath.",
+                "description": "Specify an array of path remappings; each element must itself be a two element array containing a source and destination pathname. Overrides sourcePath.",
                 "default": []
               },
               "debuggerRoot": {
                 "type": "string",
                 "description": "Specify a working directory to set the debug adaptor to so relative object files can be located."
               },
               "targetTriple": {
                 "type": "string",
"debuggers": [
                 "default": true
               },
               "sourcePath": {
                 "type": "string",
                 "description": "Specify a source path to remap \"./\" to allow full paths to be used when setting breakpoints in binaries that have relative source paths."
               },
               "sourceMap": {
                 "type": "array",
-                "description": "Specify an array of path remappings; each element must itself be a two element array containing a source and desination pathname. Overrides sourcePath.",
+                "description": "Specify an array of path remappings; each element must itself be a two element array containing a source and destination pathname. Overrides sourcePath.",
                 "default": []
               },
               "debuggerRoot": {
                 "type": "string",
                 "description": "Specify a working directory to set the debug adaptor to so relative object files can be located."
               },
               "targetTriple": {
                 "type": "string",

lldb/unittests/Process/Linux/ProcessorTraceTest.cpp

size_t ReadCylicBufferWrapper(void *buf, size_t buf_size, void *cyc_buf,
   return dst.size();
 }
 
 TEST(CyclicBuffer, EdgeCases) {
   size_t bytes_read;
   uint8_t cyclic_buffer[6] = {'l', 'i', 'c', 'c', 'y', 'c'};
 
   // We will always leave the last bytes untouched
-  // so that string comparisions work.
+  // so that string comparisons work.
   char smaller_buffer[4] = {};
 
   // empty buffer to read into
   bytes_read = ReadCylicBufferWrapper(smaller_buffer, 0, cyclic_buffer,
                                       sizeof(cyclic_buffer), 3, 0);
   ASSERT_EQ(0u, bytes_read);
 
   // empty cyclic buffer

 
 TEST(CyclicBuffer, EqualSizeBuffer) {
   size_t bytes_read = 0;
   uint8_t cyclic_buffer[6] = {'l', 'i', 'c', 'c', 'y', 'c'};
 
   char cyclic[] = "cyclic";
   for (size_t i = 0; i < sizeof(cyclic); i++) {
     // We will always leave the last bytes untouched
-    // so that string comparisions work.
+    // so that string comparisons work.
     char equal_size_buffer[7] = {};
     bytes_read =
         ReadCylicBufferWrapper(equal_size_buffer, sizeof(cyclic_buffer),
                                cyclic_buffer, sizeof(cyclic_buffer), 3, i);
     ASSERT_EQ((sizeof(cyclic) - i - 1), bytes_read);
     ASSERT_STREQ(equal_size_buffer, (cyclic + i));
   }
 }
 
 TEST(CyclicBuffer, SmallerSizeBuffer) {
   size_t bytes_read;
   uint8_t cyclic_buffer[6] = {'l', 'i', 'c', 'c', 'y', 'c'};
 
   // We will always leave the last bytes untouched
-  // so that string comparisions work.
+  // so that string comparisons work.
   char smaller_buffer[4] = {};
   bytes_read =
       ReadCylicBufferWrapper(smaller_buffer, (sizeof(smaller_buffer) - 1),
                              cyclic_buffer, sizeof(cyclic_buffer), 3, 0);
   ASSERT_EQ(3u, bytes_read);
   ASSERT_STREQ(smaller_buffer, "cyc");
 
   bytes_read =

 
 TEST(CyclicBuffer, BiggerSizeBuffer) {
   size_t bytes_read = 0;
   uint8_t cyclic_buffer[6] = {'l', 'i', 'c', 'c', 'y', 'c'};
 
   char cyclic[] = "cyclic";
   for (size_t i = 0; i < sizeof(cyclic); i++) {
     // We will always leave the last bytes untouched
-    // so that string comparisions work.
+    // so that string comparisons work.
     char bigger_buffer[10] = {};
     bytes_read =
         ReadCylicBufferWrapper(bigger_buffer, (sizeof(bigger_buffer) - 1),
                                cyclic_buffer, sizeof(cyclic_buffer), 3, i);
     ASSERT_EQ((sizeof(cyclic) - i - 1), bytes_read);
     ASSERT_STREQ(bigger_buffer, (cyclic + i));
   }
 }

lldb/unittests/Utility/ArchSpecTest.cpp

 TEST(ArchSpecTest, Compatibility) {
   {
     ArchSpec A("x86_64-apple-macosx10.12");
     ArchSpec B("x86_64-apple-macosx10.12");
     ASSERT_TRUE(A.IsExactMatch(B));
     ASSERT_TRUE(A.IsCompatibleMatch(B));
   }
   {
-    // The version information is auxiliary to support availablity but
+    // The version information is auxiliary to support availability but
     // doesn't affect compatibility.
     ArchSpec A("x86_64-apple-macosx10.11");
     ArchSpec B("x86_64-apple-macosx10.12");
     ASSERT_TRUE(A.IsExactMatch(B));
     ASSERT_TRUE(A.IsCompatibleMatch(B));
   }
   {
     ArchSpec A("x86_64-apple-macosx10.13");

lldb/unittests/debugserver/CMakeLists.txt

 # Note: debugserver is a Darwin-only implementation of a remote debugging
 # server. It is not intended to be used on other platforms. The tests are here
-# because using the LLDB Host API is convienent and allows testing of both parts
+# because using the LLDB Host API is convenient and allows testing of both parts
 # of the debugserver communication path. If you are looking for a non-darwin
 # remote debugging server, please use lldb-server.
 
 include_directories(${LLDB_SOURCE_DIR}/tools/debugserver/source
                     ${LLDB_SOURCE_DIR}/tools/debugserver/source/MacOSX)
 
 add_lldb_unittest(debugserverTests
   JSONTest.cpp