File Manager

003 File Manager

Current Path: /usr/src/contrib/llvm-project/lldb/include/lldb/API

usr / src / contrib / llvm-project / lldb / include / lldb / API /

📁 ..
📄 LLDB.h(2.82 KB)
📄 SBAddress.h(3.72 KB)
📄 SBAttachInfo.h(5.32 KB)
📄 SBBlock.h(2.53 KB)
📄 SBBreakpoint.h(4.36 KB)
📄 SBBreakpointLocation.h(2.42 KB)
📄 SBBreakpointName.h(3.07 KB)
📄 SBBroadcaster.h(2.34 KB)
📄 SBCommandInterpreter.h(14.14 KB)
📄 SBCommandInterpreterRunOptions.h(2.45 KB)
📄 SBCommandReturnObject.h(2.9 KB)
📄 SBCommunication.h(2.45 KB)
📄 SBCompileUnit.h(2.73 KB)
📄 SBData.h(5.21 KB)
📄 SBDebugger.h(10.31 KB)
📄 SBDeclaration.h(1.62 KB)
📄 SBDefines.h(3.12 KB)
📄 SBEnvironment.h(4.26 KB)
📄 SBError.h(2 KB)
📄 SBEvent.h(1.92 KB)
📄 SBExecutionContext.h(1.58 KB)
📄 SBExpressionOptions.h(3.04 KB)
📄 SBFile.h(1.23 KB)
📄 SBFileSpec.h(2.33 KB)
📄 SBFileSpecList.h(1.37 KB)
📄 SBFrame.h(6.64 KB)
📄 SBFunction.h(1.84 KB)
📄 SBHostOS.h(1.31 KB)
📄 SBInstruction.h(2.11 KB)
📄 SBInstructionList.h(1.81 KB)
📄 SBLanguageRuntime.h(744 B)
📄 SBLaunchInfo.h(5.34 KB)
📄 SBLineEntry.h(1.78 KB)
📄 SBListener.h(3.26 KB)
📄 SBMemoryRegionInfo.h(2.61 KB)
📄 SBMemoryRegionInfoList.h(1.37 KB)
📄 SBModule.h(10.9 KB)
📄 SBModuleSpec.h(3.19 KB)
📄 SBPlatform.h(3.83 KB)
📄 SBProcess.h(14.29 KB)
📄 SBProcessInfo.h(1.35 KB)
📄 SBQueue.h(1.35 KB)
📄 SBQueueItem.h(1.08 KB)
📄 SBReproducer.h(1.47 KB)
📄 SBSection.h(2.52 KB)
📄 SBSourceManager.h(1.4 KB)
📄 SBStream.h(3 KB)
📄 SBStringList.h(1.51 KB)
📄 SBStructuredData.h(3.34 KB)
📄 SBSymbol.h(2.04 KB)
📄 SBSymbolContext.h(2.27 KB)
📄 SBSymbolContextList.h(1.38 KB)
📄 SBTarget.h(30.06 KB)
📄 SBThread.h(6.83 KB)
📄 SBThreadCollection.h(1.34 KB)
📄 SBThreadPlan.h(4.27 KB)
📄 SBTrace.h(4.02 KB)
📄 SBTraceOptions.h(1.56 KB)
📄 SBType.h(5.38 KB)
📄 SBTypeCategory.h(2.72 KB)
📄 SBTypeEnumMember.h(1.81 KB)
📄 SBTypeFilter.h(1.67 KB)
📄 SBTypeFormat.h(1.78 KB)
📄 SBTypeNameSpecifier.h(1.56 KB)
📄 SBTypeSummary.h(3.35 KB)
📄 SBTypeSynthetic.h(1.9 KB)
📄 SBUnixSignals.h(1.58 KB)
📄 SBValue.h(14.47 KB)
📄 SBValueList.h(1.65 KB)
📄 SBVariablesOptions.h(1.8 KB)
📄 SBWatchpoint.h(1.85 KB)

Editing: SBFrame.h

//===-- SBFrame.h -----------------------------------------------*- C++ -*-===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//

#ifndef LLDB_API_SBFRAME_H
#define LLDB_API_SBFRAME_H

#include "lldb/API/SBDefines.h"
#include "lldb/API/SBValueList.h"

namespace lldb {

class LLDB_API SBFrame {
public:
  SBFrame();

SBFrame(const lldb::SBFrame &rhs);

const lldb::SBFrame &operator=(const lldb::SBFrame &rhs);

~SBFrame();

bool IsEqual(const lldb::SBFrame &that) const;

explicit operator bool() const;

bool IsValid() const;

uint32_t GetFrameID() const;

lldb::addr_t GetCFA() const;

lldb::addr_t GetPC() const;

bool SetPC(lldb::addr_t new_pc);

lldb::addr_t GetSP() const;

lldb::addr_t GetFP() const;

lldb::SBAddress GetPCAddress() const;

lldb::SBSymbolContext GetSymbolContext(uint32_t resolve_scope) const;

lldb::SBModule GetModule() const;

lldb::SBCompileUnit GetCompileUnit() const;

lldb::SBFunction GetFunction() const;

lldb::SBSymbol GetSymbol() const;

/// Gets the deepest block that contains the frame PC.
  ///
  /// See also GetFrameBlock().
  lldb::SBBlock GetBlock() const;

/// 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 appropriate function, symbol or inlined
  /// function name for the frame.
  ///
  /// This function returns:
  /// - the name of the inlined function (if there is one)
  /// - the name of the concrete function (if there is one)
  /// - the name of the symbol (if there is one)
  /// - NULL
  ///
  /// See also IsInlined().
  const char *GetFunctionName();

// Get an appropriate function name for this frame that is suitable for
  // display to a user
  const char *GetDisplayFunctionName();

const char *GetFunctionName() const;
  
  // Return the frame function's language.  If there isn't a function, then
  // guess the language type from the mangled name.
  lldb::LanguageType GuessLanguage() const;

/// Return true if this frame represents an inlined function.
  ///
  /// See also GetFunctionName().
  bool IsInlined();

bool IsInlined() const;

bool IsArtificial();

bool IsArtificial() const;

/// The version that doesn't supply a 'use_dynamic' value will use the
  /// target's default.
  lldb::SBValue EvaluateExpression(const char *expr);

lldb::SBValue EvaluateExpression(const char *expr,
                                   lldb::DynamicValueType use_dynamic);

lldb::SBValue EvaluateExpression(const char *expr,
                                   lldb::DynamicValueType use_dynamic,
                                   bool unwind_on_error);

lldb::SBValue EvaluateExpression(const char *expr,
                                   const SBExpressionOptions &options);

/// Gets the lexical block that defines the stack frame. Another way to think
  /// of this is it will return the block that contains all of the variables
  /// for a stack frame. Inlined functions are represented as SBBlock objects
  /// that have inlined function information: the name of the inlined function,
  /// where it was called from. The block that is returned will be the first
  /// block at or above the block for the PC (SBFrame::GetBlock()) that defines
  /// the scope of the frame. When a function contains no inlined functions,
  /// this will be the top most lexical block that defines the function.
  /// When a function has inlined functions and the PC is currently
  /// in one of those inlined functions, this method will return the inlined
  /// block that defines this frame. If the PC isn't currently in an inlined
  /// function, the lexical block that defines the function is returned.
  lldb::SBBlock GetFrameBlock() const;

lldb::SBLineEntry GetLineEntry() const;

lldb::SBThread GetThread() const;

const char *Disassemble() const;

void Clear();

bool operator==(const lldb::SBFrame &rhs) const;

bool operator!=(const lldb::SBFrame &rhs) const;

/// The version that doesn't supply a 'use_dynamic' value will use the
  /// target's default.
  lldb::SBValueList GetVariables(bool arguments, bool locals, bool statics,
                                 bool in_scope_only);

lldb::SBValueList GetVariables(bool arguments, bool locals, bool statics,
                                 bool in_scope_only,
                                 lldb::DynamicValueType use_dynamic);

lldb::SBValueList GetVariables(const lldb::SBVariablesOptions &options);

lldb::SBValueList GetRegisters();

lldb::SBValue FindRegister(const char *name);

/// The version that doesn't supply a 'use_dynamic' value will use the
  /// target's default.
  lldb::SBValue FindVariable(const char *var_name);

lldb::SBValue FindVariable(const char *var_name,
                             lldb::DynamicValueType use_dynamic);

// Find a value for a variable expression path like "rect.origin.x" or
  // "pt_ptr->x", "*self", "*this->obj_ptr". The returned value is _not_ and
  // expression result and is not a constant object like
  // SBFrame::EvaluateExpression(...) returns, but a child object of the
  // variable value.
  lldb::SBValue GetValueForVariablePath(const char *var_expr_cstr,
                                        DynamicValueType use_dynamic);

/// The version that doesn't supply a 'use_dynamic' value will use the
  /// target's default.
  lldb::SBValue GetValueForVariablePath(const char *var_path);

/// Find variables, register sets, registers, or persistent variables using
  /// the frame as the scope.
  ///
  /// NB. This function does not look up ivars in the function object pointer.
  /// To do that use GetValueForVariablePath.
  ///
  /// The version that doesn't supply a 'use_dynamic' value will use the
  /// target's default.
  lldb::SBValue FindValue(const char *name, ValueType value_type);

lldb::SBValue FindValue(const char *name, ValueType value_type,
                          lldb::DynamicValueType use_dynamic);

bool GetDescription(lldb::SBStream &description);

SBFrame(const lldb::StackFrameSP &lldb_object_sp);

protected:
  friend class SBBlock;
  friend class SBExecutionContext;
  friend class SBInstruction;
  friend class SBThread;
  friend class SBValue;

lldb::StackFrameSP GetFrameSP() const;

void SetFrameSP(const lldb::StackFrameSP &lldb_object_sp);

lldb::ExecutionContextRefSP m_opaque_sp;
};

} // namespace lldb

#endif // LLDB_API_SBFRAME_H

003 File Manager

Editing: SBFrame.h

Upload File

Create Folder