Merge branch 'main' into Introduce-New-Options

Author: Rakesh Ganesh

src/MICore/CommandFactories/MICommandFactory.cs

@@ -35,6 +35,17 @@ public enum ExceptionBreakpointStates
         BreakThrown = 0x2
     }
 
+    /// <summary>
+    /// The signals that are using for async-break.
+    /// None will be used for no signal or signals that are not listed in the enum
+    /// </summary>
+    public enum AsyncBreakSignal
+    {
+        None = 0,
+        SIGTRAP = 2,
+        SIGINT = 5
+    }
+
     public abstract class MICommandFactory
     {
         protected Debugger _debugger;
@@ -664,19 +675,22 @@ public virtual bool SupportsFrameFormatting
             get { return false; }
         }
 
-        public virtual bool IsAsyncBreakSignal(Results results)
+        public virtual AsyncBreakSignal GetAsyncBreakSignal(Results results)
         {
-            bool isAsyncBreak = false;
-
             if (results.TryFindString("reason") == "signal-received")
             {
-                if (results.TryFindString("signal-name") == "SIGTRAP")
+                string signalName = results.TryFindString("signal-name");
+                if (signalName == "SIGTRAP")
+                {
+                    return MICore.AsyncBreakSignal.SIGTRAP;
+                }
+                else if (signalName == "SIGINT")
                 {
-                    isAsyncBreak = true;
+                    return MICore.AsyncBreakSignal.SIGINT;
                 }
             }
 
-            return isAsyncBreak;
+            return MICore.AsyncBreakSignal.None;
         }
 
         public Results IsModuleLoad(string cmd)

src/MICore/Debugger.cs

@@ -283,8 +283,9 @@ private async void OnStopped(Results results)
                 results = results.Add("frame", frameResult.Find("frame"));
             }
 
-            bool fIsAsyncBreak = MICommandFactory.IsAsyncBreakSignal(results);
-            if (await DoInternalBreakActions(fIsAsyncBreak))
+            AsyncBreakSignal signal = MICommandFactory.GetAsyncBreakSignal(results);
+            bool isAsyncBreak = signal == AsyncBreakSignal.SIGTRAP || (IsUsingExecInterrupt && signal == AsyncBreakSignal.SIGINT);
+            if (await DoInternalBreakActions(isAsyncBreak))
             {
                 return;
             }
@@ -409,6 +410,8 @@ private async Task<bool> DoInternalBreakActions(bool fIsAsyncBreak)
                     {
                         CmdContinueAsync();
                         processContinued = true;
+                        // Reset since this -exec-interrupt was for an internal breakpoint.
+                        IsUsingExecInterrupt = false;
                     }
 
                     if (firstException != null)
@@ -591,7 +594,7 @@ internal bool IsLocalGdbTarget()
                 _launchOptions is LocalLaunchOptions && !IsLocalLaunchUsingServer());
         }
 
-        private bool IsRemoteGdbTarget()
+        internal bool IsRemoteGdbTarget()
         {
             return MICommandFactory.Mode == MIMode.Gdb &&
                (_launchOptions is PipeLaunchOptions || _launchOptions is UnixShellPortLaunchOptions ||
@@ -606,6 +609,11 @@ protected bool IsCoreDump
             }
         }
 
+        /// <summary>
+        /// Flag to indicate that '-exec-interrupt' was used for async-break scenarios.
+        /// </summary>
+        public bool IsUsingExecInterrupt { get; protected set; } = false;
+
         public async Task<Results> CmdTerminate()
         {
             if (!_terminating)
@@ -749,6 +757,7 @@ public Task CmdBreakInternal()
                 }
             }
 
+            IsUsingExecInterrupt = true;
             var res = CmdAsync("-exec-interrupt", ResultClass.done);
             return res.ContinueWith((t) =>
             {

src/MIDebugEngine/Engine.Impl/DebuggedProcess.cs

@@ -1332,14 +1332,18 @@ private async Task HandleBreakModeEvent(ResultEventArgs results, BreakRequest br
             else if (reason == "signal-received")
             {
                 string name = results.Results.TryFindString("signal-name");
+                AsyncBreakSignal signal = MICommandFactory.GetAsyncBreakSignal(results.Results);
+                bool isAsyncBreak = signal == AsyncBreakSignal.SIGTRAP || (IsUsingExecInterrupt && signal == AsyncBreakSignal.SIGINT);
                 if ((name == "SIG32") || (name == "SIG33"))
                 {
                     // we are going to ignore these (Sigma) signals for now
                     CmdContinueAsyncConditional(breakRequest);
                 }
-                else if (MICommandFactory.IsAsyncBreakSignal(results.Results))
+                else if (isAsyncBreak)
                 {
                     _callback.OnAsyncBreakComplete(thread);
+                    // Reset flag for real async break
+                    IsUsingExecInterrupt = false;
                 }
                 else
                 {

src/OpenDebugAD7/AD7DebugSession.cs

@@ -128,8 +128,35 @@ public AD7DebugSession(Stream debugAdapterStdIn, Stream debugAdapterStdOut, List
             m_dataBreakpoints = new Dictionary<string, IDebugPendingBreakpoint2>();
             m_exceptionBreakpoints = new List<string>();
             m_variableManager = new VariableManager();
+
+            //Register sendInvalidate request
+            Protocol.RegisterRequestType<SendInvalidateRequest, SendInvalidateArguments>(r => this.HandleSendInvalidateRequestAsync(r));
+    
         }
 
+        private void HandleSendInvalidateRequestAsync(IRequestResponder<SendInvalidateArguments> responder)
+        {
+            InvalidatedEvent invalidated = new InvalidatedEvent();
+            
+            // Setting the area and adding it to the result
+            invalidated.Areas.Add(responder.Arguments.Areas);
+
+            // Setting the StackFrameId if passed (and the 'threadId' is ignored).
+            if (null != responder.Arguments.StackFrameId)
+            {
+                invalidated.StackFrameId = responder.Arguments.StackFrameId;
+            }
+
+            // Setting the ThreadId if passed
+            else if (null != responder.Arguments.ThreadId)
+            {
+                invalidated.ThreadId = responder.Arguments.ThreadId;
+            }
+
+
+            Protocol.SendEvent(invalidated);
+
+        }
         #endregion
 
         #region Utility
@@ -3874,4 +3901,21 @@ int IDebugSettingsCallback110.ShouldSuppressImplicitToStringCalls(out int pfSupp
             }
         }
     }
+
+    internal class SendInvalidateRequest : DebugRequest<SendInvalidateArguments>
+    {
+ 
+        public SendInvalidateRequest(): base("sendInvalidate")
+        {
+        }
+    }
+
+    internal class SendInvalidateArguments : DebugRequestArguments
+    {
+
+        public InvalidatedAreas Areas { get; set; }
+        public int? ThreadId { get; set; }
+        public int? StackFrameId { get; set; }
+
+    }
 }