1 //===-- CommandObjectWatchpoint.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 "CommandObjectWatchpoint.h"
11 #include "CommandObjectWatchpointCommand.h"
12 
13 #include <vector>
14 
15 #include "llvm/ADT/StringRef.h"
16 
17 #include "lldb/Breakpoint/Watchpoint.h"
18 #include "lldb/Breakpoint/WatchpointList.h"
19 #include "lldb/Core/ValueObject.h"
20 #include "lldb/Core/ValueObjectVariable.h"
21 #include "lldb/Host/OptionParser.h"
22 #include "lldb/Interpreter/CommandCompletions.h"
23 #include "lldb/Interpreter/CommandInterpreter.h"
24 #include "lldb/Interpreter/CommandReturnObject.h"
25 #include "lldb/Symbol/Variable.h"
26 #include "lldb/Symbol/VariableList.h"
27 #include "lldb/Target/StackFrame.h"
28 #include "lldb/Target/Target.h"
29 #include "lldb/Utility/StreamString.h"
30 
31 using namespace lldb;
32 using namespace lldb_private;
33 
34 static void AddWatchpointDescription(Stream *s, Watchpoint *wp,
35                                      lldb::DescriptionLevel level) {
36   s->IndentMore();
37   wp->GetDescription(s, level);
38   s->IndentLess();
39   s->EOL();
40 }
41 
42 static bool CheckTargetForWatchpointOperations(Target *target,
43                                                CommandReturnObject &result) {
44   if (target == nullptr) {
45     result.AppendError("Invalid target.  No existing target or watchpoints.");
46     result.SetStatus(eReturnStatusFailed);
47     return false;
48   }
49   bool process_is_valid =
50       target->GetProcessSP() && target->GetProcessSP()->IsAlive();
51   if (!process_is_valid) {
52     result.AppendError("Thre's no process or it is not alive.");
53     result.SetStatus(eReturnStatusFailed);
54     return false;
55   }
56   // Target passes our checks, return true.
57   return true;
58 }
59 
60 // Equivalent class: {"-", "to", "To", "TO"} of range specifier array.
61 static const char *RSA[4] = {"-", "to", "To", "TO"};
62 
63 // Return the index to RSA if found; otherwise -1 is returned.
64 static int32_t WithRSAIndex(llvm::StringRef Arg) {
65 
66   uint32_t i;
67   for (i = 0; i < 4; ++i)
68     if (Arg.find(RSA[i]) != llvm::StringRef::npos)
69       return i;
70   return -1;
71 }
72 
73 // Return true if wp_ids is successfully populated with the watch ids. False
74 // otherwise.
75 bool CommandObjectMultiwordWatchpoint::VerifyWatchpointIDs(
76     Target *target, Args &args, std::vector<uint32_t> &wp_ids) {
77   // Pre-condition: args.GetArgumentCount() > 0.
78   if (args.GetArgumentCount() == 0) {
79     if (target == nullptr)
80       return false;
81     WatchpointSP watch_sp = target->GetLastCreatedWatchpoint();
82     if (watch_sp) {
83       wp_ids.push_back(watch_sp->GetID());
84       return true;
85     } else
86       return false;
87   }
88 
89   llvm::StringRef Minus("-");
90   std::vector<llvm::StringRef> StrRefArgs;
91   llvm::StringRef first;
92   llvm::StringRef second;
93   size_t i;
94   int32_t idx;
95   // Go through the arguments and make a canonical form of arg list containing
96   // only numbers with possible "-" in between.
97   for (auto &entry : args.entries()) {
98     if ((idx = WithRSAIndex(entry.ref)) == -1) {
99       StrRefArgs.push_back(entry.ref);
100       continue;
101     }
102     // The Arg contains the range specifier, split it, then.
103     std::tie(first, second) = entry.ref.split(RSA[idx]);
104     if (!first.empty())
105       StrRefArgs.push_back(first);
106     StrRefArgs.push_back(Minus);
107     if (!second.empty())
108       StrRefArgs.push_back(second);
109   }
110   // Now process the canonical list and fill in the vector of uint32_t's. If
111   // there is any error, return false and the client should ignore wp_ids.
112   uint32_t beg, end, id;
113   size_t size = StrRefArgs.size();
114   bool in_range = false;
115   for (i = 0; i < size; ++i) {
116     llvm::StringRef Arg = StrRefArgs[i];
117     if (in_range) {
118       // Look for the 'end' of the range.  Note StringRef::getAsInteger()
119       // returns true to signify error while parsing.
120       if (Arg.getAsInteger(0, end))
121         return false;
122       // Found a range!  Now append the elements.
123       for (id = beg; id <= end; ++id)
124         wp_ids.push_back(id);
125       in_range = false;
126       continue;
127     }
128     if (i < (size - 1) && StrRefArgs[i + 1] == Minus) {
129       if (Arg.getAsInteger(0, beg))
130         return false;
131       // Turn on the in_range flag, we are looking for end of range next.
132       ++i;
133       in_range = true;
134       continue;
135     }
136     // Otherwise, we have a simple ID.  Just append it.
137     if (Arg.getAsInteger(0, beg))
138       return false;
139     wp_ids.push_back(beg);
140   }
141 
142   // It is an error if after the loop, we're still in_range.
143   return !in_range;
144 }
145 
146 //-------------------------------------------------------------------------
147 // CommandObjectWatchpointList
148 //-------------------------------------------------------------------------
149 
150 //-------------------------------------------------------------------------
151 // CommandObjectWatchpointList::Options
152 //-------------------------------------------------------------------------
153 #pragma mark List::CommandOptions
154 
155 static constexpr OptionDefinition g_watchpoint_list_options[] = {
156     // clang-format off
157   { LLDB_OPT_SET_1, false, "brief",   'b', OptionParser::eNoArgument, nullptr, {}, 0, eArgTypeNone, "Give a brief description of the watchpoint (no location info)." },
158   { LLDB_OPT_SET_2, false, "full",    'f', OptionParser::eNoArgument, nullptr, {}, 0, eArgTypeNone, "Give a full description of the watchpoint and its locations." },
159   { LLDB_OPT_SET_3, false, "verbose", 'v', OptionParser::eNoArgument, nullptr, {}, 0, eArgTypeNone, "Explain everything we know about the watchpoint (for debugging debugger bugs)." }
160     // clang-format on
161 };
162 
163 #pragma mark List
164 
165 class CommandObjectWatchpointList : public CommandObjectParsed {
166 public:
167   CommandObjectWatchpointList(CommandInterpreter &interpreter)
168       : CommandObjectParsed(
169             interpreter, "watchpoint list",
170             "List all watchpoints at configurable levels of detail.", nullptr),
171         m_options() {
172     CommandArgumentEntry arg;
173     CommandObject::AddIDsArgumentData(arg, eArgTypeWatchpointID,
174                                       eArgTypeWatchpointIDRange);
175     // Add the entry for the first argument for this command to the object's
176     // arguments vector.
177     m_arguments.push_back(arg);
178   }
179 
180   ~CommandObjectWatchpointList() override = default;
181 
182   Options *GetOptions() override { return &m_options; }
183 
184   class CommandOptions : public Options {
185   public:
186     CommandOptions()
187         : Options(),
188           m_level(lldb::eDescriptionLevelBrief) // Watchpoint List defaults to
189                                                 // brief descriptions
190     {}
191 
192     ~CommandOptions() override = default;
193 
194     Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg,
195                           ExecutionContext *execution_context) override {
196       Status error;
197       const int short_option = m_getopt_table[option_idx].val;
198 
199       switch (short_option) {
200       case 'b':
201         m_level = lldb::eDescriptionLevelBrief;
202         break;
203       case 'f':
204         m_level = lldb::eDescriptionLevelFull;
205         break;
206       case 'v':
207         m_level = lldb::eDescriptionLevelVerbose;
208         break;
209       default:
210         error.SetErrorStringWithFormat("unrecognized option '%c'",
211                                        short_option);
212         break;
213       }
214 
215       return error;
216     }
217 
218     void OptionParsingStarting(ExecutionContext *execution_context) override {
219       m_level = lldb::eDescriptionLevelFull;
220     }
221 
222     llvm::ArrayRef<OptionDefinition> GetDefinitions() override {
223       return llvm::makeArrayRef(g_watchpoint_list_options);
224     }
225 
226     // Instance variables to hold the values for command options.
227 
228     lldb::DescriptionLevel m_level;
229   };
230 
231 protected:
232   bool DoExecute(Args &command, CommandReturnObject &result) override {
233     Target *target = m_interpreter.GetDebugger().GetSelectedTarget().get();
234     if (target == nullptr) {
235       result.AppendError("Invalid target. No current target or watchpoints.");
236       result.SetStatus(eReturnStatusSuccessFinishNoResult);
237       return true;
238     }
239 
240     if (target->GetProcessSP() && target->GetProcessSP()->IsAlive()) {
241       uint32_t num_supported_hardware_watchpoints;
242       Status error = target->GetProcessSP()->GetWatchpointSupportInfo(
243           num_supported_hardware_watchpoints);
244       if (error.Success())
245         result.AppendMessageWithFormat(
246             "Number of supported hardware watchpoints: %u\n",
247             num_supported_hardware_watchpoints);
248     }
249 
250     const WatchpointList &watchpoints = target->GetWatchpointList();
251 
252     std::unique_lock<std::recursive_mutex> lock;
253     target->GetWatchpointList().GetListMutex(lock);
254 
255     size_t num_watchpoints = watchpoints.GetSize();
256 
257     if (num_watchpoints == 0) {
258       result.AppendMessage("No watchpoints currently set.");
259       result.SetStatus(eReturnStatusSuccessFinishNoResult);
260       return true;
261     }
262 
263     Stream &output_stream = result.GetOutputStream();
264 
265     if (command.GetArgumentCount() == 0) {
266       // No watchpoint selected; show info about all currently set watchpoints.
267       result.AppendMessage("Current watchpoints:");
268       for (size_t i = 0; i < num_watchpoints; ++i) {
269         Watchpoint *wp = watchpoints.GetByIndex(i).get();
270         AddWatchpointDescription(&output_stream, wp, m_options.m_level);
271       }
272       result.SetStatus(eReturnStatusSuccessFinishNoResult);
273     } else {
274       // Particular watchpoints selected; enable them.
275       std::vector<uint32_t> wp_ids;
276       if (!CommandObjectMultiwordWatchpoint::VerifyWatchpointIDs(
277               target, command, wp_ids)) {
278         result.AppendError("Invalid watchpoints specification.");
279         result.SetStatus(eReturnStatusFailed);
280         return false;
281       }
282 
283       const size_t size = wp_ids.size();
284       for (size_t i = 0; i < size; ++i) {
285         Watchpoint *wp = watchpoints.FindByID(wp_ids[i]).get();
286         if (wp)
287           AddWatchpointDescription(&output_stream, wp, m_options.m_level);
288         result.SetStatus(eReturnStatusSuccessFinishNoResult);
289       }
290     }
291 
292     return result.Succeeded();
293   }
294 
295 private:
296   CommandOptions m_options;
297 };
298 
299 //-------------------------------------------------------------------------
300 // CommandObjectWatchpointEnable
301 //-------------------------------------------------------------------------
302 #pragma mark Enable
303 
304 class CommandObjectWatchpointEnable : public CommandObjectParsed {
305 public:
306   CommandObjectWatchpointEnable(CommandInterpreter &interpreter)
307       : CommandObjectParsed(interpreter, "enable",
308                             "Enable the specified disabled watchpoint(s). If "
309                             "no watchpoints are specified, enable all of them.",
310                             nullptr) {
311     CommandArgumentEntry arg;
312     CommandObject::AddIDsArgumentData(arg, eArgTypeWatchpointID,
313                                       eArgTypeWatchpointIDRange);
314     // Add the entry for the first argument for this command to the object's
315     // arguments vector.
316     m_arguments.push_back(arg);
317   }
318 
319   ~CommandObjectWatchpointEnable() override = default;
320 
321 protected:
322   bool DoExecute(Args &command, CommandReturnObject &result) override {
323     Target *target = m_interpreter.GetDebugger().GetSelectedTarget().get();
324     if (!CheckTargetForWatchpointOperations(target, result))
325       return false;
326 
327     std::unique_lock<std::recursive_mutex> lock;
328     target->GetWatchpointList().GetListMutex(lock);
329 
330     const WatchpointList &watchpoints = target->GetWatchpointList();
331 
332     size_t num_watchpoints = watchpoints.GetSize();
333 
334     if (num_watchpoints == 0) {
335       result.AppendError("No watchpoints exist to be enabled.");
336       result.SetStatus(eReturnStatusFailed);
337       return false;
338     }
339 
340     if (command.GetArgumentCount() == 0) {
341       // No watchpoint selected; enable all currently set watchpoints.
342       target->EnableAllWatchpoints();
343       result.AppendMessageWithFormat("All watchpoints enabled. (%" PRIu64
344                                      " watchpoints)\n",
345                                      (uint64_t)num_watchpoints);
346       result.SetStatus(eReturnStatusSuccessFinishNoResult);
347     } else {
348       // Particular watchpoints selected; enable them.
349       std::vector<uint32_t> wp_ids;
350       if (!CommandObjectMultiwordWatchpoint::VerifyWatchpointIDs(
351               target, command, wp_ids)) {
352         result.AppendError("Invalid watchpoints specification.");
353         result.SetStatus(eReturnStatusFailed);
354         return false;
355       }
356 
357       int count = 0;
358       const size_t size = wp_ids.size();
359       for (size_t i = 0; i < size; ++i)
360         if (target->EnableWatchpointByID(wp_ids[i]))
361           ++count;
362       result.AppendMessageWithFormat("%d watchpoints enabled.\n", count);
363       result.SetStatus(eReturnStatusSuccessFinishNoResult);
364     }
365 
366     return result.Succeeded();
367   }
368 };
369 
370 //-------------------------------------------------------------------------
371 // CommandObjectWatchpointDisable
372 //-------------------------------------------------------------------------
373 #pragma mark Disable
374 
375 class CommandObjectWatchpointDisable : public CommandObjectParsed {
376 public:
377   CommandObjectWatchpointDisable(CommandInterpreter &interpreter)
378       : CommandObjectParsed(interpreter, "watchpoint disable",
379                             "Disable the specified watchpoint(s) without "
380                             "removing it/them.  If no watchpoints are "
381                             "specified, disable them all.",
382                             nullptr) {
383     CommandArgumentEntry arg;
384     CommandObject::AddIDsArgumentData(arg, eArgTypeWatchpointID,
385                                       eArgTypeWatchpointIDRange);
386     // Add the entry for the first argument for this command to the object's
387     // arguments vector.
388     m_arguments.push_back(arg);
389   }
390 
391   ~CommandObjectWatchpointDisable() override = default;
392 
393 protected:
394   bool DoExecute(Args &command, CommandReturnObject &result) override {
395     Target *target = m_interpreter.GetDebugger().GetSelectedTarget().get();
396     if (!CheckTargetForWatchpointOperations(target, result))
397       return false;
398 
399     std::unique_lock<std::recursive_mutex> lock;
400     target->GetWatchpointList().GetListMutex(lock);
401 
402     const WatchpointList &watchpoints = target->GetWatchpointList();
403     size_t num_watchpoints = watchpoints.GetSize();
404 
405     if (num_watchpoints == 0) {
406       result.AppendError("No watchpoints exist to be disabled.");
407       result.SetStatus(eReturnStatusFailed);
408       return false;
409     }
410 
411     if (command.GetArgumentCount() == 0) {
412       // No watchpoint selected; disable all currently set watchpoints.
413       if (target->DisableAllWatchpoints()) {
414         result.AppendMessageWithFormat("All watchpoints disabled. (%" PRIu64
415                                        " watchpoints)\n",
416                                        (uint64_t)num_watchpoints);
417         result.SetStatus(eReturnStatusSuccessFinishNoResult);
418       } else {
419         result.AppendError("Disable all watchpoints failed\n");
420         result.SetStatus(eReturnStatusFailed);
421       }
422     } else {
423       // Particular watchpoints selected; disable them.
424       std::vector<uint32_t> wp_ids;
425       if (!CommandObjectMultiwordWatchpoint::VerifyWatchpointIDs(
426               target, command, wp_ids)) {
427         result.AppendError("Invalid watchpoints specification.");
428         result.SetStatus(eReturnStatusFailed);
429         return false;
430       }
431 
432       int count = 0;
433       const size_t size = wp_ids.size();
434       for (size_t i = 0; i < size; ++i)
435         if (target->DisableWatchpointByID(wp_ids[i]))
436           ++count;
437       result.AppendMessageWithFormat("%d watchpoints disabled.\n", count);
438       result.SetStatus(eReturnStatusSuccessFinishNoResult);
439     }
440 
441     return result.Succeeded();
442   }
443 };
444 
445 //-------------------------------------------------------------------------
446 // CommandObjectWatchpointDelete
447 //-------------------------------------------------------------------------
448 #pragma mark Delete
449 
450 class CommandObjectWatchpointDelete : public CommandObjectParsed {
451 public:
452   CommandObjectWatchpointDelete(CommandInterpreter &interpreter)
453       : CommandObjectParsed(interpreter, "watchpoint delete",
454                             "Delete the specified watchpoint(s).  If no "
455                             "watchpoints are specified, delete them all.",
456                             nullptr) {
457     CommandArgumentEntry arg;
458     CommandObject::AddIDsArgumentData(arg, eArgTypeWatchpointID,
459                                       eArgTypeWatchpointIDRange);
460     // Add the entry for the first argument for this command to the object's
461     // arguments vector.
462     m_arguments.push_back(arg);
463   }
464 
465   ~CommandObjectWatchpointDelete() override = default;
466 
467 protected:
468   bool DoExecute(Args &command, CommandReturnObject &result) override {
469     Target *target = m_interpreter.GetDebugger().GetSelectedTarget().get();
470     if (!CheckTargetForWatchpointOperations(target, result))
471       return false;
472 
473     std::unique_lock<std::recursive_mutex> lock;
474     target->GetWatchpointList().GetListMutex(lock);
475 
476     const WatchpointList &watchpoints = target->GetWatchpointList();
477 
478     size_t num_watchpoints = watchpoints.GetSize();
479 
480     if (num_watchpoints == 0) {
481       result.AppendError("No watchpoints exist to be deleted.");
482       result.SetStatus(eReturnStatusFailed);
483       return false;
484     }
485 
486     if (command.GetArgumentCount() == 0) {
487       if (!m_interpreter.Confirm(
488               "About to delete all watchpoints, do you want to do that?",
489               true)) {
490         result.AppendMessage("Operation cancelled...");
491       } else {
492         target->RemoveAllWatchpoints();
493         result.AppendMessageWithFormat("All watchpoints removed. (%" PRIu64
494                                        " watchpoints)\n",
495                                        (uint64_t)num_watchpoints);
496       }
497       result.SetStatus(eReturnStatusSuccessFinishNoResult);
498     } else {
499       // Particular watchpoints selected; delete them.
500       std::vector<uint32_t> wp_ids;
501       if (!CommandObjectMultiwordWatchpoint::VerifyWatchpointIDs(
502               target, command, wp_ids)) {
503         result.AppendError("Invalid watchpoints specification.");
504         result.SetStatus(eReturnStatusFailed);
505         return false;
506       }
507 
508       int count = 0;
509       const size_t size = wp_ids.size();
510       for (size_t i = 0; i < size; ++i)
511         if (target->RemoveWatchpointByID(wp_ids[i]))
512           ++count;
513       result.AppendMessageWithFormat("%d watchpoints deleted.\n", count);
514       result.SetStatus(eReturnStatusSuccessFinishNoResult);
515     }
516 
517     return result.Succeeded();
518   }
519 };
520 
521 //-------------------------------------------------------------------------
522 // CommandObjectWatchpointIgnore
523 //-------------------------------------------------------------------------
524 
525 #pragma mark Ignore::CommandOptions
526 static constexpr OptionDefinition g_watchpoint_ignore_options[] = {
527     // clang-format off
528   { LLDB_OPT_SET_ALL, true, "ignore-count", 'i', OptionParser::eRequiredArgument, nullptr, {}, 0, eArgTypeCount, "Set the number of times this watchpoint is skipped before stopping." }
529     // clang-format on
530 };
531 
532 class CommandObjectWatchpointIgnore : public CommandObjectParsed {
533 public:
534   CommandObjectWatchpointIgnore(CommandInterpreter &interpreter)
535       : CommandObjectParsed(interpreter, "watchpoint ignore",
536                             "Set ignore count on the specified watchpoint(s).  "
537                             "If no watchpoints are specified, set them all.",
538                             nullptr),
539         m_options() {
540     CommandArgumentEntry arg;
541     CommandObject::AddIDsArgumentData(arg, eArgTypeWatchpointID,
542                                       eArgTypeWatchpointIDRange);
543     // Add the entry for the first argument for this command to the object's
544     // arguments vector.
545     m_arguments.push_back(arg);
546   }
547 
548   ~CommandObjectWatchpointIgnore() override = default;
549 
550   Options *GetOptions() override { return &m_options; }
551 
552   class CommandOptions : public Options {
553   public:
554     CommandOptions() : Options(), m_ignore_count(0) {}
555 
556     ~CommandOptions() override = default;
557 
558     Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg,
559                           ExecutionContext *execution_context) override {
560       Status error;
561       const int short_option = m_getopt_table[option_idx].val;
562 
563       switch (short_option) {
564       case 'i':
565         if (option_arg.getAsInteger(0, m_ignore_count))
566           error.SetErrorStringWithFormat("invalid ignore count '%s'",
567                                          option_arg.str().c_str());
568         break;
569       default:
570         error.SetErrorStringWithFormat("unrecognized option '%c'",
571                                        short_option);
572         break;
573       }
574 
575       return error;
576     }
577 
578     void OptionParsingStarting(ExecutionContext *execution_context) override {
579       m_ignore_count = 0;
580     }
581 
582     llvm::ArrayRef<OptionDefinition> GetDefinitions() override {
583       return llvm::makeArrayRef(g_watchpoint_ignore_options);
584     }
585 
586     // Instance variables to hold the values for command options.
587 
588     uint32_t m_ignore_count;
589   };
590 
591 protected:
592   bool DoExecute(Args &command, CommandReturnObject &result) override {
593     Target *target = m_interpreter.GetDebugger().GetSelectedTarget().get();
594     if (!CheckTargetForWatchpointOperations(target, result))
595       return false;
596 
597     std::unique_lock<std::recursive_mutex> lock;
598     target->GetWatchpointList().GetListMutex(lock);
599 
600     const WatchpointList &watchpoints = target->GetWatchpointList();
601 
602     size_t num_watchpoints = watchpoints.GetSize();
603 
604     if (num_watchpoints == 0) {
605       result.AppendError("No watchpoints exist to be ignored.");
606       result.SetStatus(eReturnStatusFailed);
607       return false;
608     }
609 
610     if (command.GetArgumentCount() == 0) {
611       target->IgnoreAllWatchpoints(m_options.m_ignore_count);
612       result.AppendMessageWithFormat("All watchpoints ignored. (%" PRIu64
613                                      " watchpoints)\n",
614                                      (uint64_t)num_watchpoints);
615       result.SetStatus(eReturnStatusSuccessFinishNoResult);
616     } else {
617       // Particular watchpoints selected; ignore them.
618       std::vector<uint32_t> wp_ids;
619       if (!CommandObjectMultiwordWatchpoint::VerifyWatchpointIDs(
620               target, command, wp_ids)) {
621         result.AppendError("Invalid watchpoints specification.");
622         result.SetStatus(eReturnStatusFailed);
623         return false;
624       }
625 
626       int count = 0;
627       const size_t size = wp_ids.size();
628       for (size_t i = 0; i < size; ++i)
629         if (target->IgnoreWatchpointByID(wp_ids[i], m_options.m_ignore_count))
630           ++count;
631       result.AppendMessageWithFormat("%d watchpoints ignored.\n", count);
632       result.SetStatus(eReturnStatusSuccessFinishNoResult);
633     }
634 
635     return result.Succeeded();
636   }
637 
638 private:
639   CommandOptions m_options;
640 };
641 
642 //-------------------------------------------------------------------------
643 // CommandObjectWatchpointModify
644 //-------------------------------------------------------------------------
645 
646 #pragma mark Modify::CommandOptions
647 
648 static constexpr OptionDefinition g_watchpoint_modify_options[] = {
649     // clang-format off
650   { LLDB_OPT_SET_ALL, false, "condition", 'c', OptionParser::eRequiredArgument, nullptr, {}, 0, eArgTypeExpression, "The watchpoint stops only if this condition expression evaluates to true." }
651     // clang-format on
652 };
653 
654 #pragma mark Modify
655 
656 class CommandObjectWatchpointModify : public CommandObjectParsed {
657 public:
658   CommandObjectWatchpointModify(CommandInterpreter &interpreter)
659       : CommandObjectParsed(
660             interpreter, "watchpoint modify",
661             "Modify the options on a watchpoint or set of watchpoints in the "
662             "executable.  "
663             "If no watchpoint is specified, act on the last created "
664             "watchpoint.  "
665             "Passing an empty argument clears the modification.",
666             nullptr),
667         m_options() {
668     CommandArgumentEntry arg;
669     CommandObject::AddIDsArgumentData(arg, eArgTypeWatchpointID,
670                                       eArgTypeWatchpointIDRange);
671     // Add the entry for the first argument for this command to the object's
672     // arguments vector.
673     m_arguments.push_back(arg);
674   }
675 
676   ~CommandObjectWatchpointModify() override = default;
677 
678   Options *GetOptions() override { return &m_options; }
679 
680   class CommandOptions : public Options {
681   public:
682     CommandOptions() : Options(), m_condition(), m_condition_passed(false) {}
683 
684     ~CommandOptions() override = default;
685 
686     Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg,
687                           ExecutionContext *execution_context) override {
688       Status error;
689       const int short_option = m_getopt_table[option_idx].val;
690 
691       switch (short_option) {
692       case 'c':
693         m_condition = option_arg;
694         m_condition_passed = true;
695         break;
696       default:
697         error.SetErrorStringWithFormat("unrecognized option '%c'",
698                                        short_option);
699         break;
700       }
701 
702       return error;
703     }
704 
705     void OptionParsingStarting(ExecutionContext *execution_context) override {
706       m_condition.clear();
707       m_condition_passed = false;
708     }
709 
710     llvm::ArrayRef<OptionDefinition> GetDefinitions() override {
711       return llvm::makeArrayRef(g_watchpoint_modify_options);
712     }
713 
714     // Instance variables to hold the values for command options.
715 
716     std::string m_condition;
717     bool m_condition_passed;
718   };
719 
720 protected:
721   bool DoExecute(Args &command, CommandReturnObject &result) override {
722     Target *target = m_interpreter.GetDebugger().GetSelectedTarget().get();
723     if (!CheckTargetForWatchpointOperations(target, result))
724       return false;
725 
726     std::unique_lock<std::recursive_mutex> lock;
727     target->GetWatchpointList().GetListMutex(lock);
728 
729     const WatchpointList &watchpoints = target->GetWatchpointList();
730 
731     size_t num_watchpoints = watchpoints.GetSize();
732 
733     if (num_watchpoints == 0) {
734       result.AppendError("No watchpoints exist to be modified.");
735       result.SetStatus(eReturnStatusFailed);
736       return false;
737     }
738 
739     if (command.GetArgumentCount() == 0) {
740       WatchpointSP wp_sp = target->GetLastCreatedWatchpoint();
741       wp_sp->SetCondition(m_options.m_condition.c_str());
742       result.SetStatus(eReturnStatusSuccessFinishNoResult);
743     } else {
744       // Particular watchpoints selected; set condition on them.
745       std::vector<uint32_t> wp_ids;
746       if (!CommandObjectMultiwordWatchpoint::VerifyWatchpointIDs(
747               target, command, wp_ids)) {
748         result.AppendError("Invalid watchpoints specification.");
749         result.SetStatus(eReturnStatusFailed);
750         return false;
751       }
752 
753       int count = 0;
754       const size_t size = wp_ids.size();
755       for (size_t i = 0; i < size; ++i) {
756         WatchpointSP wp_sp = watchpoints.FindByID(wp_ids[i]);
757         if (wp_sp) {
758           wp_sp->SetCondition(m_options.m_condition.c_str());
759           ++count;
760         }
761       }
762       result.AppendMessageWithFormat("%d watchpoints modified.\n", count);
763       result.SetStatus(eReturnStatusSuccessFinishNoResult);
764     }
765 
766     return result.Succeeded();
767   }
768 
769 private:
770   CommandOptions m_options;
771 };
772 
773 //-------------------------------------------------------------------------
774 // CommandObjectWatchpointSetVariable
775 //-------------------------------------------------------------------------
776 #pragma mark SetVariable
777 
778 class CommandObjectWatchpointSetVariable : public CommandObjectParsed {
779 public:
780   CommandObjectWatchpointSetVariable(CommandInterpreter &interpreter)
781       : CommandObjectParsed(
782             interpreter, "watchpoint set variable",
783             "Set a watchpoint on a variable. "
784             "Use the '-w' option to specify the type of watchpoint and "
785             "the '-s' option to specify the byte size to watch for. "
786             "If no '-w' option is specified, it defaults to write. "
787             "If no '-s' option is specified, it defaults to the variable's "
788             "byte size. "
789             "Note that there are limited hardware resources for watchpoints. "
790             "If watchpoint setting fails, consider disable/delete existing "
791             "ones "
792             "to free up resources.",
793             nullptr,
794             eCommandRequiresFrame | eCommandTryTargetAPILock |
795                 eCommandProcessMustBeLaunched | eCommandProcessMustBePaused),
796         m_option_group(), m_option_watchpoint() {
797     SetHelpLong(
798         R"(
799 Examples:
800 
801 (lldb) watchpoint set variable -w read_write my_global_var
802 
803 )"
804         "    Watches my_global_var for read/write access, with the region to watch \
805 corresponding to the byte size of the data type.");
806 
807     CommandArgumentEntry arg;
808     CommandArgumentData var_name_arg;
809 
810     // Define the only variant of this arg.
811     var_name_arg.arg_type = eArgTypeVarName;
812     var_name_arg.arg_repetition = eArgRepeatPlain;
813 
814     // Push the variant into the argument entry.
815     arg.push_back(var_name_arg);
816 
817     // Push the data for the only argument into the m_arguments vector.
818     m_arguments.push_back(arg);
819 
820     // Absorb the '-w' and '-s' options into our option group.
821     m_option_group.Append(&m_option_watchpoint, LLDB_OPT_SET_ALL,
822                           LLDB_OPT_SET_1);
823     m_option_group.Finalize();
824   }
825 
826   ~CommandObjectWatchpointSetVariable() override = default;
827 
828   Options *GetOptions() override { return &m_option_group; }
829 
830 protected:
831   static size_t GetVariableCallback(void *baton, const char *name,
832                                     VariableList &variable_list) {
833     Target *target = static_cast<Target *>(baton);
834     if (target) {
835       return target->GetImages().FindGlobalVariables(ConstString(name),
836                                                      UINT32_MAX, variable_list);
837     }
838     return 0;
839   }
840 
841   bool DoExecute(Args &command, CommandReturnObject &result) override {
842     Target *target = m_interpreter.GetDebugger().GetSelectedTarget().get();
843     StackFrame *frame = m_exe_ctx.GetFramePtr();
844 
845     // If no argument is present, issue an error message.  There's no way to
846     // set a watchpoint.
847     if (command.GetArgumentCount() <= 0) {
848       result.GetErrorStream().Printf("error: required argument missing; "
849                                      "specify your program variable to watch "
850                                      "for\n");
851       result.SetStatus(eReturnStatusFailed);
852       return false;
853     }
854 
855     // If no '-w' is specified, default to '-w write'.
856     if (!m_option_watchpoint.watch_type_specified) {
857       m_option_watchpoint.watch_type = OptionGroupWatchpoint::eWatchWrite;
858     }
859 
860     // We passed the sanity check for the command. Proceed to set the
861     // watchpoint now.
862     lldb::addr_t addr = 0;
863     size_t size = 0;
864 
865     VariableSP var_sp;
866     ValueObjectSP valobj_sp;
867     Stream &output_stream = result.GetOutputStream();
868 
869     // A simple watch variable gesture allows only one argument.
870     if (command.GetArgumentCount() != 1) {
871       result.GetErrorStream().Printf(
872           "error: specify exactly one variable to watch for\n");
873       result.SetStatus(eReturnStatusFailed);
874       return false;
875     }
876 
877     // Things have checked out ok...
878     Status error;
879     uint32_t expr_path_options =
880         StackFrame::eExpressionPathOptionCheckPtrVsMember |
881         StackFrame::eExpressionPathOptionsAllowDirectIVarAccess;
882     valobj_sp = frame->GetValueForVariableExpressionPath(
883         command.GetArgumentAtIndex(0), eNoDynamicValues, expr_path_options,
884         var_sp, error);
885 
886     if (!valobj_sp) {
887       // Not in the frame; let's check the globals.
888 
889       VariableList variable_list;
890       ValueObjectList valobj_list;
891 
892       Status error(Variable::GetValuesForVariableExpressionPath(
893           command.GetArgumentAtIndex(0),
894           m_exe_ctx.GetBestExecutionContextScope(), GetVariableCallback, target,
895           variable_list, valobj_list));
896 
897       if (valobj_list.GetSize())
898         valobj_sp = valobj_list.GetValueObjectAtIndex(0);
899     }
900 
901     CompilerType compiler_type;
902 
903     if (valobj_sp) {
904       AddressType addr_type;
905       addr = valobj_sp->GetAddressOf(false, &addr_type);
906       if (addr_type == eAddressTypeLoad) {
907         // We're in business.
908         // Find out the size of this variable.
909         size = m_option_watchpoint.watch_size == 0
910                    ? valobj_sp->GetByteSize()
911                    : m_option_watchpoint.watch_size;
912       }
913       compiler_type = valobj_sp->GetCompilerType();
914     } else {
915       const char *error_cstr = error.AsCString(nullptr);
916       if (error_cstr)
917         result.GetErrorStream().Printf("error: %s\n", error_cstr);
918       else
919         result.GetErrorStream().Printf("error: unable to find any variable "
920                                        "expression path that matches '%s'\n",
921                                        command.GetArgumentAtIndex(0));
922       return false;
923     }
924 
925     // Now it's time to create the watchpoint.
926     uint32_t watch_type = m_option_watchpoint.watch_type;
927 
928     error.Clear();
929     Watchpoint *wp =
930         target->CreateWatchpoint(addr, size, &compiler_type, watch_type, error)
931             .get();
932     if (wp) {
933       wp->SetWatchSpec(command.GetArgumentAtIndex(0));
934       wp->SetWatchVariable(true);
935       if (var_sp && var_sp->GetDeclaration().GetFile()) {
936         StreamString ss;
937         // True to show fullpath for declaration file.
938         var_sp->GetDeclaration().DumpStopContext(&ss, true);
939         wp->SetDeclInfo(ss.GetString());
940       }
941       output_stream.Printf("Watchpoint created: ");
942       wp->GetDescription(&output_stream, lldb::eDescriptionLevelFull);
943       output_stream.EOL();
944       result.SetStatus(eReturnStatusSuccessFinishResult);
945     } else {
946       result.AppendErrorWithFormat(
947           "Watchpoint creation failed (addr=0x%" PRIx64 ", size=%" PRIu64
948           ", variable expression='%s').\n",
949           addr, (uint64_t)size, command.GetArgumentAtIndex(0));
950       if (error.AsCString(nullptr))
951         result.AppendError(error.AsCString());
952       result.SetStatus(eReturnStatusFailed);
953     }
954 
955     return result.Succeeded();
956   }
957 
958 private:
959   OptionGroupOptions m_option_group;
960   OptionGroupWatchpoint m_option_watchpoint;
961 };
962 
963 //-------------------------------------------------------------------------
964 // CommandObjectWatchpointSetExpression
965 //-------------------------------------------------------------------------
966 #pragma mark Set
967 
968 class CommandObjectWatchpointSetExpression : public CommandObjectRaw {
969 public:
970   CommandObjectWatchpointSetExpression(CommandInterpreter &interpreter)
971       : CommandObjectRaw(
972             interpreter, "watchpoint set expression",
973             "Set a watchpoint on an address by supplying an expression. "
974             "Use the '-w' option to specify the type of watchpoint and "
975             "the '-s' option to specify the byte size to watch for. "
976             "If no '-w' option is specified, it defaults to write. "
977             "If no '-s' option is specified, it defaults to the target's "
978             "pointer byte size. "
979             "Note that there are limited hardware resources for watchpoints. "
980             "If watchpoint setting fails, consider disable/delete existing "
981             "ones "
982             "to free up resources.",
983             "",
984             eCommandRequiresFrame | eCommandTryTargetAPILock |
985                 eCommandProcessMustBeLaunched | eCommandProcessMustBePaused),
986         m_option_group(), m_option_watchpoint() {
987     SetHelpLong(
988         R"(
989 Examples:
990 
991 (lldb) watchpoint set expression -w write -s 1 -- foo + 32
992 
993     Watches write access for the 1-byte region pointed to by the address 'foo + 32')");
994 
995     CommandArgumentEntry arg;
996     CommandArgumentData expression_arg;
997 
998     // Define the only variant of this arg.
999     expression_arg.arg_type = eArgTypeExpression;
1000     expression_arg.arg_repetition = eArgRepeatPlain;
1001 
1002     // Push the only variant into the argument entry.
1003     arg.push_back(expression_arg);
1004 
1005     // Push the data for the only argument into the m_arguments vector.
1006     m_arguments.push_back(arg);
1007 
1008     // Absorb the '-w' and '-s' options into our option group.
1009     m_option_group.Append(&m_option_watchpoint, LLDB_OPT_SET_ALL,
1010                           LLDB_OPT_SET_1);
1011     m_option_group.Finalize();
1012   }
1013 
1014   ~CommandObjectWatchpointSetExpression() override = default;
1015 
1016   // Overrides base class's behavior where WantsCompletion =
1017   // !WantsRawCommandString.
1018   bool WantsCompletion() override { return true; }
1019 
1020   Options *GetOptions() override { return &m_option_group; }
1021 
1022 protected:
1023   bool DoExecute(llvm::StringRef raw_command,
1024                  CommandReturnObject &result) override {
1025     auto exe_ctx = GetCommandInterpreter().GetExecutionContext();
1026     m_option_group.NotifyOptionParsingStarting(
1027         &exe_ctx); // This is a raw command, so notify the option group
1028 
1029     Target *target = m_interpreter.GetDebugger().GetSelectedTarget().get();
1030     StackFrame *frame = m_exe_ctx.GetFramePtr();
1031 
1032     OptionsWithRaw args(raw_command);
1033 
1034     llvm::StringRef expr = args.GetRawPart();
1035 
1036     if (args.HasArgs())
1037       if (!ParseOptionsAndNotify(args.GetArgs(), result, m_option_group,
1038                                  exe_ctx))
1039         return false;
1040 
1041     // If no argument is present, issue an error message.  There's no way to
1042     // set a watchpoint.
1043     if (raw_command.trim().empty()) {
1044       result.GetErrorStream().Printf("error: required argument missing; "
1045                                      "specify an expression to evaulate into "
1046                                      "the address to watch for\n");
1047       result.SetStatus(eReturnStatusFailed);
1048       return false;
1049     }
1050 
1051     // If no '-w' is specified, default to '-w write'.
1052     if (!m_option_watchpoint.watch_type_specified) {
1053       m_option_watchpoint.watch_type = OptionGroupWatchpoint::eWatchWrite;
1054     }
1055 
1056     // We passed the sanity check for the command. Proceed to set the
1057     // watchpoint now.
1058     lldb::addr_t addr = 0;
1059     size_t size = 0;
1060 
1061     ValueObjectSP valobj_sp;
1062 
1063     // Use expression evaluation to arrive at the address to watch.
1064     EvaluateExpressionOptions options;
1065     options.SetCoerceToId(false);
1066     options.SetUnwindOnError(true);
1067     options.SetKeepInMemory(false);
1068     options.SetTryAllThreads(true);
1069     options.SetTimeout(llvm::None);
1070 
1071     ExpressionResults expr_result =
1072         target->EvaluateExpression(expr, frame, valobj_sp, options);
1073     if (expr_result != eExpressionCompleted) {
1074       result.GetErrorStream().Printf(
1075           "error: expression evaluation of address to watch failed\n");
1076       result.GetErrorStream() << "expression evaluated: \n" << expr << "\n";
1077       result.SetStatus(eReturnStatusFailed);
1078       return false;
1079     }
1080 
1081     // Get the address to watch.
1082     bool success = false;
1083     addr = valobj_sp->GetValueAsUnsigned(0, &success);
1084     if (!success) {
1085       result.GetErrorStream().Printf(
1086           "error: expression did not evaluate to an address\n");
1087       result.SetStatus(eReturnStatusFailed);
1088       return false;
1089     }
1090 
1091     if (m_option_watchpoint.watch_size != 0)
1092       size = m_option_watchpoint.watch_size;
1093     else
1094       size = target->GetArchitecture().GetAddressByteSize();
1095 
1096     // Now it's time to create the watchpoint.
1097     uint32_t watch_type = m_option_watchpoint.watch_type;
1098 
1099     // Fetch the type from the value object, the type of the watched object is
1100     // the pointee type
1101     /// of the expression, so convert to that if we  found a valid type.
1102     CompilerType compiler_type(valobj_sp->GetCompilerType());
1103 
1104     Status error;
1105     Watchpoint *wp =
1106         target->CreateWatchpoint(addr, size, &compiler_type, watch_type, error)
1107             .get();
1108     if (wp) {
1109       Stream &output_stream = result.GetOutputStream();
1110       output_stream.Printf("Watchpoint created: ");
1111       wp->GetDescription(&output_stream, lldb::eDescriptionLevelFull);
1112       output_stream.EOL();
1113       result.SetStatus(eReturnStatusSuccessFinishResult);
1114     } else {
1115       result.AppendErrorWithFormat("Watchpoint creation failed (addr=0x%" PRIx64
1116                                    ", size=%" PRIu64 ").\n",
1117                                    addr, (uint64_t)size);
1118       if (error.AsCString(nullptr))
1119         result.AppendError(error.AsCString());
1120       result.SetStatus(eReturnStatusFailed);
1121     }
1122 
1123     return result.Succeeded();
1124   }
1125 
1126 private:
1127   OptionGroupOptions m_option_group;
1128   OptionGroupWatchpoint m_option_watchpoint;
1129 };
1130 
1131 //-------------------------------------------------------------------------
1132 // CommandObjectWatchpointSet
1133 //-------------------------------------------------------------------------
1134 #pragma mark Set
1135 
1136 class CommandObjectWatchpointSet : public CommandObjectMultiword {
1137 public:
1138   CommandObjectWatchpointSet(CommandInterpreter &interpreter)
1139       : CommandObjectMultiword(
1140             interpreter, "watchpoint set", "Commands for setting a watchpoint.",
1141             "watchpoint set <subcommand> [<subcommand-options>]") {
1142 
1143     LoadSubCommand(
1144         "variable",
1145         CommandObjectSP(new CommandObjectWatchpointSetVariable(interpreter)));
1146     LoadSubCommand(
1147         "expression",
1148         CommandObjectSP(new CommandObjectWatchpointSetExpression(interpreter)));
1149   }
1150 
1151   ~CommandObjectWatchpointSet() override = default;
1152 };
1153 
1154 //-------------------------------------------------------------------------
1155 // CommandObjectMultiwordWatchpoint
1156 //-------------------------------------------------------------------------
1157 #pragma mark MultiwordWatchpoint
1158 
1159 CommandObjectMultiwordWatchpoint::CommandObjectMultiwordWatchpoint(
1160     CommandInterpreter &interpreter)
1161     : CommandObjectMultiword(interpreter, "watchpoint",
1162                              "Commands for operating on watchpoints.",
1163                              "watchpoint <subcommand> [<command-options>]") {
1164   CommandObjectSP list_command_object(
1165       new CommandObjectWatchpointList(interpreter));
1166   CommandObjectSP enable_command_object(
1167       new CommandObjectWatchpointEnable(interpreter));
1168   CommandObjectSP disable_command_object(
1169       new CommandObjectWatchpointDisable(interpreter));
1170   CommandObjectSP delete_command_object(
1171       new CommandObjectWatchpointDelete(interpreter));
1172   CommandObjectSP ignore_command_object(
1173       new CommandObjectWatchpointIgnore(interpreter));
1174   CommandObjectSP command_command_object(
1175       new CommandObjectWatchpointCommand(interpreter));
1176   CommandObjectSP modify_command_object(
1177       new CommandObjectWatchpointModify(interpreter));
1178   CommandObjectSP set_command_object(
1179       new CommandObjectWatchpointSet(interpreter));
1180 
1181   list_command_object->SetCommandName("watchpoint list");
1182   enable_command_object->SetCommandName("watchpoint enable");
1183   disable_command_object->SetCommandName("watchpoint disable");
1184   delete_command_object->SetCommandName("watchpoint delete");
1185   ignore_command_object->SetCommandName("watchpoint ignore");
1186   command_command_object->SetCommandName("watchpoint command");
1187   modify_command_object->SetCommandName("watchpoint modify");
1188   set_command_object->SetCommandName("watchpoint set");
1189 
1190   LoadSubCommand("list", list_command_object);
1191   LoadSubCommand("enable", enable_command_object);
1192   LoadSubCommand("disable", disable_command_object);
1193   LoadSubCommand("delete", delete_command_object);
1194   LoadSubCommand("ignore", ignore_command_object);
1195   LoadSubCommand("command", command_command_object);
1196   LoadSubCommand("modify", modify_command_object);
1197   LoadSubCommand("set", set_command_object);
1198 }
1199 
1200 CommandObjectMultiwordWatchpoint::~CommandObjectMultiwordWatchpoint() = default;
1201