[LLDB][GUI] Add Process Attach form

[OmarEmaraDev]

Summary

This patch adds a form window to attach a process, either by PID or by
name. This patch also adds support for dynamic field visibility such
that the form delegate can hide or show certain fields based on some
conditions.

[OmarEmaraDev]

I initially created two forms for attach by name and attach by PID, because the options were divided between them. Today I tried to reimplement that such that it is a single form with a choices field at the top that determines if it is by name or PID. The fields are then shown or hidden based on that enum. Additionally, other fields can control the visibility of other fields, for instance, the "Include existing processes" field. I think it works fine and the UX looks good. Here is an example, what do you think?

[clayborg]

lldb/source/Core/IOHandlerCursesGUI.cpp

1917

Do these actually need to be shared pointers? They can probably become std::unique_ptr<T> objects and the FieldDelegateSP would then become FieldDelegateUP after defining it as a unique_ptr

2185–2200

Spelling issue I missed before

2303

I am guessing that the first item in the list is always selected? Might be nice to provide a way for AddChoicesField to select a different item as the default selection with another optional parameter that is the index of the item that is to be selected. Doesn't have to happen in this diff, just thought of it and wanted to mention this.

2304

remove space

2305

I would be nice if we can eventually auto complete the PID by using the platform to get a list of processes. Sometimes we are not attached to a remote platform, but we are always attached to the host platform and should be able to get a list of process IDs. A new form could be popped up with all of the process details and allowing the user to filter processes with a TextField, then a ChoicesField that contains all valid processes the user could attach to with the pid, process name and possibly other details in the text for each choice. This doesn't need to be done now, but it would be a good extra functionality step to complete later if you get everything done on your list.

2306

remove space

2307

If we have a target, it might be nice to auto populate this field with the basename of the target's main executable.

2308

remove space

2309

Might be nice to iterate over all process plug-ins and make this into a ChoicesField where the first entry is "<default>" and the rest are actual plug-in names. The names can easily be retrieved using:

static const char *GetProcessPluginNameAtIndex(uint32_t idx);

from PluginManager.h

2310

remove space

2349

We might want to pop up a dialog here asking the user if they want to kill or detach since we have a GUI. In the "process attach" command we confirm with the user if the terminal is interactive.
A few ways we can do this:

• popup a form asking the user to kill/detach/cancel when the user hits submit on this form
• pop up the dialog before even showing the this form and asking the user to kill or detach, then show this form after that has been handled
• not allow the Process->Attach to happen by disabling the menu item when a process is running.

2370

We should select the target in he debugger here so that all GUI commands work correctly after this call if they ask the debugger for its selected target.

m_debugger.GetTargetList().SetSelectedTarget(...);

2423–2424

You shouldn't need to do this since you already called ProcessAttachInfo::SetContinueOnceAttached(true) on the attach_info. LLDB should take care of this for you already I think.

[OmarEmaraDev]

• Use unique pointers for field delegates.
• Fix typos in Select methods.
• Set the process name to the main executable name by default.
• Turn plugin name into a choice field.
• Update debugger target if a new one was created.
• Remove superfluous continue operation.

[OmarEmaraDev]

Currently working on the detach/kill form.

lldb/source/Core/IOHandlerCursesGUI.cpp

2349

I think the first option is the best, because it delays this decision at the very end giving the user as much time as possible to cancel attaching without altering the debugger state.

2423–2424

In the command code, there is this snippet of code at the end, so I though it might be necessary:

// This supports the use-case scenario of immediately continuing the
// process once attached.
if (m_options.attach_info.GetContinueOnceAttached())
  m_interpreter.HandleCommand("process continue", eLazyBoolNo, result);

[OmarEmaraDev]

• Add kill/detach form.
• Fix forms with no fields.

[OmarEmaraDev]

Updated UI:

Kill/Detach form.

[clayborg]

lldb/source/Core/IOHandlerCursesGUI.cpp

1837

You don't want to return a unique_ptr here, if you do something like:

FieldDelegateUP field_up = form->GetField(1);

You have now given away the one reference to this field to the local variable and it will destruct the item when the local goes out of scope.

Easy solution: just return a pointer, not a unique_ptr. The FormDelegate owns all of its fields, so it is ok to hand out a pointer as others should temporarily use the FieldDelegate. Also we should bounds check "field_index".

1988

2155–2156

2161

2178

2210–2211

2217

No need to use a std::unique_ptr here, and GetField should return a pointer as mentioned above.

2234–2235

2276

2300

When we have interaction, we should allow the user to select kill or detach. The GetShouldDetach is only for when the user doesn't interact. Can we use a ChoicesField for this with the two options? We can even go a step further and add three options: "Detach", "Detach (stopped)", and "Kill". This is easy since lldb_private::Process has this option on detach:

Status Process::Detach(bool keep_stopped);

When you detach with "keep_stopped" set to true the process will not resume. This allows another debugger to be attached, or someone to run another tool on the process in its suspended state.

2326

Does anyone remove the sub window if the user cancels this dialog?

2344–2345

most people when attaching won't ever specify the plug-in names. I wonder if we should include an extra boolean field that enables this? Maybe:

m_show_plugin_field = AddBooleanField("Show advanced settings.", false);

And then show/hide any settings that aren't commonly used like the "Plugin Name" field?

2391–2397

While loop might be easier here?

2420

Is the form for the kill/detach done by the time it reaches this code? If so, what if the user cancels the Kill/Detach dialog? Can we return false here if the user cancels?

[OmarEmaraDev]

• Return raw pointers instead of unique ones.
• Add Show Advance Settings option.
• Allow detaching and killing at the same time.
• Allow detaching while keeping process stopped.
• Handle review comments.

[OmarEmaraDev]

Two actions with an option:

lldb/source/Core/IOHandlerCursesGUI.cpp

1837

I see, I though returning it as a reference wouldn't case such issues.

2300

I think this might be a good place to add two actions with possible parameters, let me know if you think this would be a good idea.

2326

Yes. This is done in WindowDelegateHandleChar of the FormWindowDelegate.

2344–2345

This what I do for the launch and target creation forms. In this case, I didn't think it was worth it because it was just one field. But now that it is a choice field that takes a bit more space, maybe it would be a good idea to do this here as well.

2420

No, the return boolean here essentially denotes that a form for killing/detaching was spawned and that the attach form shouldn't continue executing. Once the user executes an action or cancels, the user will end up in the same attach from, where the user can execute attach again where it will succeed without the kill/detach dialog.

I can't think of a way to make the form block execution of another form until it is done without resorting to complicated trickery.

[clayborg]

I like the new detach/kill dialog as it incorporates many of your features that you added to the forms! Very close, just a few minor issues and this will be good to go.

lldb/source/Core/IOHandlerCursesGUI.cpp

1837

You are correct unless the caller of the function doesn't use a reference. All of the call sites you had in here were using references, so there wasn't an issue. But if someone else comes along and actually wrote code like the snipped I posted above, it would transfer ownership and that would be bad.

2050–2053

2420

Ok, thanks for the explanation. It makes sense.

2424

Should be easy to verify if it is needed or not. If it is, we will need to add it back.

[OmarEmaraDev]

• Manually continue if needed.

lldb/source/Core/IOHandlerCursesGUI.cpp

2424

Looks like it is actually needed. I added it it back.

[clayborg]

Looks good!

lldb/source/Core/IOHandlerCursesGUI.cpp

 #include "lldb/lldb-forward.h"
 
 #include "lldb/Interpreter/CommandCompletions.h"
 #include "lldb/Interpreter/CommandInterpreter.h"
 
 #if LLDB_ENABLE_CURSES
 #include "lldb/Breakpoint/BreakpointLocation.h"
 #include "lldb/Core/Module.h"
+#include "lldb/Core/PluginManager.h"
 #include "lldb/Core/ValueObject.h"
 #include "lldb/Core/ValueObjectRegister.h"
 #include "lldb/Symbol/Block.h"
 #include "lldb/Symbol/Function.h"
 #include "lldb/Symbol/Symbol.h"
 #include "lldb/Symbol/VariableList.h"
 #include "lldb/Target/Process.h"
 #include "lldb/Target/RegisterContext.h"
if (m_window && m_delete) {
       m_delete = false;
     }
     if (w) {
       m_window = w;
       m_panel = ::new_panel(m_window);
       m_delete = del;
     }
   }
-  //
+
   // Get the rectangle in our parent window
   Rect GetBounds() const { return Rect(GetParentOrigin(), GetSize()); }
+
+  Rect GetCenteredRect(int width, int height) {
+    Size size = GetSize();
+    width = std::min(size.width, width);
+    height = std::min(size.height, height);
+    int x = (size.width - width) / 2;
+    int y = (size.height - height) / 2;
+    return Rect(Point(x, y), Size(width, height));
+  }
+
   int GetChar() { return ::wgetch(m_window); }
   Point GetParentOrigin() const { return Point(GetParentX(), GetParentY()); }
   int GetParentX() const { return getparx(m_window); }
   int GetParentY() const { return getpary(m_window); }
   void MoveWindow(int x, int y) { MoveWindow(Point(x, y)); }
   void Resize(int w, int h) { ::wresize(m_window, h, w); }
   void Resize(const Size &size) {
     ::wresize(m_window, size.height, size.width);
public:
   // contains a single element.
   virtual bool FieldDelegateOnLastOrOnlyElement() { return true; }
 
   // Select the first element in the field if multiple elements exists.
   virtual void FieldDelegateSelectFirstElement() { return; }
 
   // Select the last element in the field if multiple elements exists.
   virtual void FieldDelegateSelectLastElement() { return; }
+
+  bool FieldDelegateIsVisible() { return m_is_visible; }
+
+  void FieldDelegateHide() { m_is_visible = false; }
+
+  void FieldDelegateShow() { m_is_visible = true; }
+
+protected:
+  bool m_is_visible = true;
 };
 
-typedef std::shared_ptr<FieldDelegate> FieldDelegateSP;
+typedef std::unique_ptr<FieldDelegate> FieldDelegateUP;
 
 class TextFieldDelegate : public FieldDelegate {
 public:
   TextFieldDelegate(const char *label, const char *content)
       : m_label(label), m_cursor_position(0), m_first_visibile_char(0) {
     if (content)
       m_content = content;
   }
public:
   bool HasError() { return !m_error.empty(); }
 
   void ClearError() { m_error.clear(); }
 
   const std::string &GetError() { return m_error; }
 
   void SetError(const char *error) { m_error = error; }
 
-  // Returns the text content of the field.
   const std::string &GetText() { return m_content; }
 
 protected:
   std::string m_label;
   // The position of the top left corner character of the border.
   std::string m_content;
   // The cursor position in the content string itself. Can be in the range
   // [0, GetContentLength()].
void RemoveField() {
     if (GetNumberOfFields() > 0) {
       m_selection_type = SelectionType::Field;
       FieldDelegate &field = m_fields[m_selection_index];
       field.FieldDelegateSelectFirstElement();
     } else
       m_selection_type = SelectionType::NewButton;
   }
 
-  HandleCharResult SelecteNext(int key) {
+  HandleCharResult SelectNext(int key) {
     if (m_selection_type == SelectionType::NewButton)
       return eKeyNotHandled;
 
     if (m_selection_type == SelectionType::RemoveButton) {
       if (m_selection_index == GetNumberOfFields() - 1) {
         m_selection_type = SelectionType::NewButton;
         return eKeyHandled;
       }
case KEY_ENTER:
       case SelectionType::RemoveButton:
         RemoveField();
         return eKeyHandled;
       default:
         break;
       }
       break;
     case '\t':
-      SelecteNext(key);
+      SelectNext(key);
       return eKeyHandled;
     case KEY_SHIFT_TAB:
       SelectPrevious(key);
       return eKeyHandled;
     default:
       break;
     }
 

 };
 
 class FormDelegate {
 public:
   FormDelegate() {}
 
   virtual ~FormDelegate() = default;
 
-  FieldDelegateSP &GetField(int field_index) { return m_fields[field_index]; }
+  virtual std::string GetName() = 0;
+
+  virtual void UpdateFieldsVisibility() { return; }
+
+  FieldDelegate *GetField(uint32_t field_index) {
+    if (field_index < m_fields.size())
+      return m_fields[field_index].get();
+    return nullptr;
+  }
 
   FormAction &GetAction(int action_index) { return m_actions[action_index]; }
 
   int GetNumberOfFields() { return m_fields.size(); }
 
   int GetNumberOfActions() { return m_actions.size(); }
 
   bool HasError() { return !m_error.empty(); }
 
   void ClearError() { m_error.clear(); }
 
   const std::string &GetError() { return m_error; }
 
   void SetError(const char *error) { m_error = error; }
 
   // Factory methods to create and add fields of specific types.
 
   TextFieldDelegate *AddTextField(const char *label, const char *content) {
     TextFieldDelegate *delegate = new TextFieldDelegate(label, content);
-    FieldDelegateSP delegate_sp = FieldDelegateSP(delegate);
-    m_fields.push_back(delegate_sp);
+    m_fields.push_back(FieldDelegateUP(delegate));
     return delegate;
   }
 
   FileFieldDelegate *AddFileField(const char *label, const char *content,
                                   bool need_to_exist = true) {
     FileFieldDelegate *delegate =
         new FileFieldDelegate(label, content, need_to_exist);
-    FieldDelegateSP delegate_sp = FieldDelegateSP(delegate);
-    m_fields.push_back(delegate_sp);
+    m_fields.push_back(FieldDelegateUP(delegate));
     return delegate;
   }
 
   DirectoryFieldDelegate *AddDirectoryField(const char *label,
                                             const char *content,
                                             bool need_to_exist = true) {
     DirectoryFieldDelegate *delegate =
         new DirectoryFieldDelegate(label, content, need_to_exist);
-    FieldDelegateSP delegate_sp = FieldDelegateSP(delegate);
-    m_fields.push_back(delegate_sp);
+    m_fields.push_back(FieldDelegateUP(delegate));
     return delegate;
   }
 
   IntegerFieldDelegate *AddIntegerField(const char *label, int content) {
     IntegerFieldDelegate *delegate = new IntegerFieldDelegate(label, content);
-    FieldDelegateSP delegate_sp = FieldDelegateSP(delegate);
-    m_fields.push_back(delegate_sp);
+    m_fields.push_back(FieldDelegateUP(delegate));
     return delegate;
   }
 
   BooleanFieldDelegate *AddBooleanField(const char *label, bool content) {
     BooleanFieldDelegate *delegate = new BooleanFieldDelegate(label, content);
-    FieldDelegateSP delegate_sp = FieldDelegateSP(delegate);
-    m_fields.push_back(delegate_sp);
+    m_fields.push_back(FieldDelegateUP(delegate));
     return delegate;
   }
 
   ChoicesFieldDelegate *AddChoicesField(const char *label, int height,
                                         std::vector<std::string> choices) {
     ChoicesFieldDelegate *delegate =
         new ChoicesFieldDelegate(label, height, choices);
-    FieldDelegateSP delegate_sp = FieldDelegateSP(delegate);
-    m_fields.push_back(delegate_sp);
+    m_fields.push_back(FieldDelegateUP(delegate));
     return delegate;
   }
 
   template <class T>
   ListFieldDelegate<T> *AddListField(const char *label, T default_field) {
     ListFieldDelegate<T> *delegate =
         new ListFieldDelegate<T>(label, default_field);
-    FieldDelegateSP delegate_sp = FieldDelegateSP(delegate);
-    m_fields.push_back(delegate_sp);
+    m_fields.push_back(FieldDelegateUP(delegate));
     return delegate;
   }
 
   // Factory methods for adding actions.
 
   void AddAction(const char *label, std::function<void(Window &)> action) {
     m_actions.push_back(FormAction(label, action));
   }
 
 protected:
-  std::vector<FieldDelegateSP> m_fields;
+  std::vector<FieldDelegateUP> m_fields;
   std::vector<FormAction> m_actions;
   // Optional error message. If empty, form is considered to have no error.
   std::string m_error;
 };
 
 typedef std::shared_ptr<FormDelegate> FormDelegateSP;
 
 class FormWindowDelegate : public WindowDelegate {
 public:
   FormWindowDelegate(FormDelegateSP &delegate_sp)
       : m_delegate_sp(delegate_sp), m_selection_index(0),
-        m_selection_type(SelectionType::Field), m_first_visible_line(0) {}
+        m_first_visible_line(0) {
+    assert(m_delegate_sp->GetNumberOfActions() > 0);
+    if (m_delegate_sp->GetNumberOfFields() > 0)
+      m_selection_type = SelectionType::Field;
+    else
+      m_selection_type = SelectionType::Action;
+  }
 
   // Signify which element is selected. If a field or an action is selected,
   // then m_selection_index signifies the particular field or action that is
   // selected.
   enum class SelectionType { Field, Action };
 
   // A form window is padded by one character from all sides. First, if an error
   // message exists, it is drawn followed by a separator. Then one or more
int GetActionsHeight() {
     return 0;
   }
 
   // Get the total number of needed lines to draw the contents.
   int GetContentHeight() {
     int height = 0;
     height += GetErrorHeight();
     for (int i = 0; i < m_delegate_sp->GetNumberOfFields(); i++) {
+      if (!m_delegate_sp->GetField(i)->FieldDelegateIsVisible())
+        continue;
       height += m_delegate_sp->GetField(i)->FieldDelegateGetHeight();
     }
     height += GetActionsHeight();
     return height;
   }
 
   ScrollContext GetScrollContext() {
     if (m_selection_type == SelectionType::Action)
       return ScrollContext(GetContentHeight() - 1);
 
-    FieldDelegateSP &field = m_delegate_sp->GetField(m_selection_index);
+    FieldDelegate *field = m_delegate_sp->GetField(m_selection_index);
     ScrollContext context = field->FieldDelegateGetScrollContext();
 
     int offset = GetErrorHeight();
     for (int i = 0; i < m_selection_index; i++) {
+      if (!m_delegate_sp->GetField(i)->FieldDelegateIsVisible())
+        continue;
       offset += m_delegate_sp->GetField(i)->FieldDelegateGetHeight();
     }
     context.Offset(offset);
 
     // If the context is touching the error, include the error in the context as
     // well.
     if (context.start == GetErrorHeight())
       context.start = 0;
void DrawError(SubPad &surface) {
     surface.HorizontalLine(surface.GetWidth());
   }
 
   void DrawFields(SubPad &surface) {
     int line = 0;
     int width = surface.GetWidth();
     bool a_field_is_selected = m_selection_type == SelectionType::Field;
     for (int i = 0; i < m_delegate_sp->GetNumberOfFields(); i++) {
+      FieldDelegate *field = m_delegate_sp->GetField(i);
+      if (!field->FieldDelegateIsVisible())
+        continue;
       bool is_field_selected = a_field_is_selected && m_selection_index == i;
-      FieldDelegateSP &field = m_delegate_sp->GetField(i);
       int height = field->FieldDelegateGetHeight();
       Rect bounds = Rect(Point(0, line), Size(width, height));
       SubPad field_surface = SubPad(surface, bounds);
       field->FieldDelegateDraw(field_surface, is_field_selected);
       line += height;
     }
   }
 
void DrawContent(DerivedWindow &surface) {
     DrawElements(elements_surface);
 
     int copy_height = std::min(surface.GetHeight(), pad.GetHeight());
     pad.CopyToSurface(surface, Point(0, m_first_visible_line), Point(),
                       Size(width, copy_height));
   }
 
   bool WindowDelegateDraw(Window &window, bool force) override {
+    m_delegate_sp->UpdateFieldsVisibility();
 
     window.Erase();
 
-    window.DrawTitleBox(window.GetName(), "Press Esc to cancel");
+    window.DrawTitleBox(m_delegate_sp->GetName().c_str(),
+                        "Press Esc to cancel");
 
     Rect content_bounds = window.GetFrame();
     content_bounds.Inset(2, 2);
     DerivedWindow content_surface = DerivedWindow(window, content_bounds);
 
     DrawContent(content_surface);
     return true;
   }
 
-  HandleCharResult SelecteNext(int key) {
+  void SkipNextHiddenFields() {
+    while (true) {
+      if (m_delegate_sp->GetField(m_selection_index)->FieldDelegateIsVisible())
+        return;
+
+      if (m_selection_index == m_delegate_sp->GetNumberOfFields() - 1) {
+        m_selection_type = SelectionType::Action;
+        m_selection_index = 0;
+        return;
+      }
+
+      m_selection_index++;
+    }
+  }
+
+  HandleCharResult SelectNext(int key) {
     if (m_selection_type == SelectionType::Action) {
       if (m_selection_index < m_delegate_sp->GetNumberOfActions() - 1) {
         m_selection_index++;
         return eKeyHandled;
       }
 
       m_selection_index = 0;
       m_selection_type = SelectionType::Field;
-      FieldDelegateSP &next_field = m_delegate_sp->GetField(m_selection_index);
+      SkipNextHiddenFields();
+      if (m_selection_type == SelectionType::Field) {
+        FieldDelegate *next_field = m_delegate_sp->GetField(m_selection_index);
         next_field->FieldDelegateSelectFirstElement();
+      }
       return eKeyHandled;
     }
 
-    FieldDelegateSP &field = m_delegate_sp->GetField(m_selection_index);
+    FieldDelegate *field = m_delegate_sp->GetField(m_selection_index);
     if (!field->FieldDelegateOnLastOrOnlyElement()) {
       return field->FieldDelegateHandleChar(key);
     }
 
     field->FieldDelegateExitCallback();
 
     if (m_selection_index == m_delegate_sp->GetNumberOfFields() - 1) {
       m_selection_type = SelectionType::Action;
       m_selection_index = 0;
       return eKeyHandled;
     }
 
     m_selection_index++;
+    SkipNextHiddenFields();
 
-    FieldDelegateSP &next_field = m_delegate_sp->GetField(m_selection_index);
+    if (m_selection_type == SelectionType::Field) {
+      FieldDelegate *next_field = m_delegate_sp->GetField(m_selection_index);
       next_field->FieldDelegateSelectFirstElement();
+    }
 
     return eKeyHandled;
   }
 
-  HandleCharResult SelectePrevious(int key) {
+  void SkipPreviousHiddenFields() {
+    while (true) {
+      if (m_delegate_sp->GetField(m_selection_index)->FieldDelegateIsVisible())
+        return;
+
+      if (m_selection_index == 0) {
+        m_selection_type = SelectionType::Action;
+        m_selection_index = 0;
+        return;
+      }
+
+      m_selection_index--;
+    }
+  }
+
+  HandleCharResult SelectPrevious(int key) {
     if (m_selection_type == SelectionType::Action) {
       if (m_selection_index > 0) {
         m_selection_index--;
         return eKeyHandled;
       }
       m_selection_index = m_delegate_sp->GetNumberOfFields() - 1;
       m_selection_type = SelectionType::Field;
-      FieldDelegateSP &previous_field =
+      SkipPreviousHiddenFields();
+      if (m_selection_type == SelectionType::Field) {
+        FieldDelegate *previous_field =
             m_delegate_sp->GetField(m_selection_index);
         previous_field->FieldDelegateSelectLastElement();
+      }
       return eKeyHandled;
     }
 
-    FieldDelegateSP &field = m_delegate_sp->GetField(m_selection_index);
+    FieldDelegate *field = m_delegate_sp->GetField(m_selection_index);
     if (!field->FieldDelegateOnFirstOrOnlyElement()) {
       return field->FieldDelegateHandleChar(key);
     }
 
     field->FieldDelegateExitCallback();
 
     if (m_selection_index == 0) {
       m_selection_type = SelectionType::Action;
       m_selection_index = m_delegate_sp->GetNumberOfActions() - 1;
       return eKeyHandled;
     }
 
     m_selection_index--;
+    SkipPreviousHiddenFields();
 
-    FieldDelegateSP &previous_field =
+    if (m_selection_type == SelectionType::Field) {
+      FieldDelegate *previous_field =
           m_delegate_sp->GetField(m_selection_index);
       previous_field->FieldDelegateSelectLastElement();
+    }
 
     return eKeyHandled;
   }
 
   void ExecuteAction(Window &window) {
     FormAction &action = m_delegate_sp->GetAction(m_selection_index);
     action.Execute(window);
+    if (m_delegate_sp->HasError()) {
       m_first_visible_line = 0;
       m_selection_index = 0;
       m_selection_type = SelectionType::Field;
     }
+  }
 
   HandleCharResult WindowDelegateHandleChar(Window &window, int key) override {
     switch (key) {
     case '\r':
     case '\n':
     case KEY_ENTER:
       if (m_selection_type == SelectionType::Action) {
         ExecuteAction(window);
         return eKeyHandled;
       }
       break;
     case '\t':
-      return SelecteNext(key);
+      return SelectNext(key);
     case KEY_SHIFT_TAB:
-      return SelectePrevious(key);
+      return SelectPrevious(key);
     case KEY_ESCAPE:
       window.GetParent()->RemoveSubWindow(&window);
       return eKeyHandled;
     default:
       break;
     }
 
     // If the key wasn't handled and one of the fields is selected, pass the key
     // to that field.
     if (m_selection_type == SelectionType::Field) {
-      FieldDelegateSP &field = m_delegate_sp->GetField(m_selection_index);
+      FieldDelegate *field = m_delegate_sp->GetField(m_selection_index);
       return field->FieldDelegateHandleChar(key);
     }
 
     return eKeyNotHandled;
   }
 
 protected:
   FormDelegateSP m_delegate_sp;
   // The index of the currently selected SelectionType.
   int m_selection_index;
   // See SelectionType class enum.
   SelectionType m_selection_type;
   // The first visible line from the pad.
   int m_first_visible_line;
 };
 
+///////////////////////////
+// Form Delegate Instances
+///////////////////////////
+
+class DetachOrKillProcessFormDelegate : public FormDelegate {
+public:
+  DetachOrKillProcessFormDelegate(Process *process) : m_process(process) {
+    SetError("There is a running process, either detach or kill it.");
+
+    m_keep_stopped_field =
+        AddBooleanField("Keep process stopped when detaching.", false);
+
+    AddAction("Detach", [this](Window &window) { Detach(window); });
+    AddAction("Kill", [this](Window &window) { Kill(window); });
+  }
+
+  std::string GetName() override { return "Detach/Kill Process"; }
+
+  void Kill(Window &window) {
+    Status destroy_status(m_process->Destroy(false));
+    if (destroy_status.Fail()) {
+      SetError("Failed to kill process.");
+      return;
+    }
+    window.GetParent()->RemoveSubWindow(&window);
+  }
+
+  void Detach(Window &window) {
+    Status detach_status(m_process->Detach(m_keep_stopped_field->GetBoolean()));
+    if (detach_status.Fail()) {
+      SetError("Failed to detach from process.");
+      return;
+    }
+    window.GetParent()->RemoveSubWindow(&window);
+  }
+
+protected:
+  Process *m_process;
+  BooleanFieldDelegate *m_keep_stopped_field;
+};
+
+class ProcessAttachFormDelegate : public FormDelegate {
+public:
+  ProcessAttachFormDelegate(Debugger &debugger, WindowSP main_window_sp)
+      : m_debugger(debugger), m_main_window_sp(main_window_sp) {
+    std::vector<std::string> types;
+    types.push_back(std::string("Name"));
+    types.push_back(std::string("PID"));
+    m_type_field = AddChoicesField("Attach By", 2, types);
+    m_pid_field = AddIntegerField("PID", 0);
+    m_name_field =
+        AddTextField("Process Name", GetDefaultProcessName().c_str());
+    m_continue_field = AddBooleanField("Continue once attached.", false);
+    m_wait_for_field = AddBooleanField("Wait for process to launch.", false);
+    m_include_existing_field =
+        AddBooleanField("Include existing processes.", false);
+    m_show_advanced_field = AddBooleanField("Show advanced settings.", false);
+    m_plugin_field =
+        AddChoicesField("Plugin Name", 3, GetPossiblePluginNames());
+
+    AddAction("Attach", [this](Window &window) { Attach(window); });
+  }
+
+  std::string GetName() override { return "Attach Process"; }
+
+  void UpdateFieldsVisibility() override {
+    if (m_type_field->GetChoiceContent() == "Name") {
+      m_pid_field->FieldDelegateHide();
+      m_name_field->FieldDelegateShow();
+      m_wait_for_field->FieldDelegateShow();
+      if (m_wait_for_field->GetBoolean())
+        m_include_existing_field->FieldDelegateShow();
+      else
+        m_include_existing_field->FieldDelegateHide();
+    } else {
+      m_pid_field->FieldDelegateShow();
+      m_name_field->FieldDelegateHide();
+      m_wait_for_field->FieldDelegateHide();
+      m_include_existing_field->FieldDelegateHide();
+    }
+    if (m_show_advanced_field->GetBoolean())
+      m_plugin_field->FieldDelegateShow();
+    else
+      m_plugin_field->FieldDelegateHide();
+  }
+
+  // Get the basename of the target's main executable if available, empty string
+  // otherwise.
+  std::string GetDefaultProcessName() {
+    Target *target = m_debugger.GetSelectedTarget().get();
+    if (target == nullptr)
+      return "";
+
+    ModuleSP module_sp = target->GetExecutableModule();
+    if (!module_sp->IsExecutable())
+      return "";
+
+    return module_sp->GetFileSpec().GetFilename().AsCString();
+  }
+
+  std::vector<std::string> GetPossiblePluginNames() {
+    std::vector<std::string> names;
+    names.push_back("<default>");
+
+    size_t i = 0;
+    while (auto name = PluginManager::GetProcessPluginNameAtIndex(i++))
+      names.push_back(name);
+    return names;
+  }
+
+  bool StopRunningProcess() {
+    ExecutionContext exe_ctx =
+        m_debugger.GetCommandInterpreter().GetExecutionContext();
+
+    if (!exe_ctx.HasProcessScope())
+      return false;
+
+    Process *process = exe_ctx.GetProcessPtr();
+    if (!(process && process->IsAlive()))
+      return false;
+
+    FormDelegateSP form_delegate_sp =
+        FormDelegateSP(new DetachOrKillProcessFormDelegate(process));
+    Rect bounds = m_main_window_sp->GetCenteredRect(85, 8);
+    WindowSP form_window_sp = m_main_window_sp->CreateSubWindow(
+        form_delegate_sp->GetName().c_str(), bounds, true);
+    WindowDelegateSP window_delegate_sp =
+        WindowDelegateSP(new FormWindowDelegate(form_delegate_sp));
+    form_window_sp->SetDelegate(window_delegate_sp);
+
+    return true;
+  }
+
+  Target *GetTarget() {
+    Target *target = m_debugger.GetSelectedTarget().get();
+
+    if (target != nullptr)
+      return target;
+
+    TargetSP new_target_sp;
+    m_debugger.GetTargetList().CreateTarget(
+        m_debugger, "", "", eLoadDependentsNo, nullptr, new_target_sp);
+
+    target = new_target_sp.get();
+
+    if (target == nullptr)
+      SetError("Failed to create target.");
+
+    m_debugger.GetTargetList().SetSelectedTarget(new_target_sp);
+
+    return target;
+  }
+
+  ProcessAttachInfo GetAttachInfo() {
+    ProcessAttachInfo attach_info;
+    attach_info.SetContinueOnceAttached(m_continue_field->GetBoolean());
+    if (m_type_field->GetChoiceContent() == "Name") {
+      attach_info.GetExecutableFile().SetFile(m_name_field->GetText(),
+                                              FileSpec::Style::native);
+      attach_info.SetWaitForLaunch(m_wait_for_field->GetBoolean());
+      if (m_wait_for_field->GetBoolean())
+        attach_info.SetIgnoreExisting(!m_include_existing_field->GetBoolean());
+    } else {
+      attach_info.SetProcessID(m_pid_field->GetInteger());
+    }
+    if (m_plugin_field->GetChoiceContent() != "<default>")
+      attach_info.SetProcessPluginName(m_plugin_field->GetChoiceContent());
+
+    return attach_info;
+  }
+
+  void Attach(Window &window) {
+    ClearError();
+
+    bool process_is_running = StopRunningProcess();
+    if (process_is_running)
+      return;
+
+    Target *target = GetTarget();
+    if (HasError())
+      return;
+
+    StreamString stream;
+    ProcessAttachInfo attach_info = GetAttachInfo();
+    Status status = target->Attach(attach_info, &stream);
+
+    if (status.Fail()) {
+      SetError(status.AsCString());
+      return;
+    }
+
+    ProcessSP process_sp(target->GetProcessSP());
+    if (!process_sp) {
+      SetError("Attached sucessfully but target has no process.");
+      return;
+    }
+
+    if (attach_info.GetContinueOnceAttached())
+      process_sp->Resume();
+
+    window.GetParent()->RemoveSubWindow(&window);
+  }
+
+protected:
+  Debugger &m_debugger;
+  WindowSP m_main_window_sp;
+
+  ChoicesFieldDelegate *m_type_field;
+  IntegerFieldDelegate *m_pid_field;
+  TextFieldDelegate *m_name_field;
+  BooleanFieldDelegate *m_continue_field;
+  BooleanFieldDelegate *m_wait_for_field;
+  BooleanFieldDelegate *m_include_existing_field;
+  BooleanFieldDelegate *m_show_advanced_field;
+  ChoicesFieldDelegate *m_plugin_field;
+};
+
 class MenuDelegate {
 public:
   virtual ~MenuDelegate() = default;
 
   virtual MenuActionResult MenuDelegateAction(Menu &menu) = 0;
 };
 
 class Menu : public WindowDelegate {
case eMenuID_ThreadStepOver: {
         Process *process = exe_ctx.GetProcessPtr();
         if (process && process->IsAlive() &&
             StateIsStoppedState(process->GetState(), true))
           exe_ctx.GetThreadRef().StepOver(true);
       }
     }
       return MenuActionResult::Handled;
 
+    case eMenuID_ProcessAttach: {
+      WindowSP main_window_sp = m_app.GetMainWindow();
+      FormDelegateSP form_delegate_sp = FormDelegateSP(
+          new ProcessAttachFormDelegate(m_debugger, main_window_sp));
+      Rect bounds = main_window_sp->GetCenteredRect(80, 22);
+      WindowSP form_window_sp = main_window_sp->CreateSubWindow(
+          form_delegate_sp->GetName().c_str(), bounds, true);
+      WindowDelegateSP window_delegate_sp =
+          WindowDelegateSP(new FormWindowDelegate(form_delegate_sp));
+      form_window_sp->SetDelegate(window_delegate_sp);
+      return MenuActionResult::Handled;
+    }
+
     case eMenuID_ProcessContinue: {
       ExecutionContext exe_ctx =
           m_debugger.GetCommandInterpreter().GetExecutionContext();
       if (exe_ctx.HasProcessScope()) {
         Process *process = exe_ctx.GetProcessPtr();
         if (process && process->IsAlive() &&
             StateIsStoppedState(process->GetState(), true))
           process->Resume();