Typo fixes.

[brucem]

A couple of additional fixes.

include/lldb/Breakpoint/BreakpointID.h

public:
   void GetDescription(Stream *s, lldb::DescriptionLevel level);
 
   static bool IsRangeIdentifier(llvm::StringRef str);
   static bool IsValidIDExpression(llvm::StringRef str);
   static llvm::ArrayRef<llvm::StringRef> GetRangeSpecifiers();
 
   //------------------------------------------------------------------
   /// Takes an input string containing the description of a breakpoint or
-  /// breakpoint and location and returns the a BreakpointID filled out with
+  /// breakpoint and location and returns a BreakpointID filled out with
   /// the proper id and location.
   ///
   /// @param[in] input
   ///     A string containing JUST the breakpoint description.
   /// @return
   ///     If \p input was not a valid breakpoint ID string, returns
   ///     \b llvm::None.  Otherwise returns a BreakpointID with members filled
   ///     out accordingly.

include/lldb/Core/Address.h

#endif
   bool IsSectionOffset() const {
     return IsValid() && (GetSection().get() != nullptr);
   }
 
   //------------------------------------------------------------------
   /// Check if the object state is valid.
   ///
   /// A valid Address object contains either a section pointer and
-  /// and offset (for section offset based addresses), or just a valid offset
+  /// offset (for section offset based addresses), or just a valid offset
   /// (for absolute addresses that have no section).
   ///
   /// @return
   ///     Returns \b true if the offset is valid, \b false
   ///     otherwise.
   //------------------------------------------------------------------
   bool IsValid() const { return m_offset != LLDB_INVALID_ADDRESS; }
 
   //------------------------------------------------------------------
   /// Get the memory cost of this object.
   ///
   /// @return
   ///     The number of bytes that this object occupies in memory.
   //------------------------------------------------------------------
   size_t MemorySize() const;
 
   //------------------------------------------------------------------
   /// Resolve a file virtual address using a section list.
   ///
-  /// Given a list of sections, attempt to resolve \a addr as a an offset into
+  /// Given a list of sections, attempt to resolve \a addr as an offset into
   /// one of the file sections.
   ///
   /// @return
   ///     Returns \b true if \a addr was able to be resolved, \b false
   ///     otherwise.
   //------------------------------------------------------------------
   bool ResolveAddressUsingFileSections(lldb::addr_t addr,
                                        const SectionList *sections);

include/lldb/Core/Broadcaster.h

protected:
     //------------------------------------------------------------------
     typedef llvm::SmallVector<std::pair<lldb::ListenerWP, uint32_t>, 4>
         collection;
     typedef std::map<uint32_t, std::string> event_names_map;
 
     llvm::SmallVector<std::pair<lldb::ListenerSP, uint32_t &>, 4>
     GetListeners();
 
-    Broadcaster &m_broadcaster;    ///< The broadcsater that this implements
+    Broadcaster &m_broadcaster;    ///< The broadcaster that this implements
     event_names_map m_event_names; ///< Optionally define event names for
                                    ///readability and logging for each event bit
     collection m_listeners; ///< A list of Listener / event_mask pairs that are
                             ///listening to this broadcaster.
     std::recursive_mutex
         m_listeners_mutex; ///< A mutex that protects \a m_listeners.
     std::vector<lldb::ListenerSP> m_hijacking_listeners; // A simple mechanism
                                                          // to intercept events

include/lldb/Target/ExecutionContext.h

 /// global or static variable might refer to a target since a stack frame
 /// isn't required in order to evaluate a global or static variable (a process
 /// isn't necessarily needed for a global variable since we might be able to
 /// read the variable value from a data section in one of the object files in
 /// a target). There are two types of objects that hold onto execution
 /// contexts: ExecutionContextRef and ExecutionContext. Both of these objects
 /// are described below.
 ///
-/// Not all objects in an ExectionContext objects will be valid. If you want
-/// to refer strongly (ExectionContext) or weakly (ExectionContextRef) to a
+/// Not all objects in an ExecutionContext objects will be valid. If you want
+/// to refer strongly (ExecutionContext) or weakly (ExecutionContextRef) to a
 /// process, then only the process and target references will be valid. For
 /// threads, only the thread, process and target references will be filled in.
 /// For frames, all of the objects will be filled in.
 ///
 /// These classes are designed to be used as baton objects that get passed to
 /// a wide variety of functions that require execution contexts.
 //===----------------------------------------------------------------------===//
 

include/lldb/Target/Process.h

#endif // SWIG
 
   //------------------------------------------------------------------
   /// Return a multi-word command object that can be used to expose plug-in
   /// specific commands.
   ///
   /// This object will be used to resolve plug-in commands and can be
   /// triggered by a call to:
   ///
-  ///     (lldb) process commmand <args>
+  ///     (lldb) process command <args>
   ///
   /// @return
   ///     A CommandObject which can be one of the concrete subclasses
   ///     of CommandObject like CommandObjectRaw, CommandObjectParsed,
   ///     or CommandObjectMultiword.
   //------------------------------------------------------------------
   virtual CommandObject *GetPluginCommandObject() { return nullptr; }
 

include/lldb/Utility/ArchSpec.h

public:
   //---------------------------------------------------------------------------
   static bool ContainsOnlyArch(const llvm::Triple &normalized_triple);
 
   static size_t AutoComplete(llvm::StringRef name, StringList &matches);
 
   //------------------------------------------------------------------
   /// Returns a static string representing the current architecture.
   ///
-  /// @return A static string correcponding to the current
+  /// @return A static string corresponding to the current
   ///         architecture.
   //------------------------------------------------------------------
   const char *GetArchitectureName() const;
 
   //-----------------------------------------------------------------
   /// if MIPS architecture return true.
   ///
   ///  @return a boolean value.
public:
   /// The default value of 0 was chosen to from the ELF spec value
   /// ELFOSABI_NONE.  ELF is the only one using this parameter.  If another
   /// format uses this parameter and 0 does not work, use a value over
   /// 255 because in the ELF header this is value is only a byte.
   ///
   /// @return True if the object, and CPU were successfully set.
   ///
   /// As a side effect, the vendor value is usually set to unknown. The
-  /// exections are
+  /// exceptions are
   ///   aarch64-apple-ios
   ///   arm-apple-ios
   ///   thumb-apple-ios
   ///   x86-apple-
   ///   x86_64-apple-
   ///
   /// As a side effect, the os value is usually set to unknown The exceptions
   /// are
public:
   /// Architecture code byte width accessor
   ///
   /// @return the size in 8-bit (host) bytes of a minimum addressable unit
   /// from the Architecture's code bus
   //------------------------------------------------------------------
   uint32_t GetCodeByteSize() const;
 
   //------------------------------------------------------------------
-  /// Architecture tripple accessor.
+  /// Architecture triple accessor.
   ///
   /// @return A triple describing this ArchSpec.
   //------------------------------------------------------------------
   llvm::Triple &GetTriple() { return m_triple; }
 
   //------------------------------------------------------------------
-  /// Architecture tripple accessor.
+  /// Architecture triple accessor.
   ///
   /// @return A triple describing this ArchSpec.
   //------------------------------------------------------------------
   const llvm::Triple &GetTriple() const { return m_triple; }
 
   void DumpTriple(Stream &s) const;
 
   //------------------------------------------------------------------
-  /// Architecture tripple setter.
+  /// Architecture triple setter.
   ///
   /// Configures this ArchSpec according to the given triple.  If the triple
   /// has unknown components in all of the vendor, OS, and the optional
   /// environment field (i.e. "i386-unknown-unknown") then default values are
   /// taken from the host.  Architecture and environment components are used
   /// to further resolve the CPU type and subtype, endian characteristics,
   /// etc.
   ///
   /// @return A triple describing this ArchSpec.
   //------------------------------------------------------------------
   bool SetTriple(const llvm::Triple &triple);
 
   bool SetTriple(llvm::StringRef triple_str);
 
   //------------------------------------------------------------------
   /// Returns the default endianness of the architecture.
   ///
   /// @return The endian enumeration for the default endianness of
   ///         the architecture.
   //------------------------------------------------------------------
   lldb::ByteOrder GetDefaultEndian() const;
 
   //------------------------------------------------------------------
-  /// Returns true if 'char' is a signed type by defualt in the architecture
+  /// Returns true if 'char' is a signed type by default in the architecture
   /// false otherwise
   ///
   /// @return True if 'char' is a signed type by default on the
   ///         architecture and false otherwise.
   //------------------------------------------------------------------
   bool CharIsSignedByDefault() const;
 
   //------------------------------------------------------------------

packages/Python/lldbsuite/test/functionalities/apropos_with_process/TestAproposWithProcess.py

 """
-Test that apropos env doesn't crash trying to touch the process plugin commmand
+Test that apropos env doesn't crash trying to touch the process plugin command
 """
 
 from __future__ import print_function
 
 
 import os
 import time
 import re
 import lldb
 from lldbsuite.test.lldbtest import *
 import lldbsuite.test.lldbutil as lldbutil
 
 
 class AproposWithProcessTestCase(TestBase):
 
     mydir = TestBase.compute_mydir(__file__)
 
     def setUp(self):
         # Call super's setUp().
         TestBase.setUp(self)
         # Find the line number to break inside main().
         self.line = line_number('main.cpp', '// break here')
 
     def test_apropos_with_process(self):
-        """Test that apropos env doesn't crash trying to touch the process plugin commmand."""
+        """Test that apropos env doesn't crash trying to touch the process plugin command."""
         self.build()
         exe = self.getBuildArtifact("a.out")
         self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET)
 
-        # Break in main() aftre the variables are assigned values.
+        # Break in main() after the variables are assigned values.
         lldbutil.run_break_set_by_file_and_line(
             self, "main.cpp", self.line, num_expected_locations=1, loc_exact=True)
 
         self.runCmd("run", RUN_SUCCEEDED)
 
         # The stop reason of the thread should be breakpoint.
         self.expect("thread list", STOPPED_DUE_TO_BREAKPOINT,
                     substrs=['stopped', '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'])
 
         self.runCmd('apropos env')

packages/Python/lldbsuite/test/functionalities/memory/find/TestMemoryFind.py

class MemoryFindTestCase(TestBase):
 
     @expectedFailureAll(oslist=["windows"])
     def test_memory_find(self):
         """Test the 'memory find' command."""
         self.build()
         exe = self.getBuildArtifact("a.out")
         self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET)
 
-        # Break in main() aftre the variables are assigned values.
+        # Break in main() after the variables are assigned values.
         lldbutil.run_break_set_by_file_and_line(
             self, "main.cpp", self.line, num_expected_locations=1, loc_exact=True)
 
         self.runCmd("run", RUN_SUCCEEDED)
 
         # The stop reason of the thread should be breakpoint.
         self.expect("thread list", STOPPED_DUE_TO_BREAKPOINT,
                     substrs=['stopped', 'stop reason = breakpoint'])

packages/Python/lldbsuite/test/functionalities/memory/read/TestMemoryRead.py

def setUp(self):
         self.line = line_number('main.cpp', '// Set break point at this line.')
 
     def test_memory_read(self):
         """Test the 'memory read' command with plain and vector formats."""
         self.build()
         exe = self.getBuildArtifact("a.out")
         self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET)
 
-        # Break in main() aftre the variables are assigned values.
+        # Break in main() after the variables are assigned values.
         lldbutil.run_break_set_by_file_and_line(
             self, "main.cpp", self.line, num_expected_locations=1, loc_exact=True)
 
         self.runCmd("run", RUN_SUCCEEDED)
 
         # The stop reason of the thread should be breakpoint.
         self.expect("thread list", STOPPED_DUE_TO_BREAKPOINT,
                     substrs=['stopped', 'stop reason = breakpoint'])

packages/Python/lldbsuite/test/functionalities/nested_alias/TestNestedAlias.py

def setUp(self):
         self.line = line_number('main.cpp', '// break here')
 
     def test_nested_alias(self):
         """Test that an alias can reference other aliases without crashing."""
         self.build()
         exe = self.getBuildArtifact("a.out")
         self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET)
 
-        # Break in main() aftre the variables are assigned values.
+        # Break in main() after the variables are assigned values.
         lldbutil.run_break_set_by_file_and_line(
             self, "main.cpp", self.line, num_expected_locations=1, loc_exact=True)
 
         self.runCmd("run", RUN_SUCCEEDED)
 
         # The stop reason of the thread should be breakpoint.
         self.expect("thread list", STOPPED_DUE_TO_BREAKPOINT,
                     substrs=['stopped', 'stop reason = breakpoint'])

packages/Python/lldbsuite/test/functionalities/thread/exit_during_break/main.cpp

 {
 
     // The first barrier waits for the non-exiting threads to start.
     // This thread will also participate in that barrier.
     // The idea here is to guarantee that the exiting thread will be
     // last in the internal list maintained by the debugger.
     pseudo_barrier_init(g_barrier1, 5);
 
-    // The second break synchronyizes thread exection with the breakpoint.
+    // The second break synchronizes thread execution with the breakpoint.
     pseudo_barrier_init(g_barrier2, 5);
 
     // The third barrier keeps the waiting threads around until the breakpoint
     // has been passed.
     pseudo_barrier_init(g_barrier3, 4);
 
     // Create a thread to hit the breakpoint
     std::thread thread_1(break_thread_func);

packages/Python/lldbsuite/test/lang/cpp/unsigned_types/TestUnsignedTypes.py

def test(self):
         """Test that variables with unsigned types display correctly."""
         self.build()
         exe = self.getBuildArtifact("a.out")
         self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET)
 
         # GCC puts a breakpoint on the last line of a multi-line expression, so
         # if GCC is the target compiler, we cannot rely on an exact line match.
         need_exact = "gcc" not in self.getCompiler()
-        # Break on line 19 in main() aftre the variables are assigned values.
+        # Break on line 19 in main() after the variables are assigned values.
         lldbutil.run_break_set_by_file_and_line(
             self,
             "main.cpp",
             self.line,
             num_expected_locations=-1,
             loc_exact=need_exact)
 
         self.runCmd("run", RUN_SUCCEEDED)

packages/Python/lldbsuite/test/lang/objc/bitfield_ivars/TestBitfieldIvars.py

 from lldbsuite.test import lldbinline
 from lldbsuite.test import decorators
 
 lldbinline.MakeInlineTest(
     __file__,
     globals(),
     [
-        # This is a Darwin-only failure related to incorrect expresssion-
+        # This is a Darwin-only failure related to incorrect expression-
         # evaluation for single-bit ObjC bitfields.
         decorators.skipUnlessDarwin,
         decorators.expectedFailureAll(
             bugnumber="rdar://problem/17990991")])

source/Commands/CommandObjectWatchpointCommand.cpp

 // CommandObjectWatchpointCommand
 //-------------------------------------------------------------------------
 
 CommandObjectWatchpointCommand::CommandObjectWatchpointCommand(
     CommandInterpreter &interpreter)
     : CommandObjectMultiword(
           interpreter, "command",
           "Commands for adding, removing and examining LLDB commands "
-          "executed when the watchpoint is hit (watchpoint 'commmands').",
+          "executed when the watchpoint is hit (watchpoint 'commands').",
           "command <sub-command> [<sub-command-options>] <watchpoint-id>") {
   CommandObjectSP add_command_object(
       new CommandObjectWatchpointCommandAdd(interpreter));
   CommandObjectSP delete_command_object(
       new CommandObjectWatchpointCommandDelete(interpreter));
   CommandObjectSP list_command_object(
       new CommandObjectWatchpointCommandList(interpreter));
 

source/Core/Communication.cpp

if (connection_sp) {
     // We currently don't protect connection_sp with any mutex for multi-
     // threaded environments. So lets not nuke our connection class without
     // putting some multi-threaded protections in. We also probably don't want
     // to pay for the overhead it might cause if every time we access the
     // connection we have to take a lock.
     //
     // This unique pointer will cleanup after itself when this object goes
     // away, so there is no need to currently have it destroy itself
-    // immediately upon disconnnect.
+    // immediately upon disconnect.
     // connection_sp.reset();
     return status;
   }
   return eConnectionStatusNoConnection;
 }
 
 bool Communication::IsConnected() const {
   lldb::ConnectionSP connection_sp(m_connection_sp);

source/Core/ValueObjectVariable.cpp

if (expr.Evaluate(&exe_ctx, nullptr, loclist_base_load_addr, nullptr,
         else
           SetAddressTypeOfChildren(eAddressTypeFile);
         break;
       case Value::eValueTypeHostAddress:
         // Same as above for load addresses, except children of pointer or refs
         // are always load addresses. Host addresses are used to store freeze
         // dried variables. If this type is a struct, the entire struct
         // contents will be copied into the heap of the
-        // LLDB process, but we do not currrently follow any pointers.
+        // LLDB process, but we do not currently follow any pointers.
         if (is_pointer_or_ref)
           SetAddressTypeOfChildren(eAddressTypeLoad);
         else
           SetAddressTypeOfChildren(eAddressTypeHost);
         break;
       case Value::eValueTypeLoadAddress:
       case Value::eValueTypeScalar:
       case Value::eValueTypeVector:

source/Expression/DWARFExpression.cpp

case DW_OP_bit_piece: // 0x9d ULEB128 bit size, ULEB128 bit offset (DWARF3);
         } break;
 
         case Value::eValueTypeFileAddress:
         case Value::eValueTypeLoadAddress:
         case Value::eValueTypeHostAddress:
           if (error_ptr) {
             error_ptr->SetErrorStringWithFormat(
                 "unable to extract DW_OP_bit_piece(bit_size = %" PRIu64
-                ", bit_offset = %" PRIu64 ") from an addresss value.",
+                ", bit_offset = %" PRIu64 ") from an address value.",
                 piece_bit_size, piece_bit_offset);
           }
           return false;
 
         case Value::eValueTypeVector:
           if (error_ptr) {
             error_ptr->SetErrorStringWithFormat(
                 "unable to extract DW_OP_bit_piece(bit_size = %" PRIu64

source/Plugins/Architecture/Arm/ArchitectureArm.cpp

 // and the condition doesn't pass. This can happen if you set a breakpoint on
 // an instruction that is conditional. We currently will _always_ stop on the
 // instruction which is bad. You can also run into this while single stepping
 // and you could appear to run code in the "if" and in the "else" clause
 // because it would stop at all of the conditional instructions in both. In
 // such cases, we really don't want to stop at this location.
 // I will check with the lldb-dev list first before I enable this.
 #if 0
-    // ARM mode: check for condition on intsruction
+    // ARM mode: check for condition on instruction
     const addr_t pc = reg_ctx_sp->GetPC();
     Status error;
     // If we fail to read the opcode we will get UINT64_MAX as the result in
     // "opcode" which we can use to detect if we read a valid opcode.
     const uint64_t opcode = thread.GetProcess()->ReadUnsignedIntegerFromMemory(pc, 4, UINT64_MAX, error);
     if (opcode <= UINT32_MAX)
     {
         const uint32_t condition = Bits32((uint32_t)opcode, 31, 28);

source/Plugins/ExpressionParser/Clang/ClangExpressionParser.cpp

lldb_private::Status ClangExpressionParser::PrepareForExecution(
   } else if (lldb::TargetSP target_sp = exe_ctx.GetTargetSP()) {
     sc.target_sp = target_sp;
   }
 
   LLVMUserExpression::IRPasses custom_passes;
   {
     auto lang = m_expr.Language();
     if (log)
-      log->Printf("%s - Currrent expression language is %s\n", __FUNCTION__,
+      log->Printf("%s - Current expression language is %s\n", __FUNCTION__,
                   Language::GetNameForLanguageType(lang));
     lldb::ProcessSP process_sp = exe_ctx.GetProcessSP();
     if (process_sp && lang != lldb::eLanguageTypeUnknown) {
       auto runtime = process_sp->GetLanguageRuntime(lang);
       if (runtime)
         runtime->GetIRPasses(custom_passes);
     }
   }

source/Plugins/LanguageRuntime/RenderScript/RenderScriptRuntime/RenderScriptRuntime.cpp

struct RenderScriptRuntime::Element {
   empirical_type<DataKind>
       type_kind; // Defines pixel type if Allocation is created from an image
   empirical_type<uint32_t>
       type_vec_size; // Vector size of each data point, e.g '4' for uchar4
   empirical_type<uint32_t> field_count; // Number of Subelements
   empirical_type<uint32_t> datum_size;  // Size of a single Element with padding
   empirical_type<uint32_t> padding;     // Number of padding bytes
   empirical_type<uint32_t>
-      array_size;        // Number of items in array, only needed for strucrs
+      array_size;        // Number of items in array, only needed for structs
   ConstString type_name; // Name of type, only needed for structs
 
   static const ConstString &
   GetFallbackStructName(); // Print this as the type name of a struct Element
                            // If we can't resolve the actual struct name
 
   bool ShouldRefresh() const {
     const bool valid_ptr = element_ptr.isValid() && *element_ptr.get() != 0x0;
for (uint32_t y = 0; y < dim_y; ++y) {
             (alloc->element.type_name != Element::GetFallbackStructName())) {
           // Here we are dumping an Element of struct type. This is done using
           // expression evaluation with the name of the struct type and pointer
           // to element. Don't print the name of the resulting expression,
           // since this will be '$[0-9]+'
           DumpValueObjectOptions expr_options;
           expr_options.SetHideName(true);
 
-          // Setup expression as derefrencing a pointer cast to element
+          // Setup expression as dereferencing a pointer cast to element
           // address.
           char expr_char_buffer[jit_max_expr_size];
           int written =
               snprintf(expr_char_buffer, jit_max_expr_size, "*(%s*) 0x%" PRIx64,
                        alloc->element.type_name.AsCString(),
                        *alloc->data_ptr.get() + offset);
 
           if (written < 0 || written >= jit_max_expr_size) {

source/Plugins/LanguageRuntime/RenderScript/RenderScriptRuntime/RenderScriptx86ABIFixups.cpp

llvm::FunctionType *cloneToStructRetFnTy(llvm::CallInst *call_inst) {
   assert(return_type_ptr_type &&
          "failed to get function return type PointerType");
   if (!return_type_ptr_type)
     return nullptr;
 
   if (log)
     log->Printf("%s - return type pointer type for StructRet clone @ '0x%p':\n",
                 __FUNCTION__, (void *)return_type_ptr_type);
-  // put the the sret pointer argument in place at the beginning of the
+  // put the sret pointer argument in place at the beginning of the
   // argument list.
   params.emplace(params.begin(), return_type_ptr_type);
   assert(params.size() == num_params + 1);
   return llvm::FunctionType::get(return_type_ptr_type, params,
                                  orig->isVarArg());
 }
 
 bool findRSCallSites(llvm::Module &module,

source/Plugins/Process/Linux/NativeRegisterContextLinux_arm.h

public:
   Status WriteRegister(const RegisterInfo *reg_info,
                        const RegisterValue &reg_value) override;
 
   Status ReadAllRegisterValues(lldb::DataBufferSP &data_sp) override;
 
   Status WriteAllRegisterValues(const lldb::DataBufferSP &data_sp) override;
 
   //------------------------------------------------------------------
-  // Hardware breakpoints/watchpoint mangement functions
+  // Hardware breakpoints/watchpoint management functions
   //------------------------------------------------------------------
 
   uint32_t NumSupportedHardwareBreakpoints() override;
 
   uint32_t SetHardwareBreakpoint(lldb::addr_t addr, size_t size) override;
 
   bool ClearHardwareBreakpoint(uint32_t hw_idx) override;
 
private:
 
   // Debug register info for hardware breakpoints and watchpoints management.
   struct DREG {
     lldb::addr_t address;  // Breakpoint/watchpoint address value.
     lldb::addr_t hit_addr; // Address at which last watchpoint trigger exception
                            // occurred.
     lldb::addr_t real_addr; // Address value that should cause target to stop.
     uint32_t control;       // Breakpoint/watchpoint control value.
-    uint32_t refcount;      // Serves as enable/disable and refernce counter.
+    uint32_t refcount;      // Serves as enable/disable and reference counter.
   };
 
   struct DREG m_hbr_regs[16]; // Arm native linux hardware breakpoints
   struct DREG m_hwp_regs[16]; // Arm native linux hardware watchpoints
 
   uint32_t m_max_hwp_supported;
   uint32_t m_max_hbp_supported;
   bool m_refresh_hwdebug_info;

source/Plugins/Process/Linux/NativeRegisterContextLinux_arm64.h

public:
   Status WriteRegister(const RegisterInfo *reg_info,
                        const RegisterValue &reg_value) override;
 
   Status ReadAllRegisterValues(lldb::DataBufferSP &data_sp) override;
 
   Status WriteAllRegisterValues(const lldb::DataBufferSP &data_sp) override;
 
   //------------------------------------------------------------------
-  // Hardware breakpoints/watchpoint mangement functions
+  // Hardware breakpoints/watchpoint management functions
   //------------------------------------------------------------------
 
   uint32_t NumSupportedHardwareBreakpoints() override;
 
   uint32_t SetHardwareBreakpoint(lldb::addr_t addr, size_t size) override;
 
   bool ClearHardwareBreakpoint(uint32_t hw_idx) override;
 
private:
 
   // Debug register info for hardware breakpoints and watchpoints management.
   struct DREG {
     lldb::addr_t address;  // Breakpoint/watchpoint address value.
     lldb::addr_t hit_addr; // Address at which last watchpoint trigger exception
                            // occurred.
     lldb::addr_t real_addr; // Address value that should cause target to stop.
     uint32_t control;       // Breakpoint/watchpoint control value.
-    uint32_t refcount;      // Serves as enable/disable and refernce counter.
+    uint32_t refcount;      // Serves as enable/disable and reference counter.
   };
 
   struct DREG m_hbr_regs[16]; // Arm native linux hardware breakpoints
   struct DREG m_hwp_regs[16]; // Arm native linux hardware watchpoints
 
   uint32_t m_max_hwp_supported;
   uint32_t m_max_hbp_supported;
   bool m_refresh_hwdebug_info;

source/Plugins/Process/Linux/NativeRegisterContextLinux_ppc64le.h

public:
   Status WriteRegister(const RegisterInfo *reg_info,
                        const RegisterValue &reg_value) override;
 
   Status ReadAllRegisterValues(lldb::DataBufferSP &data_sp) override;
 
   Status WriteAllRegisterValues(const lldb::DataBufferSP &data_sp) override;
 
   //------------------------------------------------------------------
-  // Hardware watchpoint mangement functions
+  // Hardware watchpoint management functions
   //------------------------------------------------------------------
 
   uint32_t NumSupportedHardwareWatchpoints() override;
 
   uint32_t SetHardwareWatchpoint(lldb::addr_t addr, size_t size,
                                  uint32_t watch_flags) override;
 
   bool ClearHardwareWatchpoint(uint32_t hw_index) override;

source/Plugins/Process/Linux/ProcessorTrace.h

 // Intel(R) Processor Trace on Linux OS. There is a map keeping track
 // of different tracing instances on each thread, which enables trace
 // gathering on a per thread level.
 //
 // The tracing instance is linked with a trace id. The trace id acts like
 // a key to the tracing instance and trace manipulations could be
 // performed using the trace id.
 //
-// The traace id could map to trace instances for a group of threads
+// The trace id could map to trace instances for a group of threads
 // (spanning to all the threads in the process) or a single thread.
 // The kernel interface for us is the perf_event_open.
 // ---------------------------------------------------------------------
 
 class ProcessorTraceMonitor;
 typedef std::unique_ptr<ProcessorTraceMonitor> ProcessorTraceMonitorUP;
 
 class ProcessorTraceMonitor {

source/Plugins/Process/MacOSX-Kernel/ProcessKDP.cpp

Status ProcessKDP::DoLaunch(Module *exe_module,
   return error;
 }
 
 Status
 ProcessKDP::DoAttachToProcessWithID(lldb::pid_t attach_pid,
                                     const ProcessAttachInfo &attach_info) {
   Status error;
   error.SetErrorString(
-      "attach to process by ID is not suppported in kdp remote debugging");
+      "attach to process by ID is not supported in kdp remote debugging");
   return error;
 }
 
 Status
 ProcessKDP::DoAttachToProcessWithName(const char *process_name,
                                       const ProcessAttachInfo &attach_info) {
   Status error;
   error.SetErrorString(
-      "attach to process by name is not suppported in kdp remote debugging");
+      "attach to process by name is not supported in kdp remote debugging");
   return error;
 }
 
 void ProcessKDP::DidAttach(ArchSpec &process_arch) {
   Process::DidAttach(process_arch);
 
   Log *log(ProcessKDPLog::GetLogIfAllCategoriesSet(KDP_LOG_PROCESS));
   if (log)
void ProcessKDP::RefreshStateAfterStop() {
   m_thread_list.RefreshStateAfterStop();
 }
 
 Status ProcessKDP::DoHalt(bool &caused_stop) {
   Status error;
 
   if (m_comm.IsRunning()) {
     if (m_destroy_in_process) {
-      // If we are attemping to destroy, we need to not return an error to Halt
+      // If we are attempting to destroy, we need to not return an error to Halt
       // or DoDestroy won't get called. We are also currently running, so send
       // a process stopped event
       SetPrivateState(eStateStopped);
     } else {
       error.SetErrorString("KDP cannot interrupt a running kernel");
     }
   }
   return error;
if (m_comm.IsConnected())
     return m_comm.SendRequestWriteMemory(addr, buf, size, error);
   error.SetErrorString("not connected");
   return 0;
 }
 
 lldb::addr_t ProcessKDP::DoAllocateMemory(size_t size, uint32_t permissions,
                                           Status &error) {
   error.SetErrorString(
-      "memory allocation not suppported in kdp remote debugging");
+      "memory allocation not supported in kdp remote debugging");
   return LLDB_INVALID_ADDRESS;
 }
 
 Status ProcessKDP::DoDeallocateMemory(lldb::addr_t addr) {
   Status error;
   error.SetErrorString(
-      "memory deallocation not suppported in kdp remote debugging");
+      "memory deallocation not supported in kdp remote debugging");
   return error;
 }
 
 Status ProcessKDP::EnableBreakpointSite(BreakpointSite *bp_site) {
   if (m_comm.LocalBreakpointsAreSupported()) {
     Status error;
     if (!bp_site->IsEnabled()) {
       if (m_comm.SendRequestBreakpoint(true, bp_site->GetLoadAddress())) {
if (m_comm.LocalBreakpointsAreSupported()) {
     return error;
   }
   return DisableSoftwareBreakpoint(bp_site);
 }
 
 Status ProcessKDP::EnableWatchpoint(Watchpoint *wp, bool notify) {
   Status error;
   error.SetErrorString(
-      "watchpoints are not suppported in kdp remote debugging");
+      "watchpoints are not supported in kdp remote debugging");
   return error;
 }
 
 Status ProcessKDP::DisableWatchpoint(Watchpoint *wp, bool notify) {
   Status error;
   error.SetErrorString(
-      "watchpoints are not suppported in kdp remote debugging");
+      "watchpoints are not supported in kdp remote debugging");
   return error;
 }
 
 void ProcessKDP::Clear() { m_thread_list.Clear(); }
 
 Status ProcessKDP::DoSignal(int signo) {
   Status error;
   error.SetErrorString(
-      "sending signals is not suppported in kdp remote debugging");
+      "sending signals is not supported in kdp remote debugging");
   return error;
 }
 
 void ProcessKDP::Initialize() {
   static llvm::once_flag g_once_flag;
 
   llvm::call_once(g_once_flag, []() {
     PluginManager::RegisterPlugin(GetPluginNameStatic(),

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

 
 static StructuredData::ObjectSP
 ParseStructuredDataPacket(llvm::StringRef packet) {
   Log *log(ProcessGDBRemoteLog::GetLogIfAllCategoriesSet(GDBR_LOG_PROCESS));
 
   if (!packet.consume_front(s_async_json_packet_prefix)) {
     if (log) {
       log->Printf(
-          "GDBRemoteCommmunicationClientBase::%s() received $J packet "
+          "GDBRemoteCommunicationClientBase::%s() received $J packet "
           "but was not a StructuredData packet: packet starts with "
           "%s",
           __FUNCTION__,
           packet.slice(0, strlen(s_async_json_packet_prefix)).str().c_str());
     }
     return StructuredData::ObjectSP();
   }
 

source/Plugins/StructuredData/DarwinLog/StructuredDataDarwinLog.cpp

 
 const char *const s_filter_attributes[] = {
     "activity",       // current activity
     "activity-chain", // entire activity chain, each level separated by ':'
     "category",       // category of the log message
     "message",        // message contents, fully expanded
     "subsystem"       // subsystem of the log message
 
-    // Consider impelmenting this action as it would be cheaper to filter.
+    // Consider implementing this action as it would be cheaper to filter.
     // "message" requires always formatting the message, which is a waste of
     // cycles if it ends up being rejected. "format",      // format string
     // used to format message text
 };
 
 static const ConstString &GetDarwinLogTypeName() {
   static const ConstString s_key_name("DarwinLog");
   return s_key_name;
static OptionDefinition g_enable_option_table[] = {
      "message.  The timestamp is relative to the first displayed "
      "message."},
     {LLDB_OPT_SET_ALL, false, "subsystem", 's', OptionParser::eNoArgument,
      nullptr, nullptr, 0, eArgTypeNone,
      "Include the subsystem in the the message header when displaying "
      "a log message."},
     {LLDB_OPT_SET_ALL, false, "category", 'c', OptionParser::eNoArgument,
      nullptr, nullptr, 0, eArgTypeNone,
-     "Include the category in the the message header when displaying "
+     "Include the category in the message header when displaying "
      "a log message."},
     {LLDB_OPT_SET_ALL, false, "activity-chain", 'C', OptionParser::eNoArgument,
      nullptr, nullptr, 0, eArgTypeNone,
-     "Include the activity parent-child chain in the the message header "
+     "Include the activity parent-child chain in the message header "
      "when displaying a log message.  The activity hierarchy is "
      "displayed as {grandparent-activity}:"
      "{parent-activity}:{activity}[:...]."},
     {LLDB_OPT_SET_ALL, false, "all-fields", 'A', OptionParser::eNoArgument,
      nullptr, nullptr, 0, eArgTypeNone,
      "Shortcut to specify that all header fields should be displayed."}};
 
 class EnableOptions : public Options {
StructuredData::DictionarySP BuildConfigurationData(bool enabled) {
 
     // Handle source stream flags.
     auto source_flags_sp =
         StructuredData::DictionarySP(new StructuredData::Dictionary());
     config_sp->AddItem("source-flags", source_flags_sp);
 
     source_flags_sp->AddBooleanItem("any-process", m_include_any_process);
     source_flags_sp->AddBooleanItem("debug-level", m_include_debug_level);
-    // The debug-level flag, if set, im␓plies info-level.
+    // The debug-level flag, if set, implies info-level.
     source_flags_sp->AddBooleanItem("info-level", m_include_info_level ||
                                                       m_include_debug_level);
     source_flags_sp->AddBooleanItem("live-stream", m_live_stream);
 
     // Specify default filter rule (the fall-through)
     config_sp->AddBooleanItem("filter-fall-through-accepts",
                               m_filter_fall_through_accepts);
 
bool DoExecute(Args &command, CommandReturnObject &result) override {
     // Report results.
     if (!error.Success()) {
       result.AppendError(error.AsCString());
       result.SetStatus(eReturnStatusFailed);
       // Our configuration failed, so we're definitely disabled.
       plugin.SetEnabled(false);
     } else {
       result.SetStatus(eReturnStatusSuccessFinishNoResult);
-      // Our configuration succeeeded, so we're enabled/disabled per whichever
+      // Our configuration succeeded, so we're enabled/disabled per whichever
       // one this command is setup to do.
       plugin.SetEnabled(m_enable);
     }
     return result.Succeeded();
   }
 
   Options *GetOptions() override {
     // We don't have options when this represents disable.
Status StructuredDataDarwinLog::FilterLaunchInfo(ProcessLaunchInfo &launch_info,
 
   // If we're not debugging this launched process, there's nothing for us to do
   // here.
   if (!launch_info.GetFlags().AnySet(eLaunchFlagDebug))
     return error;
 
   // Darwin os_log() support automatically adds debug-level and info-level
   // messages when a debugger is attached to a process.  However, with
-  // integrated suppport for debugging built into the command-line LLDB, the
+  // integrated support for debugging built into the command-line LLDB, the
   // user may specifically set to *not* include debug-level and info-level
   // content.  When the user is using the integrated log support, we want to
   // put the kabosh on that automatic adding of info and debug level. This is
   // done by adding an environment variable to the process on launch. (This
   // also means it is not possible to suppress this behavior if attaching to an
   // already-running app).
   // Log *log(GetLogIfAnyCategoriesSet(LIBLLDB_LOG_PLATFORM));
 

source/Plugins/UnwindAssembly/InstEmulation/UnwindAssemblyInstEmulation.cpp

if (disasm_sp) {
                 inst->GetAddress().GetFileAddress() - base_addr;
             auto it = saved_unwind_states.upper_bound(current_offset);
             assert(it != saved_unwind_states.begin() &&
                    "Unwind row for the function entry missing");
             --it; // Move it to the row corresponding to the current offset
 
             // If the offset of m_curr_row don't match with the offset we see
             // in saved_unwind_states then we have to update m_curr_row and
-            // m_register_values based on the saved values. It is happenning
+            // m_register_values based on the saved values. It is happening
             // after we processed an epilogue and a return to caller
             // instruction.
             if (it->second.first->GetOffset() != m_curr_row->GetOffset()) {
               UnwindPlan::Row *newrow = new UnwindPlan::Row;
               *newrow = *it->second.first;
               m_curr_row.reset(newrow);
               m_register_values = it->second.second;
             }
if (disasm_sp) {
                     true; // The last instruction might already
                           // created a row for this offset and
                           // we want to overwrite it.
                 unwind_plan.InsertRow(
                     std::make_shared<UnwindPlan::Row>(*m_curr_row),
                     replace_existing);
               }
 
-              // We are starting a new conditional block at the catual offset
+              // We are starting a new conditional block at the actual offset
               condition_block_start_offset = current_offset;
             }
 
             if (log && log->GetVerbose()) {
               StreamString strm;
               lldb_private::FormatEntity::Entry format;
               FormatEntity::Parse("${frame.pc}: ", format);
               inst->Dump(&strm, inst_list.GetMaxOpcocdeByteSize(), show_address,
if (disasm_sp) {
                    {newrow, m_register_values}});
               unwind_plan.InsertRow(newrow);
             }
 
             // Were there any changes to the CFI while evaluating this
             // instruction?
             if (m_curr_row_modified) {
               // Save the modified row if we don't already have a CFI row in
-              // the currennt address
+              // the current address
               if (saved_unwind_states.count(
                       current_offset + inst->GetOpcode().GetByteSize()) == 0) {
                 m_curr_row->SetOffset(current_offset +
                                       inst->GetOpcode().GetByteSize());
                 unwind_plan.InsertRow(m_curr_row);
                 saved_unwind_states.insert(
                     {current_offset + inst->GetOpcode().GetByteSize(),
                      {m_curr_row, m_register_values}});

source/Target/TargetList.cpp

Status TargetList::CreateTargetInternal(
   }
 
   ArchSpec platform_arch(arch);
 
   bool prefer_platform_arch = false;
 
   CommandInterpreter &interpreter = debugger.GetCommandInterpreter();
 
-  // let's see if there is already an existing plaform before we go creating
+  // let's see if there is already an existing platform before we go creating
   // another...
   platform_sp = debugger.GetPlatformList().GetSelectedPlatform();
 
   if (platform_options && platform_options->PlatformWasSpecified()) {
     // Create a new platform if it doesn't match the selected platform
     if (!platform_options->PlatformMatches(platform_sp)) {
       const bool select_platform = true;
       platform_sp = platform_options->CreatePlatformWithOptions(
if (num_specs > 0) {
                 break;
               }
             } else {
               platform_ptr = the_platform_sp.get();
             }
           }
 
           if (platform_ptr) {
-            // All platforms for all modules in the exectuable match, so we can
+            // All platforms for all modules in the executable match, so we can
             // select this platform
             platform_sp = platforms.front();
           } else if (more_than_one_platforms == false) {
             // No platforms claim to support this file
             error.SetErrorString("No matching platforms found for this file, "
                                  "specify one with the --platform option");
             return error;
           } else {

source/Utility/Status.cpp

 
 //----------------------------------------------------------------------
 // Returns true if this object contains a value that describes an error or
 // otherwise non-success result.
 //----------------------------------------------------------------------
 bool Status::Fail() const { return m_code != 0; }
 
 //----------------------------------------------------------------------
-// Set accesssor for the error value to "err" and the type to
+// Set accessor for the error value to "err" and the type to
 // "eErrorTypeMachKernel"
 //----------------------------------------------------------------------
 void Status::SetMachError(uint32_t err) {
   m_code = err;
   m_type = eErrorTypeMachKernel;
   m_string.clear();
 }
 
if (format != nullptr && format[0]) {
     m_string.clear();
   }
   m_code = result;
   m_type = eErrorTypeExpression;
   return length;
 }
 
 //----------------------------------------------------------------------
-// Set accesssor for the error value and type.
+// Set accessor for the error value and type.
 //----------------------------------------------------------------------
 void Status::SetError(ValueType err, ErrorType type) {
   m_code = err;
   m_type = type;
   m_string.clear();
 }
 
 //----------------------------------------------------------------------

tools/debugserver/source/MacOSX/MachProcess.mm

bool MachProcess::Detach() {
   int ret = ::ptrace(PT_DETACH, pid, (caddr_t)1, 0);
   DNBError err(errno, DNBError::POSIX);
   if (DNBLogCheckLogBit(LOG_PROCESS) || err.Fail() || (ret != 0))
     err.LogThreaded("::ptrace (PT_DETACH, %u, (caddr_t)1, 0)", pid);
 
   // Resume our task
   m_task.Resume();
 
-  // NULL our task out as we have already retored all exception ports
+  // NULL our task out as we have already restored all exception ports
   m_task.Clear();
 
   // Clear out any notion of the process we once were
   const bool detaching = true;
   Clear(detaching);
 
   SetState(eStateDetached);
 
if (break_op_size > 0) {
       uint8_t curr_break_op[break_op_size];
       bool break_op_found = false;
 
       // Read the breakpoint opcode
       if (m_task.ReadMemory(addr, break_op_size, curr_break_op) ==
           break_op_size) {
         bool verify = false;
         if (bp->IsEnabled()) {
-          // Make sure we have the a breakpoint opcode exists at this address
+          // Make sure a breakpoint opcode exists at this address
           if (memcmp(curr_break_op, break_op, break_op_size) == 0) {
             break_op_found = true;
             // We found a valid breakpoint opcode at this address, now restore
             // the saved opcode.
             if (m_task.WriteMemory(addr, break_op_size,
                                    bp->SavedOpcodeBytes()) == break_op_size) {
               verify = true;
             } else {

tools/debugserver/source/RNBServices.cpp

for (i = 0; i < num_proc_infos; i++) {
 
       // Get the process id for the app (if there is one)
       const int32_t pid_int32 = pid;
       CFReleaser<CFNumberRef> pidCFNumber(
           ::CFNumberCreate(alloc, kCFNumberSInt32Type, &pid_int32));
       ::CFDictionarySetValue(appInfoDict.get(), DTSERVICES_APP_PID_KEY,
                              pidCFNumber.get());
 
-      // Set the a boolean to indicate if this is the front most
+      // Set a boolean to indicate if this is the front most
       ::CFDictionarySetValue(appInfoDict.get(), DTSERVICES_APP_FRONTMOST_KEY,
                              kCFBooleanFalse);
 
       const char *pid_basename = proc_info.kp_proc.p_comm;
       char proc_path_buf[PATH_MAX];
 
       int return_val = proc_pidpath(pid, proc_path_buf, PATH_MAX);
       if (return_val > 0) {
for (i = 0; i < count; i++) {
       if (::SBSProcessIDForDisplayIdentifier((CFStringRef)displayIdentifier,
                                              &pid) == true) {
         CFReleaser<CFNumberRef> pidCFNumber(
             ::CFNumberCreate(alloc, kCFNumberSInt32Type, &pid));
         ::CFDictionarySetValue(appInfoDict.get(), DTSERVICES_APP_PID_KEY,
                                pidCFNumber.get());
       }
 
-      // Set the a boolean to indicate if this is the front most
+      // Set a boolean to indicate if this is the front most
       if (sbsFrontAppID.get() && displayIdentifier &&
           (::CFStringCompare(sbsFrontAppID.get(), displayIdentifier, 0) ==
            kCFCompareEqualTo))
         ::CFDictionarySetValue(appInfoDict.get(), DTSERVICES_APP_FRONTMOST_KEY,
                                kCFBooleanTrue);
       else
         ::CFDictionarySetValue(appInfoDict.get(), DTSERVICES_APP_FRONTMOST_KEY,
                                kCFBooleanFalse);

tools/lldb-mi/MICmnResources.cpp

CMICmnResources::ms_pResourceId2TextData[] = {
         {IDS_CMD_ERR_GDBSET_OPT_PRINT_UNKNOWN_OPTION,
          "'print' error. The option '%s' not found"},
         {IDS_CMD_ERR_GDBSHOW_OPT_PRINT_BAD_ARGS,
          "'print' expects option-name and \"on\" or \"off\""},
         {IDS_CMD_ERR_GDBSHOW_OPT_PRINT_UNKNOWN_OPTION,
          "'print' error. The option '%s' not found"},
         {IDS_CMD_ERR_EXPR_INVALID, "Failed to evaluate expression: %s"},
         {IDS_CMD_ERR_ATTACH_FAILED,
-         "Command '%s'. Attach to processs failed: %s"},
+         "Command '%s'. Attach to process failed: %s"},
         {IDS_CMD_ERR_ATTACH_BAD_ARGS,
          "Command '%s'. Must specify either a PID or a Name"}};
 
 //++
 //------------------------------------------------------------------------------------
 // Details: CMICmnResources constructor.
 // Type:    Method.
 // Args:    None.

tools/lldb-mi/MIReadMe.txt

 ========================================================================
     The MI Driver - LLDB Machine Interface V2 (MI)  Project Overview
 ========================================================================
 
 The MI Driver is a stand alone executable that either be used via a 
 client i.e. Eclipse or directly from the command line. 
 
 For help information on using the MI driver type at the command line:
 
   lldb-mi --interpreter --help
 
-A blog about the MI Driver is available on CodePlay's website. ALthough it may not be
+A blog about the MI Driver is available on CodePlay's website. Although it may not be
 completely accurate after the recent changes in lldb-mi.
 http://www.codeplay.com/portal/lldb-mi-driver---part-1-introduction
 
 In MI mode and invoked with --log option, lldb-mi generates lldb-mi-log.txt 
 This file keeps a history of the MI Driver's activity for one session. It is
 used to aid the debugging of the MI Driver. It also gives warnings about
 command's which do not support certain argument or options.  
 
 Note any command or text sent to the MI Driver in MI mode that is not a command 
-registered in the MI Driver's Command Factory will be rejected and an error messsage
+registered in the MI Driver's Command Factory will be rejected and an error message
 will be generated.
 
 All the files prefix with MI are specifically for the MI driver code only.
 File MIDriverMain.cpp contains the executables main() function.
 
 =========================================================================
 Current limitations:
 1. Not all commands and their options have been implemented. Please see
 the source code for details.
-2. LLDB-MI may have additinal arguments not used in GDB MI. Please see
-MIExtesnsions.txt
+2. LLDB-MI may have additional arguments not used in GDB MI. Please see
+MIExtensions.txt
 
 =========================================================================
 The MI Driver build configuration:
 MICmnConfig.h defines various preprocessor build options.

www/remote.html

<div id="content">
             </code>
             <p>
               The default platform is the platform <code>host</code> which is used for local
               debugging. Apart from this, the list should contain a number of plug-ins, for
               debugging different kinds of systems. The remote plug-ins are prefixed with
               "<code>remote-</code>". For example, to debug a remote Linux application:
             <br>
             <code>
-              <br>(lldb) <b>patform select remote-linux</b>
+              <br>(lldb) <b>platform select remote-linux</b>
             </code>
 
             <p>
               After selecting the platform plug-in, you should receive a prompt which confirms
               the selected platform, and states that you are not connected. This is because
               remote plug-ins need to be connected to their remote platform counterpart to
               operate. This is achieved using the <code>platform connect</code> command. This
               command takes a number of arguments (as always, use the <code>help</code> command
<div id="content">
             <p>
               If we run again, the program will be installed into /usr/local/bin.
             </p>
 
 
             <h4>Install and run by specifying a remote install path</h4>
             <p>
               If you want the "a.out" executable to be installed into
-              "/bin/a.out" instead of the platorm's current working directory,
+              "/bin/a.out" instead of the platform's current working directory,
               we can set the platform file specification using python:
             <br>
             <code>
               <br>(lldb) <b>file a.out</b>
               <br>(lldb) <b>script lldb.target.module['a.out'].SetPlatformFileSpec("/bin/a.out")</b>
               <br>(lldb) <b>run</b>
             </code>
             <p>
               Now when you run your program, the program will be uploaded to
-              "/bin/a.out" instead of the the platform current working directory.
+              "/bin/a.out" instead of the platform current working directory.
               Only the main executable is uploaded to the remote system by
               default when launching the application. If you have shared
               libraries that should also be uploaded, then you can add the
               locally build shared library to the current target and set its
               platform file specification:
             </p>
             <code>
               <br>(lldb) <b>file a.out</b>

www/tutorial.html

<div id="middle">
                    <p>To set a breakpoint on a function named <code>foo</code> in LLDB you can enter either of:</p>
 
                     <code>
                         (lldb) breakpoint set --name foo
                         <br>(lldb) breakpoint set -n foo
                     </code>
 
                    <p>You can use the --name option multiple times to make a breakpoint on a set of functions as well.  This is convenient
-                      since it allows you to set commmon conditions or commands without having to specify them multiple times:</p>
+                      since it allows you to set common conditions or commands without having to specify them multiple times:</p>
 
                     <code>
                         (lldb) breakpoint set --name foo --name bar
                     </code>
 
                    <p>Setting breakpoints by name is even more specialized in LLDB as you can specify
                        that you want to set a breakpoint at a function by method name. To set a breakpoint
                        on all C++ methods named <code>foo</code> you can enter either of:</p>