[lldb] Fix typos.

[teemperor]

LGTM but could you split out the non-NFC change (and then you can also mark this whole commit as NFC). I'm just going to accept this module that change.

lldb/source/API/SBDebugger.cpp

164

Can you clang-format and move this into its own patch (it's not really a NFC typo).

[brucem]

Remove incorrect change.

[brucem]

Mark as NFC.

[teemperor]

I assume you don't have requested commit access yet (?) so I'm going to land this for you. Thanks for the patch!

[brucem]

I had requested it and got it a short bit ago. Looks like I landed it successfully. Thanks for the review!

lldb/docs/design/overview.rst

 - ABI for function calling in process being debugged
 - Execution context batons
 
 Utility
 -------
 
 This module contains the lowest layers of LLDB. A lot of these classes don't
 really have anything to do with debugging -- they are just there because the
-higher layers of the debugger use these clasess to implement their
+higher layers of the debugger use these classes to implement their
 functionality. Others are data structures used in many other parts of the
 debugger (TraceOptions). Most of the functionality in this module could be
 useful in an application that is not a debugger; however, providing a general
 purpose C++ library is an explicit non-goal of this module.
 
 This module provides following functionality:
 
 - Abstract path manipulation (FileSpec)

lldb/docs/resources/test.rst

 On the same topic, another interesting aspect of the shell tests is that there
 you can often get away with a broken or incomplete binary, whereas the API
 tests almost always require a fully functional executable. This enables testing
 of (some) aspects of handling of binaries with non-native architectures or
 operating systems.
 
 Finally, the shell tests always run in batch mode. You start with some input
 and the test verifies the output. The debugger can be sensitive to its
-environment, such as the the platform it runs on. It can be hard to express
+environment, such as the platform it runs on. It can be hard to express
 that the same test might behave slightly differently on macOS and Linux.
 Additionally, the debugger is an interactive tool, and the shell test provide
 no good way of testing those interactive aspects, such as tab completion for
 example.
 
 API Tests
 `````````
 

lldb/docs/status/projects.rst

 for research and 3rd party uses.
 
 Use instruction emulation to reduce the overhead for breakpoints
 ----------------------------------------------------------------
 
 At present, breakpoints are implemented by inserting a trap instruction, then
 when the trap is hit, replace the trap with the actual instruction and single
 step. Then swap back and continue. This causes problems for read only text, and
-also means that no-stop debugging ust either stop all threads briefly to handle
+also means that no-stop debugging must either stop all threads briefly to handle
 this two-step or risk missing some breakpoint hits. If you emulated the
 instruction and wrote back the results, you wouldn't have these problems, and
 it would also save a stop per breakpoint hit. Since we use breakpoints to
 implement stepping, this savings could be significant on slow connections.
 
 Use the JIT to speed up conditional breakpoint evaluation
 ---------------------------------------------------------
 

lldb/docs/use/python-reference.rst

 gets done.
 
 The other function is specifying to the Searcher at what depth in the above
 described recursion it wants to be called. Setting a search depth also provides
 a stop for the recursion. For instance, if you request a Module depth search,
 then the callback will be called for each Module as it gets added to the
 Target, but the searcher will not recurse into the Compile Units in the module.
 
-One other slight sublety is that the depth at which you get called back is not
-necessarily the depth at which the the SearchFilter is specified. For instance,
+One other slight subtlety is that the depth at which you get called back is not
+necessarily the depth at which the SearchFilter is specified. For instance,
 if you are doing symbol searches, it is convenient to use the Module depth for
 the search, since symbols are stored in the module. But the SearchFilter might
 specify some subset of CompileUnits, so not all the symbols you might find in
 each module will pass the search. You don't need to handle this situation
 yourself, since SBBreakpoint::AddLocation will only add locations that pass the
 Search Filter. This API returns an SBError to inform you whether your location
 was added.
 

lldb/examples/python/process_events.py

parser.add_option(
         dest='env_vars',
         help='Environment variables to set in the inferior process when launching a process.')
     parser.add_option(
         '-d',
         '--working-dir',
         type='string',
         metavar='DIR',
         dest='working_dir',
-        help='The the current working directory when launching a process.',
+        help='The current working directory when launching a process.',
         default=None)
     parser.add_option(
         '-p',
         '--attach-pid',
         type='int',
         dest='attach_pid',
         metavar='PID',
         help='Specify a process to attach to by process ID.',

lldb/include/lldb/Core/Debugger.h

protected:
   /// \param [in] total
   ///   The total amount of work units that need to be completed. If this value
   ///   is UINT64_MAX, then an indeterminate progress indicator should be
   ///   displayed.
   ///
   /// \param [in] debugger_id
   ///   If this optional parameter has a value, it indicates the unique
   ///   debugger identifier that this progress should be delivered to. If this
-  ///   optional parameter does not have a value, the the progress will be
+  ///   optional parameter does not have a value, the progress will be
   ///   delivered to all debuggers.
   static void ReportProgress(uint64_t progress_id, const std::string &message,
                              uint64_t completed, uint64_t total,
                              llvm::Optional<lldb::user_id_t> debugger_id);
 
   bool StartEventHandlerThread();
 
   void StopEventHandlerThread();

lldb/source/API/SBDebugger.cpp

const char *SBDebugger::GetBroadcasterClass() {
 
   return Debugger::GetStaticBroadcasterClass().AsCString();
 }
 
 const char *SBDebugger::GetProgressFromEvent(const lldb::SBEvent &event,
                                              uint64_t &progress_id,
                                              uint64_t &completed,
                                              uint64_t &total,
                                              bool &is_debugger_specific) {
   const Debugger::ProgressEventData *progress_data =
       Debugger::ProgressEventData::GetEventDataFromEvent(event.get());
   if (progress_data == nullptr)
     return nullptr;
   progress_id = progress_data->GetID();
   completed = progress_data->GetCompleted();
   total = progress_data->GetTotal();
   is_debugger_specific = progress_data->IsDebuggerSpecific();
-  // We must record the static method _after_ the out paramters have been
+  // We must record the static method _after_ the out parameters have been
   // filled in.
   LLDB_RECORD_STATIC_METHOD(
       const char *, SBDebugger, GetProgressFromEvent,
       (const lldb::SBEvent &, uint64_t &, uint64_t &, uint64_t &, bool &),
       event, progress_id, completed, total, is_debugger_specific);
   return LLDB_RECORD_RESULT(progress_data->GetMessage().c_str())
 }
 

lldb/source/Core/ValueObject.cpp

else
     return GetCompilerType().IsPossibleDynamicType(nullptr, true, true);
 }
 
 bool ValueObject::IsRuntimeSupportValue() {
   Process *process(GetProcessSP().get());
   if (!process)
     return false;
 
-  // We trust the the compiler did the right thing and marked runtime support
+  // We trust that the compiler did the right thing and marked runtime support
   // values as artificial.
   if (!GetVariable() || !GetVariable()->IsArtificial())
     return false;
 
   if (auto *runtime = process->GetLanguageRuntime(GetVariable()->GetLanguage()))
     if (runtime->IsAllowedRuntimeValue(GetName()))
       return false;
 

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

bool RenderScriptRuntime::RefreshAllocation(AllocationDetails *alloc,
 
   // Sets the datum_size member in Element
   SetElementSize(alloc->element);
 
   // Use GetOffsetPointer() to infer size of the allocation
   return JITAllocationSize(alloc, frame_ptr);
 }
 
-// Function attempts to set the type_name member of the paramaterised Element
+// Function attempts to set the type_name member of the parameterised Element
 // object. This string should be the name of the struct type the Element
 // represents. We need this string for pretty printing the Element to users.
 void RenderScriptRuntime::FindStructTypeName(Element &elem,
                                              StackFrame *frame_ptr) {
   Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_LANGUAGE));
 
   if (!elem.type_name.IsEmpty()) // Name already set
     return;

lldb/source/Plugins/ObjectFile/Mach-O/ObjectFileMachO.cpp

 
 void ObjectFileMachO::SanitizeSegmentCommand(segment_command_64 &seg_cmd,
                                              uint32_t cmd_idx) {
   if (m_length == 0 || seg_cmd.filesize == 0)
     return;
 
   if ((m_header.flags & MH_DYLIB_IN_CACHE) && !IsInMemory()) {
     // In shared cache images, the load commands are relative to the
-    // shared cache file, and not the the specific image we are
+    // shared cache file, and not the specific image we are
     // examining. Let's fix this up so that it looks like a normal
     // image.
     if (strncmp(seg_cmd.segname, "__TEXT", sizeof(seg_cmd.segname)) == 0)
       m_text_address = seg_cmd.vmaddr;
     if (strncmp(seg_cmd.segname, "__LINKEDIT", sizeof(seg_cmd.segname)) == 0)
       m_linkedit_original_offset = seg_cmd.fileoff;
 
     seg_cmd.fileoff = seg_cmd.vmaddr - m_text_address;

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

  * SigContextSize(vq_from_vl(sve_context.vl)),
  * the SVE registers were not live for the thread and no register data
  * is included: in this case, the Sig*() functions should not be
  * used except for this check.
  *
  * The same convention applies when returning from a signal: a caller
  * will need to remove or resize the sve_context block if it wants to
  * make the SVE registers live when they were previously non-live or
- * vice-versa.  This may require the the caller to allocate fresh
+ * vice-versa.  This may require the caller to allocate fresh
  * memory and/or move other context blocks in the signal frame.
  *
  * Changing the vector length during signal return is not permitted:
  * sve_context.vl must equal the thread's current vector length when
  * doing a sigreturn.
  *
  *
  * Note: for all these functions, the "vq" argument denotes the SVE

lldb/test/API/commands/expression/call-function/TestCallUserDefinedFunction.py

class ExprCommandCallUserDefinedFunction(TestBase):
     def test(self):
         """Test return values of user defined function calls."""
         self.build()
         lldbutil.run_to_source_breakpoint(self, "// break here", lldb.SBFileSpec("main.cpp"))
 
         # Test recursive function call.
         self.expect_expr("fib(5)", result_type="unsigned int", result_value="5")
 
-        # Test function with more than one paramter
+        # Test function with more than one parameter
         self.expect_expr("add(4, 8)", result_type="int", result_value="12")
 
-        # Test nesting function calls in function paramters
+        # Test nesting function calls in function parameters
         self.expect_expr("add(add(5,2),add(3,4))", result_type="int", result_value="14")
         self.expect_expr("add(add(5,2),fib(5))", result_type="int", result_value="12")
 
-        # Test function with pointer paramter
+        # Test function with pointer parameter
         self.expect_expr('stringCompare((const char*) \"Hello world\")', result_type="bool", result_value="true")
         self.expect_expr('stringCompare((const char*) \"Hellworld\")', result_type="bool", result_value="false")

lldb/test/API/lang/c/enum_types/TestEnumTypes.py

def check_enum_members(self, members):
         self.assertEqual(len(members), num_matches, "enum_members returns the right number of elements")
         for idx in range(0, num_matches):
             member = members[idx]
             self.assertTrue(member.IsValid(), "Got a valid member for idx: %d"%(idx))
             self.assertEqual(member.name, name_matches[idx], "Name matches for %d"%(idx))
             self.assertEqual(member.signed, value_matches[idx], "Value matches for %d"%(idx))
         
     def test_api(self):
-        """Test the the SBTypeEnumMember API's work correctly for enum_test_days"""
+        """Test that the SBTypeEnumMember API's work correctly for enum_test_days"""
         self.build()
         target = lldbutil.run_to_breakpoint_make_target(self)
 
         types = target.FindTypes("enum_test_days")
         self.assertEqual(len(types), 1, "Found more than one enum_test_days type...")
         type = types.GetTypeAtIndex(0)
 
         # First check using the Python list returned by the type:

lldb/test/API/lang/cpp/covariant-return-types/TestCovariantReturnTypes.py

def test(self):
         self.build()
         lldbutil.run_to_source_breakpoint(self,"// break here", lldb.SBFileSpec("main.cpp"))
 
         # Test covariant return types for pointers to class that contains the called function.
         self.expect_expr("derived.getPtr()", result_type="Derived *")
         self.expect_expr("base_ptr_to_derived->getPtr()", result_type="Base *")
         self.expect_expr("base.getPtr()", result_type="Base *")
         # The same tests with reference types. LLDB drops the reference when it turns the
-        # result into a SBValue so check for the the underlying type of the result.
+        # result into a SBValue so check for the underlying type of the result.
         self.expect_expr("derived.getRef()", result_type="Derived")
         self.expect_expr("base_ptr_to_derived->getRef()", result_type="Base")
         self.expect_expr("base.getRef()", result_type="Base")
 
         # Test covariant return types for pointers to class that does *not* contain the called function.
         self.expect_expr("derived.getOtherPtr()", result_type="OtherDerived *")
         self.expect_expr("base_ptr_to_derived->getOtherPtr()", result_type="OtherBase *")
         self.expect_expr("base.getOtherPtr()", result_type="OtherBase *")
         # The same tests with reference types. LLDB drops the reference when it turns the
-        # result into a SBValue so check for the the underlying type of the result.
+        # result into a SBValue so check for the underlying type of the result.
         self.expect_expr("derived.getOtherRef()", result_type="OtherDerived")
         self.expect_expr("base_ptr_to_derived->getOtherRef()", result_type="OtherBase")
         self.expect_expr("base.getOtherRef()", result_type="OtherBase")
 
         # Test that we call the right function and get the right value back.
         self.expect_expr("derived.getOtherPtr()->value()", result_summary='"derived"')
         self.expect_expr("base_ptr_to_derived->getOtherPtr()->value()", result_summary='"derived"')
         self.expect_expr("base.getOtherPtr()->value()", result_summary='"base"')
         self.expect_expr("derived.getOtherRef().value()", result_summary='"derived"')
         self.expect_expr("base_ptr_to_derived->getOtherRef().value()", result_summary='"derived"')
         self.expect_expr("base.getOtherRef().value()", result_summary='"base"')
 
         self.expect_expr("referencing_derived.getOther()->get()->a", result_value='42')

lldb/unittests/Symbol/TestClangASTImporter.cpp

TEST_F(TestClangASTImporter, CopyTypeTagDecl) {
   EXPECT_EQ(origin.decl, source.record_decl);
 }
 
 TEST_F(TestClangASTImporter, CompleteFwdDeclWithOtherOrigin) {
   // Create an AST with a full type that is defined.
   clang_utils::SourceASTWithRecord source_with_definition;
 
   // Create an AST with a type thst is only a forward declaration with the
-  // same name as the one in the the other source.
+  // same name as the one in the other source.
   std::unique_ptr<TypeSystemClang> fwd_decl_source = clang_utils::createAST();
   CompilerType fwd_decl_type = clang_utils::createRecord(
       *fwd_decl_source, source_with_definition.record_decl->getName());
 
   // Create a target and import the forward decl.
   std::unique_ptr<TypeSystemClang> target = clang_utils::createAST();
   ClangASTImporter importer;
   CompilerType imported = importer.CopyType(*target, fwd_decl_type);