reference, declaration → definition
definition → references, declarations, derived classes, virtual overrides
reference to multiple definitions → definitions
unreferenced

Definitions

   17 class LLDB_API SBAddress {

   18 class LLDB_API SBAttachInfo {

   19 class LLDB_API SBBlock {

   18 class LLDB_API SBBreakpoint {
  153 class LLDB_API SBBreakpointList {

   17 class LLDB_API SBBreakpointLocation {

   18 class LLDB_API SBBreakpointName {

   16 class LLDB_API SBBroadcaster {

   65 class SBCommandInterpreter {
  261 class SBCommand {

   24 class LLDB_API SBCommandReturnObject {

   17 class LLDB_API SBCommunication {

   17 class LLDB_API SBCompileUnit {

   16 class LLDB_API SBData {

   34 class LLDB_API SBDebugger {

   18 class LLDB_API SBDeclaration {

   16 class LLDB_API SBError {

   21 class LLDB_API SBEvent {

   20 class LLDB_API SBExecutionContext {

   18 class LLDB_API SBExpressionOptions {

   16 class LLDB_API SBFile {

   16 class LLDB_API SBFileSpec {

   17 class LLDB_API SBFileSpecList {

   17 class LLDB_API SBFrame {

   18 class LLDB_API SBFunction {

   24 class LLDB_API SBInstruction {

   18 class LLDB_API SBInstructionList {

   23 class LLDB_API SBLaunchInfo {

   18 class LLDB_API SBLineEntry {

   16 class LLDB_API SBListener {

   17 class LLDB_API SBMemoryRegionInfo {

   18 class LLDB_API SBMemoryRegionInfoList {

   20 class LLDB_API SBModule {

   17 class LLDB_API SBModuleSpec {
   90 class SBModuleSpecList {

   23 class LLDB_API SBPlatformConnectOptions {
   52 class LLDB_API SBPlatformShellCommand {
   86 class LLDB_API SBPlatform {

   23 class LLDB_API SBProcess {

   16 class LLDB_API SBProcessInfo {

   19 class LLDB_API SBQueue {

   17 class LLDB_API SBQueueItem {

   17 class LLDB_API SBSection {

   18 class LLDB_API SBSourceManager {

   18 class LLDB_API SBStream {

   16 class LLDB_API SBStringList {

   17 class SBStructuredData {

   19 class LLDB_API SBSymbol {

   22 class LLDB_API SBSymbolContext {

   17 class LLDB_API SBSymbolContextList {

   29 class LLDB_API SBTarget {

   20 class LLDB_API SBThread {

   16 class LLDB_API SBThreadCollection {

   18 class LLDB_API SBThreadPlan {

   19 class LLDB_API SBTrace {

   16 class LLDB_API SBTraceOptions {

   18 class LLDB_API SBTypeMember {
   59 class SBTypeMemberFunction {
  104 class SBType {
  234 class SBTypeList {

   17 class LLDB_API SBTypeCategory {

   17 class LLDB_API SBTypeEnumMember {
   57 class SBTypeEnumMemberList {

   17 class LLDB_API SBTypeFilter {

   17 class LLDB_API SBTypeFormat {

   17 class LLDB_API SBTypeNameSpecifier {

   16 class LLDB_API SBTypeSummaryOptions {
   57 class SBTypeSummary {

   17 class LLDB_API SBTypeSynthetic {

   17 class LLDB_API SBUnixSignals {

   21 class LLDB_API SBValue {

   18 class LLDB_API SBValueList {

   19 class LLDB_API SBVariablesOptions {

   16 class LLDB_API SBWatchpoint {

  509   template <Result (Class::*m)(Args...)> struct method {

   57 const SBAddress &SBAddress::operator=(const SBAddress &rhs) {
  154 bool SBAddress::OffsetAddress(addr_t offset) {
  167 lldb::SBSection SBAddress::GetSection() {
  176 lldb::addr_t SBAddress::GetOffset() {
  203 bool SBAddress::GetDescription(SBStream &description) {
  219 SBModule SBAddress::GetModule() {
  228 SBSymbolContext SBAddress::GetSymbolContext(uint32_t resolve_scope) {
  239 SBCompileUnit SBAddress::GetCompileUnit() {
  248 SBFunction SBAddress::GetFunction() {
  257 SBBlock SBAddress::GetBlock() {
  266 SBSymbol SBAddress::GetSymbol() {
  275 SBLineEntry SBAddress::GetLineEntry() {

   61 SBAttachInfo &SBAttachInfo::operator=(const SBAttachInfo &rhs) {
   70 lldb::pid_t SBAttachInfo::GetProcessID() {
   82 uint32_t SBAttachInfo::GetResumeCount() {
   94 const char *SBAttachInfo::GetProcessPluginName() {
  126 bool SBAttachInfo::GetWaitForLaunch() {
  146 bool SBAttachInfo::GetIgnoreExisting() {
  158 uint32_t SBAttachInfo::GetUserID() {
  164 uint32_t SBAttachInfo::GetGroupID() {
  170 bool SBAttachInfo::UserIDIsValid() {
  176 bool SBAttachInfo::GroupIDIsValid() {
  194 uint32_t SBAttachInfo::GetEffectiveUserID() {
  200 uint32_t SBAttachInfo::GetEffectiveGroupID() {
  206 bool SBAttachInfo::EffectiveUserIDIsValid() {
  212 bool SBAttachInfo::EffectiveGroupIDIsValid() {
  230 lldb::pid_t SBAttachInfo::GetParentProcessID() {
  243 bool SBAttachInfo::ParentProcessIDIsValid() {
  249 SBListener SBAttachInfo::GetListener() {

   39 const SBBlock &SBBlock::operator=(const SBBlock &rhs) {
  133 SBBlock SBBlock::GetParent() {
  142 lldb::SBBlock SBBlock::GetContainingInlinedBlock() {
  151 SBBlock SBBlock::GetSibling() {
  160 SBBlock SBBlock::GetFirstChild() {
  173 bool SBBlock::GetDescription(SBStream &description) {
  198 uint32_t SBBlock::GetNumRanges() {
  206 lldb::SBAddress SBBlock::GetRangeStartAddress(uint32_t idx) {
  220 lldb::SBAddress SBBlock::GetRangeEndAddress(uint32_t idx) {
  235 uint32_t SBBlock::GetRangeIndexForBlockAddress(lldb::SBAddress block_addr) {
  246 lldb::SBValueList SBBlock::GetVariables(lldb::SBFrame &frame, bool arguments,
  303 lldb::SBValueList SBBlock::GetVariables(lldb::SBTarget &target, bool arguments,

   62 const SBBreakpoint &SBBreakpoint::operator=(const SBBreakpoint &rhs) {
   70 bool SBBreakpoint::operator==(const lldb::SBBreakpoint &rhs) {
   77 bool SBBreakpoint::operator!=(const lldb::SBBreakpoint &rhs) {
  122 SBBreakpointLocation SBBreakpoint::FindLocationByAddress(addr_t vm_addr) {
  144 break_id_t SBBreakpoint::FindLocationIDByAddress(addr_t vm_addr) {
  165 SBBreakpointLocation SBBreakpoint::FindLocationByID(break_id_t bp_loc_id) {
  181 SBBreakpointLocation SBBreakpoint::GetLocationAtIndex(uint32_t index) {
  209 bool SBBreakpoint::IsEnabled() {
  245 bool SBBreakpoint::IsInternal() {
  281 const char *SBBreakpoint::GetCondition() {
  305 bool SBBreakpoint::GetAutoContinue() {
  356 tid_t SBBreakpoint::GetThreadID() {
  502 bool SBBreakpoint::GetCommandLineCommands(SBStringList &commands) {
  517 bool SBBreakpoint::GetDescription(SBStream &s) {
  523 bool SBBreakpoint::GetDescription(SBStream &s, bool include_locations) {
  544 SBError SBBreakpoint::AddLocation(SBAddress &address) {
  602 SBError SBBreakpoint::SetScriptCallbackFunction(
  629 SBError SBBreakpoint::SetScriptCallbackBody(const char *callback_body_text) {
  652 bool SBBreakpoint::AddName(const char *new_name) {
  684 bool SBBreakpoint::MatchesName(const char *name) {
  887 SBBreakpoint SBBreakpointList::GetBreakpointAtIndex(size_t idx) {
  898 SBBreakpoint SBBreakpointList::FindBreakpointByID(lldb::break_id_t id) {
  928 bool SBBreakpointList::AppendIfUnique(const SBBreakpoint &sb_bkpt) {

   52 operator=(const SBBreakpointLocation &rhs) {
   78 SBAddress SBBreakpointLocation::GetAddress() {
   89 addr_t SBBreakpointLocation::GetLoadAddress() {
  116 bool SBBreakpointLocation::IsEnabled() {
  128 uint32_t SBBreakpointLocation::GetHitCount() {
  140 uint32_t SBBreakpointLocation::GetIgnoreCount() {
  175 const char *SBBreakpointLocation::GetCondition() {
  199 bool SBBreakpointLocation::GetAutoContinue() {
  217 SBError SBBreakpointLocation::SetScriptCallbackFunction(
  247 SBBreakpointLocation::SetScriptCallbackBody(const char *callback_body_text) {
  289 bool SBBreakpointLocation::GetCommandLineCommands(SBStringList &commands) {
  316 tid_t SBBreakpointLocation::GetThreadID() {
  405 bool SBBreakpointLocation::IsResolved() {
  423 bool SBBreakpointLocation::GetDescription(SBStream &description,
  443 break_id_t SBBreakpointLocation::GetID() {
  455 SBBreakpoint SBBreakpointLocation::GetBreakpoint() {

  164 operator=(const SBBreakpointName &rhs) {
  179 bool SBBreakpointName::operator==(const lldb::SBBreakpointName &rhs) {
  186 bool SBBreakpointName::operator!=(const lldb::SBBreakpointName &rhs) {
  237 bool SBBreakpointName::IsEnabled() {
  319 const char *SBBreakpointName::GetCondition() {
  347 bool SBBreakpointName::GetAutoContinue() {
  374 tid_t SBBreakpointName::GetThreadID() {
  492 bool SBBreakpointName::GetCommandLineCommands(SBStringList &commands) {
  533 bool SBBreakpointName::GetDescription(SBStream &s) {
  577 SBError SBBreakpointName::SetScriptCallbackFunction(
  608 SBBreakpointName::SetScriptCallbackBody(const char *callback_body_text) {
  652 bool SBBreakpointName::GetAllowDelete() {
  671 bool SBBreakpointName::GetAllowDisable() {

   38 const SBBroadcaster &SBBroadcaster::operator=(const SBBroadcaster &rhs) {
   90 uint32_t SBBroadcaster::AddListener(const SBListener &listener,
  109 bool SBBroadcaster::EventTypeHasListeners(uint32_t event_type) {
  118 bool SBBroadcaster::RemoveListener(const SBListener &listener,

  191 operator=(const SBCommandInterpreter &rhs) {
  211 bool SBCommandInterpreter::CommandExists(const char *cmd) {
  219 bool SBCommandInterpreter::AliasExists(const char *cmd) {
  227 bool SBCommandInterpreter::IsActive() {
  239 const char *SBCommandInterpreter::GetIOHandlerControlSequence(char ch) {
  251 SBCommandInterpreter::HandleCommand(const char *command_line,
  262 lldb::ReturnStatus SBCommandInterpreter::HandleCommand(
  329 int SBCommandInterpreter::HandleCompletion(
  344 int SBCommandInterpreter::HandleCompletionWithDescriptions(
  414 int SBCommandInterpreter::HandleCompletionWithDescriptions(
  432 int SBCommandInterpreter::HandleCompletion(const char *current_line,
  448 bool SBCommandInterpreter::HasCommands() {
  454 bool SBCommandInterpreter::HasAliases() {
  460 bool SBCommandInterpreter::HasAliasOptions() {
  466 SBProcess SBCommandInterpreter::GetProcess() {
  483 SBDebugger SBCommandInterpreter::GetDebugger() {
  494 bool SBCommandInterpreter::GetPromptOnQuit() {
  515 bool SBCommandInterpreter::HasCustomQuitExitCode() {
  524 int SBCommandInterpreter::GetQuitStatus() {
  596 SBBroadcaster SBCommandInterpreter::GetBroadcaster() {
  662 lldb::SBCommand SBCommandInterpreter::AddMultiwordCommand(const char *name,
  677 lldb::SBCommand SBCommandInterpreter::AddCommand(
  695 SBCommandInterpreter::AddCommand(const char *name,
  717 bool SBCommand::IsValid() {
  727 const char *SBCommand::GetName() {
  733 const char *SBCommand::GetHelp() {
  740 const char *SBCommand::GetHelpLong() {
  761 lldb::SBCommand SBCommand::AddMultiwordCommand(const char *name,
  779 lldb::SBCommand SBCommand::AddCommand(const char *name,
  799 lldb::SBCommand SBCommand::AddCommand(const char *name,
  819 uint32_t SBCommand::GetFlags() {

   68 operator=(const SBCommandReturnObject &rhs) {
   92 const char *SBCommandReturnObject::GetOutput() {
   99 const char *SBCommandReturnObject::GetError() {
  106 size_t SBCommandReturnObject::GetOutputSize() {
  112 size_t SBCommandReturnObject::GetErrorSize() {
  118 size_t SBCommandReturnObject::PutOutput(FILE *fh) {
  128 size_t SBCommandReturnObject::PutOutput(FileSP file_sp) {
  136 size_t SBCommandReturnObject::PutOutput(SBFile file) {
  143 size_t SBCommandReturnObject::PutError(FILE *fh) {
  153 size_t SBCommandReturnObject::PutError(FileSP file_sp) {
  161 size_t SBCommandReturnObject::PutError(SBFile file) {
  174 lldb::ReturnStatus SBCommandReturnObject::GetStatus() {
  188 bool SBCommandReturnObject::Succeeded() {
  194 bool SBCommandReturnObject::HasResult() {
  230 bool SBCommandReturnObject::GetDescription(SBStream &description) {
  323 const char *SBCommandReturnObject::GetOutput(bool only_if_no_immediate) {
  333 const char *SBCommandReturnObject::GetError(bool only_if_no_immediate) {

   45 bool SBCommunication::GetCloseOnEOF() {
   60 ConnectionStatus SBCommunication::Connect(const char *url) {
   72 ConnectionStatus SBCommunication::AdoptFileDesriptor(int fd, bool owns_fd) {
   91 ConnectionStatus SBCommunication::Disconnect() {
  140 bool SBCommunication::ReadThreadStart() {
  146 bool SBCommunication::ReadThreadStop() {
  152 bool SBCommunication::ReadThreadIsRunning() {
  172 SBBroadcaster SBCommunication::GetBroadcaster() {

   36 const SBCompileUnit &SBCompileUnit::operator=(const SBCompileUnit &rhs) {
  128 lldb::SBTypeList SBCompileUnit::GetTypes(uint32_t type_mask) {
  166 uint32_t SBCompileUnit::FindSupportFileIndex(uint32_t start_idx,
  180 lldb::LanguageType SBCompileUnit::GetLanguage() {
  226 bool SBCompileUnit::GetDescription(SBStream &description) {

   35 const SBData &SBData::operator=(const SBData &rhs) {
   60 bool SBData::IsValid() {
   70 uint8_t SBData::GetAddressByteSize() {
   94 size_t SBData::GetByteSize() {
  103 lldb::ByteOrder SBData::GetByteOrder() {
  119 float SBData::GetFloat(lldb::SBError &error, lldb::offset_t offset) {
  135 double SBData::GetDouble(lldb::SBError &error, lldb::offset_t offset) {
  151 long double SBData::GetLongDouble(lldb::SBError &error, lldb::offset_t offset) {
  167 lldb::addr_t SBData::GetAddress(lldb::SBError &error, lldb::offset_t offset) {
  183 uint8_t SBData::GetUnsignedInt8(lldb::SBError &error, lldb::offset_t offset) {
  199 uint16_t SBData::GetUnsignedInt16(lldb::SBError &error, lldb::offset_t offset) {
  215 uint32_t SBData::GetUnsignedInt32(lldb::SBError &error, lldb::offset_t offset) {
  231 uint64_t SBData::GetUnsignedInt64(lldb::SBError &error, lldb::offset_t offset) {
  247 int8_t SBData::GetSignedInt8(lldb::SBError &error, lldb::offset_t offset) {
  263 int16_t SBData::GetSignedInt16(lldb::SBError &error, lldb::offset_t offset) {
  279 int32_t SBData::GetSignedInt32(lldb::SBError &error, lldb::offset_t offset) {
  295 int64_t SBData::GetSignedInt64(lldb::SBError &error, lldb::offset_t offset) {
  311 const char *SBData::GetString(lldb::SBError &error, lldb::offset_t offset) {
  327 bool SBData::GetDescription(lldb::SBStream &description,
  377 bool SBData::Append(const SBData &rhs) {
  517 bool SBData::SetDataFromCString(const char *data) {
  539 bool SBData::SetDataFromUInt64Array(uint64_t *array, size_t array_len) {
  562 bool SBData::SetDataFromUInt32Array(uint32_t *array, size_t array_len) {
  584 bool SBData::SetDataFromSInt64Array(int64_t *array, size_t array_len) {
  606 bool SBData::SetDataFromSInt32Array(int32_t *array, size_t array_len) {
  628 bool SBData::SetDataFromDoubleArray(double *array, size_t array_len) {

  140 SBDebugger &SBDebugger::operator=(const SBDebugger &rhs) {
  269 bool SBDebugger::GetAsync() {
  295 SBError SBDebugger::SetInputFile(FileSP file_sp) {
  303 SBError SBDebugger::SetInputFile(SBFile file) {
  340 SBError SBDebugger::SetOutputFile(FileSP file_sp) {
  351 SBError SBDebugger::SetOutputFile(SBFile file) {
  372 SBError SBDebugger::SetErrorFile(FileSP file_sp) {
  377 SBError SBDebugger::SetErrorFile(SBFile file) {
  392 FILE *SBDebugger::GetInputFileHandle() {
  401 SBFile SBDebugger::GetInputFile() {
  409 FILE *SBDebugger::GetOutputFileHandle() {
  418 SBFile SBDebugger::GetOutputFile() {
  427 FILE *SBDebugger::GetErrorFileHandle() {
  437 SBFile SBDebugger::GetErrorFile() {
  460 SBCommandInterpreter SBDebugger::GetCommandInterpreter() {
  504 SBListener SBDebugger::GetListener() {
  588 SBSourceManager SBDebugger::GetSourceManager() {
  633 SBDebugger::GetScriptingLanguage(const char *script_language_name) {
  716 lldb::SBTarget SBDebugger::CreateTarget(const char *filename,
  757 SBDebugger::CreateTargetWithFileAndTargetTriple(const char *filename,
  784 SBTarget SBDebugger::CreateTargetWithFileAndArch(const char *filename,
  817 SBTarget SBDebugger::CreateTarget(const char *filename) {
  844 SBTarget SBDebugger::GetDummyTarget() {
  858 bool SBDebugger::DeleteTarget(lldb::SBTarget &target) {
  883 SBTarget SBDebugger::GetTargetAtIndex(uint32_t idx) {
  895 uint32_t SBDebugger::GetIndexOfTarget(lldb::SBTarget target) {
  909 SBTarget SBDebugger::FindTargetWithProcessID(lldb::pid_t pid) {
  921 SBTarget SBDebugger::FindTargetWithFileAndArch(const char *filename,
  949 uint32_t SBDebugger::GetNumTargets() {
  959 SBTarget SBDebugger::GetSelectedTarget() {
 1002 SBPlatform SBDebugger::GetSelectedPlatform() {
 1036 uint32_t SBDebugger::GetNumPlatforms() {
 1046 SBPlatform SBDebugger::GetPlatformAtIndex(uint32_t idx) {
 1058 uint32_t SBDebugger::GetNumAvailablePlatforms() {
 1072 SBStructuredData SBDebugger::GetAvailablePlatformInfoAtIndex(uint32_t idx) {
 1187 SBError SBDebugger::RunREPL(lldb::LanguageType language,
 1226 const char *SBDebugger::GetInstanceName() {
 1343 bool SBDebugger::SetUseExternalEditor(bool value) {
 1349 bool SBDebugger::GetUseExternalEditor() {
 1355 bool SBDebugger::SetUseColor(bool value) {
 1367 bool SBDebugger::GetDescription(SBStream &description) {
 1383 user_id_t SBDebugger::GetID() {
 1389 SBError SBDebugger::SetCurrentPlatform(const char *platform_name_cstr) {
 1420 bool SBDebugger::SetCurrentPlatformSDKRoot(const char *sysroot) {
 1453 SBTypeCategory SBDebugger::GetCategory(const char *category_name) {
 1470 SBTypeCategory SBDebugger::GetCategory(lldb::LanguageType lang_type) {
 1482 SBTypeCategory SBDebugger::CreateCategory(const char *category_name) {
 1499 bool SBDebugger::DeleteCategory(const char *category_name) {
 1509 uint32_t SBDebugger::GetNumCategories() {
 1515 SBTypeCategory SBDebugger::GetCategoryAtIndex(uint32_t index) {
 1523 SBTypeCategory SBDebugger::GetDefaultCategory() {
 1530 SBTypeFormat SBDebugger::GetFormatForType(SBTypeNameSpecifier type_name) {
 1540 SBTypeSummary SBDebugger::GetSummaryForType(SBTypeNameSpecifier type_name) {
 1550 SBTypeFilter SBDebugger::GetFilterForType(SBTypeNameSpecifier type_name) {
 1560 SBTypeSynthetic SBDebugger::GetSyntheticForType(SBTypeNameSpecifier type_name) {
 1579 bool SBDebugger::EnableLog(const char *channel, const char **categories) {

   38 const SBDeclaration &SBDeclaration::operator=(const SBDeclaration &rhs) {
  159 bool SBDeclaration::GetDescription(SBStream &description) {

   30 const SBError &SBError::operator=(const SBError &rhs) {
  169 bool SBError::GetDescription(SBStream &description) {

   50 const SBEvent &SBEvent::operator=(const SBEvent &rhs) {
   63 const char *SBEvent::GetDataFlavor() {
  109 bool SBEvent::BroadcasterMatchesPtr(const SBBroadcaster *broadcaster) {
  118 bool SBEvent::BroadcasterMatchesRef(const SBBroadcaster &broadcaster) {
  182 bool SBEvent::GetDescription(SBStream &description) {

   72 operator=(const lldb::SBExecutionContext &rhs) {

   33 operator=(const SBExpressionOptions &rhs) {
  188 bool SBExpressionOptions::GetGenerateDebugInfo() {
  201 bool SBExpressionOptions::GetSuppressPersistentResult() {
  229 bool SBExpressionOptions::GetAutoApplyFixIts() {
  241 bool SBExpressionOptions::GetTopLevel() {
  254 bool SBExpressionOptions::GetAllowJIT() {

   74 SBError SBFile::Flush() {
   91 SBError SBFile::Close() {

   56 const SBFileSpec &SBFileSpec::operator=(const SBFileSpec &rhs) {
   95 bool SBFileSpec::ResolveExecutableLocation() {

   37 const SBFileSpecList &SBFileSpecList::operator=(const SBFileSpecList &rhs) {
   60 bool SBFileSpecList::AppendIfUnique(const SBFileSpec &sb_file) {
   73 uint32_t SBFileSpecList::FindFileIndex(uint32_t idx, const SBFileSpec &sb_file,

   75 const SBFrame &SBFrame::operator=(const SBFrame &rhs) {
  350 bool SBFrame::SetPC(addr_t new_pc) {
  445 lldb::SBValue SBFrame::GetValueForVariablePath(const char *var_path) {
  463 lldb::SBValue SBFrame::GetValueForVariablePath(const char *var_path,
  499 SBValue SBFrame::FindVariable(const char *name) {
  517 SBValue SBFrame::FindVariable(const char *name,
  552 SBValue SBFrame::FindValue(const char *name, ValueType value_type) {
  570 SBValue SBFrame::FindValue(const char *name, ValueType value_type,
  751 SBValueList SBFrame::GetVariables(bool arguments, bool locals, bool statics,
  782 lldb::SBValueList SBFrame::GetVariables(bool arguments, bool locals,
  805 SBValueList SBFrame::GetVariables(const lldb::SBVariablesOptions &options) {
  908 SBValueList SBFrame::GetRegisters() {
  938 SBValue SBFrame::FindRegister(const char *name) {
  978 bool SBFrame::GetDescription(SBStream &description) {
 1005 SBValue SBFrame::EvaluateExpression(const char *expr) {
 1032 SBFrame::EvaluateExpression(const char *expr,
 1054 SBValue SBFrame::EvaluateExpression(const char *expr,
 1077 lldb::SBValue SBFrame::EvaluateExpression(const char *expr,
 1131 bool SBFrame::IsInlined() {
 1161 bool SBFrame::IsArtificial() {
 1180 const char *SBFrame::GetFunctionName() {
 1250 const char *SBFrame::GetDisplayFunctionName() {

   37 const SBFunction &SBFunction::operator=(const SBFunction &rhs) {
  102 bool SBFunction::GetDescription(SBStream &s) {
  117 SBInstructionList SBFunction::GetInstructions(SBTarget target) {
  124 SBInstructionList SBFunction::GetInstructions(SBTarget target,
  157 SBAddress SBFunction::GetStartAddress() {
  166 SBAddress SBFunction::GetEndAddress() {
  180 const char *SBFunction::GetArgumentName(uint32_t arg_idx) {
  199 uint32_t SBFunction::GetPrologueByteSize() {
  207 SBType SBFunction::GetType() {
  219 SBBlock SBFunction::GetBlock() {
  228 lldb::LanguageType SBFunction::GetLanguage() {
  238 bool SBFunction::GetIsOptimized() {

   82 const SBInstruction &SBInstruction::operator=(const SBInstruction &rhs) {
   94 bool SBInstruction::IsValid() {
  104 SBAddress SBInstruction::GetAddress() {
  114 const char *SBInstruction::GetMnemonic(SBTarget target) {
  134 const char *SBInstruction::GetOperands(SBTarget target) {
  154 const char *SBInstruction::GetComment(SBTarget target) {
  174 size_t SBInstruction::GetByteSize() {
  183 SBData SBInstruction::GetData(SBTarget target) {
  198 bool SBInstruction::DoesBranch() {
  207 bool SBInstruction::HasDelaySlot() {
  216 bool SBInstruction::CanSetBreakpoint() {
  237 bool SBInstruction::GetDescription(lldb::SBStream &s) {
  292 bool SBInstruction::EmulateWithFrame(lldb::SBFrame &frame,
  318 bool SBInstruction::DumpEmulation(const char *triple) {
  329 bool SBInstruction::TestEmulation(lldb::SBStream &output_stream,

   35 operator=(const SBInstructionList &rhs) {
   57 size_t SBInstructionList::GetSize() {
   65 SBInstruction SBInstructionList::GetInstructionAtIndex(uint32_t idx) {
   77 size_t SBInstructionList::GetInstructionsCount(const SBAddress &start,
  145 bool SBInstructionList::GetDescription(lldb::SBStream &stream) {
  188 bool SBInstructionList::DumpEmulationForAllInstructions(const char *triple) {

   56 lldb::pid_t SBLaunchInfo::GetProcessID() {
   62 uint32_t SBLaunchInfo::GetUserID() {
   68 uint32_t SBLaunchInfo::GetGroupID() {
   74 bool SBLaunchInfo::UserIDIsValid() {
   80 bool SBLaunchInfo::GroupIDIsValid() {
   98 SBFileSpec SBLaunchInfo::GetExecutableFile() {
  112 SBListener SBLaunchInfo::GetListener() {
  125 uint32_t SBLaunchInfo::GetNumArguments() {
  131 const char *SBLaunchInfo::GetArgumentAtIndex(uint32_t idx) {
  153 uint32_t SBLaunchInfo::GetNumEnvironmentEntries() {
  159 const char *SBLaunchInfo::GetEnvironmentEntryAtIndex(uint32_t idx) {
  200 uint32_t SBLaunchInfo::GetLaunchFlags() {
  212 const char *SBLaunchInfo::GetProcessPluginName() {
  225 const char *SBLaunchInfo::GetShell() {
  240 bool SBLaunchInfo::GetShellExpandArguments() {
  253 uint32_t SBLaunchInfo::GetResumeCount() {
  265 bool SBLaunchInfo::AddCloseFileAction(int fd) {
  271 bool SBLaunchInfo::AddDuplicateFileAction(int fd, int dup_fd) {
  278 bool SBLaunchInfo::AddOpenFileAction(int fd, const char *path, bool read,
  286 bool SBLaunchInfo::AddSuppressFileAction(int fd, bool read, bool write) {

   38 const SBLineEntry &SBLineEntry::operator=(const SBLineEntry &rhs) {
  172 bool SBLineEntry::GetDescription(SBStream &description) {

   37 const lldb::SBListener &SBListener::operator=(const lldb::SBListener &rhs) {
   79 uint32_t SBListener::StartListeningForEventClass(SBDebugger &debugger,
   97 bool SBListener::StopListeningForEventClass(SBDebugger &debugger,
  115 uint32_t SBListener::StartListeningForEvents(const SBBroadcaster &broadcaster,
  130 bool SBListener::StopListeningForEvents(const SBBroadcaster &broadcaster,
  142 bool SBListener::WaitForEvent(uint32_t timeout_secs, SBEvent &event) {
  167 bool SBListener::WaitForEventForBroadcaster(uint32_t num_seconds,
  189 bool SBListener::WaitForEventForBroadcasterWithType(
  212 bool SBListener::PeekAtNextEvent(SBEvent &event) {
  224 bool SBListener::PeekAtNextEventForBroadcaster(const SBBroadcaster &broadcaster,
  238 bool SBListener::PeekAtNextEventForBroadcasterWithType(
  254 bool SBListener::GetNextEvent(SBEvent &event) {
  268 bool SBListener::GetNextEventForBroadcaster(const SBBroadcaster &broadcaster,
  286 bool SBListener::GetNextEventForBroadcasterWithType(
  306 bool SBListener::HandleBroadcastEvent(const SBEvent &event) {

   39 operator=(const SBMemoryRegionInfo &rhs) {
   77 lldb::addr_t SBMemoryRegionInfo::GetRegionBase() {
   83 lldb::addr_t SBMemoryRegionInfo::GetRegionEnd() {
   89 bool SBMemoryRegionInfo::IsReadable() {
   95 bool SBMemoryRegionInfo::IsWritable() {
  101 bool SBMemoryRegionInfo::IsExecutable() {
  107 bool SBMemoryRegionInfo::IsMapped() {
  113 const char *SBMemoryRegionInfo::GetName() {
  119 bool SBMemoryRegionInfo::GetDescription(SBStream &description) {

   88 operator=(const SBMemoryRegionInfoList &rhs) {
  106 bool SBMemoryRegionInfoList::GetMemoryRegionAtIndex(

   69 const SBModule &SBModule::operator=(const SBModule &rhs) {
  120 bool SBModule::SetPlatformFileSpec(const lldb::SBFileSpec &platform_file) {
  135 lldb::SBFileSpec SBModule::GetRemoteInstallFileSpec() {
  146 bool SBModule::SetRemoteInstallFileSpec(lldb::SBFileSpec &file) {
  211 SBAddress SBModule::ResolveFileAddress(lldb::addr_t vm_addr) {
  226 SBModule::ResolveSymbolContextForAddress(const SBAddress &addr,
  240 bool SBModule::GetDescription(SBStream &description) {
  255 uint32_t SBModule::GetNumCompileUnits() {
  265 SBCompileUnit SBModule::GetCompileUnitAtIndex(uint32_t index) {
  278 SBSymbolContextList SBModule::FindCompileUnits(const SBFileSpec &sb_file_spec) {
  296 size_t SBModule::GetNumSymbols() {
  305 SBSymbol SBModule::GetSymbolAtIndex(size_t idx) {
  316 lldb::SBSymbol SBModule::FindSymbol(const char *name,
  333 lldb::SBSymbolContextList SBModule::FindSymbols(const char *name,
  362 size_t SBModule::GetNumSections() {
  376 SBSection SBModule::GetSectionAtIndex(size_t idx) {
  393 lldb::SBSymbolContextList SBModule::FindFunctions(const char *name,
  410 SBValueList SBModule::FindGlobalVariables(SBTarget &target, const char *name,
  438 lldb::SBValue SBModule::FindFirstGlobalVariable(lldb::SBTarget &target,
  449 lldb::SBType SBModule::FindFirstType(const char *name_cstr) {
  475 lldb::SBType SBModule::GetBasicType(lldb::BasicType type) {
  493 lldb::SBTypeList SBModule::FindTypes(const char *type) {
  530 lldb::SBType SBModule::GetTypeByID(lldb::user_id_t uid) {
  545 lldb::SBTypeList SBModule::GetTypes(uint32_t type_mask) {
  565 SBSection SBModule::FindSection(const char *sect_name) {
  587 lldb::ByteOrder SBModule::GetByteOrder() {
  596 const char *SBModule::GetTriple() {
  611 uint32_t SBModule::GetAddressByteSize() {
  620 uint32_t SBModule::GetVersion(uint32_t *versions, uint32_t num_versions) {

   32 const SBModuleSpec &SBModuleSpec::operator=(const SBModuleSpec &rhs) {
   59 SBFileSpec SBModuleSpec::GetFileSpec() {
   73 lldb::SBFileSpec SBModuleSpec::GetPlatformFileSpec() {
   87 lldb::SBFileSpec SBModuleSpec::GetSymbolFileSpec() {
  100 const char *SBModuleSpec::GetObjectName() {
  112 const char *SBModuleSpec::GetTriple() {
  133 size_t SBModuleSpec::GetUUIDLength() {
  144 bool SBModuleSpec::GetDescription(lldb::SBStream &description) {
  162 SBModuleSpecList &SBModuleSpecList::operator=(const SBModuleSpecList &rhs) {
  200 size_t SBModuleSpecList::GetSize() {
  206 SBModuleSpec SBModuleSpecList::GetSpecAtIndex(size_t i) {
  216 SBModuleSpecList::FindFirstMatchingSpec(const SBModuleSpec &match_spec) {
  228 SBModuleSpecList::FindMatchingSpecs(const SBModuleSpec &match_spec) {
  239 bool SBModuleSpecList::GetDescription(lldb::SBStream &description) {

   93 const char *SBPlatformConnectOptions::GetURL() {
  111 bool SBPlatformConnectOptions::GetRsyncEnabled() {
  144 const char *SBPlatformConnectOptions::GetLocalCacheDirectory() {
  187 const char *SBPlatformShellCommand::GetCommand() {
  205 const char *SBPlatformShellCommand::GetWorkingDirectory() {
  224 uint32_t SBPlatformShellCommand::GetTimeoutSeconds() {
  243 int SBPlatformShellCommand::GetSignal() {
  249 int SBPlatformShellCommand::GetStatus() {
  255 const char *SBPlatformShellCommand::GetOutput() {
  294 const char *SBPlatform::GetName() {
  309 const char *SBPlatform::GetWorkingDirectory() {
  318 bool SBPlatform::SetWorkingDirectory(const char *path) {
  333 SBError SBPlatform::ConnectRemote(SBPlatformConnectOptions &connect_options) {
  358 bool SBPlatform::IsConnected() {
  367 const char *SBPlatform::GetTriple() {
  382 const char *SBPlatform::GetOSBuild() {
  399 const char *SBPlatform::GetOSDescription() {
  416 const char *SBPlatform::GetHostname() {
  425 uint32_t SBPlatform::GetOSMajorVersion() {
  434 uint32_t SBPlatform::GetOSMinorVersion() {
  443 uint32_t SBPlatform::GetOSUpdateVersion() {
  452 SBError SBPlatform::Get(SBFileSpec &src, SBFileSpec &dst) {
  466 SBError SBPlatform::Put(SBFileSpec &src, SBFileSpec &dst) {
  491 SBError SBPlatform::Install(SBFileSpec &src, SBFileSpec &dst) {
  506 SBError SBPlatform::Run(SBPlatformShellCommand &shell_command) {
  529 SBError SBPlatform::Launch(SBLaunchInfo &launch_info) {
  541 SBError SBPlatform::Kill(const lldb::pid_t pid) {
  564 SBError SBPlatform::MakeDirectory(const char *path, uint32_t file_permissions) {
  579 uint32_t SBPlatform::GetFilePermissions(const char *path) {
  592 SBError SBPlatform::SetFilePermissions(const char *path,

   67 const SBProcess &SBProcess::operator=(const SBProcess &rhs) {
   86 const char *SBProcess::GetPluginName() {
   96 const char *SBProcess::GetShortPluginName() {
  127 bool SBProcess::RemoteLaunch(char const **argv, char const **envp,
  168 bool SBProcess::RemoteAttachToProcessWithID(lldb::pid_t pid,
  192 uint32_t SBProcess::GetNumThreads() {
  226 SBThread SBProcess::CreateOSPluginThread(lldb::tid_t tid,
  258 size_t SBProcess::PutSTDIN(const char *src, size_t src_len) {
  314 lldb::SBTrace SBProcess::StartTrace(SBTraceOptions &options,
  382 bool SBProcess::SetSelectedThread(const SBThread &thread) {
  396 bool SBProcess::SetSelectedThreadByID(lldb::tid_t tid) {
  412 bool SBProcess::SetSelectedThreadByIndexID(uint32_t index_id) {
  428 SBThread SBProcess::GetThreadAtIndex(size_t index) {
  447 uint32_t SBProcess::GetNumQueues() {
  464 SBQueue SBProcess::GetQueueAtIndex(size_t index) {
  484 uint32_t SBProcess::GetStopID(bool include_expression_stops) {
  500 SBEvent SBProcess::GetStopEventForStopID(uint32_t stop_id) {
  517 StateType SBProcess::GetState() {
  531 int SBProcess::GetExitStatus() {
  545 const char *SBProcess::GetExitDescription() {
  558 lldb::pid_t SBProcess::GetProcessID() {
  569 uint32_t SBProcess::GetUniqueID() {
  603 SBError SBProcess::Continue() {
  623 SBError SBProcess::Destroy() {
  638 SBError SBProcess::Stop() {
  653 SBError SBProcess::Kill() {
  668 SBError SBProcess::Detach() {
  676 SBError SBProcess::Detach(bool keep_stopped) {
  691 SBError SBProcess::Signal(int signo) {
  706 SBUnixSignals SBProcess::GetUnixSignals() {
  724 SBThread SBProcess::GetThreadByID(tid_t tid) {
  743 SBThread SBProcess::GetThreadByIndexID(uint32_t index_id) {
  917 uint64_t SBProcess::ReadUnsignedFromMemory(addr_t addr, uint32_t byte_size,
  941 lldb::addr_t SBProcess::ReadPointerFromMemory(addr_t addr,
  988 bool SBProcess::GetDescription(SBStream &description) {
 1031 uint32_t SBProcess::LoadImage(lldb::SBFileSpec &sb_remote_image_spec,
 1040 uint32_t SBProcess::LoadImage(const lldb::SBFileSpec &sb_local_image_spec,
 1066 uint32_t SBProcess::LoadImageUsingPaths(const lldb::SBFileSpec &image_spec,
 1104 lldb::SBError SBProcess::UnloadImage(uint32_t image_token) {
 1126 lldb::SBError SBProcess::SendEventData(const char *event_data) {
 1146 uint32_t SBProcess::GetNumExtendedBacktraceTypes() {
 1157 const char *SBProcess::GetExtendedBacktraceTypeAtIndex(uint32_t idx) {
 1173 SBThreadCollection SBProcess::GetHistoryThreads(addr_t addr) {
 1185 bool SBProcess::IsInstrumentationRuntimePresent(
 1206 lldb::SBError SBProcess::SaveCore(const char *file_name) {
 1231 SBProcess::GetMemoryRegionInfo(lldb::addr_t load_addr,
 1256 lldb::SBMemoryRegionInfoList SBProcess::GetMemoryRegions() {
 1274 lldb::SBProcessInfo SBProcess::GetProcessInfo() {

   30 SBProcessInfo &SBProcessInfo::operator=(const SBProcessInfo &rhs) {
   61 const char *SBProcessInfo::GetName() {
   71 SBFileSpec SBProcessInfo::GetExecutableFile() {
   82 lldb::pid_t SBProcessInfo::GetProcessID() {
   92 uint32_t SBProcessInfo::GetUserID() {
  102 uint32_t SBProcessInfo::GetGroupID() {
  112 bool SBProcessInfo::UserIDIsValid() {
  122 bool SBProcessInfo::GroupIDIsValid() {
  132 uint32_t SBProcessInfo::GetEffectiveUserID() {
  142 uint32_t SBProcessInfo::GetEffectiveGroupID() {
  152 bool SBProcessInfo::EffectiveUserIDIsValid() {
  162 bool SBProcessInfo::EffectiveGroupIDIsValid() {
  172 lldb::pid_t SBProcessInfo::GetParentProcessID() {

  238 const lldb::SBQueue &SBQueue::operator=(const lldb::SBQueue &rhs) {
  287 uint32_t SBQueue::GetNumThreads() {
  293 SBThread SBQueue::GetThreadAtIndex(uint32_t idx) {
  301 uint32_t SBQueue::GetNumPendingItems() {
  307 SBQueueItem SBQueue::GetPendingItemAtIndex(uint32_t idx) {
  314 uint32_t SBQueue::GetNumRunningItems() {
  320 SBProcess SBQueue::GetProcess() {
  326 lldb::QueueKind SBQueue::GetKind() {

   96 SBThread SBQueueItem::GetExtendedBacktraceThread(const char *type) {

   39 const SBSection &SBSection::operator=(const SBSection &rhs) {
   60 const char *SBSection::GetName() {
   69 lldb::SBSection SBSection::GetParent() {
   82 lldb::SBSection SBSection::FindSubSection(const char *sect_name) {
   98 size_t SBSection::GetNumSubSections() {
  107 lldb::SBSection SBSection::GetSubSectionAtIndex(size_t idx) {
  124 lldb::addr_t SBSection::GetFileAddress() {
  134 lldb::addr_t SBSection::GetLoadAddress(lldb::SBTarget &sb_target) {
  147 lldb::addr_t SBSection::GetByteSize() {
  156 uint64_t SBSection::GetFileOffset() {
  171 uint64_t SBSection::GetFileByteSize() {
  180 SBData SBSection::GetSectionData() {
  186 SBData SBSection::GetSectionData(uint64_t offset, uint64_t size) {
  226 SectionType SBSection::GetSectionType() {
  244 uint32_t SBSection::GetTargetByteSize() {
  253 bool SBSection::operator==(const SBSection &rhs) {
  264 bool SBSection::operator!=(const SBSection &rhs) {
  273 bool SBSection::GetDescription(SBStream &description) {

   98 operator=(const lldb::SBSourceManager &rhs) {
  109 size_t SBSourceManager::DisplaySourceLinesWithLineNumbers(
  124 size_t SBSourceManager::DisplaySourceLinesWithLineNumbersAndColumn(

   43 const char *SBStream::GetData() {
   54 size_t SBStream::GetSize() {

   33 const SBStringList &SBStringList::operator=(const SBStringList &rhs) {
  111 const char *SBStringList::GetStringAtIndex(size_t idx) {

   51 operator=(const lldb::SBStructuredData &rhs) {
   60 lldb::SBError SBStructuredData::SetFromJSON(lldb::SBStream &stream) {

   32 const SBSymbol &SBSymbol::operator=(const SBSymbol &rhs) {
  101 bool SBSymbol::GetDescription(SBStream &description) {
  115 SBInstructionList SBSymbol::GetInstructions(SBTarget target) {
  122 SBInstructionList SBSymbol::GetInstructions(SBTarget target,
  156 SBAddress SBSymbol::GetStartAddress() {
  166 SBAddress SBSymbol::GetEndAddress() {
  180 uint32_t SBSymbol::GetPrologueByteSize() {
  188 SymbolType SBSymbol::GetType() {
  196 bool SBSymbol::IsExternal() {
  204 bool SBSymbol::IsSynthetic() {

   42 const SBSymbolContext &SBSymbolContext::operator=(const SBSymbolContext &rhs) {
   69 SBModule SBSymbolContext::GetModule() {
   82 SBCompileUnit SBSymbolContext::GetCompileUnit() {
   90 SBFunction SBSymbolContext::GetFunction() {
  103 SBBlock SBSymbolContext::GetBlock() {
  110 SBLineEntry SBSymbolContext::GetLineEntry() {
  120 SBSymbol SBSymbolContext::GetSymbol() {
  202 bool SBSymbolContext::GetDescription(SBStream &description) {

   34 operator=(const SBSymbolContextList &rhs) {
   52 SBSymbolContext SBSymbolContextList::GetContextAtIndex(uint32_t idx) {
  108 bool SBSymbolContextList::GetDescription(lldb::SBStream &description) {

  112 const SBTarget &SBTarget::operator=(const SBTarget &rhs) {
  176 SBProcess SBTarget::GetProcess() {
  190 SBPlatform SBTarget::GetPlatform() {
  213 SBStructuredData SBTarget::GetStatistics() {
  243 bool SBTarget::GetCollectingStats() {
  252 SBProcess SBTarget::LoadCore(const char *core_file) {
  260 SBProcess SBTarget::LoadCore(const char *core_file, lldb::SBError &error) {
  284 SBProcess SBTarget::LaunchSimple(char const **argv, char const **envp,
  302 SBError SBTarget::Install() {
  314 SBProcess SBTarget::Launch(SBListener &listener, char const **argv,
  393 SBProcess SBTarget::Launch(SBLaunchInfo &sb_launch_info, SBError &error) {
  442 lldb::SBProcess SBTarget::Attach(SBAttachInfo &sb_attach_info, SBError &error) {
  477 lldb::SBProcess SBTarget::AttachToProcessWithID(
  508 lldb::SBProcess SBTarget::AttachToProcessWithName(
  537 lldb::SBProcess SBTarget::ConnectRemote(SBListener &listener, const char *url,
  571 SBFileSpec SBTarget::GetExecutable() {
  605 lldb::SBAddress SBTarget::ResolveLoadAddress(lldb::addr_t vm_addr) {
  624 lldb::SBAddress SBTarget::ResolveFileAddress(lldb::addr_t file_addr) {
  641 lldb::SBAddress SBTarget::ResolvePastLoadAddress(uint32_t stop_id,
  662 SBTarget::ResolveSymbolContextForAddress(const SBAddress &addr,
  699 SBBreakpoint SBTarget::BreakpointCreateByLocation(const char *file,
  709 SBTarget::BreakpointCreateByLocation(const SBFileSpec &sb_file_spec,
  718 SBTarget::BreakpointCreateByLocation(const SBFileSpec &sb_file_spec,
  730 SBTarget::BreakpointCreateByLocation(const SBFileSpec &sb_file_spec,
  742 SBBreakpoint SBTarget::BreakpointCreateByLocation(
  772 SBBreakpoint SBTarget::BreakpointCreateByName(const char *symbol_name,
  803 SBTarget::BreakpointCreateByName(const char *symbol_name,
  817 lldb::SBBreakpoint SBTarget::BreakpointCreateByName(
  830 lldb::SBBreakpoint SBTarget::BreakpointCreateByName(
  857 lldb::SBBreakpoint SBTarget::BreakpointCreateByNames(
  871 lldb::SBBreakpoint SBTarget::BreakpointCreateByNames(
  887 lldb::SBBreakpoint SBTarget::BreakpointCreateByNames(
  914 SBBreakpoint SBTarget::BreakpointCreateByRegex(const char *symbol_name_regex,
  931 SBTarget::BreakpointCreateByRegex(const char *symbol_name_regex,
  943 lldb::SBBreakpoint SBTarget::BreakpointCreateByRegex(
  970 SBBreakpoint SBTarget::BreakpointCreateByAddress(addr_t address) {
  985 SBBreakpoint SBTarget::BreakpointCreateBySBAddress(SBAddress &sb_address) {
 1005 SBTarget::BreakpointCreateBySourceRegex(const char *source_regex,
 1028 lldb::SBBreakpoint SBTarget::BreakpointCreateBySourceRegex(
 1041 lldb::SBBreakpoint SBTarget::BreakpointCreateBySourceRegex(
 1072 SBTarget::BreakpointCreateForException(lldb::LanguageType language,
 1090 lldb::SBBreakpoint SBTarget::BreakpointCreateFromScript(
 1144 bool SBTarget::BreakpointDelete(break_id_t bp_id) {
 1158 SBBreakpoint SBTarget::FindBreakpointByID(break_id_t bp_id) {
 1172 bool SBTarget::FindBreakpointsByName(const char *name,
 1220 bool SBTarget::EnableAllBreakpoints() {
 1232 bool SBTarget::DisableAllBreakpoints() {
 1244 bool SBTarget::DeleteAllBreakpoints() {
 1256 lldb::SBError SBTarget::BreakpointsCreateFromFile(SBFileSpec &source_file,
 1267 lldb::SBError SBTarget::BreakpointsCreateFromFile(SBFileSpec &source_file,
 1304 lldb::SBError SBTarget::BreakpointsWriteToFile(SBFileSpec &dest_file) {
 1318 lldb::SBError SBTarget::BreakpointsWriteToFile(SBFileSpec &dest_file,
 1364 bool SBTarget::DeleteWatchpoint(watch_id_t wp_id) {
 1381 SBWatchpoint SBTarget::FindWatchpointByID(lldb::watch_id_t wp_id) {
 1400 lldb::SBWatchpoint SBTarget::WatchAddress(lldb::addr_t addr, size_t size,
 1437 bool SBTarget::EnableAllWatchpoints() {
 1451 bool SBTarget::DisableAllWatchpoints() {
 1465 SBValue SBTarget::CreateValueFromAddress(const char *name, SBAddress addr,
 1485 lldb::SBValue SBTarget::CreateValueFromData(const char *name, lldb::SBData data,
 1505 lldb::SBValue SBTarget::CreateValueFromExpression(const char *name,
 1522 bool SBTarget::DeleteAllWatchpoints() {
 1555 lldb::SBModule SBTarget::AddModule(const char *path, const char *triple,
 1564 lldb::SBModule SBTarget::AddModule(const char *path, const char *triple,
 1594 lldb::SBModule SBTarget::AddModule(const SBModuleSpec &module_spec) {
 1606 bool SBTarget::AddModule(lldb::SBModule &module) {
 1636 SBModule SBTarget::FindModule(const SBFileSpec &sb_file_spec) {
 1650 SBSymbolContextList SBTarget::FindCompileUnits(const SBFileSpec &sb_file_spec) {
 1661 lldb::ByteOrder SBTarget::GetByteOrder() {
 1670 const char *SBTarget::GetTriple() {
 1685 uint32_t SBTarget::GetDataByteSize() {
 1695 uint32_t SBTarget::GetCodeByteSize() {
 1705 uint32_t SBTarget::GetAddressByteSize() {
 1714 SBModule SBTarget::GetModuleAtIndex(uint32_t idx) {
 1730 bool SBTarget::RemoveModule(lldb::SBModule module) {
 1751 bool SBTarget::GetDescription(SBStream &description,
 1768 lldb::SBSymbolContextList SBTarget::FindFunctions(const char *name,
 1789 lldb::SBSymbolContextList SBTarget::FindGlobalFunctions(const char *name,
 1822 lldb::SBType SBTarget::FindFirstType(const char *typename_cstr) {
 1864 SBType SBTarget::GetBasicType(lldb::BasicType type) {
 1877 lldb::SBTypeList SBTarget::FindTypes(const char *typename_cstr) {
 1921 SBValueList SBTarget::FindGlobalVariables(const char *name,
 1950 SBValueList SBTarget::FindGlobalVariables(const char *name,
 1998 lldb::SBValue SBTarget::FindFirstGlobalVariable(const char *name) {
 2008 SBSourceManager SBTarget::GetSourceManager() {
 2015 lldb::SBInstructionList SBTarget::ReadInstructions(lldb::SBAddress base_addr,
 2023 lldb::SBInstructionList SBTarget::ReadInstructions(lldb::SBAddress base_addr,
 2116 SBError SBTarget::SetSectionLoadAddress(lldb::SBSection section,
 2155 SBError SBTarget::ClearSectionLoadAddress(lldb::SBSection section) {
 2190 SBError SBTarget::SetModuleLoadAddress(lldb::SBModule module,
 2225 SBError SBTarget::ClearModuleLoadAddress(lldb::SBModule module) {
 2277 lldb::SBSymbolContextList SBTarget::FindSymbols(const char *name,
 2292 lldb::SBValue SBTarget::EvaluateExpression(const char *expr) {
 2308 lldb::SBValue SBTarget::EvaluateExpression(const char *expr,
 2354 lldb::addr_t SBTarget::GetStackRedZoneSize() {

   79 const lldb::SBThread &SBThread::operator=(const SBThread &rhs) {
  139 StopReason SBThread::GetStopReason() {
  156 size_t SBThread::GetStopReasonDataCount() {
  205 uint64_t SBThread::GetStopReasonDataAtIndex(uint32_t idx) {
  267 bool SBThread::GetStopReasonExtendedInfoAsJSON(lldb::SBStream &stream) {
  290 SBThread::GetStopReasonExtendedBacktraces(InstrumentationRuntimeType type) {
  315 size_t SBThread::GetStopDescription(char *dst, size_t dst_len) {
  412 SBValue SBThread::GetStopReturnValue() {
  505 bool SBThread::GetInfoItemByPathAsString(const char *path, SBStream &strm) {
  843 SBError SBThread::StepOverUntil(lldb::SBFrame &sb_frame,
  961 SBError SBThread::StepUsingScriptedThreadPlan(const char *script_class_name) {
  969 SBError SBThread::StepUsingScriptedThreadPlan(const char *script_class_name,
  982 SBError SBThread::StepUsingScriptedThreadPlan(const char *script_class_name,
 1023 SBError SBThread::JumpToLine(lldb::SBFileSpec &file_spec, uint32_t line) {
 1044 SBError SBThread::ReturnFromFrame(SBFrame &frame, SBValue &return_value) {
 1062 SBError SBThread::UnwindInnermostExpression() {
 1081 bool SBThread::Suspend() {
 1088 bool SBThread::Suspend(SBError &error) {
 1108 bool SBThread::Resume() {
 1115 bool SBThread::Resume(SBError &error) {
 1136 bool SBThread::IsSuspended() {
 1147 bool SBThread::IsStopped() {
 1158 SBProcess SBThread::GetProcess() {
 1174 uint32_t SBThread::GetNumFrames() {
 1191 SBFrame SBThread::GetFrameAtIndex(uint32_t idx) {
 1210 lldb::SBFrame SBThread::GetSelectedFrame() {
 1229 lldb::SBFrame SBThread::SetSelectedFrame(uint32_t idx) {
 1337 SBThread SBThread::GetExtendedBacktraceThread(const char *type) {
 1372 uint32_t SBThread::GetExtendedBacktraceOriginatingIndexID() {
 1382 SBValue SBThread::GetCurrentException() {
 1392 SBThread SBThread::GetCurrentExceptionBacktrace() {
 1404 bool SBThread::SafeToCallFunctions() {

   28 operator=(const SBThreadCollection &rhs) {
   73 size_t SBThreadCollection::GetSize() {
   81 SBThread SBThreadCollection::GetThreadAtIndex(size_t idx) {

   90 const lldb::SBThreadPlan &SBThreadPlan::operator=(const SBThreadPlan &rhs) {
  119 lldb::StopReason SBThreadPlan::GetStopReason() {
  125 size_t SBThreadPlan::GetStopReasonDataCount() {
  131 uint64_t SBThreadPlan::GetStopReasonDataAtIndex(uint32_t idx) {
  171 bool SBThreadPlan::IsPlanComplete() {
  180 bool SBThreadPlan::IsPlanStale() {
  189 bool SBThreadPlan::IsValid() {
  205 SBThreadPlan::QueueThreadPlanForStepOverRange(SBAddress &sb_start_address,
  216 SBThreadPlan SBThreadPlan::QueueThreadPlanForStepOverRange(
  248 SBThreadPlan::QueueThreadPlanForStepInRange(SBAddress &sb_start_address,
  260 SBThreadPlan::QueueThreadPlanForStepInRange(SBAddress &sb_start_address,
  292 SBThreadPlan::QueueThreadPlanForStepOut(uint32_t frame_idx_to_step_to,
  304 SBThreadPlan::QueueThreadPlanForStepOut(uint32_t frame_idx_to_step_to,
  332 SBThreadPlan::QueueThreadPlanForRunToAddress(SBAddress sb_address) {
  341 SBThreadPlan SBThreadPlan::QueueThreadPlanForRunToAddress(SBAddress sb_address,
  367 SBThreadPlan::QueueThreadPlanForStepScripted(const char *script_class_name) {
  378 SBThreadPlan::QueueThreadPlanForStepScripted(const char *script_class_name,
  401 SBThreadPlan::QueueThreadPlanForStepScripted(const char *script_class_name,

   94 lldb::user_id_t SBTrace::GetTraceUID() {
  117 bool SBTrace::IsValid() {

   45 lldb::SBStructuredData SBTraceOptions::getTraceParams(lldb::SBError &error) {
  105 bool SBTraceOptions::IsValid() {
  125 lldb::tid_t SBTraceOptions::getThreadID() {

   52 bool SBType::operator==(SBType &rhs) {
   64 bool SBType::operator!=(SBType &rhs) {
   82 SBType &SBType::operator=(const SBType &rhs) {
  121 uint64_t SBType::GetByteSize() {
  131 bool SBType::IsPointerType() {
  139 bool SBType::IsArrayType() {
  148 bool SBType::IsVectorType() {
  156 bool SBType::IsReferenceType() {
  164 SBType SBType::GetPointerType() {
  174 SBType SBType::GetPointeeType() {
  183 SBType SBType::GetReferenceType() {
  192 SBType SBType::GetTypedefedType() {
  201 SBType SBType::GetDereferencedType() {
  210 SBType SBType::GetArrayElementType() {
  219 SBType SBType::GetArrayType(uint64_t size) {
  228 SBType SBType::GetVectorElementType() {
  241 bool SBType::IsFunctionType() {
  249 bool SBType::IsPolymorphicClass() {
  257 bool SBType::IsTypedefType() {
  265 bool SBType::IsAnonymousType() {
  273 lldb::SBType SBType::GetFunctionReturnType() {
  285 lldb::SBTypeList SBType::GetFunctionArgumentTypes() {
  300 uint32_t SBType::GetNumberOfMemberFunctions() {
  309 lldb::SBTypeMemberFunction SBType::GetMemberFunctionAtIndex(uint32_t idx) {
  320 lldb::SBType SBType::GetUnqualifiedType() {
  329 lldb::SBType SBType::GetCanonicalType() {
  338 lldb::BasicType SBType::GetBasicType() {
  346 SBType SBType::GetBasicType(lldb::BasicType basic_type) {
  356 uint32_t SBType::GetNumberOfDirectBaseClasses() {
  364 uint32_t SBType::GetNumberOfVirtualBaseClasses() {
  372 uint32_t SBType::GetNumberOfFields() {
  380 bool SBType::GetDescription(SBStream &description,
  396 SBTypeMember SBType::GetDirectBaseClassAtIndex(uint32_t idx) {
  413 SBTypeMember SBType::GetVirtualBaseClassAtIndex(uint32_t idx) {
  430 SBTypeEnumMemberList SBType::GetEnumMembers() {
  453 SBTypeMember SBType::GetFieldAtIndex(uint32_t idx) {
  480 bool SBType::IsTypeComplete() {
  488 uint32_t SBType::GetTypeFlags() {
  496 const char *SBType::GetName() {
  504 const char *SBType::GetDisplayTypeName() {
  512 lldb::TypeClass SBType::GetTypeClass() {
  520 uint32_t SBType::GetNumberOfTemplateArguments() {
  528 lldb::SBType SBType::GetTemplateArgumentType(uint32_t idx) {
  553 lldb::TemplateArgumentKind SBType::GetTemplateArgumentKind(uint32_t idx) {
  575 bool SBTypeList::IsValid() {
  585 SBTypeList &SBTypeList::operator=(const SBTypeList &rhs) {
  605 SBType SBTypeList::GetTypeAtIndex(uint32_t index) {
  614 uint32_t SBTypeList::GetSize() {
  637 lldb::SBTypeMember &SBTypeMember::operator=(const lldb::SBTypeMember &rhs) {
  658 const char *SBTypeMember::GetName() {
  666 SBType SBTypeMember::GetType() {
  676 uint64_t SBTypeMember::GetOffsetInBytes() {
  684 uint64_t SBTypeMember::GetOffsetInBits() {
  692 bool SBTypeMember::IsBitfield() {
  700 uint32_t SBTypeMember::GetBitfieldSizeInBits() {
  708 bool SBTypeMember::GetDescription(lldb::SBStream &description,
  766 operator=(const lldb::SBTypeMemberFunction &rhs) {
  787 const char *SBTypeMemberFunction::GetName() {
  795 const char *SBTypeMemberFunction::GetDemangledName() {
  809 const char *SBTypeMemberFunction::GetMangledName() {
  818 SBType SBTypeMemberFunction::GetType() {
  828 lldb::SBType SBTypeMemberFunction::GetReturnType() {
  838 uint32_t SBTypeMemberFunction::GetNumberOfArguments() {
  847 lldb::SBType SBTypeMemberFunction::GetArgumentTypeAtIndex(uint32_t i) {
  859 lldb::MemberFunctionKind SBTypeMemberFunction::GetKind() {
  868 bool SBTypeMemberFunction::GetDescription(

   55 bool SBTypeCategory::GetEnabled() {
   74 const char *SBTypeCategory::GetName() {
   82 lldb::LanguageType SBTypeCategory::GetLanguageAtIndex(uint32_t idx) {
   91 uint32_t SBTypeCategory::GetNumLanguages() {
  107 uint32_t SBTypeCategory::GetNumFormats() {
  117 uint32_t SBTypeCategory::GetNumSummaries() {
  126 uint32_t SBTypeCategory::GetNumFilters() {
  135 uint32_t SBTypeCategory::GetNumSynthetics() {
  145 SBTypeCategory::GetTypeNameSpecifierForFilterAtIndex(uint32_t index) {
  156 SBTypeCategory::GetTypeNameSpecifierForFormatAtIndex(uint32_t index) {
  167 SBTypeCategory::GetTypeNameSpecifierForSummaryAtIndex(uint32_t index) {
  178 SBTypeCategory::GetTypeNameSpecifierForSyntheticAtIndex(uint32_t index) {
  189 SBTypeFilter SBTypeCategory::GetFilterForType(SBTypeNameSpecifier spec) {
  216 SBTypeFormat SBTypeCategory::GetFormatForType(SBTypeNameSpecifier spec) {
  241 SBTypeSummary SBTypeCategory::GetSummaryForType(SBTypeNameSpecifier spec) {
  266 SBTypeSynthetic SBTypeCategory::GetSyntheticForType(SBTypeNameSpecifier spec) {
  294 SBTypeFilter SBTypeCategory::GetFilterAtIndex(uint32_t index) {
  312 SBTypeFormat SBTypeCategory::GetFormatAtIndex(uint32_t index) {
  322 SBTypeSummary SBTypeCategory::GetSummaryAtIndex(uint32_t index) {
  332 SBTypeSynthetic SBTypeCategory::GetSyntheticAtIndex(uint32_t index) {
  350 bool SBTypeCategory::AddTypeFormat(SBTypeNameSpecifier type_name,
  377 bool SBTypeCategory::DeleteTypeFormat(SBTypeNameSpecifier type_name) {
  395 bool SBTypeCategory::AddTypeSummary(SBTypeNameSpecifier type_name,
  456 bool SBTypeCategory::DeleteTypeSummary(SBTypeNameSpecifier type_name) {
  474 bool SBTypeCategory::AddTypeFilter(SBTypeNameSpecifier type_name,
  501 bool SBTypeCategory::DeleteTypeFilter(SBTypeNameSpecifier type_name) {
  519 bool SBTypeCategory::AddTypeSynthetic(SBTypeNameSpecifier type_name,
  580 bool SBTypeCategory::DeleteTypeSynthetic(SBTypeNameSpecifier type_name) {
  598 bool SBTypeCategory::GetDescription(lldb::SBStream &description,
  611 operator=(const lldb::SBTypeCategory &rhs) {
  622 bool SBTypeCategory::operator==(lldb::SBTypeCategory &rhs) {
  632 bool SBTypeCategory::operator!=(lldb::SBTypeCategory &rhs) {

   42 SBTypeEnumMember &SBTypeEnumMember::operator=(const SBTypeEnumMember &rhs) {
   62 const char *SBTypeEnumMember::GetName() {
   70 int64_t SBTypeEnumMember::GetValueAsSigned() {
   78 uint64_t SBTypeEnumMember::GetValueAsUnsigned() {
   86 SBType SBTypeEnumMember::GetType() {
  126 bool SBTypeEnumMemberList::IsValid() {
  137 operator=(const SBTypeEnumMemberList &rhs) {
  163 SBTypeEnumMemberList::GetTypeEnumMemberAtIndex(uint32_t index) {
  173 uint32_t SBTypeEnumMemberList::GetSize() {
  181 bool SBTypeEnumMember::GetDescription(

   46 uint32_t SBTypeFilter::GetOptions() {
   61 bool SBTypeFilter::GetDescription(lldb::SBStream &description,
   82 uint32_t SBTypeFilter::GetNumberOfExpressionPaths() {
   91 const char *SBTypeFilter::GetExpressionPathAtIndex(uint32_t i) {
  104 bool SBTypeFilter::ReplaceExpressionPathAtIndex(uint32_t i, const char *item) {
  122 lldb::SBTypeFilter &SBTypeFilter::operator=(const lldb::SBTypeFilter &rhs) {
  132 bool SBTypeFilter::operator==(lldb::SBTypeFilter &rhs) {
  142 bool SBTypeFilter::IsEqualTo(lldb::SBTypeFilter &rhs) {
  160 bool SBTypeFilter::operator!=(lldb::SBTypeFilter &rhs) {

   55 lldb::Format SBTypeFormat::GetFormat() {
   63 const char *SBTypeFormat::GetTypeName() {
   73 uint32_t SBTypeFormat::GetOptions() {
  103 bool SBTypeFormat::GetDescription(lldb::SBStream &description,
  117 lldb::SBTypeFormat &SBTypeFormat::operator=(const lldb::SBTypeFormat &rhs) {
  127 bool SBTypeFormat::operator==(lldb::SBTypeFormat &rhs) {
  136 bool SBTypeFormat::IsEqualTo(lldb::SBTypeFormat &rhs) {
  149 bool SBTypeFormat::operator!=(lldb::SBTypeFormat &rhs) {

   60 const char *SBTypeNameSpecifier::GetName() {
   69 SBType SBTypeNameSpecifier::GetType() {
   80 bool SBTypeNameSpecifier::IsRegex() {
   89 bool SBTypeNameSpecifier::GetDescription(
  103 operator=(const lldb::SBTypeNameSpecifier &rhs) {
  114 bool SBTypeNameSpecifier::operator==(lldb::SBTypeNameSpecifier &rhs) {
  123 bool SBTypeNameSpecifier::IsEqualTo(lldb::SBTypeNameSpecifier &rhs) {
  138 bool SBTypeNameSpecifier::operator!=(lldb::SBTypeNameSpecifier &rhs) {

   38 bool SBTypeSummaryOptions::IsValid() {
   48 lldb::LanguageType SBTypeSummaryOptions::GetLanguage() {
   57 lldb::TypeSummaryCapping SBTypeSummaryOptions::GetCapping() {
  208 bool SBTypeSummary::IsFunctionCode() {
  221 bool SBTypeSummary::IsFunctionName() {
  234 bool SBTypeSummary::IsSummaryString() {
  243 const char *SBTypeSummary::GetData() {
  261 uint32_t SBTypeSummary::GetOptions() {
  316 bool SBTypeSummary::GetDescription(lldb::SBStream &description,
  330 bool SBTypeSummary::DoesPrintValue(lldb::SBValue value) {
  340 lldb::SBTypeSummary &SBTypeSummary::operator=(const lldb::SBTypeSummary &rhs) {
  351 bool SBTypeSummary::operator==(lldb::SBTypeSummary &rhs) {
  360 bool SBTypeSummary::IsEqualTo(lldb::SBTypeSummary &rhs) {
  401 bool SBTypeSummary::operator!=(lldb::SBTypeSummary &rhs) {

   66 bool SBTypeSynthetic::IsClassCode() {
   75 bool SBTypeSynthetic::IsClassName() {
   83 const char *SBTypeSynthetic::GetData() {
  108 uint32_t SBTypeSynthetic::GetOptions() {
  124 bool SBTypeSynthetic::GetDescription(lldb::SBStream &description,
  138 operator=(const lldb::SBTypeSynthetic &rhs) {
  149 bool SBTypeSynthetic::operator==(lldb::SBTypeSynthetic &rhs) {
  158 bool SBTypeSynthetic::IsEqualTo(lldb::SBTypeSynthetic &rhs) {
  177 bool SBTypeSynthetic::operator!=(lldb::SBTypeSynthetic &rhs) {

   36 const SBUnixSignals &SBUnixSignals::operator=(const SBUnixSignals &rhs) {
  100 bool SBUnixSignals::SetShouldSuppress(int32_t signo, bool value) {
  122 bool SBUnixSignals::SetShouldStop(int32_t signo, bool value) {
  144 bool SBUnixSignals::SetShouldNotify(int32_t signo, bool value) {

  232 SBValue &SBValue::operator=(const SBValue &rhs) {
  244 bool SBValue::IsValid() {
  264 SBError SBValue::GetError() {
  280 user_id_t SBValue::GetID() {
  290 const char *SBValue::GetName() {
  302 const char *SBValue::GetTypeName() {
  315 const char *SBValue::GetDisplayTypeName() {
  328 size_t SBValue::GetByteSize() {
  342 bool SBValue::IsInScope() {
  356 const char *SBValue::GetValue() {
  369 ValueType SBValue::GetValueType() {
  381 const char *SBValue::GetObjectDescription() {
  394 const char *SBValue::GetTypeValidatorResult() {
  413 SBType SBValue::GetType() {
  428 bool SBValue::GetValueDidChange() {
  442 const char *SBValue::GetSummary() {
  455 const char *SBValue::GetSummary(lldb::SBStream &stream,
  472 const char *SBValue::GetLocation() {
  485 bool SBValue::SetValueFromCString(const char *value_str) {
  493 bool SBValue::SetValueFromCString(const char *value_str, lldb::SBError &error) {
  509 lldb::SBTypeFormat SBValue::GetTypeFormat() {
  525 lldb::SBTypeSummary SBValue::GetTypeSummary() {
  541 lldb::SBTypeFilter SBValue::GetTypeFilter() {
  561 lldb::SBTypeSynthetic SBValue::GetTypeSynthetic() {
  581 lldb::SBValue SBValue::CreateChildAtOffset(const char *name, uint32_t offset,
  602 lldb::SBValue SBValue::Cast(SBType type) {
  615 lldb::SBValue SBValue::CreateValueFromExpression(const char *name,
  626 lldb::SBValue SBValue::CreateValueFromExpression(const char *name,
  648 lldb::SBValue SBValue::CreateValueFromAddress(const char *name,
  670 lldb::SBValue SBValue::CreateValueFromData(const char *name, SBData data,
  691 SBValue SBValue::GetChildAtIndex(uint32_t idx) {
  707 SBValue SBValue::GetChildAtIndex(uint32_t idx,
  732 uint32_t SBValue::GetIndexOfChildWithName(const char *name) {
  745 SBValue SBValue::GetChildMemberWithName(const char *name) {
  760 SBValue::GetChildMemberWithName(const char *name,
  781 lldb::SBValue SBValue::GetDynamicValue(lldb::DynamicValueType use_dynamic) {
  794 lldb::SBValue SBValue::GetStaticValue() {
  807 lldb::SBValue SBValue::GetNonSyntheticValue() {
  819 lldb::DynamicValueType SBValue::GetPreferDynamicValue() {
  836 bool SBValue::GetPreferSyntheticValue() {
  852 bool SBValue::IsDynamic() {
  862 bool SBValue::IsSynthetic() {
  872 bool SBValue::IsSyntheticChildrenGenerated() {
  891 lldb::SBValue SBValue::GetValueForExpressionPath(const char *expr_path) {
  909 int64_t SBValue::GetValueAsSigned(SBError &error, int64_t fail_value) {
  930 uint64_t SBValue::GetValueAsUnsigned(SBError &error, uint64_t fail_value) {
  951 int64_t SBValue::GetValueAsSigned(int64_t fail_value) {
  962 uint64_t SBValue::GetValueAsUnsigned(uint64_t fail_value) {
  974 bool SBValue::MightHaveChildren() {
  986 bool SBValue::IsRuntimeSupportValue() {
  998 uint32_t SBValue::GetNumChildren() {
 1004 uint32_t SBValue::GetNumChildren(uint32_t max) {
 1017 SBValue SBValue::Dereference() {
 1032 bool SBValue::TypeIsPointerType() {
 1038 void *SBValue::GetOpaqueType() {
 1048 lldb::SBTarget SBValue::GetTarget() {
 1061 lldb::SBProcess SBValue::GetProcess() {
 1074 lldb::SBThread SBValue::GetThread() {
 1087 lldb::SBFrame SBValue::GetFrame() {
 1169 bool SBValue::GetExpressionPath(SBStream &description) {
 1182 bool SBValue::GetExpressionPath(SBStream &description,
 1272 bool SBValue::GetDescription(SBStream &description) {
 1288 lldb::Format SBValue::GetFormat() {
 1307 lldb::SBValue SBValue::AddressOf() {
 1322 lldb::addr_t SBValue::GetLoadAddress() {
 1352 lldb::SBAddress SBValue::GetAddress() {
 1381 lldb::SBData SBValue::GetPointeeData(uint32_t item_idx, uint32_t item_count) {
 1401 lldb::SBData SBValue::GetData() {
 1418 bool SBValue::SetData(lldb::SBData &data, SBError &error) {
 1453 lldb::SBDeclaration SBValue::GetDeclaration() {
 1467 lldb::SBWatchpoint SBValue::Watch(bool resolve_location, bool read, bool write,
 1532 lldb::SBWatchpoint SBValue::Watch(bool resolve_location, bool read,
 1541 lldb::SBWatchpoint SBValue::WatchPointee(bool resolve_location, bool read,
 1553 lldb::SBValue SBValue::Persist() {

  104 const SBValueList &SBValueList::operator=(const SBValueList &rhs) {
  179 SBValue SBValueList::FindValueObjectByUID(lldb::user_id_t uid) {

   95 operator=(const SBVariablesOptions &options) {

   41 const SBWatchpoint &SBWatchpoint::operator=(const SBWatchpoint &rhs) {
   51 watch_id_t SBWatchpoint::GetID() {
   87 SBError SBWatchpoint::GetError() {
   98 int32_t SBWatchpoint::GetHardwareIndex() {
  113 addr_t SBWatchpoint::GetWatchAddress() {
  128 size_t SBWatchpoint::GetWatchSize() {
  163 bool SBWatchpoint::IsEnabled() {
  175 uint32_t SBWatchpoint::GetHitCount() {
  189 uint32_t SBWatchpoint::GetIgnoreCount() {
  212 const char *SBWatchpoint::GetCondition() {
  236 bool SBWatchpoint::GetDescription(SBStream &description,

   59 class InstrumentedFoo {
   86 class InstrumentedBar {
  142 InstrumentedFoo &InstrumentedFoo::operator=(const InstrumentedFoo &foo) {
  162 int InstrumentedFoo::C(float *c) {
  201 InstrumentedFoo InstrumentedBar::GetInstrumentedFoo() {
  208 InstrumentedFoo &InstrumentedBar::GetInstrumentedFooRef() {
  216 InstrumentedFoo *InstrumentedBar::GetInstrumentedFooPtr() {