contrib/llvm/tools/lldb/include/lldb/API/SBFrame.h

   1 //===-- SBFrame.h -----------------------------------------------*- C++ -*-===//
   2 //
   3 //                     The LLVM Compiler Infrastructure
   4 //
   5 // This file is distributed under the University of Illinois Open Source
   6 // License. See LICENSE.TXT for details.
   7 //
   8 //===----------------------------------------------------------------------===//
   9
  10 #ifndef LLDB_SBFrame_h_
  11 #define LLDB_SBFrame_h_
  12
  13 #include "lldb/API/SBDefines.h"
  14 #include "lldb/API/SBValueList.h"
  15
  16 namespace lldb {
  17
  18 class SBFrame
  19 {
  20 public:
  21     SBFrame ();
  22
  23     SBFrame (const lldb::SBFrame &rhs);
  24
  25     const lldb::SBFrame &
  26     operator =(const lldb::SBFrame &rhs);
  27
  28    ~SBFrame();
  29
  30     bool
  31     IsEqual (const lldb::SBFrame &that) const;
  32
  33     bool
  34     IsValid() const;
  35
  36     uint32_t
  37     GetFrameID () const;
  38
  39     lldb::addr_t
  40     GetPC () const;
  41
  42     bool
  43     SetPC (lldb::addr_t new_pc);
  44
  45     lldb::addr_t
  46     GetSP () const;
  47
  48     lldb::addr_t
  49     GetFP () const;
  50
  51     lldb::SBAddress
  52     GetPCAddress () const;
  53
  54     lldb::SBSymbolContext
  55     GetSymbolContext (uint32_t resolve_scope) const;
  56
  57     lldb::SBModule
  58     GetModule () const;
  59
  60     lldb::SBCompileUnit
  61     GetCompileUnit () const;
  62
  63     lldb::SBFunction
  64     GetFunction () const;
  65
  66     lldb::SBSymbol
  67     GetSymbol () const;
  68
  69     /// Gets the deepest block that contains the frame PC.
  70     ///
  71     /// See also GetFrameBlock().
  72     lldb::SBBlock
  73     GetBlock () const;
  74
  75     /// Get the appropriate function name for this frame. Inlined functions in
  76     /// LLDB are represented by Blocks that have inlined function information, so
  77     /// just looking at the SBFunction or SBSymbol for a frame isn't enough.
  78     /// This function will return the appriopriate function, symbol or inlined
  79     /// function name for the frame.
  80     ///
  81     /// This function returns:
  82     /// - the name of the inlined function (if there is one)
  83     /// - the name of the concrete function (if there is one)
  84     /// - the name of the symbol (if there is one)
  85     /// - NULL
  86     ///
  87     /// See also IsInlined().
  88     const char *
  89     GetFunctionName();
  90
  91     /// Return true if this frame represents an inlined function.
  92     ///
  93     /// See also GetFunctionName().
  94     bool
  95     IsInlined();
  96
  97     /// The version that doesn't supply a 'use_dynamic' value will use the
  98     /// target's default.
  99     lldb::SBValue
 100     EvaluateExpression (const char *expr);
 101
 102     lldb::SBValue
 103     EvaluateExpression (const char *expr, lldb::DynamicValueType use_dynamic);
 104
 105     lldb::SBValue
 106     EvaluateExpression (const char *expr, lldb::DynamicValueType use_dynamic, bool unwind_on_error);
 107
 108     lldb::SBValue
 109     EvaluateExpression (const char *expr, const SBExpressionOptions &options);
 110
 111     /// Gets the lexical block that defines the stack frame. Another way to think
 112     /// of this is it will return the block that contains all of the variables
 113     /// for a stack frame. Inlined functions are represented as SBBlock objects
 114     /// that have inlined function information: the name of the inlined function,
 115     /// where it was called from. The block that is returned will be the first
 116     /// block at or above the block for the PC (SBFrame::GetBlock()) that defines
 117     /// the scope of the frame. When a function contains no inlined functions,
 118     /// this will be the top most lexical block that defines the function.
 119     /// When a function has inlined functions and the PC is currently
 120     /// in one of those inlined functions, this method will return the inlined
 121     /// block that defines this frame. If the PC isn't currently in an inlined
 122     /// function, the lexical block that defines the function is returned.
 123     lldb::SBBlock
 124     GetFrameBlock () const;
 125
 126     lldb::SBLineEntry
 127     GetLineEntry () const;
 128
 129     lldb::SBThread
 130     GetThread () const;
 131
 132     const char *
 133     Disassemble () const;
 134
 135     void
 136     Clear();
 137
 138     bool
 139     operator == (const lldb::SBFrame &rhs) const;
 140
 141     bool
 142     operator != (const lldb::SBFrame &rhs) const;
 143
 144     /// The version that doesn't supply a 'use_dynamic' value will use the
 145     /// target's default.
 146     lldb::SBValueList
 147     GetVariables (bool arguments,
 148                   bool locals,
 149                   bool statics,
 150                   bool in_scope_only);
 151
 152     lldb::SBValueList
 153     GetVariables (bool arguments,
 154                   bool locals,
 155                   bool statics,
 156                   bool in_scope_only,
 157                   lldb::DynamicValueType  use_dynamic);
 158
 159     lldb::SBValueList
 160     GetRegisters ();
 161
 162     lldb::SBValue
 163     FindRegister (const char *name);
 164
 165     /// The version that doesn't supply a 'use_dynamic' value will use the
 166     /// target's default.
 167     lldb::SBValue
 168     FindVariable (const char *var_name);
 169
 170     lldb::SBValue
 171     FindVariable (const char *var_name, lldb::DynamicValueType use_dynamic);
 172
 173     // Find a value for a variable expression path like "rect.origin.x" or
 174     // "pt_ptr->x", "*self", "*this->obj_ptr". The returned value is _not_
 175     // and expression result and is not a constant object like
 176     // SBFrame::EvaluateExpression(...) returns, but a child object of
 177     // the variable value.
 178     lldb::SBValue
 179     GetValueForVariablePath (const char *var_expr_cstr,
 180                              DynamicValueType use_dynamic);
 181
 182     /// The version that doesn't supply a 'use_dynamic' value will use the
 183     /// target's default.
 184     lldb::SBValue
 185     GetValueForVariablePath (const char *var_path);
 186
 187     /// Find variables, register sets, registers, or persistent variables using
 188     /// the frame as the scope.
 189     ///
 190     /// NB. This function does not look up ivars in the function object pointer.
 191     /// To do that use GetValueForVariablePath.
 192     ///
 193     /// The version that doesn't supply a 'use_dynamic' value will use the
 194     /// target's default.
 195     lldb::SBValue
 196     FindValue (const char *name, ValueType value_type);
 197
 198     lldb::SBValue
 199     FindValue (const char *name, ValueType value_type, lldb::DynamicValueType use_dynamic);
 200
 201     /// Find and watch a variable using the frame as the scope.
 202     /// It returns an SBValue, similar to FindValue() method, if find-and-watch
 203     /// operation succeeds.  Otherwise, an invalid SBValue is returned.
 204     /// You can use LLDB_WATCH_TYPE_READ | LLDB_WATCH_TYPE_WRITE for 'rw' watch.
 205     lldb::SBValue
 206     WatchValue (const char *name, ValueType value_type, uint32_t watch_type);
 207
 208     /// Find and watch the location pointed to by a variable using the frame as
 209     /// the scope.
 210     /// It returns an SBValue, similar to FindValue() method, if find-and-watch
 211     /// operation succeeds.  Otherwise, an invalid SBValue is returned.
 212     /// You can use LLDB_WATCH_TYPE_READ | LLDB_WATCH_TYPE_WRITE for 'rw' watch.
 213     lldb::SBValue
 214     WatchLocation (const char *name, ValueType value_type, uint32_t watch_type, size_t size);
 215
 216     bool
 217     GetDescription (lldb::SBStream &description);
 218
 219     SBFrame (const lldb::StackFrameSP &lldb_object_sp);
 220
 221 protected:
 222
 223     friend class SBBlock;
 224     friend class SBInstruction;
 225     friend class SBThread;
 226     friend class SBValue;
 227 #ifndef LLDB_DISABLE_PYTHON
 228     friend class lldb_private::ScriptInterpreterPython;
 229 #endif
 230
 231     lldb::StackFrameSP
 232     GetFrameSP() const;
 233
 234     void
 235     SetFrameSP (const lldb::StackFrameSP &lldb_object_sp);
 236
 237     lldb::ExecutionContextRefSP m_opaque_sp;
 238 };
 239
 240 } // namespace lldb
 241
 242 #endif  // LLDB_SBFrame_h_