LLDB  mainline
CommandObjectRegister.cpp
Go to the documentation of this file.
1 //===-- CommandObjectRegister.cpp -----------------------------------------===//
2 //
3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4 // See https://llvm.org/LICENSE.txt for license information.
5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6 //
7 //===----------------------------------------------------------------------===//
8 
10 #include "lldb/Core/Debugger.h"
12 #include "lldb/Host/OptionParser.h"
21 #include "lldb/Target/Process.h"
24 #include "lldb/Target/Thread.h"
25 #include "lldb/Utility/Args.h"
28 #include "llvm/Support/Errno.h"
29 
30 using namespace lldb;
31 using namespace lldb_private;
32 
33 // "register read"
34 #define LLDB_OPTIONS_register_read
35 #include "CommandOptions.inc"
36 
38 public:
41  interpreter, "register read",
42  "Dump the contents of one or more register values from the current "
43  "frame. If no register is specified, dumps them all.",
44  nullptr,
45  eCommandRequiresFrame | eCommandRequiresRegContext |
46  eCommandProcessMustBeLaunched | eCommandProcessMustBePaused),
47  m_format_options(eFormatDefault) {
49  CommandArgumentData register_arg;
50 
51  // Define the first (and only) variant of this arg.
52  register_arg.arg_type = eArgTypeRegisterName;
53  register_arg.arg_repetition = eArgRepeatStar;
54 
55  // There is only one variant this argument could be; put it into the
56  // argument entry.
57  arg.push_back(register_arg);
58 
59  // Push the data for the first argument into the m_arguments vector.
60  m_arguments.push_back(arg);
61 
62  // Add the "--format"
63  m_option_group.Append(&m_format_options,
64  OptionGroupFormat::OPTION_GROUP_FORMAT |
65  OptionGroupFormat::OPTION_GROUP_GDB_FMT,
67  m_option_group.Append(&m_command_options);
68  m_option_group.Finalize();
69  }
70 
71  ~CommandObjectRegisterRead() override = default;
72 
73  void
75  OptionElementVector &opt_element_vector) override {
76  if (!m_exe_ctx.HasProcessScope())
77  return;
78 
79  CommandCompletions::InvokeCommonCompletionCallbacks(
80  GetCommandInterpreter(), CommandCompletions::eRegisterCompletion,
81  request, nullptr);
82  }
83 
84  Options *GetOptions() override { return &m_option_group; }
85 
86  bool DumpRegister(const ExecutionContext &exe_ctx, Stream &strm,
87  RegisterContext *reg_ctx, const RegisterInfo *reg_info) {
88  if (reg_info) {
89  RegisterValue reg_value;
90 
91  if (reg_ctx->ReadRegister(reg_info, reg_value)) {
92  strm.Indent();
93 
94  bool prefix_with_altname = (bool)m_command_options.alternate_name;
95  bool prefix_with_name = !prefix_with_altname;
96  DumpRegisterValue(reg_value, &strm, reg_info, prefix_with_name,
97  prefix_with_altname, m_format_options.GetFormat(), 8,
99  if ((reg_info->encoding == eEncodingUint) ||
100  (reg_info->encoding == eEncodingSint)) {
101  Process *process = exe_ctx.GetProcessPtr();
102  if (process && reg_info->byte_size == process->GetAddressByteSize()) {
103  addr_t reg_addr = reg_value.GetAsUInt64(LLDB_INVALID_ADDRESS);
104  if (reg_addr != LLDB_INVALID_ADDRESS) {
105  Address so_reg_addr;
106  if (exe_ctx.GetTargetRef()
108  .ResolveLoadAddress(reg_addr, so_reg_addr)) {
109  strm.PutCString(" ");
110  so_reg_addr.Dump(&strm, exe_ctx.GetBestExecutionContextScope(),
111  Address::DumpStyleResolvedDescription);
112  }
113  }
114  }
115  }
116  strm.EOL();
117  return true;
118  }
119  }
120  return false;
121  }
122 
123  bool DumpRegisterSet(const ExecutionContext &exe_ctx, Stream &strm,
124  RegisterContext *reg_ctx, size_t set_idx,
125  bool primitive_only = false) {
126  uint32_t unavailable_count = 0;
127  uint32_t available_count = 0;
128 
129  if (!reg_ctx)
130  return false; // thread has no registers (i.e. core files are corrupt,
131  // incomplete crash logs...)
132 
133  const RegisterSet *const reg_set = reg_ctx->GetRegisterSet(set_idx);
134  if (reg_set) {
135  strm.Printf("%s:\n", (reg_set->name ? reg_set->name : "unknown"));
136  strm.IndentMore();
137  const size_t num_registers = reg_set->num_registers;
138  for (size_t reg_idx = 0; reg_idx < num_registers; ++reg_idx) {
139  const uint32_t reg = reg_set->registers[reg_idx];
140  const RegisterInfo *reg_info = reg_ctx->GetRegisterInfoAtIndex(reg);
141  // Skip the dumping of derived register if primitive_only is true.
142  if (primitive_only && reg_info && reg_info->value_regs)
143  continue;
144 
145  if (DumpRegister(exe_ctx, strm, reg_ctx, reg_info))
146  ++available_count;
147  else
148  ++unavailable_count;
149  }
150  strm.IndentLess();
151  if (unavailable_count) {
152  strm.Indent();
153  strm.Printf("%u registers were unavailable.\n", unavailable_count);
154  }
155  strm.EOL();
156  }
157  return available_count > 0;
158  }
159 
160 protected:
161  bool DoExecute(Args &command, CommandReturnObject &result) override {
162  Stream &strm = result.GetOutputStream();
163  RegisterContext *reg_ctx = m_exe_ctx.GetRegisterContext();
164 
165  const RegisterInfo *reg_info = nullptr;
166  if (command.GetArgumentCount() == 0) {
167  size_t set_idx;
168 
169  size_t num_register_sets = 1;
170  const size_t set_array_size = m_command_options.set_indexes.GetSize();
171  if (set_array_size > 0) {
172  for (size_t i = 0; i < set_array_size; ++i) {
173  set_idx = m_command_options.set_indexes[i]->GetUInt64Value(UINT32_MAX,
174  nullptr);
175  if (set_idx < reg_ctx->GetRegisterSetCount()) {
176  if (!DumpRegisterSet(m_exe_ctx, strm, reg_ctx, set_idx)) {
177  if (errno)
178  result.AppendErrorWithFormatv("register read failed: {0}\n",
179  llvm::sys::StrError());
180  else
181  result.AppendError("unknown error while reading registers.\n");
182  break;
183  }
184  } else {
185  result.AppendErrorWithFormat(
186  "invalid register set index: %" PRIu64 "\n", (uint64_t)set_idx);
187  break;
188  }
189  }
190  } else {
191  if (m_command_options.dump_all_sets)
192  num_register_sets = reg_ctx->GetRegisterSetCount();
193 
194  for (set_idx = 0; set_idx < num_register_sets; ++set_idx) {
195  // When dump_all_sets option is set, dump primitive as well as
196  // derived registers.
197  DumpRegisterSet(m_exe_ctx, strm, reg_ctx, set_idx,
198  !m_command_options.dump_all_sets.GetCurrentValue());
199  }
200  }
201  } else {
202  if (m_command_options.dump_all_sets) {
203  result.AppendError("the --all option can't be used when registers "
204  "names are supplied as arguments\n");
205  } else if (m_command_options.set_indexes.GetSize() > 0) {
206  result.AppendError("the --set <set> option can't be used when "
207  "registers names are supplied as arguments\n");
208  } else {
209  for (auto &entry : command) {
210  // in most LLDB commands we accept $rbx as the name for register RBX
211  // - and here we would reject it and non-existant. we should be more
212  // consistent towards the user and allow them to say reg read $rbx -
213  // internally, however, we should be strict and not allow ourselves
214  // to call our registers $rbx in our own API
215  auto arg_str = entry.ref();
216  arg_str.consume_front("$");
217 
218  reg_info = reg_ctx->GetRegisterInfoByName(arg_str);
219 
220  if (reg_info) {
221  if (!DumpRegister(m_exe_ctx, strm, reg_ctx, reg_info))
222  strm.Printf("%-12s = error: unavailable\n", reg_info->name);
223  } else {
224  result.AppendErrorWithFormat("Invalid register name '%s'.\n",
225  arg_str.str().c_str());
226  }
227  }
228  }
229  }
230  return result.Succeeded();
231  }
232 
233  class CommandOptions : public OptionGroup {
234  public:
236  : set_indexes(OptionValue::ConvertTypeToMask(OptionValue::eTypeUInt64)),
237  dump_all_sets(false, false), // Initial and default values are false
238  alternate_name(false, false) {}
239 
240  ~CommandOptions() override = default;
241 
242  llvm::ArrayRef<OptionDefinition> GetDefinitions() override {
243  return llvm::makeArrayRef(g_register_read_options);
244  }
245 
246  void OptionParsingStarting(ExecutionContext *execution_context) override {
247  set_indexes.Clear();
248  dump_all_sets.Clear();
249  alternate_name.Clear();
250  }
251 
252  Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_value,
253  ExecutionContext *execution_context) override {
254  Status error;
255  const int short_option = GetDefinitions()[option_idx].short_option;
256  switch (short_option) {
257  case 's': {
258  OptionValueSP value_sp(OptionValueUInt64::Create(option_value, error));
259  if (value_sp)
260  set_indexes.AppendValue(value_sp);
261  } break;
262 
263  case 'a':
264  // When we don't use OptionValue::SetValueFromCString(const char *) to
265  // set an option value, it won't be marked as being set in the options
266  // so we make a call to let users know the value was set via option
267  dump_all_sets.SetCurrentValue(true);
268  dump_all_sets.SetOptionWasSet();
269  break;
270 
271  case 'A':
272  // When we don't use OptionValue::SetValueFromCString(const char *) to
273  // set an option value, it won't be marked as being set in the options
274  // so we make a call to let users know the value was set via option
275  alternate_name.SetCurrentValue(true);
276  dump_all_sets.SetOptionWasSet();
277  break;
278 
279  default:
280  llvm_unreachable("Unimplemented option");
281  }
282  return error;
283  }
284 
285  // Instance variables to hold the values for command options.
289  };
290 
294 };
295 
296 // "register write"
298 public:
300  : CommandObjectParsed(interpreter, "register write",
301  "Modify a single register value.", nullptr,
302  eCommandRequiresFrame | eCommandRequiresRegContext |
303  eCommandProcessMustBeLaunched |
304  eCommandProcessMustBePaused) {
307  CommandArgumentData register_arg;
308  CommandArgumentData value_arg;
309 
310  // Define the first (and only) variant of this arg.
311  register_arg.arg_type = eArgTypeRegisterName;
312  register_arg.arg_repetition = eArgRepeatPlain;
313 
314  // There is only one variant this argument could be; put it into the
315  // argument entry.
316  arg1.push_back(register_arg);
317 
318  // Define the first (and only) variant of this arg.
319  value_arg.arg_type = eArgTypeValue;
320  value_arg.arg_repetition = eArgRepeatPlain;
321 
322  // There is only one variant this argument could be; put it into the
323  // argument entry.
324  arg2.push_back(value_arg);
325 
326  // Push the data for the first argument into the m_arguments vector.
327  m_arguments.push_back(arg1);
328  m_arguments.push_back(arg2);
329  }
330 
331  ~CommandObjectRegisterWrite() override = default;
332 
333  void
335  OptionElementVector &opt_element_vector) override {
336  if (!m_exe_ctx.HasProcessScope() || request.GetCursorIndex() != 0)
337  return;
338 
339  CommandCompletions::InvokeCommonCompletionCallbacks(
340  GetCommandInterpreter(), CommandCompletions::eRegisterCompletion,
341  request, nullptr);
342  }
343 
344 protected:
345  bool DoExecute(Args &command, CommandReturnObject &result) override {
346  DataExtractor reg_data;
347  RegisterContext *reg_ctx = m_exe_ctx.GetRegisterContext();
348 
349  if (command.GetArgumentCount() != 2) {
350  result.AppendError(
351  "register write takes exactly 2 arguments: <reg-name> <value>");
352  } else {
353  auto reg_name = command[0].ref();
354  auto value_str = command[1].ref();
355 
356  // in most LLDB commands we accept $rbx as the name for register RBX -
357  // and here we would reject it and non-existant. we should be more
358  // consistent towards the user and allow them to say reg write $rbx -
359  // internally, however, we should be strict and not allow ourselves to
360  // call our registers $rbx in our own API
361  reg_name.consume_front("$");
362 
363  const RegisterInfo *reg_info = reg_ctx->GetRegisterInfoByName(reg_name);
364 
365  if (reg_info) {
366  RegisterValue reg_value;
367 
368  Status error(reg_value.SetValueFromString(reg_info, value_str));
369  if (error.Success()) {
370  if (reg_ctx->WriteRegister(reg_info, reg_value)) {
371  // Toss all frames and anything else in the thread after a register
372  // has been written.
373  m_exe_ctx.GetThreadRef().Flush();
375  return true;
376  }
377  }
378  if (error.AsCString()) {
379  result.AppendErrorWithFormat(
380  "Failed to write register '%s' with value '%s': %s\n",
381  reg_name.str().c_str(), value_str.str().c_str(),
382  error.AsCString());
383  } else {
384  result.AppendErrorWithFormat(
385  "Failed to write register '%s' with value '%s'",
386  reg_name.str().c_str(), value_str.str().c_str());
387  }
388  } else {
389  result.AppendErrorWithFormat("Register not found for '%s'.\n",
390  reg_name.str().c_str());
391  }
392  }
393  return result.Succeeded();
394  }
395 };
396 
397 // CommandObjectRegister constructor
398 CommandObjectRegister::CommandObjectRegister(CommandInterpreter &interpreter)
399  : CommandObjectMultiword(interpreter, "register",
400  "Commands to access registers for the current "
401  "thread and stack frame.",
402  "register [read|write] ...") {
403  LoadSubCommand("read",
404  CommandObjectSP(new CommandObjectRegisterRead(interpreter)));
405  LoadSubCommand("write",
406  CommandObjectSP(new CommandObjectRegisterWrite(interpreter)));
407 }
408 
lldb::eArgTypeRegisterName
@ eArgTypeRegisterName
Definition: lldb-enumerations.h:569
lldb_private::Stream::IndentLess
void IndentLess(unsigned amount=2)
Decrement the current indentation level.
Definition: Stream.cpp:171
lldb_private::RegisterContext::WriteRegister
virtual bool WriteRegister(const RegisterInfo *reg_info, const RegisterValue &reg_value)=0
lldb_private::CommandObjectParsed
Definition: CommandObject.h:390
lldb_private::ExecutionContext
Definition: ExecutionContext.h:292
OptionGroupFormat.h
lldb_private::eArgRepeatPlain
@ eArgRepeatPlain
Definition: lldb-private-enumerations.h:95
CommandObjectRegisterRead::CommandOptions::SetOptionValue
Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_value, ExecutionContext *execution_context) override
Definition: CommandObjectRegister.cpp:252
CommandObjectRegisterRead::DumpRegister
bool DumpRegister(const ExecutionContext &exe_ctx, Stream &strm, RegisterContext *reg_ctx, const RegisterInfo *reg_info)
Definition: CommandObjectRegister.cpp:86
lldb_private::RegisterValue
Definition: RegisterValue.h:28
CommandObjectRegisterWrite
Definition: CommandObjectRegister.cpp:297
lldb_private::ExecutionContext::GetProcessPtr
Process * GetProcessPtr() const
Returns a pointer to the process object.
Definition: ExecutionContext.cpp:206
lldb_private::OptionValueBoolean
Definition: OptionValueBoolean.h:16
OptionValueUInt64.h
lldb_private::RegisterContext::GetRegisterSet
virtual const RegisterSet * GetRegisterSet(size_t reg_set)=0
CommandObjectRegisterRead::DumpRegisterSet
bool DumpRegisterSet(const ExecutionContext &exe_ctx, Stream &strm, RegisterContext *reg_ctx, size_t set_idx, bool primitive_only=false)
Definition: CommandObjectRegister.cpp:123
lldb_private::RegisterContext::ReadRegister
virtual bool ReadRegister(const RegisterInfo *reg_info, RegisterValue &reg_value)=0
lldb_private::Process
Definition: Process.h:338
lldb_private::OptionGroupOptions
Definition: Options.h:255
lldb_private::CommandObject::CommandArgumentData
Used to build individual command argument lists.
Definition: CommandObject.h:92
lldb_private::OptionGroup
Definition: Options.h:233
SectionLoadList.h
CommandObjectRegisterRead::CommandObjectRegisterRead
CommandObjectRegisterRead(CommandInterpreter &interpreter)
Definition: CommandObjectRegister.cpp:39
CommandObjectRegisterRead::m_option_group
OptionGroupOptions m_option_group
Definition: CommandObjectRegister.cpp:291
RegisterValue.h
lldb_private::CommandObject::CommandArgumentData::arg_repetition
ArgumentRepetitionType arg_repetition
Definition: CommandObject.h:94
lldb::eArgTypeValue
@ eArgTypeValue
Definition: lldb-enumerations.h:594
lldb_private::Stream
Definition: Stream.h:28
lldb_private::Args
Definition: Args.h:33
lldb::addr_t
uint64_t addr_t
Definition: lldb-types.h:83
lldb_private::CommandReturnObject::Succeeded
bool Succeeded() const
Definition: CommandReturnObject.cpp:131
CommandObjectRegisterWrite::HandleArgumentCompletion
void HandleArgumentCompletion(CompletionRequest &request, OptionElementVector &opt_element_vector) override
The input array contains a parsed version of the line.
Definition: CommandObjectRegister.cpp:334
DumpRegister
static bool DumpRegister(Stream &s, StackFrame *frame, RegisterKind reg_kind, uint32_t reg_num, Format format)
Definition: FormatEntity.cpp:594
CommandReturnObject.h
lldb_private::RegisterContext::GetRegisterInfoAtIndex
virtual const RegisterInfo * GetRegisterInfoAtIndex(size_t reg)=0
Debugger.h
lldb_private::CommandReturnObject::AppendErrorWithFormatv
void AppendErrorWithFormatv(const char *format, Args &&... args)
Definition: CommandReturnObject.h:130
Process.h
lldb_private::RegisterValue::GetAsUInt64
uint64_t GetAsUInt64(uint64_t fail_value=UINT64_MAX, bool *success_ptr=nullptr) const
Definition: RegisterValue.cpp:556
CommandObjectRegister.h
lldb::eReturnStatusSuccessFinishNoResult
@ eReturnStatusSuccessFinishNoResult
Definition: lldb-enumerations.h:261
DumpRegisterValue.h
CommandObjectRegisterWrite::DoExecute
bool DoExecute(Args &command, CommandReturnObject &result) override
Definition: CommandObjectRegister.cpp:345
CommandObjectRegisterRead
Definition: CommandObjectRegister.cpp:37
lldb_private::CommandObjectMultiword
Definition: CommandObjectMultiword.h:19
error
static llvm::raw_ostream & error(Stream &strm)
Definition: CommandReturnObject.cpp:17
Options.h
lldb::eEncodingSint
@ eEncodingSint
signed integer
Definition: lldb-enumerations.h:150
lldb_private::Options
Definition: Options.h:57
lldb_private::Stream::Indent
size_t Indent(llvm::StringRef s="")
Indent the current line in the stream.
Definition: Stream.cpp:130
lldb_private::DataExtractor
Definition: DataExtractor.h:48
Args.h
CommandObjectRegisterRead::CommandOptions::CommandOptions
CommandOptions()
Definition: CommandObjectRegister.cpp:235
lldb_private::CommandObjectMultiword::LoadSubCommand
bool LoadSubCommand(llvm::StringRef cmd_name, const lldb::CommandObjectSP &command_obj) override
Definition: CommandObjectMultiword.cpp:80
CommandObjectRegisterRead::GetOptions
Options * GetOptions() override
Definition: CommandObjectRegister.cpp:84
lldb_private::CommandReturnObject::SetStatus
void SetStatus(lldb::ReturnStatus status)
Definition: CommandReturnObject.cpp:127
lldb_private::OptionGroupFormat
Definition: OptionGroupFormat.h:24
CommandObjectRegisterRead::HandleArgumentCompletion
void HandleArgumentCompletion(CompletionRequest &request, OptionElementVector &opt_element_vector) override
The input array contains a parsed version of the line.
Definition: CommandObjectRegister.cpp:74
lldb_private::CommandReturnObject::GetOutputStream
Stream & GetOutputStream()
Definition: CommandReturnObject.h:46
LLDB_OPT_SET_ALL
#define LLDB_OPT_SET_ALL
Definition: lldb-defines.h:101
lldb_private::Process::GetAddressByteSize
uint32_t GetAddressByteSize() const
Definition: Process.cpp:3366
lldb::eEncodingUint
@ eEncodingUint
unsigned integer
Definition: lldb-enumerations.h:149
OptionValueArray.h
lldb_private::CommandInterpreter
Definition: CommandInterpreter.h:214
lldb_private::eArgRepeatStar
@ eArgRepeatStar
Definition: lldb-private-enumerations.h:98
lldb_private::CommandObjectRegister::~CommandObjectRegister
~CommandObjectRegister() override
CommandObjectRegisterRead::CommandOptions::dump_all_sets
OptionValueBoolean dump_all_sets
Definition: CommandObjectRegister.cpp:287
lldb_private::CommandObject::CommandArgumentData::arg_type
lldb::CommandArgumentType arg_type
Definition: CommandObject.h:93
lldb_private::OptionElementVector
std::vector< OptionArgElement > OptionElementVector
Definition: Options.h:42
Thread.h
lldb_private::SectionLoadList::ResolveLoadAddress
bool ResolveLoadAddress(lldb::addr_t load_addr, Address &so_addr, bool allow_section_end=false) const
Definition: SectionLoadList.cpp:219
lldb_private::RegisterContext
Definition: RegisterContext.h:17
lldb_private::RegisterContext::GetRegisterSetCount
virtual size_t GetRegisterSetCount()=0
CommandObjectRegisterRead::CommandOptions::OptionParsingStarting
void OptionParsingStarting(ExecutionContext *execution_context) override
Definition: CommandObjectRegister.cpp:246
lldb_private::Status
Definition: Status.h:44
lldb_private::Address::Dump
bool Dump(Stream *s, ExecutionContextScope *exe_scope, DumpStyle style, DumpStyle fallback_style=DumpStyleInvalid, uint32_t addr_byte_size=UINT32_MAX, bool all_ranges=false) const
Dump a description of this object to a Stream.
Definition: Address.cpp:406
lldb_private::CommandReturnObject
Definition: CommandReturnObject.h:26
uint32_t
lldb_private::ExecutionContext::GetBestExecutionContextScope
ExecutionContextScope * GetBestExecutionContextScope() const
Definition: ExecutionContext.cpp:214
lldb_private::Stream::IndentMore
void IndentMore(unsigned amount=2)
Increment the current indentation level.
Definition: Stream.cpp:168
lldb_private::Address
Definition: Address.h:59
lldb_private::Stream::EOL
size_t EOL()
Output and End of Line character to the stream.
Definition: Stream.cpp:128
CommandObjectRegisterRead::DoExecute
bool DoExecute(Args &command, CommandReturnObject &result) override
Definition: CommandObjectRegister.cpp:161
CommandObjectRegisterRead::CommandOptions::GetDefinitions
llvm::ArrayRef< OptionDefinition > GetDefinitions() override
Definition: CommandObjectRegister.cpp:242
CommandObjectRegisterRead::CommandOptions
Definition: CommandObjectRegister.cpp:233
UINT32_MAX
#define UINT32_MAX
Definition: lldb-defines.h:19
lldb_private::DumpRegisterValue
bool DumpRegisterValue(const RegisterValue &reg_val, Stream *s, const RegisterInfo *reg_info, bool prefix_with_name, bool prefix_with_alt_name, lldb::Format format, uint32_t reg_name_right_align_at=0, ExecutionContextScope *exe_scope=nullptr)
Definition: DumpRegisterValue.cpp:18
lldb_private::Target::GetSectionLoadList
SectionLoadList & GetSectionLoadList()
Definition: Target.h:1102
LLDB_INVALID_ADDRESS
#define LLDB_INVALID_ADDRESS
Definition: lldb-defines.h:74
CommandObjectRegisterRead::CommandOptions::alternate_name
OptionValueBoolean alternate_name
Definition: CommandObjectRegister.cpp:288
DataExtractor.h
lldb_private::Stream::Printf
size_t Printf(const char *format,...) __attribute__((format(printf
Output printf formatted output to the stream.
Definition: Stream.cpp:107
lldb_private::ExecutionContext::GetTargetRef
Target & GetTargetRef() const
Returns a reference to the target object.
Definition: ExecutionContext.cpp:224
lldb_private::CommandReturnObject::AppendErrorWithFormat
void AppendErrorWithFormat(const char *format,...) __attribute__((format(printf
Definition: CommandReturnObject.cpp:46
CommandObjectRegisterRead::m_format_options
OptionGroupFormat m_format_options
Definition: CommandObjectRegister.cpp:292
OptionParser.h
lldb_private::CompletionRequest::GetCursorIndex
size_t GetCursorIndex() const
Definition: CompletionRequest.h:156
lldb_private
A class that represents a running process on the host machine.
Definition: SBCommandInterpreterRunOptions.h:16
CommandOptionArgumentTable.h
CommandObjectRegisterWrite::CommandObjectRegisterWrite
CommandObjectRegisterWrite(CommandInterpreter &interpreter)
Definition: CommandObjectRegister.cpp:299
lldb_private::Stream::PutCString
size_t PutCString(llvm::StringRef cstr)
Output a C string to the stream.
Definition: Stream.cpp:63
OptionValueBoolean.h
lldb_private::OptionValue
Definition: OptionValue.h:25
lldb_private::CommandObject::CommandArgumentEntry
std::vector< CommandArgumentData > CommandArgumentEntry
Definition: CommandObject.h:107
lldb_private::CommandReturnObject::AppendError
void void AppendError(llvm::StringRef in_string)
Definition: CommandReturnObject.cpp:100
lldb_private::Args::GetArgumentCount
size_t GetArgumentCount() const
Gets the number of arguments left in this command object.
Definition: Args.h:116
lldb
Definition: SBAddress.h:15
CommandObjectRegisterRead::CommandOptions::set_indexes
OptionValueArray set_indexes
Definition: CommandObjectRegister.cpp:286
RegisterContext.h
lldb_private::RegisterValue::SetValueFromString
Status SetValueFromString(const RegisterInfo *reg_info, llvm::StringRef value_str)
Definition: RegisterValue.cpp:328
lldb::eFormatDefault
@ eFormatDefault
Definition: lldb-enumerations.h:157
ExecutionContext.h
CommandObjectRegisterRead::m_command_options
CommandOptions m_command_options
Definition: CommandObjectRegister.cpp:293
lldb_private::RegisterContext::GetRegisterInfoByName
const RegisterInfo * GetRegisterInfoByName(llvm::StringRef reg_name, uint32_t start_idx=0)
Definition: RegisterContext.cpp:52
lldb_private::CompletionRequest
Definition: CompletionRequest.h:100
lldb_private::OptionValueArray
Definition: OptionValueArray.h:18