Make breakpoint names real entities.

When introduced, breakpoint names were just tags that you could
apply to breakpoints that would allow you to refer to a breakpoint
when you couldn't capture the ID, or to refer to a collection of
breakpoints.  

This change makes the names independent holders of breakpoint options
that you can then apply to breakpoints when you add the name to the
breakpoint.  It adds the "breakpoint name configure" command to set
up or reconfigure breakpoint names.  There is also full support for
then in the SB API, including a new SBBreakpointName class.

The connection between the name and the breakpoints
sharing the name remains live, so if you reconfigure the name, all the
breakpoint options all change as well.  This allows a quick way
to share complex breakpoint behavior among a bunch of breakpoints, and
a convenient way to iterate on the set.

You can also create a name from a breakpoint, allowing a quick way
to copy options from one breakpoint to another.

I also added the ability to make hidden and delete/disable protected
names.  When applied to a breakpoint, you will only be able to list,
delete or disable that breakpoint if you refer to it explicitly by ID.

This feature will allow GUI's that need to use breakpoints for their
own purposes to keep their breakpoints from getting accidentally 
disabled or deleted.

<rdar://problem/22094452>

llvm-svn: 313292

6 files changed, 245 insertions, 32 deletions

diff --git a/lldb/source/Breakpoint/Breakpoint.cpp b/lldb/source/Breakpoint/Breakpoint.cpp
index fd606aa83d6..3f6c63e1e5b 100644
--- a/lldb/source/Breakpoint/Breakpoint.cpp
+++ b/lldb/source/Breakpoint/Breakpoint.cpp
@@ -210,7 +210,7 @@ lldb::BreakpointSP Breakpoint::CreateFromStructuredData(
       llvm::StringRef name;
       Status error;
       success = names_array->GetItemAtIndexAsString(i, name);
-      result_sp->AddName(name, error);
+      target.AddNameToBreakpoint(result_sp, name.str().c_str(), error);
     }
   }
 
@@ -455,6 +455,10 @@ bool Breakpoint::InvokeCallback(StoppointCallbackContext *context,
 
 BreakpointOptions *Breakpoint::GetOptions() { return m_options_up.get(); }
 
+const BreakpointOptions *Breakpoint::GetOptions() const {
+  return m_options_up.get();
+}
+
 void Breakpoint::ResolveBreakpoint() {
   if (m_resolver_sp)
     m_resolver_sp->ResolveBreakpoint(*m_filter_sp);
@@ -841,18 +845,8 @@ size_t Breakpoint::GetNumResolvedLocations() const {
 
 size_t Breakpoint::GetNumLocations() const { return m_locations.GetSize(); }
 
-bool Breakpoint::AddName(llvm::StringRef new_name, Status &error) {
-  if (new_name.empty())
-    return false;
-  if (!BreakpointID::StringIsBreakpointName(new_name, error)) {
-    error.SetErrorStringWithFormatv("input name \"{0}\" not a breakpoint name.",
-                                    new_name);
-    return false;
-  }
-  if (!error.Success())
-    return false;
-
-  m_name_list.insert(new_name);
+bool Breakpoint::AddName(llvm::StringRef new_name) {
+  m_name_list.insert(new_name.str().c_str());
   return true;
 }
 
diff --git a/lldb/source/Breakpoint/BreakpointID.cpp b/lldb/source/Breakpoint/BreakpointID.cpp
index 112f7c0b519..b8010654682 100644
--- a/lldb/source/Breakpoint/BreakpointID.cpp
+++ b/lldb/source/Breakpoint/BreakpointID.cpp
@@ -101,15 +101,24 @@ BreakpointID::ParseCanonicalReference(llvm::StringRef input) {
 bool BreakpointID::StringIsBreakpointName(llvm::StringRef str, Status &error) {
   error.Clear();
   if (str.empty())
+  {
+    error.SetErrorStringWithFormat("Empty breakpoint names are not allowed");
     return false;
+  }
 
   // First character must be a letter or _
   if (!isalpha(str[0]) && str[0] != '_')
+  {
+    error.SetErrorStringWithFormat("Breakpoint names must start with a "
+                                   "character or underscore: %s",
+                                   str.str().c_str());
     return false;
+  }
 
   // Cannot contain ., -, or space.
   if (str.find_first_of(".- ") != llvm::StringRef::npos) {
-    error.SetErrorStringWithFormat("invalid breakpoint name: \"%s\"",
+    error.SetErrorStringWithFormat("Breakpoint names cannot contain "
+                                   "'.' or '-': \"%s\"",
                                    str.str().c_str());
     return false;
   }
diff --git a/lldb/source/Breakpoint/BreakpointIDList.cpp b/lldb/source/Breakpoint/BreakpointIDList.cpp
index 7b461147a4e..0a704fdc918 100644
--- a/lldb/source/Breakpoint/BreakpointIDList.cpp
+++ b/lldb/source/Breakpoint/BreakpointIDList.cpp
@@ -11,6 +11,7 @@
 // C++ Includes
 // Other libraries and framework includes
 // Project includes
+#include "lldb/lldb-enumerations.h"
 #include "lldb/Breakpoint/BreakpointIDList.h"
 
 #include "lldb/Breakpoint/Breakpoint.h"
@@ -117,6 +118,8 @@ void BreakpointIDList::InsertStringArray(const char **string_array,
 
 void BreakpointIDList::FindAndReplaceIDRanges(Args &old_args, Target *target,
                                               bool allow_locations,
+                                              BreakpointName::Permissions
+                                                  ::PermissionKinds purpose,
                                               CommandReturnObject &result,
                                               Args &new_args) {
   llvm::StringRef range_from;
@@ -302,14 +305,29 @@ void BreakpointIDList::FindAndReplaceIDRanges(Args &old_args, Target *target,
   }
 
   // Okay, now see if we found any names, and if we did, add them:
-  if (target && names_found.size()) {
-    for (BreakpointSP bkpt_sp : target->GetBreakpointList().Breakpoints()) {
-      for (std::string name : names_found) {
-        if (bkpt_sp->MatchesName(name.c_str())) {
-          StreamString canonical_id_str;
-          BreakpointID::GetCanonicalReference(
-              &canonical_id_str, bkpt_sp->GetID(), LLDB_INVALID_BREAK_ID);
-          new_args.AppendArgument(canonical_id_str.GetString());
+  if (target && !names_found.empty()) {
+    Status error;
+    // Remove any names that aren't visible for this purpose:
+    auto iter = names_found.begin();
+    while (iter != names_found.end()) {
+      BreakpointName *bp_name = target->FindBreakpointName(ConstString(*iter),
+                                                           true,
+                                                           error);
+      if (bp_name && !bp_name->GetPermission(purpose))
+        iter = names_found.erase(iter);
+      else
+        iter++;
+    }
+    
+    if (!names_found.empty()) {
+      for (BreakpointSP bkpt_sp : target->GetBreakpointList().Breakpoints()) {
+        for (std::string name : names_found) {
+          if (bkpt_sp->MatchesName(name.c_str())) {
+            StreamString canonical_id_str;
+            BreakpointID::GetCanonicalReference(
+                &canonical_id_str, bkpt_sp->GetID(), LLDB_INVALID_BREAK_ID);
+            new_args.AppendArgument(canonical_id_str.GetString());
+          }
         }
       }
     }
diff --git a/lldb/source/Breakpoint/BreakpointList.cpp b/lldb/source/Breakpoint/BreakpointList.cpp
index 15bcb34a3d8..01ac59f0a90 100644
--- a/lldb/source/Breakpoint/BreakpointList.cpp
+++ b/lldb/source/Breakpoint/BreakpointList.cpp
@@ -71,6 +71,13 @@ void BreakpointList::SetEnabledAll(bool enabled) {
     bp_sp->SetEnabled(enabled);
 }
 
+void BreakpointList::SetEnabledAllowed(bool enabled) {
+  std::lock_guard<std::recursive_mutex> guard(m_mutex);
+  for (const auto &bp_sp : m_breakpoints)
+    if (bp_sp->AllowDisable())
+      bp_sp->SetEnabled(enabled);
+}
+
 void BreakpointList::RemoveAll(bool notify) {
   std::lock_guard<std::recursive_mutex> guard(m_mutex);
   ClearAllBreakpointSites();
@@ -90,6 +97,32 @@ void BreakpointList::RemoveAll(bool notify) {
   m_breakpoints.erase(m_breakpoints.begin(), m_breakpoints.end());
 }
 
+void BreakpointList::RemoveAllowed(bool notify) {
+  std::lock_guard<std::recursive_mutex> guard(m_mutex);
+  
+  bp_collection::iterator pos, end = m_breakpoints.end();
+  if (notify) {
+    for (pos = m_breakpoints.begin(); pos != end; ++pos) {
+      if(!(*pos)->AllowDelete())
+        continue;
+      if ((*pos)->GetTarget().EventTypeHasListeners(
+              Target::eBroadcastBitBreakpointChanged)) {
+        (*pos)->GetTarget().BroadcastEvent(
+            Target::eBroadcastBitBreakpointChanged,
+            new Breakpoint::BreakpointEventData(eBreakpointEventTypeRemoved,
+                                                *pos));
+      }
+    }
+  }
+  pos = m_breakpoints.begin();
+  while ( pos != end) {
+      if((*pos)->AllowDelete())
+        pos = m_breakpoints.erase(pos);
+      else
+        pos++;
+  }
+}
+
 class BreakpointIDMatches {
 public:
   BreakpointIDMatches(break_id_t break_id) : m_break_id(break_id) {}
diff --git a/lldb/source/Breakpoint/BreakpointName.cpp b/lldb/source/Breakpoint/BreakpointName.cpp
new file mode 100644
index 00000000000..7b9a2acfbc4
--- /dev/null
+++ b/lldb/source/Breakpoint/BreakpointName.cpp
@@ -0,0 +1,88 @@
+//===-- Breakpoint.cpp ------------------------------------------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details->
+//
+//===----------------------------------------------------------------------===//
+
+// C Includes
+// C++ Includes
+// Other libraries and framework includes
+#include "llvm/Support/Casting.h"
+
+// Project includes
+#include "lldb/Breakpoint/Breakpoint.h"
+#include "lldb/Breakpoint/BreakpointOptions.h"
+#include "lldb/Breakpoint/BreakpointLocationCollection.h"
+#include "lldb/Breakpoint/BreakpointResolver.h"
+#include "lldb/Breakpoint/BreakpointResolverFileLine.h"
+#include "lldb/Utility/Log.h"
+#include "lldb/Utility/Stream.h"
+#include "lldb/Utility/StreamString.h"
+
+using namespace lldb;
+using namespace lldb_private;
+
+const Flags::ValueType BreakpointName::Permissions::permissions_mask
+    [BreakpointName::Permissions::PermissionKinds::allPerms + 1] =  { 
+      (1u << 0),
+      (1u << 1),
+      (1u << 2),
+      (0x5u)
+};
+
+BreakpointName::BreakpointName(const ConstString &name, const Breakpoint &bkpt,
+                 const char *help) :
+      m_name(name), m_options(bkpt.GetOptions())
+{
+  SetHelp(help);
+}
+
+bool BreakpointName::Permissions::GetDescription(Stream *s,
+                                                 lldb::DescriptionLevel level) {
+    if (!AnySet())
+      return false;
+    s->IndentMore();
+    s->Indent();
+    if (IsSet(listPerm))
+      s->Printf("list: %s", GetAllowList() ? "allowed" : "disallowed");
+  
+    if (IsSet(disablePerm))
+      s->Printf("disable: %s", GetAllowDisable() ? "allowed" : "disallowed");
+  
+    if (IsSet(deletePerm))
+      s->Printf("delete: %s", GetAllowDelete() ? "allowed" : "disallowed");
+    s->IndentLess();
+    return true;
+}
+
+bool BreakpointName::GetDescription(Stream *s, lldb::DescriptionLevel level) {
+  bool printed_any = false;
+  if (GetOptions().AnySet())
+  {
+    s->PutCString("Options: \n");
+    s->IndentMore();
+    s->Indent();
+    GetOptions().GetDescription(s, level);
+    printed_any = true;
+    s->IndentLess();
+  }
+  if (GetPermissions().AnySet())
+  {
+    s->PutCString("Permissions: \n");
+    s->IndentMore();
+    s->Indent();
+    GetPermissions().GetDescription(s, level);
+    printed_any = true;
+    s->IndentLess();
+ }
+  return printed_any;
+}
+
+void BreakpointName::ConfigureBreakpoint(lldb::BreakpointSP bp_sp)
+{
+   bp_sp->GetOptions()->CopyOverSetOptions(GetOptions());
+   bp_sp->GetPermissions().MergeInto(GetPermissions());
+}
diff --git a/lldb/source/Breakpoint/BreakpointOptions.cpp b/lldb/source/Breakpoint/BreakpointOptions.cpp
index 7159688102d..662b288794d 100644
--- a/lldb/source/Breakpoint/BreakpointOptions.cpp
+++ b/lldb/source/Breakpoint/BreakpointOptions.cpp
@@ -132,7 +132,7 @@ BreakpointOptions::BreakpointOptions(bool all_flags_set)
       m_baton_is_command_baton(false), m_callback_is_synchronous(false),
       m_enabled(true), m_one_shot(false), m_ignore_count(0), m_thread_spec_ap(),
       m_condition_text(), m_condition_text_hash(0), m_auto_continue(false),
-      m_set_flags() {
+      m_set_flags(0) {
         if (all_flags_set)
           m_set_flags.Set(~((Flags::ValueType) 0));
       }
@@ -142,11 +142,14 @@ BreakpointOptions::BreakpointOptions(const char *condition, bool enabled,
                                      bool auto_continue)
     : m_callback(nullptr), m_baton_is_command_baton(false),
       m_callback_is_synchronous(false), m_enabled(enabled),
-      m_one_shot(one_shot), m_ignore_count(ignore), m_condition_text(condition),
+      m_one_shot(one_shot), m_ignore_count(ignore),
       m_condition_text_hash(0), m_auto_continue(auto_continue)
 {
     m_set_flags.Set(eEnabled | eIgnoreCount | eOneShot 
-                   | eCondition | eAutoContinue);
+                   | eAutoContinue);
+    if (condition && *condition != '\0') {
+      SetCondition(condition);
+    }
 }
 
 //----------------------------------------------------------------------
@@ -187,6 +190,59 @@ operator=(const BreakpointOptions &rhs) {
   return *this;
 }
 
+void BreakpointOptions::CopyOverSetOptions(const BreakpointOptions &incoming)
+{
+  if (incoming.m_set_flags.Test(eEnabled))
+  {
+    m_enabled = incoming.m_enabled;
+    m_set_flags.Set(eEnabled);
+  }
+  if (incoming.m_set_flags.Test(eOneShot))
+  {
+    m_one_shot = incoming.m_one_shot;
+    m_set_flags.Set(eOneShot);
+  }
+  if (incoming.m_set_flags.Test(eCallback))
+  {
+    m_callback = incoming.m_callback;
+    m_callback_baton_sp = incoming.m_callback_baton_sp;
+    m_callback_is_synchronous = incoming.m_callback_is_synchronous;
+    m_baton_is_command_baton = incoming.m_baton_is_command_baton;
+    m_set_flags.Set(eCallback);
+  }
+  if (incoming.m_set_flags.Test(eIgnoreCount))
+  {
+    m_ignore_count = incoming.m_ignore_count;
+    m_set_flags.Set(eIgnoreCount);
+  }
+  if (incoming.m_set_flags.Test(eCondition))
+  {
+    // If we're copying over an empty condition, mark it as unset.
+    if (incoming.m_condition_text.empty()) {
+      m_condition_text.clear();
+      m_condition_text_hash = 0;
+      m_set_flags.Clear(eCondition);
+    } else {
+      m_condition_text = incoming.m_condition_text;
+      m_condition_text_hash = incoming.m_condition_text_hash;
+      m_set_flags.Set(eCondition);
+    }
+  }
+  if (incoming.m_set_flags.Test(eAutoContinue))
+  {
+    m_auto_continue = incoming.m_auto_continue;
+    m_set_flags.Set(eAutoContinue);
+  }
+  if (incoming.m_set_flags.Test(eThreadSpec) && incoming.m_thread_spec_ap)
+  {
+    if (!m_thread_spec_ap)
+      m_thread_spec_ap.reset(new ThreadSpec(*incoming.m_thread_spec_ap.get()));
+    else
+      *m_thread_spec_ap.get() = *incoming.m_thread_spec_ap.get();
+    m_set_flags.Set(eThreadSpec);
+  }
+}
+
 //----------------------------------------------------------------------
 // Destructor
 //----------------------------------------------------------------------
@@ -327,23 +383,23 @@ std::unique_ptr<BreakpointOptions> BreakpointOptions::CreateFromStructuredData(
 StructuredData::ObjectSP BreakpointOptions::SerializeToStructuredData() {
   StructuredData::DictionarySP options_dict_sp(
       new StructuredData::Dictionary());
-  if (m_set_flags.Set(eEnabled))
+  if (m_set_flags.Test(eEnabled))
     options_dict_sp->AddBooleanItem(GetKey(OptionNames::EnabledState),
                                     m_enabled);
-  if (m_set_flags.Set(eOneShot))
+  if (m_set_flags.Test(eOneShot))
     options_dict_sp->AddBooleanItem(GetKey(OptionNames::OneShotState),
                                m_one_shot);
-  if (m_set_flags.Set(eAutoContinue))
+  if (m_set_flags.Test(eAutoContinue))
     options_dict_sp->AddBooleanItem(GetKey(OptionNames::AutoContinue),
                                m_auto_continue);
-  if (m_set_flags.Set(eIgnoreCount))
+  if (m_set_flags.Test(eIgnoreCount))
     options_dict_sp->AddIntegerItem(GetKey(OptionNames::IgnoreCount),
                                     m_ignore_count);
-  if (m_set_flags.Set(eCondition))
+  if (m_set_flags.Test(eCondition))
     options_dict_sp->AddStringItem(GetKey(OptionNames::ConditionText),
                                    m_condition_text);
          
-  if (m_set_flags.Set(eCallback) && m_baton_is_command_baton) {
+  if (m_set_flags.Test(eCallback) && m_baton_is_command_baton) {
     auto cmd_baton =
         std::static_pointer_cast<CommandBaton>(m_callback_baton_sp);
     StructuredData::ObjectSP commands_sp =
@@ -353,7 +409,7 @@ StructuredData::ObjectSP BreakpointOptions::SerializeToStructuredData() {
           BreakpointOptions::CommandData::GetSerializationKey(), commands_sp);
     }
   }
-  if (m_set_flags.Set(eThreadSpec) && m_thread_spec_ap) {
+  if (m_set_flags.Test(eThreadSpec) && m_thread_spec_ap) {
     StructuredData::ObjectSP thread_spec_sp =
         m_thread_spec_ap->SerializeToStructuredData();
     options_dict_sp->AddItem(ThreadSpec::GetSerializationKey(), thread_spec_sp);
@@ -618,3 +674,18 @@ bool BreakpointOptions::BreakpointOptionsCallbackFunction(
   }
   return ret_value;
 }
+
+void BreakpointOptions::Clear()
+{
+  m_set_flags.Clear();
+  m_thread_spec_ap.release();
+  m_one_shot = false;
+  m_ignore_count = 0;
+  m_auto_continue = false;
+  m_callback = nullptr;
+  m_callback_baton_sp.reset();
+  m_baton_is_command_baton = false;
+  m_callback_is_synchronous = false;
+  m_enabled = false;
+  m_condition_text.clear();
+}