// "qsProcessInfo"
//
// BRIEF
-// Get the first process info (qfProcessInfo) or subsequent processs
+// Get the first process info (qfProcessInfo) or subsequent process
// info (qsProcessInfo) for one or more processes on the remote
// platform. The first call gets the first match and subsequent calls
// to qsProcessInfo gets the subsequent matches. Return an error EXX,
// sending strings with arbitrary contents in them, including the '#', '$', and '*'
// characters that have special meaning in gdb-remote protocol and cannot occur
// in the middle of the string. The standard solution for this would be to require
-// ascii-hex encoding of all strings, or ascii-hex encode the entier JSON payload.
+// ascii-hex encoding of all strings, or ascii-hex encode the entire JSON payload.
//
// Instead, the binary escaping convention is used for JSON data. This convention
// (e.g. used for the X packet) says that if '#', '$', '*', or '}' are to occur in
generated using:
(lldb) log enable --threadsafe --timestamp --file <FILE> ....
- This log file will contain timestamps and this fucntion will then normalize
+ This log file will contain timestamps and this function will then normalize
those packets to be relative to the first value timestamp that is found and
show delta times between log lines and also keep track of how long it takes
for GDB remote commands to make a send/receive round trip. This can be
return ''
def bold(self, on = True):
- '''Enable or disable bold depending on the "on" paramter.'''
+ '''Enable or disable bold depending on the "on" parameter.'''
if self.enabled:
if on:
return "\x1b[1m";
return ''
def italics(self, on = True):
- '''Enable or disable italics depending on the "on" paramter.'''
+ '''Enable or disable italics depending on the "on" parameter.'''
if self.enabled:
if on:
return "\x1b[3m";
return ''
def underline(self, on = True):
- '''Enable or disable underline depending on the "on" paramter.'''
+ '''Enable or disable underline depending on the "on" parameter.'''
if self.enabled:
if on:
return "\x1b[4m";
return ''
def inverse(self, on = True):
- '''Enable or disable inverse depending on the "on" paramter.'''
+ '''Enable or disable inverse depending on the "on" parameter.'''
if self.enabled:
if on:
return "\x1b[7m";
return ''
def strike(self, on = True):
- '''Enable or disable strike through depending on the "on" paramter.'''
+ '''Enable or disable strike through depending on the "on" parameter.'''
if self.enabled:
if on:
return "\x1b[9m";
def parse_gdb_log_file(file, options):
'''Parse a GDB log file that was generated by enabling logging with:
(lldb) log enable --threadsafe --timestamp --file <FILE> gdb-remote packets
- This log file will contain timestamps and this fucntion will then normalize
+ This log file will contain timestamps and this function will then normalize
those packets to be relative to the first value timestamp that is found and
show delta times between log lines and also keep track of how long it takes
for GDB remote commands to make a send/receive round trip. This can be
return ''
def bold(self, on = True):
- '''Enable or disable bold depending on the "on" paramter.'''
+ '''Enable or disable bold depending on the "on" parameter.'''
if self.enabled:
if on:
return "\x1b[1m";
return ''
def italics(self, on = True):
- '''Enable or disable italics depending on the "on" paramter.'''
+ '''Enable or disable italics depending on the "on" parameter.'''
if self.enabled:
if on:
return "\x1b[3m";
return ''
def underline(self, on = True):
- '''Enable or disable underline depending on the "on" paramter.'''
+ '''Enable or disable underline depending on the "on" parameter.'''
if self.enabled:
if on:
return "\x1b[4m";
return ''
def inverse(self, on = True):
- '''Enable or disable inverse depending on the "on" paramter.'''
+ '''Enable or disable inverse depending on the "on" parameter.'''
if self.enabled:
if on:
return "\x1b[7m";
return ''
def strike(self, on = True):
- '''Enable or disable strike through depending on the "on" paramter.'''
+ '''Enable or disable strike through depending on the "on" parameter.'''
if self.enabled:
if on:
return "\x1b[9m";
SBFileSpec (const lldb::SBFileSpec &rhs);
- SBFileSpec (const char *path);// Deprected, use SBFileSpec (const char *path, bool resolve)
+ SBFileSpec (const char *path);// Deprecated, use SBFileSpec (const char *path, bool resolve)
SBFileSpec (const char *path, bool resolve);
/// Get the appropriate function name for this frame. Inlined functions in
/// LLDB are represented by Blocks that have inlined function information, so
/// just looking at the SBFunction or SBSymbol for a frame isn't enough.
- /// This function will return the appriopriate function, symbol or inlined
+ /// This function will return the appropriate function, symbol or inlined
/// function name for the frame.
///
/// This function returns:
///
/// This only needs to be specified if clients wish to carefully control
/// the exact path will be used to launch a binary. If you create a
- /// target with a symlink, that simlink will get resolved in the target
+ /// target with a symlink, that symlink will get resolved in the target
/// and the resolved path will get used to launch the process. Calling
/// this function can help you still launch your process using the
/// path of your choice.
/// Some launch options specified by logical OR'ing
/// lldb::LaunchFlags enumeration values together.
///
- /// @param[in] stop_at_endtry
+ /// @param[in] stop_at_entry
/// If false do not stop the inferior at the entry point.
///
/// @param[out]
//------------------------------------------------------------------
- /// The the section base load addresses for all sections in a module.
+ /// Clear the section base load addresses for all sections in a module.
///
/// @param[in] module
/// The module to unload.
/// the other threads in a process are allowed to run. So when
/// SBProcess::Continue() is called, any threads that aren't suspended will
/// be allowed to run. If any of the SBThread functions for stepping are
- /// called (StepOver, StepInto, StepOut, StepInstruction, RunToAddres), the
- /// thread will not be allowed to run and these funtions will simply return.
+ /// called (StepOver, StepInto, StepOut, StepInstruction, RunToAddress), the
+ /// thread will not be allowed to run and these functions will simply return.
///
/// Eventually we plan to add support for thread centric debugging where
/// each thread is controlled individually and each thread would broadcast
//------------------------------------------------------------------
/// Get a child value by index from a value.
///
- /// Structs, unions, classes, arrays and and pointers have child
+ /// Structs, unions, classes, arrays and pointers have child
/// values that can be access by index.
///
/// Structs and unions access child members using a zero based index
/// The index of the child value to get
///
/// @param[in] use_dynamic
- /// An enumeration that specifies wether to get dynamic values,
+ /// An enumeration that specifies whether to get dynamic values,
/// and also if the target can be run to figure out the dynamic
/// type of the child value.
///
/// @param[in] is_synchronous
/// If \b true the callback will be run on the private event thread
/// before the stop event gets reported. If false, the callback will get
- /// handled on the public event thead after the stop has been posted.
+ /// handled on the public event thread after the stop has been posted.
///
/// @return
/// \b true if the process should stop when you hit the breakpoint.
ClearAllBreakpointSites ();
//------------------------------------------------------------------
- /// Tells all the breakopint locations in this list to attempt to
+ /// Tells all the breakpoint locations in this list to attempt to
/// resolve any possible breakpoint sites.
//------------------------------------------------------------------
void
/// The BreakpointSite class handles the physical breakpoint that is
/// actually inserted in the target program. As such, it is also the
/// one that gets hit, when the program stops. It keeps a list of all
-/// BreakpointLocations that share this phsyical site. When the
+/// BreakpointLocations that share this physical site. When the
/// breakpoint is hit, all the locations are informed by the breakpoint
/// site. Breakpoint sites are owned by the process.
//----------------------------------------------------------------------
// and m_trap_opcode contain the saved and written opcode.
eHardware, // Breakpoint site is set as a hardware breakpoint
eExternal // Breakpoint site is managed by an external debug nub or
- // debug interface where memory reads trasparently will not
+ // debug interface where memory reads transparently will not
// display any breakpoint opcodes.
};
/// Sets whether the current breakpoint site is enabled or not
///
/// @param[in] enabled
- /// \b true if the breakoint is enabled, \b false otherwise.
+ /// \b true if the breakpoint is enabled, \b false otherwise.
//------------------------------------------------------------------
void
SetEnabled (bool enabled);
GetNumberOfOwners ();
//------------------------------------------------------------------
- /// This method returns the the breakpoint location at index \a index
+ /// This method returns the breakpoint location at index \a index
/// located at this breakpoint site. The owners are listed ordinally
/// from 0 to GetNumberOfOwners() - 1 so you can use this method to iterate
/// over the owners
/// @param[in] is_synchronous
/// If \b true the callback will be run on the private event thread
/// before the stop event gets reported. If false, the callback will get
- /// handled on the public event thead after the stop has been posted.
+ /// handled on the public event thread after the stop has been posted.
///
/// @return
/// \b true if the process should stop when you hit the watchpoint.
// undergoing a pair of temporary disable/enable actions to avoid recursively
// triggering further watchpoint events.
uint32_t m_disabled_count; // Keep track of the count that the watchpoint is disabled while in ephemeral mode.
- // At the end of the ephemeral mode when the watchpoint is to be enabled agian,
+ // At the end of the ephemeral mode when the watchpoint is to be enabled again,
// we check the count, if it is more than 1, it means the user-supplied actions
// actually want the watchpoint to be disabled!
uint32_t m_watch_read:1, // 1 if we stop when the watched data is read from
/// offset based address, and \a style lets the user choose.
///
/// @param[in] s
- /// The stream to which to dump the object descripton.
+ /// The stream to which to dump the object description.
///
/// @param[in] style
/// The display style for the address.
///
/// This function will first resolve its address to a load address.
/// Then, if the address turns out to be in code address, return the
- /// load address for a an opcode. This address object might have
+ /// load address for an opcode. This address object might have
/// extra bits set (bit zero will be set to Thumb functions for an
/// ARM target) that are required for changing the program counter
/// and this function will remove any bits that are intended for
/// offset (for absolute addresses that have no section).
///
/// @return
- /// Returns \b true if the the offset is valid, \b false
+ /// Returns \b true if the offset is valid, \b false
/// otherwise.
//------------------------------------------------------------------
bool
/// how the base address gets displayed.
///
/// @param[in] s
- /// The stream to which to dump the object descripton.
+ /// The stream to which to dump the object description.
///
/// @param[in] style
/// The display style for the address.
/// and pointer values, reference counts, etc.
///
/// @param[in] s
- /// The stream to which to dump the object descripton.
+ /// The stream to which to dump the object description.
//------------------------------------------------------------------
void
DumpDebug (Stream *s) const;
///
/// bool Communication::StartReadThread (Error *);
///
-/// If true is returned a read thead has been spawned that will
+/// If true is returned a read thread has been spawned that will
/// continually execute a call to the pure virtual DoRead function:
///
/// size_t Communication::ReadFromConnection (void *, size_t, uint32_t);
//------------------------------------------------------------------
/// The static read thread function. This function will call
/// the "DoRead" function continuously and wait for data to become
- /// avaialble. When data is received it will append the available
+ /// available. When data is received it will append the available
/// data to the internal cache and broadcast a
/// \b eBroadcastBitReadThreadGotBytes event.
///
/// returns an integer result.
///
/// NOTE: only call this function when you want a true string
- /// comparision. If you want string equality use the, use the ==
+ /// comparison. If you want string equality use the, use the ==
/// operator as it is much more efficient. Also if you want string
/// inequality, use the != operator for the same reasons.
///
//------------------------------------------------------------------
/// Set the C string value and its mangled counterpart.
///
- /// Object files and debug sybmols often use mangled string to
+ /// Object files and debug symbols often use mangled string to
/// represent the linkage name for a symbol, function or global.
/// The string pool can efficiently store these values and their
/// counterparts so when we run into another instance of a mangled
/// Retrieve the mangled or demangled counterpart for a mangled
/// or demangled ConstString.
///
- /// Object files and debug sybmols often use mangled string to
+ /// Object files and debug symbols often use mangled string to
/// represent the linkage name for a symbol, function or global.
/// The string pool can efficiently store these values and their
/// counterparts so when we run into another instance of a mangled
//------------------------------------------------------------------
/// Get the size in bytes of the current global string pool.
///
- /// Reports the the size in bytes of all shared C string values,
+ /// Reports the size in bytes of all shared C string values,
/// containers and any other values as a byte size for the
/// entire string pool.
///
/// @class DataBuffer DataBuffer.h "lldb/Core/DataBuffer.h"
/// @brief A pure virtual protocol class for abstracted data buffers.
///
-/// DataBuffer is an abtract class that gets packaged into a shared pointer
+/// DataBuffer is an abstract class that gets packaged into a shared pointer
/// that can use to implement various ways to store data (on the heap,
/// memory mapped, cached inferior memory). It gets used by DataExtractor
/// so many DataExtractor objects can share the same data and sub-ranges
}
//------------------------------------------------------------------
- /// Get a the data start pointer.
+ /// Get the data start pointer.
///
/// @return
/// Returns a pointer to the first byte contained in this
/// The size in byte of the integer to encode.
///
/// @param[in] value
- /// The integer value to write. The least significate bytes of
+ /// The integer value to write. The least significant bytes of
/// the integer value will be written if the size is less than
/// 8 bytes.
///
/// start encoding.
///
/// @param[int] src
- /// The buffer that contains the the bytes to encode.
+ /// The buffer that contains the bytes to encode.
///
/// @param[in] src_len
/// The number of bytes to encode.
///
/// This will return true if the input stream is a terminal (tty or
/// pty) and can cause IO handlers to do different things (like
- /// for a comfirmation when deleting all breakpoints).
+ /// for a confirmation when deleting all breakpoints).
//------------------------------------------------------------------
bool
GetIsInteractive ();
/// Check if the input is coming from a real terminal.
///
/// A real terminal has a valid size with a certain number of rows
- /// and colums. If this function returns true, then terminal escape
+ /// and columns. If this function returns true, then terminal escape
/// sequences are expected to work (cursor movement escape sequences,
- /// clearning lines, etc).
+ /// clearing lines, etc).
//------------------------------------------------------------------
bool
GetIsRealTerminal ();
//------------------------------------------------------------------
/// Called when a line or lines have been retrieved.
///
- /// This funtion can handle the current line and possibly call
+ /// This function can handle the current line and possibly call
/// IOHandler::SetIsDone(true) when the IO handler is done like when
/// "quit" is entered as a command, of when an empty line is
/// received. It is up to the delegate to determine when a line
/// demangled name to be computed currently (we don't use the accessor).
///
/// @param[in] s
- /// The stream to which to dump the object descripton.
+ /// The stream to which to dump the object description.
//----------------------------------------------------------------------
void
Dump (Stream *s) const;
/// Dump a debug description of this object to a Stream \a s.
///
/// @param[in] s
- /// The stream to which to dump the object descripton.
+ /// The stream to which to dump the object description.
//----------------------------------------------------------------------
void
DumpDebug (Stream *s) const;
/// Which name would you prefer to get?
///
/// @return
- /// A const reference to the the preferred name string object if this
+ /// A const reference to the preferred name string object if this
/// object has a valid name of that kind, else a const reference to the
/// other name is returned.
//----------------------------------------------------------------------
/// use ModuleList::GetSharedModule().
///
/// @param[in] file_spec
- /// The file specification for the on disk repesentation of
+ /// The file specification for the on disk representation of
/// this executable image.
///
/// @param[in] arch
/// in a module.
///
/// @param[in] s
- /// The stream to which to dump the object descripton.
+ /// The stream to which to dump the object description.
//------------------------------------------------------------------
void
Dump (Stream *s);
VariableList& variable_list);
//------------------------------------------------------------------
- /// Find global and static variables by regular exression.
+ /// Find global and static variables by regular expression.
///
/// @param[in] regex
/// A regular expression to use when matching the name.
///
/// @param[in] type_name
/// The name of the type we are looking for that is a fully
- /// or partially qualfieid type name.
+ /// or partially qualified type name.
///
/// @param[in] exact_match
- /// If \b true, \a type_name is fully qualifed and must match
- /// exactly. If \b false, \a type_name is a partially qualfied
+ /// If \b true, \a type_name is fully qualified and must match
+ /// exactly. If \b false, \a type_name is a partially qualified
/// name where the leading namespaces or classes can be
/// omitted to make finding types that a user may type
/// easier.
/// A debugging function that will cause everything in a module to
/// be parsed.
///
- /// All compile units will be pasred, along with all globals and
+ /// All compile units will be parsed, along with all globals and
/// static variables and all functions for those compile units.
/// All types, scopes, local variables, static variables, global
/// variables, and line tables will be parsed. This can be used
/// prior to dumping a module to see a complete list of the
- /// resuling debug information that gets parsed, or as a debug
+ /// resulting debug information that gets parsed, or as a debug
/// function to ensure that the module can consume all of the
/// debug data the symbol vendor provides.
//------------------------------------------------------------------
//------------------------------------------------------------------
// Return true if the file backing this module has changed since the
- // module was originally created since we saved the intial file
+ // module was originally created since we saved the initial file
// modification time when the module first gets created.
//------------------------------------------------------------------
bool
///
/// Clears the list of modules and releases a reference to each
/// module object and if the reference count goes to zero, the
- /// module will be deleted. Also relese all memory that might be
+ /// module will be deleted. Also release all memory that might be
/// held by any collection classes (like std::vector)
//------------------------------------------------------------------
void
/// the supplied stream \a s.
///
/// @param[in] s
- /// The stream to which to dump the object descripton.
+ /// The stream to which to dump the object description.
///
/// @see Module::Dump(Stream *) const
//------------------------------------------------------------------
VariableList& variable_list) const;
//------------------------------------------------------------------
- /// Find global and static variables by regular exression.
+ /// Find global and static variables by regular expression.
///
/// @param[in] regex
/// A regular expression to use when matching the name.
RegularExpression ();
//------------------------------------------------------------------
- /// Constructor that takes a regulare expression with flags.
+ /// Constructor that takes a regular expression with flags.
///
/// Constructor that compiles \a re using \a flags and stores the
/// resulting compiled regular expression into this object.
/// compile.
///
/// @param[in] flags
- /// Flags that are passed the the \c regcomp() function.
+ /// Flags that are passed to the \c regcomp() function.
//------------------------------------------------------------------
explicit
RegularExpression (const char* re, int flags);
//------------------------------------------------------------------
/// Destructor.
///
- /// Any previosuly compiled regular expression contained in this
+ /// Any previously compiled regular expression contained in this
/// object will be freed.
//------------------------------------------------------------------
~RegularExpression ();
/// Compile a regular expression.
///
/// Compile a regular expression using the supplied regular
- /// expression text and flags. The compied regular expression lives
+ /// expression text and flags. The compiled regular expression lives
/// in this object so that it can be readily used for regular
/// expression matches. Execute() can be called after the regular
- /// expression is compiled. Any previosuly compiled regular
+ /// expression is compiled. Any previously compiled regular
/// expression contained in this object will be freed.
///
/// @param[in] re
/// expression to compile.
///
/// @param[in] flags
- /// Flags that are passed the the \c regcomp() function.
+ /// Flags that are passed to the \c regcomp() function.
///
/// @return
/// \b true if the regular expression compiles successfully,
CalculateLineOffsets (uint32_t line = UINT32_MAX);
FileSpec m_file_spec_orig; // The original file spec that was used (can be different from m_file_spec)
- FileSpec m_file_spec; // The actualy file spec being used (if the target has source mappings, this might be different from m_file_spec_orig)
+ FileSpec m_file_spec; // The actually file spec being used (if the target has source mappings, this might be different from m_file_spec_orig)
TimeValue m_mod_time; // Keep the modification time that this file data is valid for
uint32_t m_source_map_mod_id; // If the target uses path remappings, be sure to clear our notion of a source file if the path modification ID changes
lldb::DataBufferSP m_data_sp;
/// Indent the current line in the stream.
///
/// Indent the current line using the current indentation level and
- /// print an optional string following the idenatation spaces.
+ /// print an optional string following the indentation spaces.
///
/// @param[in] s
/// A C string to print following the indentation. If NULL, just
/// ValueObject:
///
/// This abstract class provides an interface to a particular value, be it a register, a local or global variable,
-/// that is evaluated in some particular scope. The ValueObject also has the capibility of being the "child" of
+/// that is evaluated in some particular scope. The ValueObject also has the capability of being the "child" of
/// some other variable object, and in turn of having children.
/// If a ValueObject is a root variable object - having no parent - then it must be constructed with respect to some
/// particular ExecutionContextScope. If it is a child, it inherits the ExecutionContextScope from its parent.
GetTypeImpl ();
//------------------------------------------------------------------
- // Sublasses must implement the functions below.
+ // Subclasses must implement the functions below.
//------------------------------------------------------------------
virtual uint64_t
GetByteSize() = 0;
GetValueType() const = 0;
//------------------------------------------------------------------
- // Sublasses can implement the functions below.
+ // Subclasses can implement the functions below.
//------------------------------------------------------------------
virtual ConstString
GetTypeName();
GetDeclaration (Declaration &decl);
//------------------------------------------------------------------
- // The functions below should NOT be modified by sublasses
+ // The functions below should NOT be modified by subclasses
//------------------------------------------------------------------
const Error &
GetError();
ClearDynamicTypeInformation ();
//------------------------------------------------------------------
- // Sublasses must implement the functions below.
+ // Subclasses must implement the functions below.
//------------------------------------------------------------------
virtual ClangASTType
///
/// The definition of this struct is itself in the body of the wrapper function,
/// so Clang does the structure layout itself. ASTStructExtractor reads through
-/// the AST for the wrapper funtion and finds the struct.
+/// the AST for the wrapper function and finds the struct.
//----------------------------------------------------------------------
class ASTStructExtractor : public clang::SemaConsumer
{
//------------------------------------------------------------------
/// Constructor
///
- /// Initializes class variabes.
+ /// Initializes class variables.
///
/// @param[in] exe_scope,
/// If non-NULL, an execution context scope that can help to
// this function is used to copy the address-of m_live_sp into m_frozen_sp
// this is necessary because the results of certain cast and pointer-arithmetic
// operations (such as those described in bugzilla issues 11588 and 11618) generate
- // frozen objcts that do not have a valid address-of, which can be troublesome when
- // using synthetic children providers. transferring the address-of the live object
+ // frozen objects that do not have a valid address-of, which can be troublesome when
+ // using synthetic children providers. Transferring the address-of the live object
// solves these issues and provides the expected user-level behavior
void
TransferAddress (bool force = false);
///
/// @param[in] function_stack_pointer
/// A pointer to the base of the function's stack frame. This
- /// is used to determine whether the expession result resides in
+ /// is used to determine whether the expression result resides in
/// memory that will still be valid, or whether it needs to be
/// treated as homeless for the purpose of future expressions.
///
static const Error::ValueType kNoResult = 0x1001; ///< ValueObject::GetError() returns this if there is no result from the expression.
private:
//------------------------------------------------------------------
- /// Populate m_cplusplus and m_objetivec based on the environment.
+ /// Populate m_cplusplus and m_objectivec based on the environment.
//------------------------------------------------------------------
void
//------------------------------------------------------------------
/// Constructor
///
- /// Initializes class variabes.
+ /// Initializes class variables.
///
/// @param[in] name
/// The name of the function.
//----------------------------------------------------------------------
/// @class AllocationRecord IRExecutionUnit.h "lldb/Expression/IRExecutionUnit.h"
- /// @brief Enacpsulates a single allocation request made by the JIT.
+ /// @brief Encapsulates a single allocation request made by the JIT.
///
/// Allocations made by the JIT are first queued up and then applied in
/// bulk to the underlying process.
//------------------------------------------------------------------
//------------------------------------------------------------------
- /// Get the address of a fuction, and a location to put the complete
+ /// Get the address of a function, and a location to put the complete
/// Value of the function if one is available.
///
/// @param[in] function
ReplaceStrings ();
//------------------------------------------------------------------
- /// A basick block-level pass to find all literals that will be
+ /// A basic block-level pass to find all literals that will be
/// allocated as statics by the JIT (in contrast to the Strings,
/// which already are statics) and synthesize loads for them.
//------------------------------------------------------------------
///
/// A class that wraps up a pthread condition (pthread_cond_t). The
/// class will create a pthread condition when an instance is
-/// constructed, and detroy it when it is destructed. It also provides
+/// constructed, and destroy it when it is destructed. It also provides
/// access to the standard pthread condition calls.
//----------------------------------------------------------------------
class Condition
///
/// @param[in/out] offset
/// The offset to seek to within the file relative to the
- /// end of the file which gets filled in the the resulting
+ /// end of the file which gets filled in with the resulting
/// absolute file offset.
///
/// @param[in] error_ptr
///
/// Just knowing a file is a interactive isn't enough, we also need
/// to know if the terminal has a width and height so we can do
- /// cursor movement and other terminal maninpulations by sending
+ /// cursor movement and other terminal manipulations by sending
/// escape sequences.
///
/// @return
/// by a directory delimiter, and the filename.
///
/// @param[in] s
- /// The stream to which to dump the object descripton.
+ /// The stream to which to dump the object description.
//------------------------------------------------------------------
void
Dump (Stream *s) const;
/// Returns a shared pointer to a data buffer that contains all or
/// part of the contents of a file. The data is memory mapped and
/// will lazily page in data from the file as memory is accessed.
- /// The data that is mappped will start \a offset bytes into the
+ /// The data that is mapped will start \a offset bytes into the
/// file, and \a length bytes will be mapped. If \a length is
/// greater than the number of bytes available in the file starting
/// at \a offset, the number of bytes will be appropriately
/// as many bytes as possible.
///
/// @return
- /// A shared pointer to the memeory mapped data. This shared
+ /// A shared pointer to the memory mapped data. This shared
/// pointer can contain a NULL DataBuffer pointer, so the contained
/// pointer must be checked prior to using it.
//------------------------------------------------------------------
lldb::DataBufferSP
ReadFileContentsAsCString(Error *error_ptr = NULL);
//------------------------------------------------------------------
- /// Change the file specificed with a new path.
+ /// Change the file specified with a new path.
///
/// Update the contents of this object with a new path. The path will
/// be split up into a directory and filename and stored as uniqued
/// thread so the callback function must be thread safe.
///
/// When the callback gets called, the return value indicates if
- /// minotoring should stop. If \b true is returned from \a callback
+ /// monitoring should stop. If \b true is returned from \a callback
/// the information will be removed. If \b false is returned then
/// monitoring will continue. If the child process exits, the
/// monitoring will automatically stop after the callback returned
- /// ragardless of the callback return value.
+ /// regardless of the callback return value.
///
/// @param[in] callback
/// A function callback to call when a child receives a signal
///
/// This function call lets the current host OS do any thread
/// specific initialization that it needs, including naming the
- /// thread. No cleanup routine is exptected to be called
+ /// thread. No cleanup routine is expected to be called
///
/// @param[in] name
/// The current thread's name in the current process.
//------------------------------------------------------------------
/// When executable files may live within a directory, where the
/// directory represents an executable bundle (like the MacOSX
- /// app bundles), the locate the executable within the containing
+ /// app bundles), then locate the executable within the containing
/// bundle.
///
/// @param[in,out] file
/// directory member gets filled in.
///
/// @param[in] file_spec
- /// A file spec that gets filled in with the appriopriate path.
+ /// A file spec that gets filled in with the appropriate path.
///
/// @return
/// \b true if \a resource_path was resolved, \a false otherwise.
GetLength () const;
//------------------------------------------------------------------
- // Get the mex length for the the largest socket address supported.
+ // Get the max length for the largest socket address supported.
//------------------------------------------------------------------
static socklen_t
GetMaxLength ();
// Conversion operators to allow getting the contents of this class
// as a pointer to the appropriate structure. This allows an instance
// of this class to be used in calls that take one of the sockaddr
- // structure variants without having to manally use the correct
+ // structure variants without having to manually use the correct
// accessor function.
//------------------------------------------------------------------
// Locate the object and symbol file given a module specification.
//
// Locating the file can try to download the file from a corporate build
- // respository, or using any other means necessary to locate both the
+ // repository, or using any other means necessary to locate both the
// unstripped object file and the debug symbols.
// The force_lookup argument controls whether the external program is called
// unconditionally to find the symbol file, or if the user's settings are
///
/// @param[in] save_process_group
/// If \b true, save the process group settings, else do not
- /// save the process group setttings for a TTY.
+ /// save the process group settings for a TTY.
///
/// @return
/// Returns \b true if \a fd describes a TTY and if the state
/// A copy \a arg_cstr will be made.
///
/// @param[in] arg_cstr
- /// The argument to push on the front the the argument stack.
+ /// The argument to push on the front of the argument stack.
///
/// @param[in] quote_char
/// If the argument was originally quoted, put in the quote char here.
/// Parse the arguments in the contained arguments.
///
/// The arguments that are consumed by the argument parsing process
- /// will be removed from the argument vector. The arguements that
+ /// will be removed from the argument vector. The arguments that
/// get processed start at the second argument. The first argument
/// is assumed to be the command and will not be touched.
///
EncodeEscapeSequences (const char *src, std::string &dst);
// ExpandEscapeSequences will change a string of possibly non-printable
- // characters and expand them into text. So '\n' will turn into two chracters
+ // characters and expand them into text. So '\n' will turn into two characters
// like "\n" which is suitable for human reading. When a character is not
// printable and isn't one of the common in escape sequences listed in the
// help for EncodeEscapeSequences, then it will be encoded as octal. Printable
};
//----------------------------------------------------------------------
- // SouceFileCompleter implements the source file completer
+ // SourceFileCompleter implements the source file completer
//----------------------------------------------------------------------
class SourceFileCompleter : public Completer
{
// This version just returns matches, and doesn't compute the substring. It is here so the
// Help command can call it for the first argument.
- // word_complete tells whether a the completions are considered a "complete" response (so the
+ // word_complete tells whether the completions are considered a "complete" response (so the
// completer should complete the quote & put a space after the word.
int
//
// Ensures a valid register context (from the selected frame if there
// is a frame in m_exe_ctx, or from the selected thread from m_exe_ctx)
- // is availble from m_exe_ctx prior to executing the command. If a
+ // is available from m_exe_ctx prior to executing the command. If a
// target doesn't exist or is invalid, the command will fail and
// CommandObject::GetInvalidRegContextDescription() will be returned as
// the error. CommandObject subclasses can override the virtual function
/// Block objects. The BlockList object contains a section offset
/// address range, and Block objects contain one or more ranges
/// which are offsets into that range. Blocks are can have discontiguous
-/// ranges within the BlockList adress range, and each block can
+/// ranges within the BlockList address range, and each block can
/// contain child blocks each with their own sets of ranges.
///
/// Each block has a variable list that represents local, argument, and
/// static variables that are scoped to the block.
///
-/// Inlined functions are representated by attaching a
+/// Inlined functions are represented by attaching a
/// InlineFunctionInfo shared pointer object to a block. Inlined
/// functions are represented as named blocks.
//----------------------------------------------------------------------
/// Dump the block contents.
///
/// @param[in] s
- /// The stream to which to dump the object descripton.
+ /// The stream to which to dump the object description.
///
/// @param[in] base_addr
/// The resolved start address of the Function's address
/// Get const accessor for any inlined function information.
///
/// @return
- /// A comst pointer to any inlined function information, or NULL
+ /// A const pointer to any inlined function information, or NULL
/// if this is a regular block.
//------------------------------------------------------------------
const InlineFunctionInfo*
GetRangeIndexContainingAddress (const Address& addr);
//------------------------------------------------------------------
- // Since blocks might have multiple discontiguous addresss ranges,
+ // Since blocks might have multiple discontiguous address ranges,
// we need to be able to get at any of the address ranges in a block.
//------------------------------------------------------------------
bool
collection m_children;
RangeList m_ranges;
lldb::InlineFunctionInfoSP m_inlineInfoSP; ///< Inlined function information.
- lldb::VariableListSP m_variable_list_sp; ///< The variable list for all local, static and paramter variables scoped to this block.
+ lldb::VariableListSP m_variable_list_sp; ///< The variable list for all local, static and parameter variables scoped to this block.
bool m_parsed_block_info:1, ///< Set to true if this block and it's children have all been parsed
m_parsed_block_variables:1,
m_parsed_child_blocks:1;
void BuildNamespaceMap (const clang::NamespaceDecl *decl);
//
- // Comleters for maps
+ // Completers for maps
//
class MapCompleter
ClangASTType
GetFullyUnqualifiedType () const;
- // Returns -1 if this isn't a function of if the fucntion doesn't have a prototype
+ // Returns -1 if this isn't a function of if the function doesn't have a prototype
// Returns a value >= 0 if there is a prototype.
int
GetFunctionArgumentCount () const;
#define liblldb_ClangExternalASTSourceCommon_h
// Clang headers like to use NDEBUG inside of them to enable/disable debug
-// releated features using "#ifndef NDEBUG" preprocessor blocks to do one thing
+// related features using "#ifndef NDEBUG" preprocessor blocks to do one thing
// or another. This is bad because it means that if clang was built in release
// mode, it assumes that you are building in release mode which is not always
// the case. You can end up with functions that are defined as empty in header
/// parse the debug information.
///
/// @param[in] function_sp
- /// A shared pointer to the a Function object.
+ /// A shared pointer to the Function object.
//------------------------------------------------------------------
void
AddFunction(lldb::FunctionSP& function_sp);
/// Dump the compile unit contents to the stream \a s.
///
/// @param[in] s
- /// The stream to which to dump the object descripton.
+ /// The stream to which to dump the object description.
///
/// @param[in] show_context
/// If \b true, variables will dump their symbol context
///
/// Multiple calls to this function can find all entries that match
/// a given file and line by starting with \a start_idx equal to zero,
- /// and calling this function back with the return valeu + 1.
+ /// and calling this function back with the return value + 1.
///
/// @param[in] start_idx
/// The zero based index at which to start looking for matches.
/// using a LineEntry base address will be able to be resolved.
///
/// @param[out] sc_list
- /// A SymbolContext list class that willl get any matching
+ /// A SymbolContext list class that will get any matching
/// entries appended to.
///
/// @return
/// supplied stream \a s.
///
/// @param[in] s
- /// The stream to which to dump the object descripton.
+ /// The stream to which to dump the object description.
//------------------------------------------------------------------
void
Dump (Stream *s, bool show_fullpaths) const;
/// Set accessor for the declaration file specification.
///
/// @param[in] file_spec
- /// The new declaration file specifciation.
+ /// The new declaration file specification.
//------------------------------------------------------------------
void
SetFile (const FileSpec& file_spec)
// This is often sourced from the eh_frame exception handling info
// 2. Unwinding from a non-call site (any location in the function)
// This is often done by analyzing the function prologue assembly
- // langauge instructions
+ // language instructions
// 3. A fast unwind method for this function which only retrieves a
// limited set of registers necessary to walk the stack
// 4. An architectural default unwind plan when none of the above are
/// @class FunctionInfo Function.h "lldb/Symbol/Function.h"
/// @brief A class that contains generic function information.
///
-/// This provides generic function information that gets resused between
+/// This provides generic function information that gets reused between
/// inline functions and function types.
//----------------------------------------------------------------------
class FunctionInfo
/// supplied stream \a s.
///
/// @param[in] s
- /// The stream to which to dump the object descripton.
+ /// The stream to which to dump the object description.
//------------------------------------------------------------------
void
Dump (Stream *s, bool show_fullpaths) const;
/// supplied stream \a s.
///
/// @param[in] s
- /// The stream to which to dump the object descripton.
+ /// The stream to which to dump the object description.
//------------------------------------------------------------------
void
Dump(Stream *s, bool show_fullpaths) const;
/// (Function::m_type), and contains lexical blocks
/// (Function::m_blocks).
///
-/// The function inforation is split into a few pieces:
+/// The function information is split into a few pieces:
/// @li The concrete instance information
/// @li The abstract information
///
/// The abstract information is found in the function type (Type) that
/// describes a function information, return type and parameter types.
///
-/// The concreate information is the address range information and
+/// The concrete information is the address range information and
/// specific locations for an instance of this function.
//----------------------------------------------------------------------
class Function :
//------------------------------------------------------------------
/// Get accessor for the type that describes the function
- /// return value type, and paramter types.
+ /// return value type, and parameter types.
///
/// @return
/// A type object pointer.
//------------------------------------------------------------------
/// Get const accessor for the type that describes the function
- /// return value type, and paramter types.
+ /// return value type, and parameter types.
///
/// @return
/// A const type object pointer.
/// supplied stream \a s.
///
/// @param[in] s
- /// The stream to which to dump the object descripton.
+ /// The stream to which to dump the object description.
///
/// @param[in] show_context
/// If \b true, variables will dump their symbol context
/// supplied stream \a s.
///
/// @param[in] s
- /// The stream to which to dump the object descripton.
+ /// The stream to which to dump the object description.
///
/// @param[in] comp_unit
/// The compile unit object that contains the support file
/// line entry to the supplied stream \a s.
///
/// @param[in] s
- /// The stream to which to dump the object descripton.
+ /// The stream to which to dump the object description.
///
/// @param[in] comp_unit
/// The compile unit object that contains the support file
bool is_epilogue_begin,
bool is_terminal_entry);
- // Used to instantiate the LineSequence helper classw
+ // Used to instantiate the LineSequence helper class
LineSequence*
CreateLineSequenceContainer ();
/// Dump all line entries in this line table to the stream \a s.
///
/// @param[in] s
- /// The stream to which to dump the object descripton.
+ /// The stream to which to dump the object description.
///
/// @param[in] style
/// The display style for the address.
/// if it has been parsed.
///
/// @param[in] s
- /// The stream to which to dump the object descripton.
+ /// The stream to which to dump the object description.
//------------------------------------------------------------------
virtual void
Dump (Stream *s) const = 0;
/// and the next plug-in can attempt to parse an object file.
///
/// @return
- /// Returns \b true if the header was parsed succesfully, \b
+ /// Returns \b true if the header was parsed successfully, \b
/// false otherwise.
//------------------------------------------------------------------
virtual bool
/// if it has been parsed.
///
/// @param[in] s
- /// The stream to which to dump the object descripton.
+ /// The stream to which to dump the object description.
//------------------------------------------------------------------
virtual void
Dump (Stream *s) = 0;
/// and the next plug-in can attempt to parse an object file.
///
/// @return
- /// Returns \b true if the header was parsed succesfully, \b
+ /// Returns \b true if the header was parsed successfully, \b
/// false otherwise.
//------------------------------------------------------------------
virtual bool
/// supplied stream \a s.
///
/// @param[in] s
- /// The stream to which to dump the object descripton.
+ /// The stream to which to dump the object description.
//------------------------------------------------------------------
void
Dump (Stream *s, Target *target) const;
/// was stopped will be displayed.
///
/// @param[in] s
- /// The stream to which to dump the object descripton.
+ /// The stream to which to dump the object description.
///
/// @param[in] so_addr
/// The resolved section offset address.
/// the result of a query that can contain a multiple results. Examples
/// of such queries include:
/// @li Looking up a function by name.
-/// @li Finding all addressses for a specified file and line number.
+/// @li Finding all addresses for a specified file and line number.
//----------------------------------------------------------------------
class SymbolContextList
{
/// the list to the supplied stream \a s.
///
/// @param[in] s
- /// The stream to which to dump the object descripton.
+ /// The stream to which to dump the object description.
//------------------------------------------------------------------
void
Dump(Stream *s, Target *target) const;
~SymbolContextScope () {}
//------------------------------------------------------------------
- /// Reconstruct the object's symbolc context into \a sc.
+ /// Reconstruct the object's symbol context into \a sc.
///
/// The object should fill in as much of the SymbolContext as it
/// can so function calls that require a symbol context can be made
}
//------------------------------------------------------------------
- /// Dump the object's symbolc context to the stream \a s.
+ /// Dump the object's symbol context to the stream \a s.
///
/// The object should dump its symbol context to the stream \a s.
/// This function is widely used in the DumpDebug and verbose output
- /// for lldb objets.
+ /// for lldb objects.
///
/// @param[in] s
/// The stream to which to dump the object's symbol context.
/// Each symbol file gets to respond with a mask of abilities that
/// it supports for each object file. This happens when we are
/// trying to figure out which symbol file plug-in will get used
- /// for a given object file. The plug-in that resoonds with the
+ /// for a given object file. The plug-in that responds with the
/// best mix of "SymbolFile::Abilities" bits set, will get chosen to
/// be the symbol file parser. This allows each plug-in to check for
/// sections that contain data a symbol file plug-in would need. For
AppendVariablesIfUnique(VariableList &var_list);
// Returns the actual number of unique variables that were added to the
- // list. "total_matches" will get updated with the actualy number of
+ // list. "total_matches" will get updated with the actually number of
// matches that were found regardless of whether they were unique or not
// to allow for error conditions when nothing is found, versus conditions
- // where any varaibles that match "regex" were already in "var_list".
+ // where any variables that match "regex" were already in "var_list".
size_t
AppendVariablesIfUnique (const RegularExpression& regex,
VariableList &var_list,
protected:
// This is the method the ABI will call to actually calculate the return value.
- // Don't put it in a persistant value object, that will be done by the ABI::GetReturnValueObject.
+ // Don't put it in a persistent value object, that will be done by the ABI::GetReturnValueObject.
virtual lldb::ValueObjectSP
GetReturnValueObjectImpl (Thread &thread,
ClangASTType &type) const = 0;
static bool
StripNamespacesFromVariableName (const char *name, const char *&base_name_start, const char *&base_name_end);
- // in some cases, compilers will output different names for one same type. when tht happens, it might be impossible
+ // in some cases, compilers will output different names for one same type. when that happens, it might be impossible
// to construct SBType objects for a valid type, because the name that is available is not the same as the name that
// can be used as a search key in FindTypes(). the equivalents map here is meant to return possible alternative names
// for a type through which a search can be conducted. Currently, this is only enabled for C++ but can be extended
/// 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 deascribed below.
+/// objects are described below.
///
/// Not all objects in an ExectionContext objects will be valid. If you want
-/// to refer stronly (ExectionContext) or weakly (ExectionContextRef) to
+/// to refer strongly (ExectionContext) or weakly (ExectionContextRef) 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.
/// context that might change over time. For example, if an object wants
/// to refer to a stack frame, it should hold onto an ExecutionContextRef
/// to a frame object. The backing object that represents the stack frame
-/// might change over time and instaces of this object can track the logical
+/// might change over time and instances of this object can track the logical
/// object that refers to a frame even if it does change.
///
/// These objects also don't keep execution objects around longer than they
/// don't keep these objects around, they are safe to keep around.
///
/// The general rule of thumb is all long lived objects that want to
-/// refer to execution contexts should use ExecutionContextRef objcts.
+/// refer to execution contexts should use ExecutionContextRef objects.
/// The ExecutionContext class is used to temporarily get shared
/// pointers to any execution context objects that are still around
/// so they are guaranteed to exist during a function that requires the
/// Construct using an ExecutionContext object that might be NULL.
///
/// If \a exe_ctx_ptr is valid, then make weak references to any
- /// valid objects in the ExecutionContext, othewise no weak
+ /// valid objects in the ExecutionContext, otherwise no weak
/// references to any execution context objects will be made.
//------------------------------------------------------------------
ExecutionContextRef (const ExecutionContext *exe_ctx_ptr);
//------------------------------------------------------------------
/// Assignment operator
///
- /// Copy all weak refernces in \a rhs.
+ /// Copy all weak references in \a rhs.
//------------------------------------------------------------------
ExecutionContextRef &
operator =(const ExecutionContextRef &rhs);
//------------------------------------------------------------------
/// Assignment operator from a ExecutionContext
///
- /// Make weak refernces to any stringly referenced objects in \a exe_ctx.
+ /// Make weak references to any strongly referenced objects in \a exe_ctx.
//------------------------------------------------------------------
ExecutionContextRef &
operator =(const ExecutionContext &exe_ctx);
/// Construct using an execution context scope.
///
/// If the ExecutionContextScope object is valid and refers to a frame,
- /// make weak refernces too the frame, thread, process and target.
+ /// make weak references too the frame, thread, process and target.
/// If the ExecutionContextScope object is valid and refers to a thread,
- /// make weak refernces too the thread, process and target.
+ /// make weak references too the thread, process and target.
/// If the ExecutionContextScope object is valid and refers to a process,
- /// make weak refernces too the process and target.
+ /// make weak references too the process and target.
/// If the ExecutionContextScope object is valid and refers to a target,
- /// make weak refernces too the target.
+ /// make weak references too the target.
//------------------------------------------------------------------
ExecutionContextRef (ExecutionContextScope *exe_scope);
/// Construct using an execution context scope.
///
/// If the ExecutionContextScope object refers to a frame,
- /// make weak refernces too the frame, thread, process and target.
+ /// make weak references too the frame, thread, process and target.
/// If the ExecutionContextScope object refers to a thread,
- /// make weak refernces too the thread, process and target.
+ /// make weak references too the thread, process and target.
/// If the ExecutionContextScope object refers to a process,
- /// make weak refernces too the process and target.
+ /// make weak references too the process and target.
/// If the ExecutionContextScope object refers to a target,
- /// make weak refernces too the target.
+ /// make weak references too the target.
//------------------------------------------------------------------
ExecutionContextRef (ExecutionContextScope &exe_scope);
//------------------------------------------------------------------
/// Returns true if this object has a weak reference to a thread.
- /// The return value is only an indication of wether this object has
- /// a weak reference and does not indicate wether the weak rerference
+ /// The return value is only an indication of whether this object has
+ /// a weak reference and does not indicate whether the weak reference
/// is valid or not.
//------------------------------------------------------------------
bool
//------------------------------------------------------------------
/// Returns true if this object has a weak reference to a frame.
- /// The return value is only an indication of wether this object has
- /// a weak reference and does not indicate wether the weak rerference
+ /// The return value is only an indication of whether this object has
+ /// a weak reference and does not indicate whether the weak reference
/// is valid or not.
//------------------------------------------------------------------
bool
/// ExecutionContext object in the object state. Examples of these
/// objects include: Process, Thread, RegisterContext and StackFrame.
///
-/// Bbjects can contain a valid pointer to an instance of this so they
+/// Objects can contain a valid pointer to an instance of this so they
/// can reconstruct the execution context.
///
/// Objects that adhere to this protocol can reconstruct enough of a
///
/// Plugins of this kind listen for code generated at runtime in the
/// target. They are very similar to dynamic loader, with the difference
-/// that they do not have information about the the target's dyld and
+/// that they do not have information about the target's dyld and
/// that there may be multiple JITLoader plugins per process, while
/// there is at most one DynamicLoader.
//----------------------------------------------------------------------
/// m_arch - The architecture we are looking for when resolving
/// the symbol file.
/// m_uuid - The UUID of the executable and symbol file. This
- /// can often be used to match up an exectuable with
+ /// can often be used to match up an executable with
/// a symbol file, or resolve an symbol file in a
/// symbol file bundle.
///
/// @param[out] sym_file
/// The resolved symbol file spec if the returned error
- /// indicates succes.
+ /// indicates success.
///
/// @return
/// Returns an error that describes success or failure.
bool
GetOSKernelDescription (std::string &s);
- // Returns the the name of the platform
+ // Returns the name of the platform
ConstString
GetName ();
/// A zero based architecture index
///
/// @param[out] arch
- /// A copy of the archgitecture at index if the return value is
+ /// A copy of the architecture at index if the return value is
/// \b true.
///
/// @return
/// attempt to attach to the process with the process ID of \a pid.
/// The platform subclass should return an appropriate ProcessSP
/// subclass that is attached to the process, or an empty shared
- /// pointer with an appriopriate error.
+ /// pointer with an appropriate error.
///
/// @param[in] pid
/// The process ID that we should attempt to attach to.
/// An appropriate ProcessSP containing a valid shared pointer
/// to the default Process subclass for the platform that is
/// attached to the process, or an empty shared pointer with an
- /// appriopriate error fill into the \a error object.
+ /// appropriate error fill into the \a error object.
//------------------------------------------------------------------
virtual lldb::ProcessSP
Attach (ProcessAttachInfo &attach_info,
//------------------------------------------------------------------
/// Register for process and thread notifications.
///
- /// Clients can register nofication callbacks by filling out a
+ /// Clients can register notification callbacks by filling out a
/// Process::Notifications structure and calling this function.
///
/// @param[in] callbacks
//------------------------------------------------------------------
/// Unregister for process and thread notifications.
///
- /// Clients can unregister nofication callbacks by passing a copy of
+ /// Clients can unregister notification callbacks by passing a copy of
/// the original baton and callbacks in \a callbacks.
///
/// @param[in] callbacks
DoSignal (int signal)
{
Error error;
- error.SetErrorStringWithFormat("error: %s does not support senging signals to processes", GetPluginName().GetCString());
+ error.SetErrorStringWithFormat("error: %s does not support sending signals to processes", GetPluginName().GetCString());
return error;
}
///
/// The value contained in \a scalar will be swapped to match the
/// byte order of the process that is being debugged. If \a size is
- /// less than the size of scalar, the least significate \a size bytes
+ /// less than the size of scalar, the least significant \a size bytes
/// from scalar will be written. If \a size is larger than the byte
/// size of scalar, then the extra space will be padded with zeros
/// and the scalar value will be placed in the least significant
Broadcaster m_private_state_control_broadcaster; // This is the control broadcaster, used to pause, resume & stop the private state thread.
Listener m_private_state_listener; // This is the listener for the private state thread.
Predicate<bool> m_private_state_control_wait; /// This Predicate is used to signal that a control operation is complete.
- lldb::thread_t m_private_state_thread; // Thread ID for the thread that watches interal state events
+ lldb::thread_t m_private_state_thread; // Thread ID for the thread that watches internal state events
ProcessModID m_mod_id; ///< Tracks the state of the process over stops and other alterations.
uint32_t m_process_unique_id; ///< Each lldb_private::Process class that is created gets a unique integer ID that increments with each new instance
uint32_t m_thread_index_id; ///< Each thread is created with a 1 based index that won't get re-used.
///
/// @return
/// A QueueSP to the queue requested, if it is present in the QueueList.
- /// An empty QueueSP willbe returned if this queue was not found.
+ /// An empty QueueSP will be returned if this queue was not found.
//------------------------------------------------------------------
lldb::QueueSP
FindQueueByID (lldb::queue_id_t qid);
///
/// @return
/// A QueueSP to the queue requested, if it is present in the QueueList.
- /// An empty QueueSP willbe returned if this queue was not found.
+ /// An empty QueueSP will be returned if this queue was not found.
//------------------------------------------------------------------
lldb::QueueSP
FindQueueByIndexID (uint32_t index_id);
///
/// The StackFrame maintains this SymbolContext and adds additional information
/// to it on an as-needed basis. This helps to avoid different functions
- /// looking up symbolic information for a given pc value multple times.
+ /// looking up symbolic information for a given pc value multiple times.
///
/// @params [in] resolve_scope
/// Flags from the SymbolContextItem enumerated type which specify what
///
/// @param[in] get_file_globals
/// Whether to also retrieve compilation-unit scoped variables
- /// that are visisble to the entire compilation unit (e.g. file
+ /// that are visible to the entire compilation unit (e.g. file
/// static in C, globals that are homed in this CU).
///
/// @return
///
/// @param[in] get_file_globals
/// Whether to also retrieve compilation-unit scoped variables
- /// that are visisble to the entire compilation unit (e.g. file
+ /// that are visible to the entire compilation unit (e.g. file
/// static in C, globals that are homed in this CU).
///
/// @return
/// in a target.
///
/// @param[in] s
- /// The stream to which to dump the object descripton.
+ /// The stream to which to dump the object description.
//------------------------------------------------------------------
void
Dump (Stream *s, lldb::DescriptionLevel description_level);
//------------------------------------------------------------------
/// Delete a Target object from the list.
///
- /// When clients are done with the Target objets, this function
+ /// When clients are done with the Target objects, this function
/// should be called to release the memory associated with a target
/// object.
///
int m_resume_signal; ///< The signal that should be used when continuing this thread.
lldb::StateType m_resume_state; ///< This state is used to force a thread to be suspended from outside the ThreadPlan logic.
lldb::StateType m_temporary_resume_state; ///< This state records what the thread was told to do by the thread plan logic for the current resume.
- /// It gets set in Thread::ShoudResume.
+ /// It gets set in Thread::ShouldResume.
std::unique_ptr<lldb_private::Unwind> m_unwinder_ap;
bool m_destroy_called; // This is used internally to make sure derived Thread classes call DestroyThread.
LazyBool m_override_should_notify;
// This is an interface that ThreadPlans can adopt to allow flexible modifications of the behavior
// when a thread plan comes to a place where it would ordinarily stop. If such modification makes
// sense for your plan, inherit from this class, and when you would be about to stop (in your ShouldStop
-// method), call InvokeShouldStopHereCallback, passing in the frame comparision between where the step operation
+// method), call InvokeShouldStopHereCallback, passing in the frame comparison between where the step operation
// started and where you arrived. If it returns true, then QueueStepOutFromHere will queue the plan
// to execute instead of stopping.
//
// file descriptors, opaque handles, pointers, etc). If more complex
// type T objects are desired, we need to probably specialize this class
// to take "const T&" for all input T parameters. Yet if a type T is
-// complex already it might be better to build the cleanup funcionality
+// complex already it might be better to build the cleanup functionality
// into T.
//
// The cleanup function must take one argument that is of type T.
/// @class PseudoTerminal PseudoTerminal.h "lldb/Core/PseudoTerminal.h"
/// @brief A pseudo terminal helper class.
///
-/// The pseudo terminal class abtracts the use of pseudo terminals on
+/// The pseudo terminal class abstracts the use of pseudo terminals on
/// the host system.
//----------------------------------------------------------------------
class PseudoTerminal
/// Destructor
///
/// The destructor will close the master and slave file descriptors
- /// if they are valid and ownwership has not been released using
+ /// if they are valid and ownership has not been released using
/// one of:
/// @li PseudoTerminal::ReleaseMasterFileDescriptor()
/// @li PseudoTerminal::ReleaseSaveFileDescriptor()
// Microsoft Visual C++ currently does not enable std::atomic to work
// in CLR mode - as such we need to "hack around it" for MSVC++ builds only
-// using Windows specific instrinsics instead of the C++11 atomic support
+// using Windows specific intrinsics instead of the C++11 atomic support
#ifdef _MSC_VER
#include <intrin.h>
#else
private:
virtual void on_zero_shared();
- // Outlaw copy constructor and assignment operator to keep effictive C++
- // warnings down to a minumum
+ // Outlaw copy constructor and assignment operator to keep effective C++
+ // warnings down to a minimum
shared_ptr_pointer (const shared_ptr_pointer &);
shared_ptr_pointer & operator=(const shared_ptr_pointer &);
};
namespace lldb {
%feature("docstring",
-"Represents a file specfication that divides the path into a directory and
+"Represents a file specification that divides the path into a directory and
basename. The string values of the paths are put into uniqued string pools
for fast comparisons and efficient memory usage.
gets the line entry from the symbol context when a thread is stopped.
It gets the file spec corresponding to the line entry and checks that
-the filename and the directory matches wat we expect.
+the filename and the directory matches what we expect.
") SBFileSpec;
class SBFileSpec
{
SBFileSpec (const lldb::SBFileSpec &rhs);
- SBFileSpec (const char *path);// Deprected, use SBFileSpec (const char *path, bool resolve)
+ SBFileSpec (const char *path);// Deprecated, use SBFileSpec (const char *path, bool resolve)
SBFileSpec (const char *path, bool resolve);
/// Get the appropriate function name for this frame. Inlined functions in
/// LLDB are represented by Blocks that have inlined function information, so
/// just looking at the SBFunction or SBSymbol for a frame isn't enough.
- /// This function will return the appriopriate function, symbol or inlined
+ /// This function will return the appropriate function, symbol or inlined
/// function name for the frame.
///
/// This function returns:
/// SBProcess::Continue() is called, any threads that aren't suspended will
/// be allowed to run. If any of the SBThread functions for stepping are
/// called (StepOver, StepInto, StepOut, StepInstruction, RunToAddres), the
- /// thread will now be allowed to run and these funtions will simply return.
+ /// thread will now be allowed to run and these functions will simply return.
///
/// Eventually we plan to add support for thread centric debugging where
/// each thread is controlled individually and each thread would broadcast
//------------------------------------------------------------------
/// Get a child value by index from a value.
///
- /// Structs, unions, classes, arrays and and pointers have child
+ /// Structs, unions, classes, arrays and pointers have child
/// values that can be access by index.
///
/// Structs and unions access child members using a zero based index
/// The index of the child value to get
///
/// @param[in] use_dynamic
- /// An enumeration that specifies wether to get dynamic values,
+ /// An enumeration that specifies whether to get dynamic values,
/// and also if the target can be run to figure out the dynamic
/// type of the child value.
///
/// The name of the child value to get
///
/// @param[in] use_dynamic
- /// An enumeration that specifies wether to get dynamic values,
+ /// An enumeration that specifies whether to get dynamic values,
/// and also if the target can be run to figure out the dynamic
/// type of the child value.
///
# This script should be pointed to a valid llvm.build folder that
# was created using the "build-llvm.pl" shell script. It will create
-# a new llvm.zip file that can be checked into the respository
+# a new llvm.zip file that can be checked into the repository
# at lldb/llvm.zip
use strict;
#----------------------------------------------------------------------
sub dump_A_command
{
- my $cmd = get_exptected_char(\@_, 'A') or print "error: incorrect command letter for argument packet, exptected 'A'\n";
+ my $cmd = get_expected_char(\@_, 'A') or print "error: incorrect command letter for argument packet, expected 'A'\n";
printf("set_program_arguments (\n");
do
{
my $arg_len = get_uint(\@_);
- get_exptected_char(\@_, ',') or die "error: missing comma after argument length...?\n";
+ get_expected_char(\@_, ',') or die "error: missing comma after argument length...?\n";
my $arg_idx = get_uint(\@_);
- get_exptected_char(\@_, ',') or die "error: missing comma after argument number...?\n";
+ get_expected_char(\@_, ',') or die "error: missing comma after argument number...?\n";
my $arg = '';
my $num_hex8_bytes = $arg_len/2;
printf(" <%3u> argv[%u] = '%s'\n", $arg_len, $arg_idx, $arg);
if (@_ > 0)
{
- get_exptected_char(\@_, ',') or die "error: missing comma after argument argument ASCII hex bytes...?\n";
+ get_expected_char(\@_, ',') or die "error: missing comma after argument argument ASCII hex bytes...?\n";
}
} while (@_ > 0);
printf(" )\n");
}
#----------------------------------------------------------------------
-# Get a an unsigned integer value by grabbing items off the front of
+# Get an unsigned integer value by grabbing items off the front of
# the array stopping when a non-digit char string is encountered.
#
# The argument for this function needs to be a reference to an array
# character doesn't match, it won't touch the array. If the first
# character does match, it will shift it off and return it.
#----------------------------------------------------------------------
-sub get_exptected_char
+sub get_expected_char
{
my $arrayref = shift;
my $expected_char = shift;
=head1 EXAMPLES
# Recursively process all source files in the current working directory
-# and and subdirectories and also expand tabs to spaces. All source files
+# and subdirectories and also expand tabs to spaces. All source files
# will be overwritten with the newly transformed source files.
% sed-sources -e $cwd
# Recursively process all source files in the current working directory
-# and and subdirectories and also unexpand spaces to tabs and preview the
+# and subdirectories and also unexpand spaces to tabs and preview the
# results to STDOUT
% sed-sources -p -u $cwd
# call the main function
-main();
\ No newline at end of file
+main();
{
}
-// Deprected!!!
+// Deprecated!!!
SBFileSpec::SBFileSpec (const char *path) :
m_opaque_ap(new FileSpec (path, true))
{
if (context.module_sp)
{
context.module_sp->FindFunctions (m_regex,
- !filter_by_cu, // include symbols only if we aren't filterning by CU
+ !filter_by_cu, // include symbols only if we aren't filtering by CU
include_inlines,
append,
func_list);
}
}
- // Remove any duplicates between the funcion list and the symbol list
+ // Remove any duplicates between the function list and the symbol list
SymbolContext sc;
if (func_list.GetSize())
{
SetHelpLong(
"This command allows the user to create powerful regular expression commands\n"
"with substitutions. The regular expressions and substitutions are specified\n"
-"using the regular exression substitution format of:\n"
+"using the regular expression substitution format of:\n"
"\n"
" s/<regex>/<subst>/\n"
"\n"
{
SetHelpLong(
"Timeouts:\n\
- If the expression can be evaluated statically (without runnning code) then it will be.\n\
+ If the expression can be evaluated statically (without running code) then it will be.\n\
Otherwise, by default the expression will run on the current thread with a short timeout:\n\
currently .25 seconds. If it doesn't return in that time, the evaluation will be interrupted\n\
and resumed with all threads running. You can use the -a option to disable retrying on all\n\
if (argc != 1)
{
- result.AppendError ("'setttings clear' takes exactly one argument");
+ result.AppendError ("'settings clear' takes exactly one argument");
result.SetStatus (eReturnStatusFailed);
return false;
}
break;
}
- // Remove any duplicates between the funcion list and the symbol list
+ // Remove any duplicates between the function list and the symbol list
if (func_list.GetSize())
{
for (i = 0; i < func_list.GetSize(); i++)
else if (module_spec.GetArchitecture().IsValid())
m_arch = module_spec.GetArchitecture();
- // Copy the file spec over and use the specfied one (if there was one) so we
+ // Copy the file spec over and use the specified one (if there was one) so we
// don't use a path that might have gotten resolved a path in 'matching_module_spec'
if (module_spec.GetFileSpec())
m_file = module_spec.GetFileSpec();
// Check if "name" starts with "::" which means the qualified type starts
// from the root namespace and implies and exact match. The typenames we
// get back from clang do not start with "::" so we need to strip this off
- // in order to get the qualfied names to match
+ // in order to get the qualified names to match
if (type_scope.size() >= 2 && type_scope[0] == ':' && type_scope[1] == ':')
{
return false;
}
- LoadScriptFromSymFile shoud_load = target->TargetProperties::GetLoadScriptFromSymbolFile();
+ LoadScriptFromSymFile should_load = target->TargetProperties::GetLoadScriptFromSymbolFile();
Debugger &debugger = target->GetDebugger();
const ScriptLanguage script_language = debugger.GetScriptLanguage();
FileSpec scripting_fspec (file_specs.GetFileSpecAtIndex(i));
if (scripting_fspec && scripting_fspec.Exists())
{
- if (shoud_load == eLoadScriptFromSymFileFalse)
+ if (should_load == eLoadScriptFromSymFileFalse)
return false;
- if (shoud_load == eLoadScriptFromSymFileWarn)
+ if (should_load == eLoadScriptFromSymFileWarn)
{
if (feedback_stream)
feedback_stream->Printf("warning: '%s' contains a debug script. To run this script in "
if (!cpp_method.GetQualifiers().empty())
{
- // There is a "const" or other qualifer following the end of the fucntion parens,
+ // There is a "const" or other qualifier following the end of the function parens,
// this can't be a eFunctionNameTypeBase
lookup_name_type_mask &= ~(eFunctionNameTypeBase);
if (lookup_name_type_mask == eFunctionNameTypeNone)
//----------------------------------------------------------------------
// Destructor
//
-// Any previosuly compiled regular expression contained in this
+// Any previously compiled regular expression contained in this
// object will be freed.
//----------------------------------------------------------------------
RegularExpression::~RegularExpression()
//----------------------------------------------------------------------
// Compile a regular expression using the supplied regular
-// expression text and flags. The compied regular expression lives
+// expression text and flags. The compiled regular expression lives
// in this object so that it can be readily used for regular
// expression matches. Execute() can be called after the regular
-// expression is compiled. Any previosuly compiled regular
+// expression is compiled. Any previously compiled regular
// expression contained in this object will be freed.
//
// RETURNS
-// True of the refular expression compiles successfully, false
+// True if the regular expression compiles successfully, false
// otherwise.
//----------------------------------------------------------------------
bool
promoted_lhs_ptr = &temp_value; // Update the pointer for the promoted left hand side
}
- // Make sure our type promotion worked as exptected
+ // Make sure our type promotion worked as expected
if (promoted_lhs_ptr->GetType() == promoted_rhs_ptr->GetType())
return promoted_lhs_ptr->GetType(); // Return the resulting max type
//------------------------------------------------------------------
// Indent the current line using the current indentation level and
-// print an optional string following the idenatation spaces.
+// print an optional string following the indentation spaces.
//------------------------------------------------------------------
size_t
Stream::Indent(const char *s)
using namespace lldb_private;
// this macro enables a simpler implementation for some method calls in this object that relies only upon
-// ValueObject knowning how to set the address type of its children correctly. the alternative implementation
+// ValueObject knowing how to set the address type of its children correctly. the alternative implementation
// relies on being able to create a target copy of the frozen object, which makes it less bug-prone but less
// efficient as well. once we are confident the faster implementation is bug-free, this macro (and the slower
// implementations) can go
}
//------------------------------------------------------------------
-// Virtual destrcuctor in case anyone inherits from this class.
+// Virtual destructor in case anyone inherits from this class.
//------------------------------------------------------------------
FileSpec::~FileSpec()
{
// Returns a shared pointer to a data buffer that contains all or
// part of the contents of a file. The data is memory mapped and
// will lazily page in data from the file as memory is accessed.
-// The data that is mappped will start "file_offset" bytes into the
+// The data that is mapped will start "file_offset" bytes into the
// file, and "file_size" bytes will be mapped. If "file_size" is
// greater than the number of bytes available in the file starting
// at "file_offset", the number of bytes will be appropriately
{
error.SetErrorString("timed out waiting for shell command to complete");
- // Kill the process since it didn't complete withint the timeout specified
+ // Kill the process since it didn't complete within the timeout specified
Kill (pid, SIGKILL);
// Wait for the monitor callback to get the message
timeout_time = TimeValue::Now();
next_var += strlen(next_var) + 1;
}
- // Get the commond line used to start the process.
+ // Get the command line used to start the process.
buf_sp = ProcFileReader::ReadIntoDataBuffer(pid, "cmdline");
// Grab Arg0 first, if there is one.
s_distribution_id.SetCString (id_string.c_str ());
if (log)
- log->Printf ("distribion id set to \"%s\"",
+ log->Printf ("distribution id set to \"%s\"",
s_distribution_id.GetCString ());
}
else
if (launch_info.GetFlags().Test (eLaunchFlagDisableASLR))
command.PutCString(" --disable-aslr");
- // We are launching on this host in a terminal. So compare the environemnt on the host
- // to what is supplied in the launch_info. Any items that aren't in the host environemnt
+ // We are launching on this host in a terminal. So compare the environment on the host
+ // to what is supplied in the launch_info. Any items that aren't in the host environment
// need to be sent to darwin-debug. If we send all environment entries, we might blow the
// max command line length, so we only send user modified entries.
const char **envp = launch_info.GetEnvironmentEntries().GetConstArgumentVector ();
{
pid = (intptr_t)accept_thread_result;
- // Wait for process to be stopped the the entry point by watching
+ // Wait for process to be stopped at the entry point by watching
// for the process status to be set to SSTOP which indicates it it
// SIGSTOP'ed at the entry point
WaitForProcessToSIGSTOP (pid, 5);
return;
} else if (event == XPC_ERROR_CONNECTION_INVALID) {
// The service is invalid. Either the service name supplied to xpc_connection_create() is incorrect
- // or we (this process) have canceled the service; we can do any cleanup of appliation state at this point.
+ // or we (this process) have canceled the service; we can do any cleanup of application state at this point.
// printf("Service disconnected");
return;
} else {
#if !defined(__arm__) && !defined(__arm64__)
return LaunchInNewTerminalWithAppleScript (exe_path, launch_info);
#else
- error.SetErrorString ("launching a processs in a new terminal is not supported on iOS devices");
+ error.SetErrorString ("launching a process in a new terminal is not supported on iOS devices");
return error;
#endif
}
const RegisterInfo *reg_info = NULL;
if (is_return_value)
{
- // We are assumging we are decoding this immediately after returning
+ // We are assuming we are decoding this immediately after returning
// from a function call and that the address of the structure is in x8
reg_info = reg_ctx->GetRegisterInfoByName("x8", 0);
}
else
{
// We are assuming we are stopped at the first instruction in a function
- // and that the ABI is being respected so all paramters appear where they
+ // and that the ABI is being respected so all parameters appear where they
// should be (functions with no external linkage can legally violate the ABI).
if (NGRN >= 8)
return false;
//----------------------------------------------------------------------
// Try and figure out where dyld is by first asking the Process
-// if it knows (which currently calls down in the the lldb::Process
+// if it knows (which currently calls down in the lldb::Process
// to get the DYLD info (available on SnowLeopard only). If that fails,
// then check in the default addresses.
//----------------------------------------------------------------------
image_infos[idx].PutToLog (log);
}
- // Remove this image_infos from the m_all_image_infos. We do the comparision by address
+ // Remove this image_infos from the m_all_image_infos. We do the comparison by address
// rather than by file spec because we can have many modules with the same "file spec" in the
// case that they are modules loaded from memory.
//
// On Mac OS X libobjc (the Objective-C runtime) has several critical dispatch
// functions written in hand-written assembly, and also have hand-written unwind
// information in the eh_frame section. Normally we prefer analyzing the
-// assembly instructions of a curently executing frame to unwind from that frame --
+// assembly instructions of a currently executing frame to unwind from that frame --
// but on hand-written functions this profiling can fail. We should use the
// eh_frame instructions for these functions all the time.
//
if (process)
{
// Update the process stop ID that indicates the last time we updated the
- // map, wether it was successful or not.
+ // map, whether it was successful or not.
m_isa_to_descriptor_stop_id = process->GetStopID();
Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_PROCESS));
Error err;
// This currently holds true for all platforms we support, but we might
- // need to change this to use get the actualy byte size of "unsigned"
+ // need to change this to use get the actually byte size of "unsigned"
// from the target AST...
const uint32_t unsigned_byte_size = sizeof(uint32_t);
// Skip the prototype as we don't need it (const struct +NXMapTablePrototype *prototype)
RemoteNXMapTable hash_table;
// Update the process stop ID that indicates the last time we updated the
- // map, wether it was successful or not.
+ // map, whether it was successful or not.
m_isa_to_descriptor_stop_id = process->GetStopID();
if (!m_hash_signature.NeedsUpdate(process, this, hash_table))
m_hash_signature.UpdateSignature (hash_table);
- // Grab the dynamicly loaded objc classes from the hash table in memory
+ // Grab the dynamically loaded objc classes from the hash table in memory
UpdateISAToDescriptorMapDynamic(hash_table);
// Now get the objc classes that are baked into the Objective C runtime
if (segment_data.SetData(object_data, ph_offset, ph_size) != ph_size)
{
// The ELF program header contained incorrect data,
- // prabably corefile is incomplete or corrupted.
+ // probably corefile is incomplete or corrupted.
break;
}
(file.GetByteSize()-file_offset)/1024);
// For core files - which usually don't happen to have a gnu_debuglink,
- // and are pretty bulky - calulating whole contents crc32 would be too much of luxury.
+ // and are pretty bulky - calculating whole contents crc32 would be too much of luxury.
// Thus we will need to fallback to something simpler.
if (header.e_type == llvm::ELF::ET_CORE)
{
uint32_t &gnu_debuglink_crc,
ArchSpec &arch_spec)
{
- // Only intialize the arch_spec to okay defaults if they're not already set.
+ // Only initialize the arch_spec to okay defaults if they're not already set.
// We'll refine this with note data as we parse the notes.
if (arch_spec.GetTriple ().getOS () == llvm::Triple::OSType::UnknownOS)
{
case 7:
case 8:
case 9:
- // fancy flavors that encapsulate of the the above
- // falvors...
+ // fancy flavors that encapsulate of the above
+ // flavors...
break;
default:
case 7:
case 8:
case 9:
- // fancy flavors that encapsulate of the the above
- // falvors...
+ // fancy flavors that encapsulate of the above
+ // flavors...
break;
default:
{
if (load_cmd.fileoff > m_length)
{
- // We have a load command that says it extends past the end of hte file. This is likely
+ // We have a load command that says it extends past the end of the file. This is likely
// a corrupt file. We don't have any way to return an error condition here (this method
- // was likely invokved from something like ObjectFile::GetSectionList()) -- all we can do
+ // was likely invoked from something like ObjectFile::GetSectionList()) -- all we can do
// is null out the SectionList vector and if a process has been set up, dump a message
// to stdout. The most common case here is core file debugging with a truncated file.
const char *lc_segment_name = load_cmd.cmd == LC_SEGMENT_64 ? "LC_SEGMENT_64" : "LC_SEGMENT";
if (load_cmd.fileoff + load_cmd.filesize > m_length)
{
- // We have a load command that says it extends past the end of hte file. This is likely
+ // We have a load command that says it extends past the end of the file. This is likely
// a corrupt file. We don't have any way to return an error condition here (this method
- // was likely invokved from something like ObjectFile::GetSectionList()) -- all we can do
+ // was likely invoked from something like ObjectFile::GetSectionList()) -- all we can do
// is null out the SectionList vector and if a process has been set up, dump a message
// to stdout. The most common case here is core file debugging with a truncated file.
const char *lc_segment_name = load_cmd.cmd == LC_SEGMENT_64 ? "LC_SEGMENT_64" : "LC_SEGMENT";
load_cmd.vmaddr, // File VM address == addresses as they are found in the object file
load_cmd.vmsize, // VM size in bytes of this section
load_cmd.fileoff, // Offset to the data for this section in the file
- load_cmd.filesize, // Size in bytes of this section as found in the the file
+ load_cmd.filesize, // Size in bytes of this section as found in the file
0, // Segments have no alignment information
load_cmd.flags)); // Flags for this section
sect64.addr, // File VM address == addresses as they are found in the object file
sect64.size, // VM size in bytes of this section
sect64.offset, // Offset to the data for this section in the file
- sect64.offset ? sect64.size : 0, // Size in bytes of this section as found in the the file
+ sect64.offset ? sect64.size : 0, // Size in bytes of this section as found in the file
sect64.align,
load_cmd.flags)); // Flags for this section
segment_sp->SetIsFake(true);
if (path)
{
FileSpec file_spec(path, false);
- // Strip the path if there is @rpath, @executanble, etc so we just use the basename
+ // Strip the path if there is @rpath, @executable, etc so we just use the basename
if (path[0] == '@')
file_spec.GetDirectory().Clear();
const bool is_arm = (m_header.cputype == llvm::MachO::CPU_TYPE_ARM);
- // lldb works best if it knows the start addresss of all functions in a module.
+ // lldb works best if it knows the start address of all functions in a module.
// Linker symbols or debug info are normally the best source of information for start addr / size but
// they may be stripped in a released binary.
// Two additional sources of information exist in Mach-O binaries:
lldb_private::Mutex::Locker locker(module_sp->GetMutex());
struct load_command load_cmd;
lldb::offset_t offset = MachHeaderSizeFromMagic(m_header.magic);
- const bool resolve_path = false; // Don't resolve the dependend file paths since they may not reside on this system
+ const bool resolve_path = false; // Don't resolve the dependent file paths since they may not reside on this system
uint32_t i;
for (i=0; i<m_header.ncmds; ++i)
{
StopAllThreads(lldb::tid_t stop_tid);
/// Adds the thread to the list of threads for which we have received the initial stopping signal.
- /// The \p stop_tid paramter indicates the thread which the stop happened for.
+ /// The \p stop_tid parameter indicates the thread which the stop happened for.
bool
AddThreadForInitialStopIfNeeded(lldb::tid_t stop_tid);
// then the caller that requested the interrupt will want to keep the sequence
// locked down so that no one else can send packets while the caller has control.
// This function usually gets called when we are running and need to stop the
-// target. It can also be used when we are running and and we need to do something
+// target. It can also be used when we are running and we need to do something
// else (like read/write memory), so we need to interrupt the running process
// (gdb remote protocol requires this), and do what we need to do, then resume.
GDBRemoteCommunicationClient::SendArgumentsPacket (const ProcessLaunchInfo &launch_info)
{
// Since we don't get the send argv0 separate from the executable path, we need to
- // make sure to use the actual exectuable path found in the launch_info...
+ // make sure to use the actual executable path found in the launch_info...
std::vector<const char *> argv;
FileSpec exe_file = launch_info.GetExecutableFile();
std::string exe_path;
type,
addr,
length);
- // Check we havent overwritten the end of the packet buffer
+ // Check we haven't overwritten the end of the packet buffer
assert (packet_len + 1 < (int)sizeof(packet));
StringExtractorGDBRemote response;
// Try to send the breakpoint packet, and check that it was correctly sent
}
}
}
- // Signal generic faliure
+ // Signal generic failure
return UINT8_MAX;
}
bool
GDBRemoteCommunicationClient::RestoreRegisterState (lldb::tid_t tid, uint32_t save_id)
{
- // We use the "m_supports_QSaveRegisterState" variable here becuase the
+ // We use the "m_supports_QSaveRegisterState" variable here because the
// QSaveRegisterState and QRestoreRegisterState packets must both be supported in
// order to be useful
if (m_supports_QSaveRegisterState == eLazyBoolNo)
// indicates if the packet was send and any response was received
// even in the response is UNIMPLEMENTED. If the packet failed to
// get a response, then false is returned. This quickly tells us
- // if we were able to connect and communicte with the remote GDB
+ // if we were able to connect and communicate with the remote GDB
// server
bool
QueryNoAckModeSupported ();
/// directory for the platform process.
///
/// @param[in] path
- /// The path to a directory to use when launching our processs
+ /// The path to a directory to use when launching our process
///
/// @return
/// Zero if the for success, or an error code for failure.
// If a 'QListThreadsInStopReply' was sent to enable this feature, we
// will send all thread IDs back in the "threads" key whose value is
- // a listc of hex thread IDs separated by commas:
+ // a list of hex thread IDs separated by commas:
// "threads:10a,10b,10c;"
// This will save the debugger from having to send a pair of qfThreadInfo
// and qsThreadInfo packets, but it also might take a lot of room in the
success = false;
else
{
- // Decode the argument index. We ignore this really becuase
+ // Decode the argument index. We ignore this really because
// who would really send down the arguments in a random order???
const uint32_t arg_idx = packet.GetU32(UINT32_MAX);
if (arg_idx == UINT32_MAX)
Error error;
std::string hostname;
// TODO: /tmp/ should not be hardcoded. User might want to override /tmp
- // with the TMPDIR environnement variable
+ // with the TMPDIR environment variable
packet.SetFilePos(::strlen ("qLaunchGDBServer;"));
std::string name;
std::string value;
return true;
}
- // the launched process still lives. Now try killling it again,
+ // the launched process still lives. Now try killing it again,
// this time with an unblockable signal.
Host::Kill (pid, SIGKILL);
if (m_destroy_tried_resuming)
{
if (log)
- log->PutCString ("ProcessGDBRemote::DoDestroy()Tried resuming to destroy once already, not doing it again.");
+ log->PutCString ("ProcessGDBRemote::DoDestroy() - Tried resuming to destroy once already, not doing it again.");
}
else
{
return error;
}
- // We will reach here when the stub gives an unsported response to a hardware breakpoint
+ // We will reach here when the stub gives an unsupported response to a hardware breakpoint
if (log)
log->Printf("Hardware breakpoints are unsupported");
// character in gdb-remote binary mode. lldb currently doesn't escape
// these characters in its packet output -- so we add the quoted version
// of the } character here manually in case we talk to a debugserver which
- // un-escapes the chracters at packet read time.
+ // un-escapes the characters at packet read time.
packet << (char) (0x7d ^ 0x20);
StringExtractorGDBRemote response;
m_remote_stub_max_memory_size = stub_max_size;
// Even if the stub says it can support ginormous packets,
- // don't exceed our resonable largeish default packet size.
+ // don't exceed our reasonable largeish default packet size.
if (stub_max_size > reasonable_largeish_default)
{
stub_max_size = reasonable_largeish_default;
{
if (return_implementation_only_if_available)
{
- // We found the one true definiton for this class, so
+ // We found the one true definition for this class, so
// only return that
die_offsets.clear();
die_offsets.push_back (die_info_array[i].offset);
// is complete. If we don't do this, clang will crash when we
// call setBases() inside of "clang_type.SetBaseClassesForClassType()"
// below. Since we provide layout assistance, all ivars in this
- // class and other classe will be fine, this is the best we can do
+ // class and other classes will be fine, this is the best we can do
// short of crashing.
base_class_type.StartTagDeclarationDefinition ();
base_class_type.CompleteTagDeclarationDefinition ();
{
// We have a namespace_decl that was not NULL but it contained
// a NULL "clang::NamespaceDecl", so this means the global namespace
- // So as long the the contained decl context DIE isn't a namespace
+ // So as long the contained decl context DIE isn't a namespace
// we should be ok.
if (decl_ctx_die->Tag() != DW_TAG_namespace)
return true;
if (count1 != count2)
return false;
- // Make sure the DW_TAG values match all the way back up the the
+ // Make sure the DW_TAG values match all the way back up the
// compile unit. If they don't, then we are done.
const DWARFDebugInfoEntry *decl_ctx_die1;
const DWARFDebugInfoEntry *decl_ctx_die2;
if (accessibility == eAccessNone && decl_ctx)
{
// Check the decl context that contains this class/struct/union.
- // If it is a class we must give it an accessability.
+ // If it is a class we must give it an accessibility.
const clang::Decl::Kind containing_decl_kind = decl_ctx->getDeclKind();
if (DeclKindIsCXXClass (containing_decl_kind))
accessibility = default_accessibility;
// Start the definition if the class is not objective C since
// the underlying decls respond to isCompleteDefinition(). Objective
// C decls dont' respond to isCompleteDefinition() so we can't
- // start the declaration definition right away. For C++ classs/union/structs
+ // start the declaration definition right away. For C++ class/union/structs
// we want to start the definition in case the class is needed as the
// declaration context for a contained class or type without the need
// to complete that type..
const bool is_cxx_method = DeclKindIsCXXClass (containing_decl_kind);
// Start off static. This will be set to false in ParseChildParameters(...)
- // if we find a "this" paramters as the first parameter
+ // if we find a "this" parameters as the first parameter
if (is_cxx_method)
is_static = true;
// DWARF doesn't specify if a DW_TAG_variable is a local, global
// or static variable, so we have to do a little digging by
- // looking at the location of a varaible to see if it contains
+ // looking at the location of a variable to see if it contains
// a DW_OP_addr opcode _somewhere_ in the definition. I say
// somewhere because clang likes to combine small global variables
// into the same symbol and have locations like:
if (block == NULL)
{
// This must be a specification or abstract origin with
- // a concrete block couterpart in the current function. We need
+ // a concrete block counterpart in the current function. We need
// to find the concrete block so we can correctly add the
// variable to it
DWARFCompileUnit *concrete_block_die_cu = dwarf_cu;
LinkOSOFileAddress (SymbolFileDWARF *oso_symfile, lldb::addr_t oso_file_addr);
//------------------------------------------------------------------
- /// Given a line table full of lines with "file adresses" that are
+ /// Given a line table full of lines with "file addresses" that are
/// for a .o file represented by \a oso_symfile, link a new line table
/// and return it.
///
///
/// @return
/// Returns a valid line table full of linked addresses, or NULL
- /// if none of the line table adresses exist in the main
+ /// if none of the line table addresses exist in the main
/// executable.
//------------------------------------------------------------------
lldb_private::LineTable *
m_inst_emulator_ap.get())
{
- // The the instruction emulation subclass setup the unwind plan for the
+ // The instruction emulation subclass setup the unwind plan for the
// first instruction.
m_inst_emulator_ap->CreateFunctionEntryUnwind (unwind_plan);
// Initialize the CFA with a known value. In the 32 bit case
// it will be 0x80000000, and in the 64 bit case 0x8000000000000000.
- // We use the address byte size to be safe for any future addresss sizes
+ // We use the address byte size to be safe for any future address sizes
m_initial_sp = (1ull << ((addr_byte_size * 8) - 1));
RegisterValue cfa_reg_value;
cfa_reg_value.SetUInt (m_initial_sp, m_cfa_reg_info.byte_size);
// While parsing the instructions of this function, if we've ever
// seen the return address register (aka lr on arm) in a non-IsSame() state,
- // it has been saved on the stack. If it's evern back to IsSame(), we've
+ // it has been saved on the stack. If it's ever back to IsSame(), we've
// executed an epilogue.
if (ra_reg_num != LLDB_INVALID_REGNUM
&& m_curr_row->GetRegisterInfo (ra_reg_num, ra_regloc)
// Other libraries and framework includes
// Clang headers like to use NDEBUG inside of them to enable/disable debug
-// releated features using "#ifndef NDEBUG" preprocessor blocks to do one thing
+// related features using "#ifndef NDEBUG" preprocessor blocks to do one thing
// or another. This is bad because it means that if clang was built in release
// mode, it assumes that you are building in release mode which is not always
// the case. You can end up with functions that are defined as empty in header
{
// FIXME: Cleanup per-file based stuff.
- // Set some properties which depend soley on the input kind; it would be nice
+ // Set some properties which depend solely on the input kind; it would be nice
// to move these to the language standard, and have the driver resolve the
// input kind + language standard.
if (IK == IK_Asm) {
g_type_map.Append(ConstString("__int128_t").GetCString(), eBasicTypeInt128);
g_type_map.Append(ConstString("__uint128_t").GetCString(), eBasicTypeUnsignedInt128);
- // Miscelaneous
+ // Miscellaneous
g_type_map.Append(ConstString("bool").GetCString(), eBasicTypeBool);
g_type_map.Append(ConstString("float").GetCString(), eBasicTypeFloat);
g_type_map.Append(ConstString("double").GetCString(), eBasicTypeDouble);
if(op_kind == OO_Call)
return true;
- // The parameter count doens't include "this"
+ // The parameter count doesn't include "this"
if (num_params == 0)
return unary;
if (num_params == 1)
if (process)
{
lldb::offset_t offset = data_byte_offset;
- lldb::addr_t pointer_addresss = data.GetMaxU64(&offset, data_byte_size);
+ lldb::addr_t pointer_address = data.GetMaxU64(&offset, data_byte_size);
std::vector<uint8_t> buf;
if (length > 0)
buf.resize (length);
size_t bytes_read;
size_t total_cstr_len = 0;
Error error;
- while ((bytes_read = process->ReadMemory (pointer_addresss, &buf.front(), buf.size(), error)) > 0)
+ while ((bytes_read = process->ReadMemory (pointer_address, &buf.front(), buf.size(), error)) > 0)
{
const size_t len = strlen((const char *)&buf.front());
if (len == 0)
total_cstr_len += len;
if (len < buf.size())
break;
- pointer_addresss += total_cstr_len;
+ pointer_address += total_cstr_len;
}
if (total_cstr_len > 0)
s->PutChar ('"');
// Other libraries and framework includes
// Clang headers like to use NDEBUG inside of them to enable/disable debug
-// releated features using "#ifndef NDEBUG" preprocessor blocks to do one thing
+// related features using "#ifndef NDEBUG" preprocessor blocks to do one thing
// or another. This is bad because it means that if clang was built in release
// mode, it assumes that you are building in release mode which is not always
// the case. You can end up with functions that are defined as empty in header
virtual const Property *
GetPropertyAtIndex (const ExecutionContext *exe_ctx, bool will_modify, uint32_t idx) const
{
- // When gettings the value for a key from the process options, we will always
+ // When getting the value for a key from the process options, we will always
// try and grab the setting from the current process if there is one. Else we just
// use the one from this instance.
if (exe_ctx)
}
// This static callback can be used to watch for local child processes on
-// the current host. The the child process exits, the process will be
+// the current host. The child process exits, the process will be
// found in the global target list (we want to be completely sure that the
// lldb_private::Process doesn't go away before we can deliver the signal.
bool
const uint8_t * const break_op = bp_site->GetTrapOpcodeBytes();
if (break_op_size > 0)
{
- // Clear a software breakoint instruction
+ // Clear a software breakpoint instruction
uint8_t curr_break_op[8];
assert (break_op_size <= sizeof(curr_break_op));
bool break_op_found = false;
break;
default:
// TODO: make this work correctly. For now always report
- // run if we aren't running so we don't miss any runnning
+ // run if we aren't running so we don't miss any running
// events. If I run the lldb/test/thread/a.out file and
// break at main.cpp:58, run and hit the breakpoints on
// multiple threads, then somehow during the stepping over
{
case eBroadcastInternalStateControlStop:
exit_now = true;
- break; // doing any internal state managment below
+ break; // doing any internal state management below
case eBroadcastInternalStateControlPause:
control_only = true;
if (stop_id == eStopIDNow)
{
// If we are asking for the latest and greatest value, it is always
- // at the end of our list becuase that will be the highest stop ID.
+ // at the end of our list because that will be the highest stop ID.
StopIDToSectionLoadList::reverse_iterator rpos = m_stop_id_to_section_load_list.rbegin();
return rpos->second.get();
}
"Target::SetExecutableModule (executable = '%s')",
executable_sp->GetFileSpec().GetPath().c_str());
- m_images.Append(executable_sp); // The first image is our exectuable file
+ m_images.Append(executable_sp); // The first image is our executable file
// If we haven't set an architecture yet, reset our architecture based on what we found in the executable module.
if (!m_arch.IsValid())
SectionSP section_sp (addr.GetSection());
if (section_sp)
{
- // If the contents of this section are encrypted, the on-disk file is unusuable. Read only from live memory.
+ // If the contents of this section are encrypted, the on-disk file is unusable. Read only from live memory.
if (section_sp->IsEncrypted())
{
error.SetErrorString("section is encrypted");
}
else
{
- // We have at least one section loaded. This can be becuase
+ // We have at least one section loaded. This can be because
// we have manually loaded some sections with "target modules load ..."
// or because we have have a live process that has sections loaded
// through the dynamic loader
}
// If the address is not section offset we have an address that
// doesn't resolve to any address in any currently loaded shared
- // libaries and we failed to read memory so there isn't anything
+ // libraries and we failed to read memory so there isn't anything
// more we can do. If it is section offset, we might be able to
// read cached memory from the object file.
if (!resolved_addr.IsSectionOffset())
}
else
{
- // We have at least one section loaded. This can be becuase
+ // We have at least one section loaded. This can be because
// we have manually loaded some sections with "target modules load ..."
// or because we have have a live process that has sections loaded
// through the dynamic loader
virtual const Property *
GetPropertyAtIndex (const ExecutionContext *exe_ctx, bool will_modify, uint32_t idx) const
{
- // When gettings the value for a key from the target options, we will always
+ // When getting the value for a key from the target options, we will always
// try and grab the setting from the current target if there is one. Else we just
// use the one from this instance.
if (idx == ePropertyEnvVars)
virtual const Property *
GetPropertyAtIndex (const ExecutionContext *exe_ctx, bool will_modify, uint32_t idx) const
{
- // When gettings the value for a key from the thread options, we will always
+ // When getting the value for a key from the thread options, we will always
// try and grab the setting from the current thread if there is one. Else we just
// use the one from this instance.
if (exe_ctx)
m_addresses (addresses),
m_break_ids ()
{
- // Convert all addressses into opcode addresses to make sure we set
+ // Convert all addresses into opcode addresses to make sure we set
// breakpoints at the correct address.
Target &target = thread.GetProcess()->GetTarget();
std::vector<lldb::addr_t>::iterator pos, end = m_addresses.end();
// Destructor
//
// The destructor will close the master and slave file descriptors
-// if they are valid and ownwership has not been released using the
+// if they are valid and ownership has not been released using the
// ReleaseMasterFileDescriptor() or the ReleaseSaveFileDescriptor()
// member functions.
//----------------------------------------------------------------------
" host - log host activities\n"
" jit - log JIT events in the target\n"
" mmap - log mmap related activities\n"
- " module - log module activities such as when modules are created, detroyed, replaced, and more\n"
+ " module - log module activities such as when modules are created, destroyed, replaced, and more\n"
" object - log object construction/destruction for important objects\n"
" os - log OperatingSystem plugin related activities\n"
" platform - log platform events and activities\n"
based rules to build binaries for the inferiors.
By default, the built executable name is a.out, which can be overwritten by
- specifying your EXE make variable, via the Makefile under the specfic test
+ specifying your EXE make variable, via the Makefile under the specific test
directory or via supplying a Python dictionary to the build method in your
Python test script. An example of the latter can be found in
test/lang/objc/radar-9691614/TestObjCMethodReturningBOOL.py, where:
bmExecutable = None
# The breakpoint specification of bmExecutable, as specified by the '-x' option.
bmBreakpointSpec = None
-# The benchamrk iteration count, as specified by the '-y' option.
+# The benchmark iteration count, as specified by the '-y' option.
bmIterationCount = -1
# By default, don't exclude any directories. Use '-X' to add one excluded directory.
print """
Examples:
-This is an example of using the -f option to pinpoint to a specfic test class
+This is an example of using the -f option to pinpoint to a specific test class
and test method to be run:
$ ./dotest.py -f ClassTypesTestCase.test_with_dsym_and_run_command
Overwrite addError(), addFailure(), and addExpectedFailure() methods
to enable each test instance to track its failure/error status. It
is used in the LLDB test framework to emit detailed trace messages
- to a log file for easier human inspection of test failres/errors.
+ to a log file for easier human inspection of test failures/errors.
"""
__singleton__ = None
__ignore_singleton__ = False
substrs = ['stop reason = watchpoint'])
# Before continuing, we'll disable the watchpoint, which means we won't
- # stop agian after this.
+ # stop again after this.
self.runCmd("watchpoint disable")
self.expect("watchpoint list -v",
substrs = ['stop reason = breakpoint'])
# Before continuing, we'll enable the watchpoint, which means we will
- # stop agian after this.
+ # stop again after this.
self.runCmd("watchpoint enable")
self.expect("watchpoint list -v",
line_number = thread.GetFrameAtIndex(0).GetLineEntry().GetLine()
self.assertTrue (line_number == self.sourceBase_returnsStruct_start_line, "Stepped through super into SourceBase returnsStruct.")
- # Cool now continue to get past the call that intializes the Observer, and then do our steps in again to see that
+ # Cool now continue to get past the call that initializes the Observer, and then do our steps in again to see that
# we can find our way when we're stepping through a KVO swizzled object.
threads = lldbutil.continue_to_breakpoint (process, break3)
case 'E':
{
// Since we will exec this program into our new program, we can just set environment
- // varaibles in this process and they will make it into the child process.
+ // variables in this process and they will make it into the child process.
std::string name;
std::string value;
const char *equal_pos = strchr (optarg, '=');
2008-12-05 Greg Clayton <gclayton@apple.com>
* DNBDefs.h (LOG_TASK): New log bit.
- * DNB.cpp (DNBProcessIsAlive): User newly abtracted MachTask class.
+ * DNB.cpp (DNBProcessIsAlive): User newly abstracted MachTask class.
(DNBProcessMemoryRead): Ditto.
(DNBProcessMemoryWrite): Ditto.
* DNBArchImpl.cpp (DNBArchMachARM::EnableHardwareSingleStep): Ditto.
(MachException::PortInfo::Restore): Cleaned up logging and now return an
error instead of the number of restored port infos.
* MachProcess.cpp (class MachProcess): Abstracted out all of the task_t
- related stuff (suspend, resuyme, exception ports, exception thread, and
+ related stuff (suspend, resume, exception ports, exception thread, and
more) into a new class MachTask.
(MachProcess::Task): Now returns a reference to a MachTask class.
(MachProcess::Clear): Uses new abstracted MachTask class.
* arm/DBNArchImpl.cpp (DNBArchMachARM::EnableHardwareSingleStep): Log using
new LOG_STEP instead of LOG_BREAKPOINTS.
(DNBArchMachARM::SetSingleStepSoftwareBreakpoints): Ditto.
- * MachException.cpp (MachException::Message::Dump): Log excetion header
+ * MachException.cpp (MachException::Message::Dump): Log exception header
and reply header on two separate lines.
* MachProcess.cpp (IsSBProcess): Check for NULL CFArrayRef returned from
SBSCopyApplicationDisplayIdentifiers for SkankPhone.
* RNBRemote.h: Change default for gdb's max incoming packet size to
reflect the real default size.
- * RNBRemote.cpp (HandlePacket_Q): Correct the string comparisions for
+ * RNBRemote.cpp (HandlePacket_Q): Correct the string comparisons for
the QSetMaxPayloadSize and QSetMaxPacketSize packets.
2008-02-19 Christopher Friesen <friesen@apple.com>
m_pid = ::getpid ();
else
m_pid = pid;
- return m_pid; // Return actualy PID in case a zero pid was passed in
+ return m_pid; // Return actually PID in case a zero pid was passed in
}
nub_state_t
const uint8_t * const break_op = DNBArchProtocol::GetBreakpointOpcode (bp->ByteSize());
if (break_op_size > 0)
{
- // Clear a software breakoint instruction
+ // Clear a software breakpoint instruction
uint8_t curr_break_op[break_op_size];
bool break_op_found = false;
// MACH_RCV_TIMEOUT option with a zero timeout to grab all other current
// exceptions for our process. After we have received the last pending
// exception, we will get a timeout which enables us to then notify
- // our main thread that we have an exception bundle avaiable. We then wait
+ // our main thread that we have an exception bundle available. We then wait
// for the main thread to tell this exception thread to start trying to get
// exceptions messages again and we start again with a mach_msg read with
// infinite timeout.
// MACH_RCV_TIMEOUT option with a zero timeout to grab all other current
// exceptions for our process. After we have received the last pending
// exception, we will get a timeout which enables us to then notify
- // our main thread that we have an exception bundle avaiable. We then wait
+ // our main thread that we have an exception bundle available. We then wait
// for the main thread to tell this exception thread to start trying to get
// exceptions messages again and we start again with a mach_msg read with
// infinite timeout.
{
// Step required to add new packets:
// 1 - Add new enumeration to RNBRemote::PacketEnum
- // 2 - Create a the RNBRemote::HandlePacket_ function if a new function is needed
+ // 2 - Create the RNBRemote::HandlePacket_ function if a new function is needed
// 3 - Register the Packet definition with any needed callbacks in this function
// - If no response is needed for a command, then use NULL for the normal callback
// - If the packet is not supported while the target is running, use NULL for the async callback
// t.push_back (Packet (query_symbol_lookup, &RNBRemote::HandlePacket_UNIMPLEMENTED, NULL, "qSymbol", "Notify that host debugger is ready to do symbol lookups"));
t.push_back (Packet (json_query_thread_extended_info, &RNBRemote::HandlePacket_jThreadExtendedInfo, NULL, "jThreadExtendedInfo", "Replies with JSON data of thread extended information."));
t.push_back (Packet (start_noack_mode, &RNBRemote::HandlePacket_QStartNoAckMode , NULL, "QStartNoAckMode", "Request that " DEBUGSERVER_PROGRAM_NAME " stop acking remote protocol packets"));
- t.push_back (Packet (prefix_reg_packets_with_tid, &RNBRemote::HandlePacket_QThreadSuffixSupported , NULL, "QThreadSuffixSupported", "Check if thread specifc packets (register packets 'g', 'G', 'p', and 'P') support having the thread ID appended to the end of the command"));
+ t.push_back (Packet (prefix_reg_packets_with_tid, &RNBRemote::HandlePacket_QThreadSuffixSupported , NULL, "QThreadSuffixSupported", "Check if thread specific packets (register packets 'g', 'G', 'p', and 'P') support having the thread ID appended to the end of the command"));
t.push_back (Packet (set_logging_mode, &RNBRemote::HandlePacket_QSetLogging , NULL, "QSetLogging:", "Check if register packets ('g', 'G', 'p', and 'P' support having the thread ID prefix"));
t.push_back (Packet (set_max_packet_size, &RNBRemote::HandlePacket_QSetMaxPacketSize , NULL, "QSetMaxPacketSize:", "Tell " DEBUGSERVER_PROGRAM_NAME " the max sized packet gdb can handle"));
t.push_back (Packet (set_max_payload_size, &RNBRemote::HandlePacket_QSetMaxPayloadSize , NULL, "QSetMaxPayloadSize:", "Tell " DEBUGSERVER_PROGRAM_NAME " the max sized payload gdb can handle"));
t.push_back (Packet (set_environment_variable, &RNBRemote::HandlePacket_QEnvironment , NULL, "QEnvironment:", "Add an environment variable to the inferior's environment"));
t.push_back (Packet (set_environment_variable_hex, &RNBRemote::HandlePacket_QEnvironmentHexEncoded , NULL, "QEnvironmentHexEncoded:", "Add an environment variable to the inferior's environment"));
t.push_back (Packet (set_launch_arch, &RNBRemote::HandlePacket_QLaunchArch , NULL, "QLaunchArch:", "Set the architecture to use when launching a process for hosts that can run multiple architecture slices from universal files."));
- t.push_back (Packet (set_disable_aslr, &RNBRemote::HandlePacket_QSetDisableASLR , NULL, "QSetDisableASLR:", "Set wether to disable ASLR when launching the process with the set argv ('A') packet"));
+ t.push_back (Packet (set_disable_aslr, &RNBRemote::HandlePacket_QSetDisableASLR , NULL, "QSetDisableASLR:", "Set whether to disable ASLR when launching the process with the set argv ('A') packet"));
t.push_back (Packet (set_stdin, &RNBRemote::HandlePacket_QSetSTDIO , NULL, "QSetSTDIN:", "Set the standard input for a process to be launched with the 'A' packet"));
t.push_back (Packet (set_stdout, &RNBRemote::HandlePacket_QSetSTDIO , NULL, "QSetSTDOUT:", "Set the standard output for a process to be launched with the 'A' packet"));
t.push_back (Packet (set_stderr, &RNBRemote::HandlePacket_QSetSTDIO , NULL, "QSetSTDERR:", "Set the standard error for a process to be launched with the 'A' packet"));
QEnvironmentHexEncoded:VARIABLE=VALUE
- The VARIABLE=VALUE part is sent hex-encoded so chracters like '#' with special
+ The VARIABLE=VALUE part is sent hex-encoded so characters like '#' with special
meaning in the remote protocol won't break it.
*/
}
else
{
- // If we fail to read a regiser value, check if it has a default
+ // If we fail to read a register value, check if it has a default
// fail value. If it does, return this instead in case some of
// the registers are not available on the current system.
if (reg->nub_info.size > 0)
// If a 'QListThreadsInStopReply' was sent to enable this feature, we
// will send all thread IDs back in the "threads" key whose value is
- // a listc of hex thread IDs separated by commas:
+ // a list of hex thread IDs separated by commas:
// "threads:10a,10b,10c;"
// This will save the debugger from having to send a pair of qfThreadInfo
// and qsThreadInfo packets, but it also might take a lot of room in the
// Type: Template method.
// Args: vErrorResrcId - (R) The string resource ID error message identifier to place in errMsg.
// vwrbOk - (RW) On input True = Try to initalise MI driver module.
-// On output True = MI driver module intialise successfully.
-// vwrErrMsg - (W) MI driver module intialise error description on failure.
+// On output True = MI driver module initialise successfully.
+// vwrErrMsg - (W) MI driver module initialise error description on failure.
// Return: MIstatus::success - Functional succeeded.
// MIstatus::failure - Functional failed.
// Authors: Aidan Dodds 17/03/2014.
// vwrbOk - (W) If not already false make false on module
// shutdown failure.
// vwrErrMsg - (RW) Append to existing error description string MI
-// driver module intialise error description on
+// driver module initialise error description on
// failure.
// Return: True - Module shutdown succeeded.
// False - Module shutdown failed.
<tr>
<td class="content">
<b>(gdb)</b> break main<br>
- <i>(Hope that there are no C funtions named <b>main</b>)</i>.
+ <i>(Hope that there are no C functions named <b>main</b>)</i>.
</td>
<td class="content">
<b>(lldb)</b> breakpoint set --method main<br>
<tr>
<td class="content">
<b>(gdb)</b> break count<br>
- <i>(Hope that there are no C or C++ funtions named <b>count</b>)</i>.
+ <i>(Hope that there are no C or C++ functions named <b>count</b>)</i>.
</td>
<td class="content">
<b>(lldb)</b> breakpoint set --selector count<br>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1" />
<link href="style.css" rel="stylesheet" type="text/css" />
-<title>Debug Sybmols on Mac OS X</title>
+<title>Debug Symbols on Mac OS X</title>
</head>
<body>
<key>DBGDSYMPath</key>
<string>/path/to/foo.dSYM/Contents/Resources/DWARF/foo</string>
<key>DBGSymbolRichExecutable</key>
- <string>/path/to/unstripped/exectuable</string>
+ <string>/path/to/unstripped/executable</string>
</dict>
<key>A40597AA-5529-3337-8C09-D8A014EB1578</key>
<dict>
<key>DBGDSYMPath</key>
<string>/path/to/foo.dSYM/Contents/Resources/DWARF/foo</string>
<key>DBGSymbolRichExecutable</key>
- <string>/path/to/unstripped/exectuable</string>
+ <string>/path/to/unstripped/executable</string>
</dict>
</dict>
</plist>
<key>DBGDSYMPath</key>
<string>/path/to/foo.dSYM/Contents/Resources/DWARF/foo</string>
<key>DBGSymbolRichExecutable</key>
- <string>/path/to/unstripped/exectuable</string>
+ <string>/path/to/unstripped/executable</string>
</dict>
</plist>
</tt></pre></code>
</div>
</div>
</body>
-</html>
\ No newline at end of file
+</html>