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
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
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
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
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',
/// \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,
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,
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;
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,
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)
* 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:
# 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")
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)
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")
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")
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());
projects / platform / upstream / llvm.git / commitdiff