Fix spurious exception on entry and add stopAtConnect

Author: benmcmorran

src/MICore/JsonLaunchOptions.cs

@@ -95,6 +95,12 @@ public abstract partial class BaseOptions
         /// </summary>
         [JsonProperty("setupCommands", DefaultValueHandling = DefaultValueHandling.Ignore)]
         public List<SetupCommand> SetupCommands { get; protected set; }
+
+        /// <summary>
+        /// Optional parameter. If true, the debugger should stop after connecting to the target.
+        /// </summary>
+        [JsonProperty("stopAtConnect", DefaultValueHandling = DefaultValueHandling.Ignore)]
+        public bool? StopAtConnect { get; set; }
     }
 
     public partial class AttachOptions : BaseOptions
@@ -127,7 +133,8 @@ public AttachOptions(
             string miDebuggerServerAddress = null,
             Dictionary<string, object> sourceFileMap = null,
             PipeTransport pipeTransport = null,
-            SymbolLoadInfo symbolLoadInfo = null)
+            SymbolLoadInfo symbolLoadInfo = null,
+            bool? stopAtConnect = null)
         {
             this.Program = program;
             this.Type = type;
@@ -143,6 +150,7 @@ public AttachOptions(
             this.SourceFileMap = sourceFileMap;
             this.PipeTransport = pipeTransport;
             this.SymbolLoadInfo = symbolLoadInfo;
+            this.StopAtConnect = stopAtConnect;
         }
 
         #endregion
@@ -345,7 +353,8 @@ public LaunchOptions(
             string coreDumpPath = null,
             bool? externalConsole = null,
             Dictionary<string, object> sourceFileMap = null,
-            PipeTransport pipeTransport = null)
+            PipeTransport pipeTransport = null,
+            bool? stopAtConnect = null)
         {
             this.Program = program;
             this.Args = args;
@@ -374,6 +383,7 @@ public LaunchOptions(
             this.ExternalConsole = externalConsole;
             this.SourceFileMap = sourceFileMap;
             this.PipeTransport = pipeTransport;
+            this.StopAtConnect = stopAtConnect;
         }
 
         #endregion

src/MICore/LaunchOptions.cs

@@ -1126,6 +1126,21 @@ public ReadOnlyCollection<EnvironmentEntry> Environment
             }
         }
 
+        private bool _stopAtConnect;
+
+        /// <summary>
+        /// Optional parameter. If true, the debugger should stop after connecting to the target.
+        /// </summary>
+        public bool StopAtConnect
+        {
+            get { return _stopAtConnect; }
+            set
+            {
+                VerifyCanModifyProperty(nameof(StopAtConnect));
+                _stopAtConnect = value;
+            }
+        }
+
         public string GetOptionsString()
         {
             try
@@ -1714,7 +1729,7 @@ protected void InitializeCommonOptions(Json.LaunchOptions.BaseOptions options)
             }
 
             this.SetupCommands = LaunchCommand.CreateCollection(options.SetupCommands);
-
+            this.StopAtConnect = options.StopAtConnect ?? false;
         }
 
         protected void InitializeCommonOptions(Xml.LaunchOptions.BaseLaunchOptions source)

src/MIDebugEngine/Engine.Impl/DebuggedProcess.cs

@@ -1103,24 +1103,41 @@ private async Task HandleBreakModeEvent(ResultEventArgs results, BreakRequest br
             if (String.IsNullOrWhiteSpace(reason) && !this.EntrypointHit)
             {
                 breakRequest = BreakRequest.None;   // don't let stopping interfere with launch processing
+                bool shouldContinue = true;
 
+                if (_launchOptions.StopAtConnect)
+                {
+                    this.EntrypointHit = true;
+                    await this.ClearEntrypointBreakpoint();
+
+                    // Send a breakpoint event to force the client to stop (entry point may not stop depending on how the user started debugging)
+                    _callback.OnBreakpoint(thread, new ReadOnlyCollection<object>(new AD7BoundBreakpoint[] { }));
+                    shouldContinue = false;
+                }
                 // MinGW sends a stopped event on attach. gdb<->gdbserver also sends a stopped event when first attached.
                 // If this is a gdb<->gdbserver connection, ignore this as the entryPoint
-                if (IsLocalLaunchUsingServer())
+                else if (IsLocalLaunchUsingServer())
                 {
                     // If the stopped event occurs on gdbserver, ignore it unless it contains a filename.
                     TupleValue frame = results.Results.TryFind<TupleValue>("frame");
                     if (frame.Contains("file"))
                     {
                         this.EntrypointHit = true;
+                        await this.ClearEntrypointBreakpoint();
+                        _callback.OnEntryPoint(thread);
+                        shouldContinue = false;
                     }
                 }
                 else
                 {
                     this.EntrypointHit = true;
+                    await this.ClearEntrypointBreakpoint();
                 }
 
-                CmdContinueAsync();
+                if (shouldContinue)
+                {
+                    CmdContinueAsync();
+                }
                 FireDeviceAppLauncherResume();
             }
             else if (reason == "entry-point-hit")
@@ -1315,6 +1332,14 @@ private async Task OnEntrypointHit()
                 await ConsoleCmdAsync("process handle --pass true --stop false --notify false SIGHUP", allowWhileRunning: false, ignoreFailures: true);
             }
 
+            await this.ClearEntrypointBreakpoint();
+        }
+
+        /// <summary>
+        /// Attempts to remove the breakpoint automatically set at the entrypoint of the application.
+        /// </summary>
+        private async Task ClearEntrypointBreakpoint()
+        {
             if (this._deleteEntryPointBreakpoint && !String.IsNullOrWhiteSpace(this._entryPointBreakpoint))
             {
                 // Try and delete the entrypoint breakpoint. We only try this once but in some cases this won't succeed