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

   1 //===-- CommandObjectLog.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 "CommandObjectLog.h"
  13
  14 // C Includes
  15 // C++ Includes
  16 // Other libraries and framework includes
  17 // Project includes
  18 #include "lldb/lldb-private-log.h"
  19
  20 #include "lldb/Interpreter/Args.h"
  21 #include "lldb/Core/Debugger.h"
  22 #include "lldb/Host/FileSpec.h"
  23 #include "lldb/Core/Log.h"
  24 #include "lldb/Core/Module.h"
  25 #include "lldb/Interpreter/Options.h"
  26 #include "lldb/Core/RegularExpression.h"
  27 #include "lldb/Core/Stream.h"
  28 #include "lldb/Core/StreamFile.h"
  29 #include "lldb/Core/Timer.h"
  30
  31 #include "lldb/Core/Debugger.h"
  32 #include "lldb/Interpreter/CommandInterpreter.h"
  33 #include "lldb/Interpreter/CommandReturnObject.h"
  34
  35 #include "lldb/Symbol/LineTable.h"
  36 #include "lldb/Symbol/ObjectFile.h"
  37 #include "lldb/Symbol/SymbolFile.h"
  38 #include "lldb/Symbol/SymbolVendor.h"
  39
  40 #include "lldb/Target/Process.h"
  41 #include "lldb/Target/Target.h"
  42
  43 using namespace lldb;
  44 using namespace lldb_private;
  45
  46
  47 class CommandObjectLogEnable : public CommandObjectParsed
  48 {
  49 public:
  50     //------------------------------------------------------------------
  51     // Constructors and Destructors
  52     //------------------------------------------------------------------
  53     CommandObjectLogEnable(CommandInterpreter &interpreter) :
  54         CommandObjectParsed (interpreter,
  55                              "log enable",
  56                              "Enable logging for a single log channel.",
  57                              NULL),
  58         m_options (interpreter)
  59     {
  60
  61         CommandArgumentEntry arg1;
  62         CommandArgumentEntry arg2;
  63         CommandArgumentData channel_arg;
  64         CommandArgumentData category_arg;
  65
  66         // Define the first (and only) variant of this arg.
  67         channel_arg.arg_type = eArgTypeLogChannel;
  68         channel_arg.arg_repetition = eArgRepeatPlain;
  69
  70         // There is only one variant this argument could be; put it into the argument entry.
  71         arg1.push_back (channel_arg);
  72
  73         category_arg.arg_type = eArgTypeLogCategory;
  74         category_arg.arg_repetition = eArgRepeatPlus;
  75
  76         arg2.push_back (category_arg);
  77
  78         // Push the data for the first argument into the m_arguments vector.
  79         m_arguments.push_back (arg1);
  80         m_arguments.push_back (arg2);
  81     }
  82
  83     virtual
  84     ~CommandObjectLogEnable()
  85     {
  86     }
  87
  88     Options *
  89     GetOptions ()
  90     {
  91         return &m_options;
  92     }
  93
  94 //    int
  95 //    HandleArgumentCompletion (Args &input,
  96 //                              int &cursor_index,
  97 //                              int &cursor_char_position,
  98 //                              OptionElementVector &opt_element_vector,
  99 //                              int match_start_point,
 100 //                              int max_return_elements,
 101 //                              bool &word_complete,
 102 //                              StringList &matches)
 103 //    {
 104 //        std::string completion_str (input.GetArgumentAtIndex(cursor_index));
 105 //        completion_str.erase (cursor_char_position);
 106 //
 107 //        if (cursor_index == 1)
 108 //        {
 109 //            //
 110 //            Log::AutoCompleteChannelName (completion_str.c_str(), matches);
 111 //        }
 112 //        return matches.GetSize();
 113 //    }
 114 //
 115
 116     class CommandOptions : public Options
 117     {
 118     public:
 119
 120         CommandOptions (CommandInterpreter &interpreter) :
 121             Options (interpreter),
 122             log_file (),
 123             log_options (0)
 124         {
 125         }
 126
 127
 128         virtual
 129         ~CommandOptions ()
 130         {
 131         }
 132
 133         virtual Error
 134         SetOptionValue (uint32_t option_idx, const char *option_arg)
 135         {
 136             Error error;
 137             const int short_option = m_getopt_table[option_idx].val;
 138
 139             switch (short_option)
 140             {
 141             case 'f':  log_file.SetFile(option_arg, true);                    break;
 142             case 't':  log_options |= LLDB_LOG_OPTION_THREADSAFE;             break;
 143             case 'v':  log_options |= LLDB_LOG_OPTION_VERBOSE;                break;
 144             case 'g':  log_options |= LLDB_LOG_OPTION_DEBUG;                  break;
 145             case 's':  log_options |= LLDB_LOG_OPTION_PREPEND_SEQUENCE;       break;
 146             case 'T':  log_options |= LLDB_LOG_OPTION_PREPEND_TIMESTAMP;      break;
 147             case 'p':  log_options |= LLDB_LOG_OPTION_PREPEND_PROC_AND_THREAD;break;
 148             case 'n':  log_options |= LLDB_LOG_OPTION_PREPEND_THREAD_NAME;    break;
 149             case 'S':  log_options |= LLDB_LOG_OPTION_BACKTRACE;              break;
 150             default:
 151                 error.SetErrorStringWithFormat ("unrecognized option '%c'", short_option);
 152                 break;
 153             }
 154
 155             return error;
 156         }
 157
 158         void
 159         OptionParsingStarting ()
 160         {
 161             log_file.Clear();
 162             log_options = 0;
 163         }
 164
 165         const OptionDefinition*
 166         GetDefinitions ()
 167         {
 168             return g_option_table;
 169         }
 170
 171         // Options table: Required for subclasses of Options.
 172
 173         static OptionDefinition g_option_table[];
 174
 175         // Instance variables to hold the values for command options.
 176
 177         FileSpec log_file;
 178         uint32_t log_options;
 179     };
 180
 181 protected:
 182     virtual bool
 183     DoExecute (Args& args,
 184              CommandReturnObject &result)
 185     {
 186         if (args.GetArgumentCount() < 2)
 187         {
 188             result.AppendErrorWithFormat("%s takes a log channel and one or more log types.\n", m_cmd_name.c_str());
 189         }
 190         else
 191         {
 192             std::string channel(args.GetArgumentAtIndex(0));
 193             args.Shift ();  // Shift off the channel
 194             char log_file[PATH_MAX];
 195             if (m_options.log_file)
 196                 m_options.log_file.GetPath(log_file, sizeof(log_file));
 197             else
 198                 log_file[0] = '\0';
 199             bool success = m_interpreter.GetDebugger().EnableLog (channel.c_str(),
 200                                                                   args.GetConstArgumentVector(),
 201                                                                   log_file,
 202                                                                   m_options.log_options,
 203                                                                   result.GetErrorStream());
 204             if (success)
 205                 result.SetStatus (eReturnStatusSuccessFinishNoResult);
 206             else
 207                 result.SetStatus (eReturnStatusFailed);
 208         }
 209         return result.Succeeded();
 210     }
 211
 212     CommandOptions m_options;
 213 };
 214
 215 OptionDefinition
 216 CommandObjectLogEnable::CommandOptions::g_option_table[] =
 217 {
 218 { LLDB_OPT_SET_1, false, "file",       'f', OptionParser::eRequiredArgument, NULL, 0, eArgTypeFilename,   "Set the destination file to log to."},
 219 { LLDB_OPT_SET_1, false, "threadsafe", 't', OptionParser::eNoArgument,       NULL, 0, eArgTypeNone,        "Enable thread safe logging to avoid interweaved log lines." },
 220 { LLDB_OPT_SET_1, false, "verbose",    'v', OptionParser::eNoArgument,       NULL, 0, eArgTypeNone,       "Enable verbose logging." },
 221 { LLDB_OPT_SET_1, false, "debug",      'g', OptionParser::eNoArgument,       NULL, 0, eArgTypeNone,       "Enable debug logging." },
 222 { LLDB_OPT_SET_1, false, "sequence",   's', OptionParser::eNoArgument,       NULL, 0, eArgTypeNone,       "Prepend all log lines with an increasing integer sequence id." },
 223 { LLDB_OPT_SET_1, false, "timestamp",  'T', OptionParser::eNoArgument,       NULL, 0, eArgTypeNone,       "Prepend all log lines with a timestamp." },
 224 { LLDB_OPT_SET_1, false, "pid-tid",    'p', OptionParser::eNoArgument,       NULL, 0, eArgTypeNone,       "Prepend all log lines with the process and thread ID that generates the log line." },
 225 { LLDB_OPT_SET_1, false, "thread-name",'n', OptionParser::eNoArgument,       NULL, 0, eArgTypeNone,       "Prepend all log lines with the thread name for the thread that generates the log line." },
 226 { LLDB_OPT_SET_1, false, "stack",      'S', OptionParser::eNoArgument,       NULL, 0, eArgTypeNone,       "Append a stack backtrace to each log line." },
 227 { 0, false, NULL,                       0,  0,                 NULL, 0, eArgTypeNone,       NULL }
 228 };
 229
 230 class CommandObjectLogDisable : public CommandObjectParsed
 231 {
 232 public:
 233     //------------------------------------------------------------------
 234     // Constructors and Destructors
 235     //------------------------------------------------------------------
 236     CommandObjectLogDisable(CommandInterpreter &interpreter) :
 237         CommandObjectParsed (interpreter,
 238                              "log disable",
 239                              "Disable one or more log channel categories.",
 240                              NULL)
 241     {
 242         CommandArgumentEntry arg1;
 243         CommandArgumentEntry arg2;
 244         CommandArgumentData channel_arg;
 245         CommandArgumentData category_arg;
 246
 247         // Define the first (and only) variant of this arg.
 248         channel_arg.arg_type = eArgTypeLogChannel;
 249         channel_arg.arg_repetition = eArgRepeatPlain;
 250
 251         // There is only one variant this argument could be; put it into the argument entry.
 252         arg1.push_back (channel_arg);
 253
 254         category_arg.arg_type = eArgTypeLogCategory;
 255         category_arg.arg_repetition = eArgRepeatPlus;
 256
 257         arg2.push_back (category_arg);
 258
 259         // Push the data for the first argument into the m_arguments vector.
 260         m_arguments.push_back (arg1);
 261         m_arguments.push_back (arg2);
 262     }
 263
 264     virtual
 265     ~CommandObjectLogDisable()
 266     {
 267     }
 268
 269 protected:
 270     virtual bool
 271     DoExecute (Args& args,
 272              CommandReturnObject &result)
 273     {
 274         const size_t argc = args.GetArgumentCount();
 275         if (argc == 0)
 276         {
 277             result.AppendErrorWithFormat("%s takes a log channel and one or more log types.\n", m_cmd_name.c_str());
 278         }
 279         else
 280         {
 281             Log::Callbacks log_callbacks;
 282
 283             std::string channel(args.GetArgumentAtIndex(0));
 284             args.Shift ();  // Shift off the channel
 285             if (Log::GetLogChannelCallbacks (ConstString(channel.c_str()), log_callbacks))
 286             {
 287                 log_callbacks.disable (args.GetConstArgumentVector(), &result.GetErrorStream());
 288                 result.SetStatus(eReturnStatusSuccessFinishNoResult);
 289             }
 290             else if (channel == "all")
 291             {
 292                 Log::DisableAllLogChannels(&result.GetErrorStream());
 293             }
 294             else
 295             {
 296                 LogChannelSP log_channel_sp (LogChannel::FindPlugin(channel.c_str()));
 297                 if (log_channel_sp)
 298                 {
 299                     log_channel_sp->Disable(args.GetConstArgumentVector(), &result.GetErrorStream());
 300                     result.SetStatus(eReturnStatusSuccessFinishNoResult);
 301                 }
 302                 else
 303                     result.AppendErrorWithFormat("Invalid log channel '%s'.\n", args.GetArgumentAtIndex(0));
 304             }
 305         }
 306         return result.Succeeded();
 307     }
 308 };
 309
 310 class CommandObjectLogList : public CommandObjectParsed
 311 {
 312 public:
 313     //------------------------------------------------------------------
 314     // Constructors and Destructors
 315     //------------------------------------------------------------------
 316     CommandObjectLogList(CommandInterpreter &interpreter) :
 317         CommandObjectParsed (interpreter,
 318                              "log list",
 319                              "List the log categories for one or more log channels.  If none specified, lists them all.",
 320                              NULL)
 321     {
 322         CommandArgumentEntry arg;
 323         CommandArgumentData channel_arg;
 324
 325         // Define the first (and only) variant of this arg.
 326         channel_arg.arg_type = eArgTypeLogChannel;
 327         channel_arg.arg_repetition = eArgRepeatStar;
 328
 329         // There is only one variant this argument could be; put it into the argument entry.
 330         arg.push_back (channel_arg);
 331
 332         // Push the data for the first argument into the m_arguments vector.
 333         m_arguments.push_back (arg);
 334     }
 335
 336     virtual
 337     ~CommandObjectLogList()
 338     {
 339     }
 340
 341 protected:
 342     virtual bool
 343     DoExecute (Args& args,
 344              CommandReturnObject &result)
 345     {
 346         const size_t argc = args.GetArgumentCount();
 347         if (argc == 0)
 348         {
 349             Log::ListAllLogChannels (&result.GetOutputStream());
 350             result.SetStatus(eReturnStatusSuccessFinishResult);
 351         }
 352         else
 353         {
 354             for (size_t i=0; i<argc; ++i)
 355             {
 356                 Log::Callbacks log_callbacks;
 357
 358                 std::string channel(args.GetArgumentAtIndex(i));
 359                 if (Log::GetLogChannelCallbacks (ConstString(channel.c_str()), log_callbacks))
 360                 {
 361                     log_callbacks.list_categories (&result.GetOutputStream());
 362                     result.SetStatus(eReturnStatusSuccessFinishResult);
 363                 }
 364                 else if (channel == "all")
 365                 {
 366                     Log::ListAllLogChannels (&result.GetOutputStream());
 367                     result.SetStatus(eReturnStatusSuccessFinishResult);
 368                 }
 369                 else
 370                 {
 371                     LogChannelSP log_channel_sp (LogChannel::FindPlugin(channel.c_str()));
 372                     if (log_channel_sp)
 373                     {
 374                         log_channel_sp->ListCategories(&result.GetOutputStream());
 375                         result.SetStatus(eReturnStatusSuccessFinishNoResult);
 376                     }
 377                     else
 378                         result.AppendErrorWithFormat("Invalid log channel '%s'.\n", args.GetArgumentAtIndex(0));
 379                 }
 380             }
 381         }
 382         return result.Succeeded();
 383     }
 384 };
 385
 386 class CommandObjectLogTimer : public CommandObjectParsed
 387 {
 388 public:
 389     //------------------------------------------------------------------
 390     // Constructors and Destructors
 391     //------------------------------------------------------------------
 392     CommandObjectLogTimer(CommandInterpreter &interpreter) :
 393         CommandObjectParsed (interpreter,
 394                            "log timers",
 395                            "Enable, disable, dump, and reset LLDB internal performance timers.",
 396                            "log timers < enable <depth> | disable | dump | increment <bool> | reset >")
 397     {
 398     }
 399
 400     virtual
 401     ~CommandObjectLogTimer()
 402     {
 403     }
 404
 405 protected:
 406     virtual bool
 407     DoExecute (Args& args,
 408              CommandReturnObject &result)
 409     {
 410         const size_t argc = args.GetArgumentCount();
 411         result.SetStatus(eReturnStatusFailed);
 412
 413         if (argc == 1)
 414         {
 415             const char *sub_command = args.GetArgumentAtIndex(0);
 416
 417             if (strcasecmp(sub_command, "enable") == 0)
 418             {
 419                 Timer::SetDisplayDepth (UINT32_MAX);
 420                 result.SetStatus(eReturnStatusSuccessFinishNoResult);
 421             }
 422             else if (strcasecmp(sub_command, "disable") == 0)
 423             {
 424                 Timer::DumpCategoryTimes (&result.GetOutputStream());
 425                 Timer::SetDisplayDepth (0);
 426                 result.SetStatus(eReturnStatusSuccessFinishResult);
 427             }
 428             else if (strcasecmp(sub_command, "dump") == 0)
 429             {
 430                 Timer::DumpCategoryTimes (&result.GetOutputStream());
 431                 result.SetStatus(eReturnStatusSuccessFinishResult);
 432             }
 433             else if (strcasecmp(sub_command, "reset") == 0)
 434             {
 435                 Timer::ResetCategoryTimes ();
 436                 result.SetStatus(eReturnStatusSuccessFinishResult);
 437             }
 438
 439         }
 440         else if (argc == 2)
 441         {
 442             const char *sub_command = args.GetArgumentAtIndex(0);
 443
 444             if (strcasecmp(sub_command, "enable") == 0)
 445             {
 446                 bool success;
 447                 uint32_t depth = Args::StringToUInt32(args.GetArgumentAtIndex(1), 0, 0, &success);
 448                 if (success)
 449                 {
 450                     Timer::SetDisplayDepth (depth);
 451                     result.SetStatus(eReturnStatusSuccessFinishNoResult);
 452                 }
 453                 else
 454                     result.AppendError("Could not convert enable depth to an unsigned integer.");
 455             }
 456             if (strcasecmp(sub_command, "increment") == 0)
 457             {
 458                 bool success;
 459                 bool increment = Args::StringToBoolean(args.GetArgumentAtIndex(1), false, &success);
 460                 if (success)
 461                 {
 462                     Timer::SetQuiet (!increment);
 463                     result.SetStatus(eReturnStatusSuccessFinishNoResult);
 464                 }
 465                 else
 466                     result.AppendError("Could not convert increment value to boolean.");
 467             }
 468         }
 469
 470         if (!result.Succeeded())
 471         {
 472             result.AppendError("Missing subcommand");
 473             result.AppendErrorWithFormat("Usage: %s\n", m_cmd_syntax.c_str());
 474         }
 475         return result.Succeeded();
 476     }
 477 };
 478
 479 //----------------------------------------------------------------------
 480 // CommandObjectLog constructor
 481 //----------------------------------------------------------------------
 482 CommandObjectLog::CommandObjectLog(CommandInterpreter &interpreter) :
 483     CommandObjectMultiword (interpreter,
 484                             "log",
 485                             "A set of commands for operating on logs.",
 486                             "log <command> [<command-options>]")
 487 {
 488     LoadSubCommand ("enable",  CommandObjectSP (new CommandObjectLogEnable (interpreter)));
 489     LoadSubCommand ("disable", CommandObjectSP (new CommandObjectLogDisable (interpreter)));
 490     LoadSubCommand ("list",    CommandObjectSP (new CommandObjectLogList (interpreter)));
 491     LoadSubCommand ("timers",  CommandObjectSP (new CommandObjectLogTimer (interpreter)));
 492 }
 493
 494 //----------------------------------------------------------------------
 495 // Destructor
 496 //----------------------------------------------------------------------
 497 CommandObjectLog::~CommandObjectLog()
 498 {
 499 }
 500
 501
 502
 503