contrib/llvm/tools/lldb/source/Commands/CommandObjectRegister.cpp

   1 //===-- CommandObjectRegister.cpp -------------------------------*- 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 #include "lldb/lldb-python.h"
  11
  12 #include "CommandObjectRegister.h"
  13
  14 // C Includes
  15 // C++ Includes
  16 // Other libraries and framework includes
  17 // Project includes
  18 #include "lldb/Core/DataExtractor.h"
  19 #include "lldb/Core/RegisterValue.h"
  20 #include "lldb/Core/Scalar.h"
  21 #include "lldb/Core/Debugger.h"
  22 #include "lldb/Interpreter/Args.h"
  23 #include "lldb/Interpreter/CommandInterpreter.h"
  24 #include "lldb/Interpreter/CommandReturnObject.h"
  25 #include "lldb/Interpreter/Options.h"
  26 #include "lldb/Interpreter/OptionGroupFormat.h"
  27 #include "lldb/Interpreter/OptionValueArray.h"
  28 #include "lldb/Interpreter/OptionValueUInt64.h"
  29 #include "lldb/Target/ExecutionContext.h"
  30 #include "lldb/Target/Process.h"
  31 #include "lldb/Target/RegisterContext.h"
  32 #include "lldb/Target/Thread.h"
  33
  34 using namespace lldb;
  35 using namespace lldb_private;
  36
  37 //----------------------------------------------------------------------
  38 // "register read"
  39 //----------------------------------------------------------------------
  40 class CommandObjectRegisterRead : public CommandObjectParsed
  41 {
  42 public:
  43     CommandObjectRegisterRead (CommandInterpreter &interpreter) :
  44         CommandObjectParsed (interpreter,
  45                              "register read",
  46                              "Dump the contents of one or more register values from the current frame.  If no register is specified, dumps them all.",
  47                              NULL,
  48                              eFlagRequiresFrame         |
  49                              eFlagRequiresRegContext    |
  50                              eFlagProcessMustBeLaunched |
  51                              eFlagProcessMustBePaused   ),
  52         m_option_group (interpreter),
  53         m_format_options (eFormatDefault),
  54         m_command_options ()
  55     {
  56         CommandArgumentEntry arg;
  57         CommandArgumentData register_arg;
  58
  59         // Define the first (and only) variant of this arg.
  60         register_arg.arg_type = eArgTypeRegisterName;
  61         register_arg.arg_repetition = eArgRepeatStar;
  62
  63         // There is only one variant this argument could be; put it into the argument entry.
  64         arg.push_back (register_arg);
  65
  66         // Push the data for the first argument into the m_arguments vector.
  67         m_arguments.push_back (arg);
  68
  69         // Add the "--format"
  70         m_option_group.Append (&m_format_options, OptionGroupFormat::OPTION_GROUP_FORMAT | OptionGroupFormat::OPTION_GROUP_GDB_FMT, LLDB_OPT_SET_ALL);
  71         m_option_group.Append (&m_command_options);
  72         m_option_group.Finalize();
  73
  74     }
  75
  76     virtual
  77     ~CommandObjectRegisterRead ()
  78     {
  79     }
  80
  81     Options *
  82     GetOptions ()
  83     {
  84         return &m_option_group;
  85     }
  86
  87     bool
  88     DumpRegister (const ExecutionContext &exe_ctx,
  89                   Stream &strm,
  90                   RegisterContext *reg_ctx,
  91                   const RegisterInfo *reg_info)
  92     {
  93         if (reg_info)
  94         {
  95             RegisterValue reg_value;
  96
  97             if (reg_ctx->ReadRegister (reg_info, reg_value))
  98             {
  99                 strm.Indent ();
 100
 101                 bool prefix_with_altname = m_command_options.alternate_name;
 102                 bool prefix_with_name = !prefix_with_altname;
 103                 reg_value.Dump(&strm, reg_info, prefix_with_name, prefix_with_altname, m_format_options.GetFormat(), 8);
 104                 if ((reg_info->encoding == eEncodingUint) || (reg_info->encoding == eEncodingSint))
 105                 {
 106                     Process *process = exe_ctx.GetProcessPtr();
 107                     if (process && reg_info->byte_size == process->GetAddressByteSize())
 108                     {
 109                         addr_t reg_addr = reg_value.GetAsUInt64(LLDB_INVALID_ADDRESS);
 110                         if (reg_addr != LLDB_INVALID_ADDRESS)
 111                         {
 112                             Address so_reg_addr;
 113                             if (exe_ctx.GetTargetRef().GetSectionLoadList().ResolveLoadAddress(reg_addr, so_reg_addr))
 114                             {
 115                                 strm.PutCString ("  ");
 116                                 so_reg_addr.Dump(&strm, exe_ctx.GetBestExecutionContextScope(), Address::DumpStyleResolvedDescription);
 117                             }
 118                         }
 119                     }
 120                 }
 121                 strm.EOL();
 122                 return true;
 123             }
 124         }
 125         return false;
 126     }
 127
 128     bool
 129     DumpRegisterSet (const ExecutionContext &exe_ctx,
 130                      Stream &strm,
 131                      RegisterContext *reg_ctx,
 132                      size_t set_idx,
 133                      bool primitive_only=false)
 134     {
 135         uint32_t unavailable_count = 0;
 136         uint32_t available_count = 0;
 137
 138         if (!reg_ctx)
 139             return false; // thread has no registers (i.e. core files are corrupt, incomplete crash logs...)
 140
 141         const RegisterSet * const reg_set = reg_ctx->GetRegisterSet(set_idx);
 142         if (reg_set)
 143         {
 144             strm.Printf ("%s:\n", reg_set->name);
 145             strm.IndentMore ();
 146             const size_t num_registers = reg_set->num_registers;
 147             for (size_t reg_idx = 0; reg_idx < num_registers; ++reg_idx)
 148             {
 149                 const uint32_t reg = reg_set->registers[reg_idx];
 150                 const RegisterInfo *reg_info = reg_ctx->GetRegisterInfoAtIndex(reg);
 151                 // Skip the dumping of derived register if primitive_only is true.
 152                 if (primitive_only && reg_info && reg_info->value_regs)
 153                     continue;
 154
 155                 if (DumpRegister (exe_ctx, strm, reg_ctx, reg_info))
 156                     ++available_count;
 157                 else
 158                     ++unavailable_count;
 159             }
 160             strm.IndentLess ();
 161             if (unavailable_count)
 162             {
 163                 strm.Indent ();
 164                 strm.Printf("%u registers were unavailable.\n", unavailable_count);
 165             }
 166             strm.EOL();
 167         }
 168         return available_count > 0;
 169     }
 170
 171 protected:
 172     virtual bool
 173     DoExecute (Args& command, CommandReturnObject &result)
 174     {
 175         Stream &strm = result.GetOutputStream();
 176         RegisterContext *reg_ctx = m_exe_ctx.GetRegisterContext ();
 177
 178         const RegisterInfo *reg_info = NULL;
 179         if (command.GetArgumentCount() == 0)
 180         {
 181             size_t set_idx;
 182
 183             size_t num_register_sets = 1;
 184             const size_t set_array_size = m_command_options.set_indexes.GetSize();
 185             if (set_array_size > 0)
 186             {
 187                 for (size_t i=0; i<set_array_size; ++i)
 188                 {
 189                     set_idx = m_command_options.set_indexes[i]->GetUInt64Value (UINT32_MAX, NULL);
 190                     if (set_idx < reg_ctx->GetRegisterSetCount())
 191                     {
 192                         if (!DumpRegisterSet (m_exe_ctx, strm, reg_ctx, set_idx))
 193                         {
 194                             if (errno)
 195                                 result.AppendErrorWithFormat ("register read failed with errno: %d\n", errno);
 196                             else
 197                                 result.AppendError ("unknown error while reading registers.\n");
 198                             result.SetStatus (eReturnStatusFailed);
 199                             break;
 200                         }
 201                     }
 202                     else
 203                     {
 204                         result.AppendErrorWithFormat ("invalid register set index: %zu\n", set_idx);
 205                         result.SetStatus (eReturnStatusFailed);
 206                         break;
 207                     }
 208                 }
 209             }
 210             else
 211             {
 212                 if (m_command_options.dump_all_sets)
 213                     num_register_sets = reg_ctx->GetRegisterSetCount();
 214
 215                 for (set_idx = 0; set_idx < num_register_sets; ++set_idx)
 216                 {
 217                     // When dump_all_sets option is set, dump primitive as well as derived registers.
 218                     DumpRegisterSet (m_exe_ctx, strm, reg_ctx, set_idx, !m_command_options.dump_all_sets.GetCurrentValue());
 219                 }
 220             }
 221         }
 222         else
 223         {
 224             if (m_command_options.dump_all_sets)
 225             {
 226                 result.AppendError ("the --all option can't be used when registers names are supplied as arguments\n");
 227                 result.SetStatus (eReturnStatusFailed);
 228             }
 229             else if (m_command_options.set_indexes.GetSize() > 0)
 230             {
 231                 result.AppendError ("the --set <set> option can't be used when registers names are supplied as arguments\n");
 232                 result.SetStatus (eReturnStatusFailed);
 233             }
 234             else
 235             {
 236                 const char *arg_cstr;
 237                 for (int arg_idx = 0; (arg_cstr = command.GetArgumentAtIndex(arg_idx)) != NULL; ++arg_idx)
 238                 {
 239                     // in most LLDB commands we accept $rbx as the name for register RBX - and here we would
 240                     // reject it and non-existant. we should be more consistent towards the user and allow them
 241                     // to say reg read $rbx - internally, however, we should be strict and not allow ourselves
 242                     // to call our registers $rbx in our own API
 243                     if (*arg_cstr == '$')
 244                         arg_cstr = arg_cstr+1;
 245                     reg_info = reg_ctx->GetRegisterInfoByName(arg_cstr);
 246
 247                     if (reg_info)
 248                     {
 249                         if (!DumpRegister (m_exe_ctx, strm, reg_ctx, reg_info))
 250                             strm.Printf("%-12s = error: unavailable\n", reg_info->name);
 251                     }
 252                     else
 253                     {
 254                         result.AppendErrorWithFormat ("Invalid register name '%s'.\n", arg_cstr);
 255                     }
 256                 }
 257             }
 258         }
 259         return result.Succeeded();
 260     }
 261
 262     class CommandOptions : public OptionGroup
 263     {
 264     public:
 265         CommandOptions () :
 266             OptionGroup(),
 267             set_indexes (OptionValue::ConvertTypeToMask (OptionValue::eTypeUInt64)),
 268             dump_all_sets (false, false), // Initial and default values are false
 269             alternate_name (false, false)
 270         {
 271         }
 272
 273         virtual
 274         ~CommandOptions ()
 275         {
 276         }
 277
 278
 279         virtual uint32_t
 280         GetNumDefinitions ();
 281
 282         virtual const OptionDefinition*
 283         GetDefinitions ()
 284         {
 285             return g_option_table;
 286         }
 287
 288         virtual void
 289         OptionParsingStarting (CommandInterpreter &interpreter)
 290         {
 291             set_indexes.Clear();
 292             dump_all_sets.Clear();
 293             alternate_name.Clear();
 294         }
 295
 296         virtual Error
 297         SetOptionValue (CommandInterpreter &interpreter,
 298                         uint32_t option_idx,
 299                         const char *option_value)
 300         {
 301             Error error;
 302             const int short_option = g_option_table[option_idx].short_option;
 303             switch (short_option)
 304             {
 305                 case 's':
 306                     {
 307                         OptionValueSP value_sp (OptionValueUInt64::Create (option_value, error));
 308                         if (value_sp)
 309                             set_indexes.AppendValue (value_sp);
 310                     }
 311                     break;
 312
 313                 case 'a':
 314                     // When we don't use OptionValue::SetValueFromCString(const char *) to
 315                     // set an option value, it won't be marked as being set in the options
 316                     // so we make a call to let users know the value was set via option
 317                     dump_all_sets.SetCurrentValue (true);
 318                     dump_all_sets.SetOptionWasSet ();
 319                     break;
 320
 321                 case 'A':
 322                     // When we don't use OptionValue::SetValueFromCString(const char *) to
 323                     // set an option value, it won't be marked as being set in the options
 324                     // so we make a call to let users know the value was set via option
 325                     alternate_name.SetCurrentValue (true);
 326                     dump_all_sets.SetOptionWasSet ();
 327                     break;
 328
 329                 default:
 330                     error.SetErrorStringWithFormat("unrecognized short option '%c'", short_option);
 331                     break;
 332             }
 333             return error;
 334         }
 335
 336         // Options table: Required for subclasses of Options.
 337
 338         static const OptionDefinition g_option_table[];
 339
 340         // Instance variables to hold the values for command options.
 341         OptionValueArray set_indexes;
 342         OptionValueBoolean dump_all_sets;
 343         OptionValueBoolean alternate_name;
 344     };
 345
 346     OptionGroupOptions m_option_group;
 347     OptionGroupFormat m_format_options;
 348     CommandOptions m_command_options;
 349 };
 350
 351 const OptionDefinition
 352 CommandObjectRegisterRead::CommandOptions::g_option_table[] =
 353 {
 354     { LLDB_OPT_SET_ALL, false, "alternate", 'A', no_argument      , NULL, 0, eArgTypeNone      , "Display register names using the alternate register name if there is one."},
 355     { LLDB_OPT_SET_1  , false, "set"      , 's', required_argument, NULL, 0, eArgTypeIndex     , "Specify which register sets to dump by index."},
 356     { LLDB_OPT_SET_2  , false, "all"      , 'a', no_argument      , NULL, 0, eArgTypeNone      , "Show all register sets."},
 357 };
 358
 359 uint32_t
 360 CommandObjectRegisterRead::CommandOptions::GetNumDefinitions ()
 361 {
 362     return sizeof(g_option_table)/sizeof(OptionDefinition);
 363 }
 364
 365
 366 //----------------------------------------------------------------------
 367 // "register write"
 368 //----------------------------------------------------------------------
 369 class CommandObjectRegisterWrite : public CommandObjectParsed
 370 {
 371 public:
 372     CommandObjectRegisterWrite (CommandInterpreter &interpreter) :
 373         CommandObjectParsed (interpreter,
 374                              "register write",
 375                              "Modify a single register value.",
 376                              NULL,
 377                              eFlagRequiresFrame         |
 378                              eFlagRequiresRegContext    |
 379                              eFlagProcessMustBeLaunched |
 380                              eFlagProcessMustBePaused)
 381     {
 382         CommandArgumentEntry arg1;
 383         CommandArgumentEntry arg2;
 384         CommandArgumentData register_arg;
 385         CommandArgumentData value_arg;
 386
 387         // Define the first (and only) variant of this arg.
 388         register_arg.arg_type = eArgTypeRegisterName;
 389         register_arg.arg_repetition = eArgRepeatPlain;
 390
 391         // There is only one variant this argument could be; put it into the argument entry.
 392         arg1.push_back (register_arg);
 393
 394         // Define the first (and only) variant of this arg.
 395         value_arg.arg_type = eArgTypeValue;
 396         value_arg.arg_repetition = eArgRepeatPlain;
 397
 398         // There is only one variant this argument could be; put it into the argument entry.
 399         arg2.push_back (value_arg);
 400
 401         // Push the data for the first argument into the m_arguments vector.
 402         m_arguments.push_back (arg1);
 403         m_arguments.push_back (arg2);
 404     }
 405
 406     virtual
 407     ~CommandObjectRegisterWrite ()
 408     {
 409     }
 410
 411 protected:
 412     virtual bool
 413     DoExecute(Args& command, CommandReturnObject &result)
 414     {
 415         DataExtractor reg_data;
 416         RegisterContext *reg_ctx = m_exe_ctx.GetRegisterContext ();
 417
 418         if (command.GetArgumentCount() != 2)
 419         {
 420             result.AppendError ("register write takes exactly 2 arguments: <reg-name> <value>");
 421             result.SetStatus (eReturnStatusFailed);
 422         }
 423         else
 424         {
 425             const char *reg_name = command.GetArgumentAtIndex(0);
 426             const char *value_str = command.GetArgumentAtIndex(1);
 427
 428
 429             // in most LLDB commands we accept $rbx as the name for register RBX - and here we would
 430             // reject it and non-existant. we should be more consistent towards the user and allow them
 431             // to say reg write $rbx - internally, however, we should be strict and not allow ourselves
 432             // to call our registers $rbx in our own API
 433             if (reg_name && *reg_name == '$')
 434                 reg_name = reg_name+1;
 435
 436             const RegisterInfo *reg_info = reg_ctx->GetRegisterInfoByName(reg_name);
 437
 438             if (reg_info)
 439             {
 440                 RegisterValue reg_value;
 441
 442                 Error error (reg_value.SetValueFromCString (reg_info, value_str));
 443                 if (error.Success())
 444                 {
 445                     if (reg_ctx->WriteRegister (reg_info, reg_value))
 446                     {
 447                         // Toss all frames and anything else in the thread
 448                         // after a register has been written.
 449                         m_exe_ctx.GetThreadRef().Flush();
 450                         result.SetStatus (eReturnStatusSuccessFinishNoResult);
 451                         return true;
 452                     }
 453                 }
 454                 if (error.AsCString())
 455                 {
 456                     result.AppendErrorWithFormat ("Failed to write register '%s' with value '%s': %s\n",
 457                                                  reg_name,
 458                                                  value_str,
 459                                                  error.AsCString());
 460                 }
 461                 else
 462                 {
 463                     result.AppendErrorWithFormat ("Failed to write register '%s' with value '%s'",
 464                                                  reg_name,
 465                                                  value_str);
 466                 }
 467                 result.SetStatus (eReturnStatusFailed);
 468             }
 469             else
 470             {
 471                 result.AppendErrorWithFormat ("Register not found for '%s'.\n", reg_name);
 472                 result.SetStatus (eReturnStatusFailed);
 473             }
 474         }
 475         return result.Succeeded();
 476     }
 477 };
 478
 479
 480 //----------------------------------------------------------------------
 481 // CommandObjectRegister constructor
 482 //----------------------------------------------------------------------
 483 CommandObjectRegister::CommandObjectRegister(CommandInterpreter &interpreter) :
 484     CommandObjectMultiword (interpreter,
 485                             "register",
 486                             "A set of commands to access thread registers.",
 487                             "register [read|write] ...")
 488 {
 489     LoadSubCommand ("read",  CommandObjectSP (new CommandObjectRegisterRead (interpreter)));
 490     LoadSubCommand ("write", CommandObjectSP (new CommandObjectRegisterWrite (interpreter)));
 491 }
 492
 493
 494 //----------------------------------------------------------------------
 495 // Destructor
 496 //----------------------------------------------------------------------
 497 CommandObjectRegister::~CommandObjectRegister()
 498 {
 499 }