Add the ability to specify signal actions (pass, stop or notify) for a signal before a process is created

[jingham]

Summary

One of the weaknesses of the signal handling model in lldb is that we access the information about signals from the process. That's good, since different OS'es and even different OS versions might have more or fewer signals, or they may be renumbered, etc.

However, it means you can't set signal handling behaviors in your .lldbinit, and if you set them in one run they don't persist on re-run. That's been somewhat annoying over the years.

This adds a "DummySignals" map to the target that holds signals as std::strings, and the user intentions. I called them DummySignals because if you set them in an .lldbinit, they will go into the Dummy Target, and then will prime new targets. They work like all the other Dummy Target elements, if you add a handling with no Targets, they go to the dummy target then to your target. If you add them when there's a real target, it will only go into that target.

Just like before, if you run process handle when you have a process, the UnixSignals values will be changed, but the change will also be recorded in the DummySignals map so we can apply it on re-run.

I also added a -c option to "process handle" which allows you to clear the setting from your target (and with -d from the dummy target).
I also added a -t option to "process handle" to show you just the changes you made to the default setting values.

Since I wanted you to also be able to "reset to the default" I had to change the UnixSignals class so it recorded the default value as well as the current value.

There are a couple of pieces of this that aren't done yet, but the patch was getting pretty big.

1. No SB API. I'll add an SBTarget::HandleSignal to set the handling in the dummy target.
2. When you add a signal with no process, we can't spell-check the signal name for you. The current patch emits a warning on Launch or Attach if there was a signal whose handling is configured but the signal name wasn't recognized.

I don't plan to do #2 right now. You would have to have the AddSignal add the signal name to a global pool, and then construct all the Platforms and get them to make their UnixSignals so the registry would happen. Then you could compare the signal against this list.

I'm not even sure that being able to spell check the signals is worth having to construct all the platforms to build this registry.

[clayborg]

lldb/include/lldb/Target/Target.h

1421

We should make UnixSignals::Signal a public class and then just save a std::vector of those inside this class. That class doesn't contain a signal number, so we should be able to re-use it here and avoid creating a new class that mimic what is contains.

1429

Maybe store a std::vector<UnixSignal::Signal> objects filled out as much as possible here? Then we don't need the DummySignalElement type at all.

1533–1536

Switch to std::vector< UnixSignal::Signal> here and then we can prime the UnixSignals with the vector?

lldb/include/lldb/Target/UnixSignals.h

120

If we store a vector<UnixSignals::Signal> in the target, can we reset the default values from another "Signal" struct instead of saving it here? Not a big deal if not, but just wondering.

126

To follow up with he above comment, this _could_ become:

void Reset(const UnixSignals::Signal &signal);

we can find the UnixSignals::Signal object for this signal first in the target and pass it down into here?

lldb/source/Commands/Options.td

758

Do we need the "Also" in the documentation here? Is this option only available when used with another option?

[jingham]

This patch treats the Signal structure held in the target differently from UnixSignals::Signal. The latter always has to have values for all three actions and needs to have a signal number. The former doesn't actually claim to know a signal number. After all, it might get set before we can know what signal number a given signal string has (signals with the same name do have different numbers on different platforms). So pretending it knows a signal number would just be confusing. Also, it doesn't record actual values, it records user intents, so it needs to be tri-state - thus the LazyBools.

I think the two are sufficiently different in use that it's cleaner to have separate types for them.

lldb/include/lldb/Target/Target.h

1421

The data structure held by the target is different from the one that represents actual signals because the Target one needs to record not just "true or false" but "whether set by the user." That's why I used LazyBools not bools in the structure. That's important because if you are setting a signal handling in the .lldbinit you don't yet know what the default value is, so you need to be able to say "change print to false, and leave the others at their default values".

So I don't think that the UnixSignals::Signal is the right data structure of rthis.

1429

See the comment above.

1533–1536

See the first comment.

lldb/include/lldb/Target/UnixSignals.h

120

I wondered about that, but having to make another version of Signals and hope it's constructed the same way seems a fallible way to get the default value the Signal object was constructed with. This is just 3 bytes, and won't actually change the size of the structure (plus these are not structures we have lots and lots of). So I think doing the straightforward thing is better.

126

The code that's resetting this doesn't really need to know what values the signal currently has. It knows that it changed "pass" but not "notify" or "suppress" and just wants them reset to the default values. Having to look up some other Signal to do this seems needlessly complex.

lldb/source/Commands/Options.td

758

Right now, you can either clear the values in the current Target or in the Current target and the Dummy Target. So the "also" is correct. If you think it's useful to only clear the dummy target's values, I can change the code to do that easily.

[clayborg]

So the "process handle" command allows us to set signals by signal number as well. Does this patch support this? It seems like it wouldn't be too hard to do if we wanted to handle this. Lemme know what you think, other than that LGTM.

lldb/include/lldb/Target/Target.h

1421

Makes sense.

[jingham]

In D126259#3534729, @clayborg wrote:

So the "process handle" command allows us to set signals by signal number as well. Does this patch support this? It seems like it wouldn't be too hard to do if we wanted to handle this. Lemme know what you think, other than that LGTM.

Ah, I forgot about specifying the signal by number. Before you have a process I don't think we should allow signals by number. The mapping signal number -> "signal name for any platform" is not 1-1 so we couldn't guarantee we were doing the right thing here. I'll put in a check for "specified by number with no process" and error out.

[clayborg]

In D126259#3534919, @jingham wrote:

In D126259#3534729, @clayborg wrote:

So the "process handle" command allows us to set signals by signal number as well. Does this patch support this? It seems like it wouldn't be too hard to do if we wanted to handle this. Lemme know what you think, other than that LGTM.

Ah, I forgot about specifying the signal by number. Before you have a process I don't think we should allow signals by number. The mapping signal number -> "signal name for any platform" is not 1-1 so we couldn't guarantee we were doing the right thing here. I'll put in a check for "specified by number with no process" and error out.

I would add a test for this and make sure it fails gracefully in that case

[jingham]

Don't allow setting signal actions by signal number before you have a process.

We don't know what signal 20 is going to end up being till we have a process, so allowing this by number doesn't make sense.

[jingham]

In D126259#3534944, @clayborg wrote:

In D126259#3534919, @jingham wrote:

In D126259#3534729, @clayborg wrote:

So the "process handle" command allows us to set signals by signal number as well. Does this patch support this? It seems like it wouldn't be too hard to do if we wanted to handle this. Lemme know what you think, other than that LGTM.

Ah, I forgot about specifying the signal by number. Before you have a process I don't think we should allow signals by number. The mapping signal number -> "signal name for any platform" is not 1-1 so we couldn't guarantee we were doing the right thing here. I'll put in a check for "specified by number with no process" and error out.

I would add a test for this and make sure it fails gracefully in that case

I added that. You get an error from the command saying you can't set signal actions by number w/o a process.

[clayborg]

In D126259#3534997, @jingham wrote:

Don't allow setting signal actions by signal number before you have a process.

I understand

We don't know what signal 20 is going to end up being till we have a process, so allowing this by number doesn't make sense.

I am saying that it would be a good idea to make sure an error is returned when you do try and set a signal by number before a process exists and make sure there is a test that covers this if it isn't already in the current patch.

[jingham]

In D126259#3535004, @clayborg wrote:

In D126259#3534997, @jingham wrote:

Don't allow setting signal actions by signal number before you have a process.

I understand

We don't know what signal 20 is going to end up being till we have a process, so allowing this by number doesn't make sense.

I am saying that it would be a good idea to make sure an error is returned when you do try and set a signal by number before a process exists and make sure there is a test that covers this if it isn't already in the current patch.

I think we crossed paths. I added that in the last update of the diff. The test is TestHandleProcess.py:20, and the code to enforce it starts around 1671 of CommandObjectProcess.cpp.

[clayborg]

In D126259#3535688, @jingham wrote:

In D126259#3535004, @clayborg wrote:

In D126259#3534997, @jingham wrote:

Don't allow setting signal actions by signal number before you have a process.

I understand

We don't know what signal 20 is going to end up being till we have a process, so allowing this by number doesn't make sense.

I am saying that it would be a good idea to make sure an error is returned when you do try and set a signal by number before a process exists and make sure there is a test that covers this if it isn't already in the current patch.

I think we crossed paths. I added that in the last update of the diff. The test is TestHandleProcess.py:20, and the code to enforce it starts around 1671 of CommandObjectProcess.cpp.

I see it, it is hard to tell what got updated. Thanks for the info.

[JDevlieghere]

lldb/include/lldb/Target/Target.h

1451

Was Args supposed to be a reference here? If not why do we need the copy?

I didn't look at the implementation yet, but why do we need num_signals? Can't we count the number of args?

1533

Does it matter that these are ordered? Can this use a llvm::StringMap?

lldb/source/Commands/CommandObjectProcess.cpp

1477–1479

Let's initialize these to the same values as Clear.

1582

Not your change but why Target * and not Target &?

lldb/source/Target/Process.cpp

2940–2943

Clang format

lldb/source/Target/Target.cpp

293–294

Instead of having to pass an empty Args here, can we make the input argument an Optional<Args> = {}? Then we can just call ClearDummySignals here. This looks like signal_args is an output argument.

3365

It seems like this can take a std::stringand std::move it into the pair below. Or a StringRef if you turn this into a StringMap as per the other suggestion.

3374–3382

With a StringMap you can simplify all of this into:

auto& entry = m_dummy_signals[name];
entry.pass = pass;
entry.notify = notify;
...

3394–3397

I'm wondering if we can simplify this with a little utility function. Something like this:

static void helper(LazyBool b, std::function<void(bool)> f) {
  switch(b) {
    case eLazyBoolYes:
      return f(true);
    case eLazyBookFalse:
      return f(false);
    case eLazyBoolCalculate:
      return;
  }
  llvm_unreachable("all cases handled");
}

That way we can simplify this:

helper(elem.second.pass, [](bool b) { signals_sp->SetShouldSuppress(signo, b); });

3444–3446

Should this have been

if (process_sp)
    signals_sp = process_sp->GetUnixSignals();

Now signals_sp is never initialized.

3466–3472

This seems super useful. Maybe this function, together with the other utility I suggested, can go in a LazyBoolUtils or something in Utility.

[jingham]

Address Jonas' review comments

lldb/include/lldb/Target/Target.h

1451

Args should be a reference, that was an oversight. Thanks for catching that.

The num_signals was to make the function parallel to the one that printed the process symbols, but wasn't necessary for the dummy signals, so I removed it.

1533

This is a map that's going to have a most a small handful of elements and is not on a critical path for access/copying/etc, so I don't think the actual container matters much. StringMap is marginally nicer when we set the value, so I switched to it.

lldb/source/Commands/CommandObjectProcess.cpp

1477–1479

I generally don't initialize the Option ivars on construction, on the grounds that it will mislead people into thinking the initialized values actually matter, which they don't. They are never used nor should they be. You always have to call OptionParsingStarting before reading in values for the Options, and you have to reset all the variables there.

But if it bugs you, I can add it.

1582

I don't know. That code is confused anyway, because GetSelectedTarget returns a Target &, but the variable is called target_sp meaning at some point in the past this must have been a TargetSP?

Anyway, CommandObject::GetSelectedOrDummyTarget always returns a valid target, so I changed this to Target & and took off the spurious _sp

lldb/source/Target/Target.cpp

3365

I just changed the API to take a StringRef.

3374–3382

Nice.

3394–3397

If you don't mind, I'd rather not do that.

The utility function is a little too narrow to be generally useful, since it only works on functions that take one bool and return void. And if we add the utility function here, then between it and the usages, the code I have already is IMO a lot easier to read.

3444–3446

Yup. That was a "prettifying the patch for it's diff" mis-change. It caused the test to crash, so I just made it right again.

3466–3472

This utility asserts a meaning for the three values which might or might not be appropriate in other circumstances. Given it's so simple to write, I think it's better to let the use site choose what the appropriate text is for the three value than appear to be mandating it.

[JDevlieghere]

LGTM

lldb/source/Commands/CommandObjectProcess.cpp

1477–1479

I vaguely remember at least one bug where we were using an uninitialized value, but maybe the problem there was that we didn't call OptionParsingStarting. If it's possible to forget to call that, then we should have an assert enforce that, but that's beyond the scope of this patch.

[jingham]

lldb/source/Commands/CommandObjectProcess.cpp

1477–1479

OptionParsingStarting is called for the CommandObjects by the Command runner, so it shouldn't be possible to have that not happen. But this is indeed a requirement, so it would be worthwhile putting in some kind of assert for this if it's possible.

But the easier mistake to make (and one of the reasons why I'm still a little in favor of not initializing) is to initialize the variable when you add it to Options, but forget to add it to OptionsParsingStarting. Then you end up getting stale values, and since some of these can be object pointers, you can crash from that.

But I don't know how you would write an assert (short of source analysis) that "all ivars of this class must get reset in method X"...

lldb/include/lldb/Target/Target.h

lldb::REPLSP GetREPL(Status &err, lldb::LanguageType language,
                        const char *repl_options, bool can_create);
 
   void SetREPL(lldb::LanguageType language, lldb::REPLSP repl_sp);
 
   StackFrameRecognizerManager &GetFrameRecognizerManager() {
     return *m_frame_recognizer_manager_up;
   }
 
+  /// Add a signal for the target.  This will get copied over to the process
+  /// if the signal exists on that target.  Only the values with Yes and No are
+  /// set, Calculate values will be ignored.
+protected:
+  struct DummySignalValues {
+    LazyBool pass = eLazyBoolCalculate;
+    LazyBool notify = eLazyBoolCalculate;
+    LazyBool stop = eLazyBoolCalculate;
+    DummySignalValues(LazyBool pass, LazyBool notify, LazyBool stop) : 
+        pass(pass), notify(notify), stop(stop) {}
+    DummySignalValues() = default;
+  };
+  using DummySignalElement = llvm::StringMapEntry<DummySignalValues>;
+  static bool UpdateSignalFromDummy(lldb::UnixSignalsSP signals_sp, 
+      const DummySignalElement &element);
+  static bool ResetSignalFromDummy(lldb::UnixSignalsSP signals_sp, 
+      const DummySignalElement &element);
+
+public:
+  /// Add a signal to the Target's list of stored signals/actions.  These
+  /// values will get copied into any processes launched from
+  /// this target.
+  void AddDummySignal(llvm::StringRef name, LazyBool pass, LazyBool print, 
+                      LazyBool stop);
+  /// Updates the signals in signals_sp using the stored dummy signals.
+  /// If warning_stream_sp is not null, if any stored signals are not found in
+  /// the current process, a warning will be emitted here.
+  void UpdateSignalsFromDummy(lldb::UnixSignalsSP signals_sp, 
+                              lldb::StreamSP warning_stream_sp);
+  /// Clear the dummy signals in signal_names from the target, or all signals
+  /// if signal_names is empty.  Also remove the behaviors they set from the
+  /// process's signals if it exists. 
+  void ClearDummySignals(Args &signal_names);
+  /// Print all the signals set in this target.
+  void PrintDummySignals(Stream &strm, Args &signals);
+
 protected:
   /// Implementing of ModuleList::Notifier.
 
   void NotifyModuleAdded(const ModuleList &module_list,
                          const lldb::ModuleSP &module_sp) override;
 
   void NotifyModuleRemoved(const ModuleList &module_list,
                            const lldb::ModuleSP &module_sp) override;
public:
 
     const ArchSpec &GetSpec() const { return m_spec; }
     Architecture *GetPlugin() const { return m_plugin_up.get(); }
 
   private:
     ArchSpec m_spec;
     std::unique_ptr<Architecture> m_plugin_up;
   };
+
   // Member variables.
   Debugger &m_debugger;
   lldb::PlatformSP m_platform_sp; ///< The platform for this target.
   std::recursive_mutex m_mutex; ///< An API mutex that is used by the lldb::SB*
                                 /// classes make the SB interface thread safe
   /// When the private state thread calls SB API's - usually because it is
   /// running OS plugin or Python ThreadPlan code - it should not block on the
   /// API mutex that is held by the code that kicked off the sequence of events
protected:
   bool m_suppress_stop_hooks; /// Used to not run stop hooks for expressions
   bool m_is_dummy_target;
   unsigned m_next_persistent_variable_index = 0;
   /// An optional \a lldb_private::Trace object containing processor trace
   /// information of this target.
   lldb::TraceSP m_trace_sp;
   /// Stores the frame recognizers of this target.
   lldb::StackFrameRecognizerManagerUP m_frame_recognizer_manager_up;
+  /// These are used to set the signal state when you don't have a process and 
+  /// more usefully in the Dummy target where you can't know exactly what
+  /// signals you will have.
+  llvm::StringMap<DummySignalValues> m_dummy_signals;
 
   static void ImageSearchPathsChanged(const PathMappingList &path_list,
                                       void *baton);
 
   // Utilities for `statistics` command.
 private:
   // Target metrics storage.
   TargetStats m_stats;

lldb/include/lldb/Target/UnixSignals.h

public:
   bool SetShouldStop(int32_t signo, bool value);
   bool SetShouldStop(const char *signal_name, bool value);
 
   bool GetShouldNotify(int32_t signo) const;
 
   bool SetShouldNotify(int32_t signo, bool value);
 
   bool SetShouldNotify(const char *signal_name, bool value);
   
+  bool ResetSignal(int32_t signo, bool reset_stop = true, 
+                   bool reset_notify = true, bool reset_suppress = true);
+
   // These provide an iterator through the signals available on this system.
   // Call GetFirstSignalNumber to get the first entry, then iterate on
   // GetNextSignalNumber till you get back LLDB_INVALID_SIGNAL_NUMBER.
   int32_t GetFirstSignalNumber() const;
 
   int32_t GetNextSignalNumber(int32_t current_signal) const;
 
   int32_t GetNumSignals() const;
protected:
   // Classes that inherit from UnixSignals can see and modify these
 
   struct Signal {
     ConstString m_name;
     ConstString m_alias;
     std::string m_description;
     uint32_t m_hit_count = 0;
     bool m_suppress : 1, m_stop : 1, m_notify : 1;
+    bool m_default_suppress : 1, m_default_stop : 1, m_default_notify : 1;
 
     Signal(const char *name, bool default_suppress, bool default_stop,
            bool default_notify, const char *description, const char *alias);
 
     ~Signal() = default;
+    void Reset(bool reset_stop, bool reset_notify, bool reset_suppress);
   };
 
   virtual void Reset();
 
   typedef std::map<int32_t, Signal> collection;
 
   collection m_signals;
 

lldb/packages/Python/lldbsuite/test/lldbutil.py

if platform and platform.IsValid():
         signals = platform.GetUnixSignals()
         if signals.IsValid():
             signal_number = signals.GetSignalNumberFromName(signal_name)
             if signal_number > 0:
                 return signal_number
     # No remote platform; fall back to using local python signals.
     return getattr(signal, signal_name)
 
+def get_actions_for_signal(testcase, signal_name, from_target=False, expected_absent=False):
+    """Returns a triple of (pass, stop, notify)"""
+    return_obj = lldb.SBCommandReturnObject()
+    command = "process handle {0}".format(signal_name)
+    if from_target:
+        command += " -t"
+    testcase.dbg.GetCommandInterpreter().HandleCommand(
+        command, return_obj)
+    match = re.match(
+        'NAME *PASS *STOP *NOTIFY.*(false|true|not set) *(false|true|not set) *(false|true|not set)',
+        return_obj.GetOutput(),
+        re.IGNORECASE | re.DOTALL)
+    if match and expected_absent:
+        testcase.fail('Signal "{0}" was supposed to be absent'.format(signal_name))
+    if not match:
+        if expected_absent:
+            return (None, None, None)
+        testcase.fail('Unable to retrieve default signal disposition.')
+    return (match.group(1), match.group(2), match.group(3))
+
+
+
+def set_actions_for_signal(testcase, signal_name, pass_action, stop_action, notify_action, expect_success=True):
+        return_obj = lldb.SBCommandReturnObject()
+        command = "process handle {0}".format(signal_name)
+        if pass_action != None:
+            command += " -p {0}".format(pass_action)
+        if stop_action != None:
+            command += " -s {0}".format(stop_action)
+        if notify_action != None:
+            command +=" -n {0}".format(notify_action)
+            
+        testcase.dbg.GetCommandInterpreter().HandleCommand(command, return_obj)
+        testcase.assertEqual(expect_success,
+            return_obj.Succeeded(), 
+            "Setting signal handling for {0} worked as expected".format(signal_name))
 
 class PrintableRegex(object):
 
     def __init__(self, text):
         self.regex = re.compile(text)
         self.text = text
 
     def match(self, str):

lldb/source/Commands/CommandObjectProcess.cpp

public:
     ~CommandOptions() override = default;
 
     Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg,
                           ExecutionContext *execution_context) override {
       Status error;
       const int short_option = m_getopt_table[option_idx].val;
 
       switch (short_option) {
+      case 'c':
+        do_clear = true;
+        break;
+      case 'd':
+        dummy = true;
+        break;
       case 's':
         stop = std::string(option_arg);
         break;
       case 'n':
         notify = std::string(option_arg);
         break;
       case 'p':
         pass = std::string(option_arg);
         break;
+      case 't':
+        only_target_values = true;
+        break;
       default:
         llvm_unreachable("Unimplemented option");
       }
       return error;
     }
 
     void OptionParsingStarting(ExecutionContext *execution_context) override {
       stop.clear();
       notify.clear();
       pass.clear();
+      only_target_values = false;
+      do_clear = false;
+      dummy = false;
     }
 
     llvm::ArrayRef<OptionDefinition> GetDefinitions() override {
       return llvm::makeArrayRef(g_process_handle_options);
     }
 
     // Instance variables to hold the values for command options.
 
     std::string stop;
     std::string notify;
     std::string pass;
+    bool only_target_values = false;
+    bool do_clear = false;
+    bool dummy = false;
   };
 
   CommandObjectProcessHandle(CommandInterpreter &interpreter)
       : CommandObjectParsed(interpreter, "process handle",
                             "Manage LLDB handling of OS signals for the "
                             "current target process.  Defaults to showing "
                             "current policy.",
-                            nullptr, eCommandRequiresTarget) {
-    SetHelpLong("\nIf no signals are specified, update them all.  If no update "
-                "option is specified, list the current values.");
+                            nullptr) {
+    SetHelpLong("\nIf no signals are specified but one or more actions are, "
+                "and there is a live process, update them all.  If no action "
+                "is specified, list the current values.\n"
+                "If you specify actions with no target (e.g. in an init file) "
+                "or in a target with no process "
+                "the values will get copied into subsequent targets, but "
+                "lldb won't be able to spell-check the options since it can't "
+                "know which signal set will later be in force."
+                "\nYou can see the signal modifications held by the target"
+                "by passing the -t option."
+                "\nYou can also clear the target modification for a signal"
+                "by passing the -c option");
     CommandArgumentEntry arg;
     CommandArgumentData signal_arg;
 
     signal_arg.arg_type = eArgTypeUnixSignal;
     signal_arg.arg_repetition = eArgRepeatStar;
 
     arg.push_back(signal_arg);
 
if (num_valid_signals > 0) {
                     signals_sp);
         signo = signals_sp->GetNextSignalNumber(signo);
       }
     }
   }
 
 protected:
   bool DoExecute(Args &signal_args, CommandReturnObject &result) override {
-    Target *target_sp = &GetSelectedTarget();
+    Target &target = GetSelectedOrDummyTarget();
 
-    ProcessSP process_sp = target_sp->GetProcessSP();
-
-    if (!process_sp) {
-      result.AppendError("No current process; cannot handle signals until you "
-                         "have a valid process.\n");
-      return false;
-    }
+    // Any signals that are being set should be added to the Target's 
+    // DummySignals so they will get applied on rerun, etc.
+    // If we have a process, however, we can do a more accurate job of vetting
+    // the user's options.
+    ProcessSP process_sp = target.GetProcessSP();
 
     int stop_action = -1;   // -1 means leave the current setting alone
     int pass_action = -1;   // -1 means leave the current setting alone
     int notify_action = -1; // -1 means leave the current setting alone
 
     if (!m_options.stop.empty() &&
         !VerifyCommandOptionValue(m_options.stop, stop_action)) {
       result.AppendError("Invalid argument for command option --stop; must be "
bool DoExecute(Args &signal_args, CommandReturnObject &result) override {
     }
 
     if (!m_options.pass.empty() &&
         !VerifyCommandOptionValue(m_options.pass, pass_action)) {
       result.AppendError("Invalid argument for command option --pass; must be "
                          "true or false.\n");
       return false;
     }
     
+    bool no_actions = (stop_action == -1 && pass_action == -1 
+        && notify_action == -1);
+    if (m_options.only_target_values && !no_actions) {
+      result.AppendError("-t is for reporting, not setting, target values.");
+      return false;
+    }
+
     size_t num_args = signal_args.GetArgumentCount();
-    UnixSignalsSP signals_sp = process_sp->GetUnixSignals();
+    UnixSignalsSP signals_sp;
+    if (process_sp)
+      signals_sp = process_sp->GetUnixSignals();
+
     int num_signals_set = 0;
 
+    // If we were just asked to print the target values, do that here and
+    // return:
+    if (m_options.only_target_values) {
+      target.PrintDummySignals(result.GetOutputStream(), signal_args);
+      result.SetStatus(eReturnStatusSuccessFinishResult);
+      return true;
+    }
+
+    // This handles clearing values:
+    if (m_options.do_clear) {
+      target.ClearDummySignals(signal_args);
+      if (m_options.dummy)
+        GetDummyTarget().ClearDummySignals(signal_args);
+      result.SetStatus(eReturnStatusSuccessFinishNoResult);
+      return true;
+    }
+
+    // This rest handles setting values:
     if (num_args > 0) {
       for (const auto &arg : signal_args) {
+        // Do the process first.  If we have a process we can catch
+        // invalid signal names, which we do here.
+        if (signals_sp) {
           int32_t signo = signals_sp->GetSignalNumberFromName(arg.c_str());
           if (signo != LLDB_INVALID_SIGNAL_NUMBER) {
             // Casting the actions as bools here should be okay, because
             // VerifyCommandOptionValue guarantees the value is either 0 or 1.
             if (stop_action != -1)
               signals_sp->SetShouldStop(signo, stop_action);
             if (pass_action != -1) {
               bool suppress = !pass_action;
               signals_sp->SetShouldSuppress(signo, suppress);
             }
             if (notify_action != -1)
               signals_sp->SetShouldNotify(signo, notify_action);
             ++num_signals_set;
           } else {
             result.AppendErrorWithFormat("Invalid signal name '%s'\n",
                                           arg.c_str());
+            continue;
+          }
+        } else {
+          // If there's no process we can't check, so we just set them all.
+          // But since the map signal name -> signal number across all platforms
+          // is not 1-1, we can't sensibly set signal actions by number before
+          // we have a process.  Check that here:
+          int32_t signo;
+          if (llvm::to_integer(arg.c_str(), signo)) {
+            result.AppendErrorWithFormat("Can't set signal handling by signal "
+                                         "number with no process");
+            return false;
           }
+         num_signals_set = num_args;
+        }
+        auto set_lazy_bool = [] (int action) -> LazyBool {
+          LazyBool lazy;
+          if (action == -1) 
+            lazy = eLazyBoolCalculate;
+          else if (action) 
+            lazy = eLazyBoolYes;
+          else
+            lazy = eLazyBoolNo;
+          return lazy;
+        };
+
+        // If there were no actions, we're just listing, don't add the dummy:
+        if (!no_actions)
+          target.AddDummySignal(arg.ref(),
+                                set_lazy_bool(pass_action),
+                                set_lazy_bool(notify_action),
+                                set_lazy_bool(stop_action));
       }
     } else {
       // No signal specified, if any command options were specified, update ALL
-      // signals.
-      if ((notify_action != -1) || (stop_action != -1) || (pass_action != -1)) {
+      // signals.  But we can't do this without a process since we don't know
+      // all the possible signals that might be valid for this target.
+      if (((notify_action != -1) || (stop_action != -1) || (pass_action != -1))
+          && process_sp) {
         if (m_interpreter.Confirm(
                 "Do you really want to update all the signals?", false)) {
           int32_t signo = signals_sp->GetFirstSignalNumber();
           while (signo != LLDB_INVALID_SIGNAL_NUMBER) {
             if (notify_action != -1)
               signals_sp->SetShouldNotify(signo, notify_action);
             if (stop_action != -1)
               signals_sp->SetShouldStop(signo, stop_action);
             if (pass_action != -1) {
               bool suppress = !pass_action;
               signals_sp->SetShouldSuppress(signo, suppress);
             }
             signo = signals_sp->GetNextSignalNumber(signo);
           }
         }
       }
     }
 
+    if (signals_sp)
       PrintSignalInformation(result.GetOutputStream(), signal_args,
                              num_signals_set, signals_sp);
+    else
+      target.PrintDummySignals(result.GetOutputStream(), 
+          signal_args);
 
     if (num_signals_set > 0)
-      result.SetStatus(eReturnStatusSuccessFinishNoResult);
+      result.SetStatus(eReturnStatusSuccessFinishResult);
     else
       result.SetStatus(eReturnStatusFailed);
 
     return result.Succeeded();
   }
 
   CommandOptions m_options;
 };

lldb/source/Commands/Options.td

 let Command = "process load" in {
   def process_load_install : Option<"install", "i">, OptionalArg<"Path">,
     Desc<"Install the shared library to the target. If specified without an "
     "argument then the library will installed in the current working "
     "directory.">;
 }
 
 let Command = "process handle" in {
+  def process_handle_clear : Option<"clear", "c">, Group<2>,
+    Desc<"Removes the signals listed from the Target signal handlers">;
   def process_handle_stop : Option<"stop", "s">, Group<1>, Arg<"Boolean">,
     Desc<"Whether or not the process should be stopped if the signal is "
     "received.">;
   def process_handle_notify : Option<"notify", "n">, Group<1>, Arg<"Boolean">,
     Desc<"Whether or not the debugger should notify the user if the signal is "
     "received.">;
   def process_handle_pass : Option<"pass", "p">, Group<1>, Arg<"Boolean">,
     Desc<"Whether or not the signal should be passed to the process.">;
+  def process_handle_only_target : Option<"target", "t">, Group<1>,
+    Desc<"Show only the signals with behaviors modified in this target">;
+  def process_handle_dummy : Option<"dummy", "d">, Group<2>,
+    Desc<"Also clear the values in the dummy target so they won't be inherited by new targets.">;
 }
 
 let Command = "process status" in {
   def process_status_verbose : Option<"verbose", "v">, Group<1>,
     Desc<"Show verbose process status including extended crash information.">;
 }
 
 let Command = "process save_core" in {

lldb/source/Target/Process.cpp

if (state == eStateExited) {
     // We exited while trying to launch somehow.  Don't call DidLaunch
     // as that's not likely to work, and return an invalid pid.
     HandlePrivateEvent(event_sp);
     return Status();
   }
 
   if (state == eStateStopped || state == eStateCrashed) {
     DidLaunch();
     
+    // Now that we know the process type, update its signal responses from the 
+    // ones stored in the Target:
+    if (m_unix_signals_sp) {
+      StreamSP warning_strm = GetTarget().GetDebugger().GetAsyncErrorStream();
+      GetTarget().UpdateSignalsFromDummy(m_unix_signals_sp, warning_strm);
+    }
+
     DynamicLoader *dyld = GetDynamicLoader();
     if (dyld)
       dyld->DidLaunch();
 
     GetJITLoaders().DidLaunch();
 
     SystemRuntime *system_runtime = GetSystemRuntime();
     if (system_runtime)
if (target_arch.IsValid() &&
         LLDB_LOGF(log,
                   "Process::%s switching architecture to %s based on info "
                   "the platform retrieved for pid %" PRIu64,
                   __FUNCTION__, process_arch.GetTriple().getTriple().c_str(),
                   GetID());
       }
     }
   }
+  // Now that we know the process type, update its signal responses from the 
+  // ones stored in the Target:
+  if (m_unix_signals_sp) {
+    StreamSP warning_strm = GetTarget().GetDebugger().GetAsyncErrorStream();
+    GetTarget().UpdateSignalsFromDummy(m_unix_signals_sp, warning_strm);
+  }
 
   // We have completed the attach, now it is time to find the dynamic loader
   // plug-in
   DynamicLoader *dyld = GetDynamicLoader();
   if (dyld) {
     dyld->DidAttach();
     if (log) {
       ModuleSP exe_module_sp = GetTarget().GetExecutableModule();

lldb/source/Target/Target.cpp

 #include "lldb/Target/LanguageRuntime.h"
 #include "lldb/Target/Process.h"
 #include "lldb/Target/SectionLoadList.h"
 #include "lldb/Target/StackFrame.h"
 #include "lldb/Target/StackFrameRecognizer.h"
 #include "lldb/Target/SystemRuntime.h"
 #include "lldb/Target/Thread.h"
 #include "lldb/Target/ThreadSpec.h"
+#include "lldb/Target/UnixSignals.h"
 #include "lldb/Utility/Event.h"
 #include "lldb/Utility/FileSpec.h"
 #include "lldb/Utility/LLDBAssert.h"
 #include "lldb/Utility/LLDBLog.h"
 #include "lldb/Utility/Log.h"
 #include "lldb/Utility/State.h"
 #include "lldb/Utility/StreamString.h"
 #include "lldb/Utility/Timer.h"
: TargetProperties(this),
       m_is_dummy_target(is_dummy_target),
       m_frame_recognizer_manager_up(
           std::make_unique<StackFrameRecognizerManager>()) {
   SetEventName(eBroadcastBitBreakpointChanged, "breakpoint-changed");
   SetEventName(eBroadcastBitModulesLoaded, "modules-loaded");
   SetEventName(eBroadcastBitModulesUnloaded, "modules-unloaded");
   SetEventName(eBroadcastBitWatchpointChanged, "watchpoint-changed");
   SetEventName(eBroadcastBitSymbolsLoaded, "symbols-loaded");
   
   CheckInWithManager();
 
   LLDB_LOG(GetLog(LLDBLog::Object), "{0} Target::Target()",
            static_cast<void *>(this));
   if (target_arch.IsValid()) {
     LLDB_LOG(GetLog(LLDBLog::Target),
              "Target::Target created with architecture {0} ({1})",
              target_arch.GetArchitectureName(),
void Target::PrimeFromDummyTarget(Target &target) {
   for (auto bp_name_entry : target.m_breakpoint_names) {
 
     BreakpointName *new_bp_name = new BreakpointName(*bp_name_entry.second);
     AddBreakpointName(new_bp_name);
   }
 
   m_frame_recognizer_manager_up = std::make_unique<StackFrameRecognizerManager>(
       *target.m_frame_recognizer_manager_up);
+
+  m_dummy_signals = target.m_dummy_signals;
 }
 
 void Target::Dump(Stream *s, lldb::DescriptionLevel description_level) {
   //    s->Printf("%.*p: ", (int)sizeof(void*) * 2, this);
   if (description_level != lldb::eDescriptionLevelBrief) {
     s->Indent();
     s->PutCString("Target\n");
     s->IndentMore();
void Target::Destroy() {
   m_internal_breakpoint_list.RemoveAll(notify);
   m_last_created_breakpoint.reset();
   m_last_created_watchpoint.reset();
   m_search_filter_sp.reset();
   m_image_search_paths.Clear(notify);
   m_stop_hooks.clear();
   m_stop_hook_next_id = 0;
   m_suppress_stop_hooks = false;
+  Args signal_args;
+  ClearDummySignals(signal_args);
 }
 
 llvm::StringRef Target::GetABIName() const {
   lldb::ABISP abi_sp;
   if (m_process_sp)
     abi_sp = m_process_sp->GetABI();
   if (!abi_sp)
     abi_sp = ABI::FindPlugin(ProcessSP(), GetArchitecture());
if (info.GetFlags().Test(eLaunchFlagDisableSTDIO)) {
       if (default_to_use_pty) {
         llvm::Error Err = info.SetUpPtyRedirection();
         LLDB_LOG_ERROR(log, std::move(Err), "SetUpPtyRedirection failed: {0}");
       }
     }
   }
 }
 
+void Target::AddDummySignal(llvm::StringRef name, LazyBool pass, LazyBool notify, 
+                            LazyBool stop) {
+    if (name.empty())
+      return;
+    // Don't add a signal if all the actions are trivial:
+    if (pass == eLazyBoolCalculate && notify == eLazyBoolCalculate
+        && stop == eLazyBoolCalculate)
+      return;
+
+    auto& elem = m_dummy_signals[name];
+    elem.pass = pass;
+    elem.notify = notify;
+    elem.stop = stop;
+}
+
+bool Target::UpdateSignalFromDummy(UnixSignalsSP signals_sp, 
+                                          const DummySignalElement &elem) {
+  if (!signals_sp)
+    return false;
+
+  int32_t signo 
+      = signals_sp->GetSignalNumberFromName(elem.first().str().c_str());
+  if (signo == LLDB_INVALID_SIGNAL_NUMBER)
+    return false;
+    
+  if (elem.second.pass == eLazyBoolYes)
+    signals_sp->SetShouldSuppress(signo, false);
+  else if (elem.second.pass == eLazyBoolNo)
+    signals_sp->SetShouldSuppress(signo, true);
+  
+  if (elem.second.notify == eLazyBoolYes)
+    signals_sp->SetShouldNotify(signo, true);
+  else if (elem.second.notify == eLazyBoolNo)
+    signals_sp->SetShouldNotify(signo, false);
+  
+  if (elem.second.stop == eLazyBoolYes)
+    signals_sp->SetShouldStop(signo, true);
+  else if (elem.second.stop == eLazyBoolNo)
+    signals_sp->SetShouldStop(signo, false);
+  return true;  
+}
+
+bool Target::ResetSignalFromDummy(UnixSignalsSP signals_sp, 
+                                          const DummySignalElement &elem) {
+  if (!signals_sp)
+    return false;
+  int32_t signo 
+      = signals_sp->GetSignalNumberFromName(elem.first().str().c_str());
+  if (signo == LLDB_INVALID_SIGNAL_NUMBER)
+    return false;
+  bool do_pass = elem.second.pass != eLazyBoolCalculate;
+  bool do_stop = elem.second.stop != eLazyBoolCalculate;
+  bool do_notify = elem.second.notify != eLazyBoolCalculate;
+  signals_sp->ResetSignal(signo, do_stop, do_notify, do_pass);
+  return true;
+}
+
+void Target::UpdateSignalsFromDummy(UnixSignalsSP signals_sp, 
+                                    StreamSP warning_stream_sp) {
+  if (!signals_sp)
+    return;
+
+  for (const auto &elem : m_dummy_signals) {
+    if (!UpdateSignalFromDummy(signals_sp, elem))
+      warning_stream_sp->Printf("Target signal '%s' not found in process\n", 
+          elem.first().str().c_str());
+  }
+}
+
+void Target::ClearDummySignals(Args &signal_names) {
+  ProcessSP process_sp = GetProcessSP();
+  // The simplest case, delete them all with no process to update.
+  if (signal_names.GetArgumentCount() == 0 && !process_sp) {
+    m_dummy_signals.clear();
+    return;
+  }
+  UnixSignalsSP signals_sp;
+  if (process_sp)
+    signals_sp = process_sp->GetUnixSignals();
+
+  for (const Args::ArgEntry &entry : signal_names) {
+    const char *signal_name = entry.c_str();
+    auto elem = m_dummy_signals.find(signal_name);
+    // If we didn't find it go on.
+    // FIXME: Should I pipe error handling through here?
+    if (elem == m_dummy_signals.end()) {
+      continue;
+    }
+    if (signals_sp)
+      ResetSignalFromDummy(signals_sp, *elem);
+    m_dummy_signals.erase(elem);
+  }
+}
+
+void Target::PrintDummySignals(Stream &strm, Args &signal_args) {
+  strm.Printf("NAME         PASS     STOP     NOTIFY\n");
+  strm.Printf("===========  =======  =======  =======\n");
+  
+  auto str_for_lazy = [] (LazyBool lazy) -> const char * {
+    switch (lazy) {
+      case eLazyBoolCalculate: return "not set";
+      case eLazyBoolYes: return "true   ";
+      case eLazyBoolNo: return "false  ";
+    }
+  };
+  size_t num_args = signal_args.GetArgumentCount();
+  for (const auto &elem : m_dummy_signals) {
+    bool print_it = false;
+    for (size_t idx = 0; idx < num_args; idx++) {
+      if (elem.first() == signal_args.GetArgumentAtIndex(idx)) {
+        print_it = true;
+        break;
+      }
+    }
+    if (print_it) {
+      strm.Printf("%-11s  ", elem.first().str().c_str());
+      strm.Printf("%s  %s  %s\n", str_for_lazy(elem.second.pass),
+                  str_for_lazy(elem.second.stop),
+                  str_for_lazy(elem.second.notify));
+    }
+  }
+}
+
 // Target::StopHook
 Target::StopHook::StopHook(lldb::TargetSP target_sp, lldb::user_id_t uid)
     : UserID(uid), m_target_sp(target_sp), m_specifier_sp(),
       m_thread_spec_up() {}
 
 Target::StopHook::StopHook(const StopHook &rhs)
     : UserID(rhs.GetID()), m_target_sp(rhs.m_target_sp),
       m_specifier_sp(rhs.m_specifier_sp), m_thread_spec_up(),

lldb/source/Target/UnixSignals.cpp

 using namespace lldb_private;
 using namespace llvm;
 
 UnixSignals::Signal::Signal(const char *name, bool default_suppress,
                             bool default_stop, bool default_notify,
                             const char *description, const char *alias)
     : m_name(name), m_alias(alias), m_description(),
       m_suppress(default_suppress), m_stop(default_stop),
-      m_notify(default_notify) {
+      m_notify(default_notify),
+      m_default_suppress(default_suppress), m_default_stop(default_stop),
+      m_default_notify(default_notify) {
   if (description)
     m_description.assign(description);
 }
 
 lldb::UnixSignalsSP UnixSignals::Create(const ArchSpec &arch) {
   const auto &triple = arch.GetTriple();
   switch (triple.getOS()) {
   case llvm::Triple::Linux: {
json::Value UnixSignals::GetHitCountStatistics() const {
   for (const auto &pair: m_signals) {
     if (pair.second.m_hit_count > 0)
       json_signals.emplace_back(json::Object{
         { pair.second.m_name.GetCString(), pair.second.m_hit_count }
       });
   }
   return std::move(json_signals);
 }
+
+void UnixSignals::Signal::Reset(bool reset_stop, bool reset_notify, 
+                                bool reset_suppress) {
+  if (reset_stop)
+    m_stop = m_default_stop;
+  if (reset_notify)
+    m_notify = m_default_notify;
+  if (reset_suppress)
+    m_suppress = m_default_suppress;
+}
+
+bool UnixSignals::ResetSignal(int32_t signo, bool reset_stop, 
+                                 bool reset_notify, bool reset_suppress) {
+    auto elem = m_signals.find(signo);
+    if (elem == m_signals.end())
+      return false;
+    (*elem).second.Reset(reset_stop, reset_notify, reset_suppress);
+    return true;
+}
+

lldb/test/API/commands/process/handle/Makefile

+CXX_SOURCES := main.cpp
+
+include Makefile.rules

lldb/test/API/commands/process/handle/TestProcessHandle.py

+import lldb
+from lldbsuite.test.lldbtest import *
+from lldbsuite.test import lldbutil
+from lldbsuite.test.decorators import *
+
+class TestProcessHandle(TestBase):
+
+    mydir = TestBase.compute_mydir(__file__)
+
+    @no_debug_info_test
+    @skipIfWindows
+    def test_process_handle(self):
+        """Test that calling process handle before we have a target, and before we
+           have a process will affect the process.  Also that the signal settings
+           are preserved on rerun."""
+        self.build()
+
+        # Make sure we don't accept signal values by signo with no process - we don't know what the
+        # mapping will be so we can't do the right thing with bare numbers:
+        lldbutil.set_actions_for_signal(self, "9", "true", None, None, expect_success=False)
+
+        # First, I need a reference value so I can see whether changes actually took:
+        (target, process, _, bkpt) = lldbutil.run_to_source_breakpoint(self, '// break here', lldb.SBFileSpec("main.cpp"))
+        (default_pass, default_stop, default_notify) = lldbutil.get_actions_for_signal(self, "SIGSEGV")
+        
+        # Let's change the value here, then exit and make sure the changed value sticks:
+        new_value = "false"
+        if default_pass == "true":
+            new_value = "false"
+
+        # First make sure we get an error for bogus values when running:
+        lldbutil.set_actions_for_signal(self, "NOTSIGSEGV", new_value, None, None, expect_success=False)
+
+        # Then set the one we intend to change.
+        lldbutil.set_actions_for_signal(self, "SIGSEGV", new_value, None, None)
+
+        process.Continue()
+        
+        self.assertEqual(process.GetState(), lldb.eStateExited)
+        self.assertEqual(process.GetExitStatus(), 0)
+        
+        # Check that we preserved the setting:
+        (curr_pass, curr_stop, curr_notify) = lldbutil.get_actions_for_signal(self, "SIGSEGV",from_target=True)
+        self.assertEqual(curr_pass, new_value, "Pass was set correctly")
+        self.assertEqual(curr_stop, "not set", "Stop was not set by us")
+        self.assertEqual(curr_notify, "not set", "Notify was not set by us")
+
+        # Run again and make sure that we prime the new process with these settings:
+        process = lldbutil.run_to_breakpoint_do_run(self, target, bkpt)
+
+        # We check the process settings now, to see what got copied into the process:
+        (curr_pass, curr_stop, curr_notify) = lldbutil.get_actions_for_signal(self, "SIGSEGV")
+        self.assertEqual(curr_pass, new_value, "Pass was set correctly")
+        self.assertEqual(curr_stop, default_stop, "Stop was its default value")
+        self.assertEqual(curr_notify, default_notify, "Notify was its default value")
+
+        # Now kill this target, set the handling and make sure the values get copied from the dummy into the new target.
+        success = self.dbg.DeleteTarget(target)
+        self.assertTrue(success, "Deleted the target")
+        self.assertEqual(self.dbg.GetNumTargets(), 0, "We did delete all the targets.")
+
+        # The signal settings should be back at their default - we were only setting this on the target:
+        lldbutil.get_actions_for_signal(self, "SIGSEGV", from_target=True, expected_absent=True)
+        # Set a valid one:
+        lldbutil.set_actions_for_signal(self, "SIGSEGV", new_value, None, None)
+        # Set a bogus one - we don't have a way to check pre-run so this is allowed
+        # but we should get an error message when launching:
+        lldbutil.set_actions_for_signal(self, "SIGNOTSIG", new_value, None, None)
+
+        out_filename = self.getBuildArtifact('output')
+        success = True
+        try:
+            f = open(out_filename, 'w')
+        except:
+            success = False
+
+        if not success:
+            self.fail("Couldn't open error output file for writing.")
+
+        self.dbg.SetErrorFileHandle(f, False)
+        # Now make a new process and make sure the right values got copied into the new target
+        (target, process, _, bkpt) = lldbutil.run_to_source_breakpoint(self, '// break here', lldb.SBFileSpec("main.cpp"))
+        f.write("TESTPATTERN\n")
+        f.flush()
+        f.close()
+
+        try:
+            f = open(out_filename, 'r')
+        except:
+            success = False
+
+        if not success:
+            self.fail("Couldn't open error output file for reading")
+        errors = f.read()
+        f.close()
+        
+        self.assertIn("SIGNOTSIG", errors, "We warned about the unset signal")
+        # Also make sure we didn't accidentally add this bogus setting to the process.
+        lldbutil.set_actions_for_signal(self, "SIGNOTSIG", "true", "true", "true", expect_success=False)
+        
+        # Check that they went into the target:
+        (curr_pass, curr_stop, curr_notify) = lldbutil.get_actions_for_signal(self, "SIGSEGV",from_target=True)
+        self.assertEqual(curr_pass, new_value, "Pass was set correctly")
+        self.assertEqual(curr_stop, "not set", "Stop was not set by us")
+        self.assertEqual(curr_notify, "not set", "Notify was not set by us")
+
+        # And the process:
+        # Check that they went into the target:
+        (curr_pass, curr_stop, curr_notify) = lldbutil.get_actions_for_signal(self, "SIGSEGV")
+        self.assertEqual(curr_pass, new_value, "Pass was set correctly")
+        self.assertEqual(curr_stop, default_stop, "Stop was its default value")
+        self.assertEqual(curr_notify, default_notify, "Notify was its default value")
+
+        # Now clear the handling, and make sure that we get the right signal values again:
+        self.runCmd("process handle -c SIGSEGV")
+        # Check that there is no longer configuration for SIGSEGV in the target:
+        lldbutil.get_actions_for_signal(self, "SIGSEGV",from_target=True, expected_absent=True)
+        # Make a new process, to make sure we did indeed reset the values:
+        (target, process, _, bkpt) = lldbutil.run_to_source_breakpoint(self, '// break here', lldb.SBFileSpec("main.cpp"))
+        (curr_pass, curr_stop, curr_notify) = lldbutil.get_actions_for_signal(self, "SIGSEGV")
+        self.assertEqual(curr_pass, new_value, "Pass was set correctly")
+        self.assertEqual(curr_stop, default_stop, "Stop was its default value")
+        self.assertEqual(curr_notify, default_notify, "Notify was its default value")
+
+        # Finally remove this from the dummy target as well, and make sure it was cleared from there:
+        self.runCmd("process handle -c -d SIGSEGV")
+        error = process.Kill()
+        self.assertSuccess(error, "Killed the process")
+        success = self.dbg.DeleteTarget(target)
+        self.assertTrue(success, "Destroyed the target.")
+        
+        (target, process, _, bkpt) = lldbutil.run_to_source_breakpoint(self, '// break here', lldb.SBFileSpec("main.cpp"))
+        (curr_pass, curr_stop, curr_notify) = lldbutil.get_actions_for_signal(self, "SIGSEGV")
+        self.assertEqual(curr_pass, default_pass, "Pass was set correctly")
+        self.assertEqual(curr_stop, default_stop, "Stop was its default value")
+        self.assertEqual(curr_notify, default_notify, "Notify was its default value")

lldb/test/API/commands/process/handle/main.cpp

+int main() {
+  return 0; // break here
+}

lldb/test/API/functionalities/signal/raise/TestRaise.py

class RaiseTestCase(TestBase):
 
     @skipIfNetBSD  # Hangs on NetBSD
     def test_sigtrap(self):
         self.build()
         self.signal_test('SIGTRAP', True)
 
     def launch(self, target, signal):
         # launch the process, do not stop at entry point.
+        # If we have gotten the default for this signal, reset that as well.
+        if len(self.default_pass) != 0:
+            lldbutil.set_actions_for_signal(self, signal, self.default_pass, self.default_stop, self.default_notify)
+
         process = target.LaunchSimple(
             [signal], None, self.get_process_working_directory())
         self.assertTrue(process, PROCESS_IS_VALID)
         self.assertEqual(process.GetState(), lldb.eStateStopped)
         thread = lldbutil.get_stopped_thread(
             process, lldb.eStopReasonBreakpoint)
         self.assertTrue(
             thread.IsValid(),
class RaiseTestCase(TestBase):
     def signal_test(self, signal, test_passing):
         """Test that we handle inferior raising signals"""
         exe = self.getBuildArtifact("a.out")
 
         # Create a target by the debugger.
         target = self.dbg.CreateTarget(exe)
         self.assertTrue(target, VALID_TARGET)
         lldbutil.run_break_set_by_symbol(self, "main")
+        self.default_pass = ""
+        self.default_stop = ""
+        self.default_notify = ""
 
         # launch
         process = self.launch(target, signal)
         signo = process.GetUnixSignals().GetSignalNumberFromName(signal)
 
         # retrieve default signal disposition
-        return_obj = lldb.SBCommandReturnObject()
-        self.dbg.GetCommandInterpreter().HandleCommand(
-            "process handle %s " % signal, return_obj)
-        match = re.match(
-            'NAME *PASS *STOP *NOTIFY.*(false|true) *(false|true) *(false|true)',
-            return_obj.GetOutput(),
-            re.IGNORECASE | re.DOTALL)
-        if not match:
-            self.fail('Unable to retrieve default signal disposition.')
-        default_pass = match.group(1)
-        default_stop = match.group(2)
-        default_notify = match.group(3)
+        (self.default_pass, self.default_stop, self.default_notify) = lldbutil.get_actions_for_signal(self, signal)
 
         # Make sure we stop at the signal
-        self.set_handle(signal, "false", "true", "true")
+        lldbutil.set_actions_for_signal(self, signal, "false", "true", "true")
         process.Continue()
         self.assertEqual(process.GetState(), lldb.eStateStopped)
         thread = lldbutil.get_stopped_thread(process, lldb.eStopReasonSignal)
         self.assertTrue(
             thread.IsValid(),
             "Thread should be stopped due to a signal")
         self.assertTrue(
             thread.GetStopReasonDataCount() >= 1,
             "There was data in the event.")
         self.assertEqual(thread.GetStopReasonDataAtIndex(0), signo,
                          "The stop signal was %s" % signal)
 
         # Continue until we exit.
         process.Continue()
         self.assertEqual(process.GetState(), lldb.eStateExited)
         self.assertEqual(process.GetExitStatus(), 0)
 
-        # launch again
         process = self.launch(target, signal)
 
         # Make sure we do not stop at the signal. We should still get the
         # notification.
-        self.set_handle(signal, "false", "false", "true")
+        lldbutil.set_actions_for_signal(self, signal, "false", "false", "true")
         self.expect(
             "process continue",
             substrs=[
                 "stopped and restarted",
                 signal])
         self.assertEqual(process.GetState(), lldb.eStateExited)
         self.assertEqual(process.GetExitStatus(), 0)
 
         # launch again
         process = self.launch(target, signal)
 
         # Make sure we do not stop at the signal, and we do not get the
         # notification.
-        self.set_handle(signal, "false", "false", "false")
+        lldbutil.set_actions_for_signal(self, signal, "false", "false", "false")
         self.expect(
             "process continue",
             substrs=["stopped and restarted"],
             matching=False)
         self.assertEqual(process.GetState(), lldb.eStateExited)
         self.assertEqual(process.GetExitStatus(), 0)
 
         if not test_passing:
             # reset signal handling to default
-            self.set_handle(signal, default_pass, default_stop, default_notify)
+            lldbutil.set_actions_for_signal(self, signal, self.default_pass, self.default_stop, self.default_notify)
             return
 
         # launch again
         process = self.launch(target, signal)
 
         # Make sure we stop at the signal
-        self.set_handle(signal, "true", "true", "true")
+        lldbutil.set_actions_for_signal(self, signal, "true", "true", "true")
         process.Continue()
         self.assertEqual(process.GetState(), lldb.eStateStopped)
         thread = lldbutil.get_stopped_thread(process, lldb.eStopReasonSignal)
         self.assertTrue(
             thread.IsValid(),
             "Thread should be stopped due to a signal")
         self.assertTrue(
             thread.GetStopReasonDataCount() >= 1,
def signal_test(self, signal, test_passing):
         self.assertEqual(process.GetState(), lldb.eStateExited)
         self.assertEqual(process.GetExitStatus(), signo)
 
         # launch again
         process = self.launch(target, signal)
 
         # Make sure we do not stop at the signal. We should still get the notification. Process
         # should receive the signal.
-        self.set_handle(signal, "true", "false", "true")
+        lldbutil.set_actions_for_signal(self, signal, "true", "false", "true")
         self.expect(
             "process continue",
             substrs=[
                 "stopped and restarted",
                 signal])
         self.assertEqual(process.GetState(), lldb.eStateExited)
         self.assertEqual(process.GetExitStatus(), signo)
 
         # launch again
         process = self.launch(target, signal)
 
         # Make sure we do not stop at the signal, and we do not get the notification. Process
         # should receive the signal.
-        self.set_handle(signal, "true", "false", "false")
+        lldbutil.set_actions_for_signal(self, signal, "true", "false", "false")
         self.expect(
             "process continue",
             substrs=["stopped and restarted"],
             matching=False)
         self.assertEqual(process.GetState(), lldb.eStateExited)
         self.assertEqual(process.GetExitStatus(), signo)
 
         # reset signal handling to default
-        self.set_handle(signal, default_pass, default_stop, default_notify)
+        lldbutil.set_actions_for_signal(self, signal, self.default_pass, self.default_stop, self.default_notify)

lldb/unittests/Signals/UnixSignalsTest.cpp

TEST(UnixSignalsTest, Iteration) {
   EXPECT_EQ(4, signals.GetNumSignals());
   EXPECT_EQ(2, signals.GetFirstSignalNumber());
   EXPECT_EQ(4, signals.GetNextSignalNumber(2));
   EXPECT_EQ(8, signals.GetNextSignalNumber(4));
   EXPECT_EQ(16, signals.GetNextSignalNumber(8));
   EXPECT_EQ(LLDB_INVALID_SIGNAL_NUMBER, signals.GetNextSignalNumber(16));
 }
 
+TEST(UnixSignalsTest, Reset) {
+  TestSignals signals;
+  bool stop_val     = signals.GetShouldStop(2);
+  bool notify_val   = signals.GetShouldNotify(2);
+  bool suppress_val = signals.GetShouldSuppress(2);
+  
+  // Change two, then reset one and make sure only that one was reset:
+  EXPECT_EQ(true, signals.SetShouldNotify(2, !notify_val));
+  EXPECT_EQ(true, signals.SetShouldSuppress(2, !suppress_val));
+  EXPECT_EQ(true, signals.ResetSignal(2, false, true, false));
+  EXPECT_EQ(stop_val, signals.GetShouldStop(2));
+  EXPECT_EQ(notify_val, signals.GetShouldStop(2));
+  EXPECT_EQ(!suppress_val, signals.GetShouldNotify(2));
+  
+  // Make sure reset with no arguments resets them all:
+  EXPECT_EQ(true, signals.SetShouldSuppress(2, !suppress_val));
+  EXPECT_EQ(true, signals.SetShouldNotify(2, !notify_val));
+  EXPECT_EQ(true, signals.ResetSignal(2));
+  EXPECT_EQ(stop_val, signals.GetShouldStop(2));
+  EXPECT_EQ(notify_val, signals.GetShouldNotify(2));
+  EXPECT_EQ(suppress_val, signals.GetShouldSuppress(2));
+}
+
 TEST(UnixSignalsTest, GetInfo) {
   TestSignals signals;
 
   bool should_suppress = false, should_stop = false, should_notify = false;
   int32_t signo = 4;
   std::string name =
       signals.GetSignalInfo(signo, should_suppress, should_stop, should_notify);
   EXPECT_EQ("SIG4", name);