Changed VS add-in to use nacl-gdb

visual_studio/NativeClientVSAddIn/NativeClientVSAddIn/PluginDebuggerHelper.cs

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 namespace NativeClientVSAddIn
 {
   using System;
   using System.Collections.Generic;
   using System.IO;
   using System.Linq;
@@ skipping 46 matching lines @@
     /// Path to the actual plug-in assembly.
     /// </summary>
     private string pluginAssembly_;
 
     /// <summary>
     /// Path to the NaCl IRT.
     /// </summary>
     private string irtPath_;
 
     /// <summary>
+    /// Path to the project's nmf file.
+    /// </summary>
+    private string manifestPath_;
+
+    /// <summary>
     /// Root directory of the installed NaCl SDK.
     /// </summary>
     private string sdkRootDirectory_;
 
     /// <summary>
     /// If debugging a .nexe this is the nacl-gdb process object.
     /// </summary>
     private System.Diagnostics.Process gdbProcess_;
 
     /// <summary>
@@ skipping 105 matching lines @@
     /// <summary>
     /// Initializes the PluginDebuggerHelper with the current project settings
     /// If project settings are unsupported for NaCl/Pepper debugging then
     /// the object is not initialized and we return false.
     /// </summary>
     /// <returns>True if the object is successfully initialized, false otherwise.</returns>
     public bool LoadProjectSettings()
     {
       isProperlyInitialized_ = false;
 
+      string platformToolset;
+
       // We require that there is only a single start-up project.
       // If multiple start-up projects are specified then we use the first and
       // leave a warning message in the Web Server output pane.
       Array startupProjects = dte_.Solution.SolutionBuild.StartupProjects as Array;
       if (startupProjects == null || startupProjects.Length == 0)
       {
         throw new ArgumentOutOfRangeException("startupProjects.Length");
       }
       else if (startupProjects.Length > 1)
       {
@@ skipping 24 matching lines @@
       }
 
       // We only support certain project types (e.g. C/C++ projects). Otherwise we fail.
       // If supported, extract necessary information from specific project type.
       if (Utility.IsVisualCProject(startProject))
       {
         VCConfiguration config = Utility.GetActiveVCConfiguration(startProject);
         IVCRulePropertyStorage general = config.Rules.Item("ConfigurationGeneral");
         VCLinkerTool linker = config.Tools.Item("VCLinkerTool");
         VCProject vcproj = (VCProject)startProject.Object;
+        
         sdkRootDirectory_ = general.GetEvaluatedPropertyValue("VSNaClSDKRoot");
+        platformToolset = general.GetEvaluatedPropertyValue("PlatformToolset");
         pluginOutputDirectory_ = config.Evaluate(config.OutputDirectory);
         pluginAssembly_ = config.Evaluate(linker.OutputFile);
         pluginProjectDirectory_ = vcproj.ProjectDirectory;  // Macros not allowed here.
+        
+        if (projectPlatformType_ == ProjectPlatformType.NaCl)
+        {
+          irtPath_ = general.GetEvaluatedPropertyValue("NaClIrtPath");
+          manifestPath_ = general.GetEvaluatedPropertyValue("NaClManifestPath");
+        }
       }
       else
       {
         return false;
       }
 
       if (string.IsNullOrEmpty(sdkRootDirectory_))
       {
         MessageBox.Show(
             string.Format(Strings.SDKPathNotSetFormat, Strings.SDKPathEnvironmentVariable));
         return false;
       }
 
       sdkRootDirectory_ = sdkRootDirectory_.TrimEnd("/\\".ToArray<char>());
 
       // TODO(tysand): Add user option to specify this.
       int webServerPort = 5103;
       webServerExecutable_ = "python.exe";
       webServerArguments_ = string.Format(
           "{0}\\examples\\httpd.py --no_dir_check {1}",
           sdkRootDirectory_,
           webServerPort);
 
-      // TODO(tysand): Update this to nacl-gdb when it is ready. Should be able to remove irtPath_.
-      gdbPath_ = sdkRootDirectory_ + @"\gdb-remote-x86-64\gdb.exe";
-      irtPath_ = sdkRootDirectory_ + @"\tools\irt_x86_64.nexe";
+      gdbPath_ = Path.Combine(
+          sdkRootDirectory_, "toolchain", platformToolset, @"bin\x86_64-nacl-gdb.exe");
 
       debuggedChromeMainProcess_ = null;
 
       isProperlyInitialized_ = true;
       return true;
     }
 
     /// <summary>
     /// This function should be called to start the PluginDebuggerHelper functionality.
     /// </summary>
@@ skipping 146 matching lines @@
     /// <summary>
     /// Attaches the NaCl GDB debugger to the NaCl plug-in process.  Handles loading symbols
     /// and breakpoints from Visual Studio.
     /// </summary>
     /// <param name="src">The parameter is not used.</param>
     /// <param name="args">
     /// Contains the process ID to attach to, unused since debug stub is already attached.
     /// </param>
     private void AttachNaClGDB(object src, PluginFoundEventArgs args)
     {
-      // NOTE: The settings listed here are a placeholder until nacl-gdb is ready.
-      //       Specifically, 'set architecture' and 'add-symbol-file' calls. See TODO comments.
-
       // Clean up any pre-existing GDB process (can happen if user reloads page).
       KillGDBProcess();
 
       gdbInitFileName_ = Path.GetTempFileName();
-      string projectDir = pluginProjectDirectory_.TrimEnd('\\');
       string pluginAssemblyEscaped = pluginAssembly_.Replace("\\", "\\\\");
       string irtPathEscaped = irtPath_.Replace("\\", "\\\\");
 
       // Create the initialization file to read in on GDB start.
       StringBuilder contents = new StringBuilder();
 
-      // TODO(tysand): Allow user setting for debug stub port (currently 4014).
-      contents.AppendFormat("target remote localhost:{0}", 4014);
-      contents.AppendLine();
+      if (!string.IsNullOrEmpty(manifestPath_))
+      {
+        string manifestEscaped = manifestPath_.Replace("\\", "\\\\");
+        contents.AppendFormat("nacl-manifest {0}\n", manifestEscaped);
+      }
+      else
+      {
+        contents.AppendFormat("file \"{0}\"\n", pluginAssemblyEscaped);
+      }
 
-      // TODO(tysand): Nacl-gdb should detect this automatically making this call unnecessary.
-      contents.Append("set architecture i386:x86-64");
-      contents.AppendLine();
-      contents.AppendFormat("cd {0}", projectDir);
-      contents.AppendLine();
-
-      // TODO(tysand): Nacl-gdb should handle the offset automatically. Remove 0xC00020080.
-      contents.AppendFormat("add-symbol-file \"{0}\" 0xC00020080", pluginAssemblyEscaped);
-      contents.AppendLine();
-
-      // TODO(tysand): Nacl-gdb should handle loading the irt automatically. Remove this line.
-      contents.AppendFormat("add-symbol-file \"{0}\" 0xC0fc00080", irtPathEscaped);
-      contents.AppendLine();
+      contents.AppendFormat("nacl-irt {0}\n", irtPathEscaped);
+      contents.AppendFormat("target remote localhost:{0}\n", 4014);
 
       // Insert breakpoints from Visual Studio project.
       foreach (Breakpoint bp in dte_.Debugger.Breakpoints)
       {
         if (bp.Enabled &&
             bp.LocationType == dbgBreakpointLocationType.dbgBreakpointLocationTypeFile)
         {
           contents.AppendFormat("b {0}:{1}", Path.GetFileName(bp.File), bp.FileLine);
           contents.AppendLine();
         }
@@ skipping 102 matching lines @@
         this.ProcessID = pid;
       }
 
       /// <summary>
       /// Gets or sets process ID of the found plug-in.
       /// </summary>
       public uint ProcessID { get; set; }
     }
   }
 }