[VS AddIn] Fix default library paths.

visual_studio/NativeClientVSAddIn/NaCl.Build.CPPTasks/NaClLink.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.
 using System;
 using System.IO;
 using System.Resources;
 using System.Reflection;
 using System.Text;
 using Microsoft.Build.Framework;
 using Microsoft.Build.CPPTasks;
@@ skipping 59 matching lines @@
             // so we wrap all the inputs (libraries and object) into one group so they are
             // searched iteratively.
             responseFileCmds.Append("-Wl,--start-group ");
             foreach (ITaskItem sourceFile in Sources)
             {
                 responseFileCmds.Append(GCCUtilities.ConvertPathWindowsToPosix(sourceFile.GetMetadata("Identity")));
                 responseFileCmds.Append(" ");
             }
             responseFileCmds.Append("-Wl,--end-group ");
 
-            responseFileCmds.Append(xamlParser.Parse(Sources[0], false));
+            responseFileCmds.Append(xamlParser.Parse(Sources[0], false, IsPNaCl() ? ".bc" : null));
 
             return responseFileCmds.ToString();
         }
 
+        private static string PexeToBC(string pexe)
+        {
+            return Path.ChangeExtension(pexe, ".bc");
+        }
+
         private static string PexeToNexe(string pexe, string arch)
         {
             string basename = Path.GetFileNameWithoutExtension(pexe) + "_" + arch + ".nexe";
             return Path.Combine(Path.GetDirectoryName(pexe), basename);
         }
 
+        private bool Finalize()
+        {
+            string dirname = Path.GetDirectoryName(GenerateFullPathToTool());
+            string finalize = Path.Combine(dirname, "pnacl-finalize.bat");
+            string cmd = String.Format("\"{0}\" -o \"{1}\"", PexeToBC(OutputFile), OutputFile);
+            if (!OutputCommandLine)
+                Log.LogMessage("pnacl-finalize -> {0}", Path.GetFileName(OutputFile));
+
+            return ExecuteTool(finalize, cmd, string.Empty) == 0;
+        }
+
         private bool Translate(string arch, string pnacl_arch=null)
         {
             if (pnacl_arch == null)
                 pnacl_arch = arch;
             string outfile = PexeToNexe(OutputFile, arch);
             string cmd = String.Format("-arch {0} \"{1}\" -o \"{2}\"",
                                        pnacl_arch, OutputFile, outfile);
 
             string dirname = Path.GetDirectoryName(GenerateFullPathToTool());
             string translateTool = Path.Combine(dirname, "pnacl-translate.bat");
             if (!OutputCommandLine)
                 Log.LogMessage("pnacl-translate -> {0}", Path.GetFileName(outfile));
 
-            if (ExecuteTool(translateTool, cmd, string.Empty) != 0)
-            {
-                return false;
-            }
-
-            return true;
+            return ExecuteTool(translateTool, cmd, string.Empty) == 0;
         }
 
         public override bool Execute()
         {
-            if (!OutputCommandLine)
-                Log.LogMessage("Linking: {0}", Path.GetFileName(OutputFile));
+            if (!OutputCommandLine) {
+                string filename = OutputFile;
+                if (IsPNaCl())
+                   filename = PexeToBC(OutputFile);
+                Log.LogMessage("Linking: {0}", filename);
+            }
 
             if (!base.Execute())
                 return false;
 
             if (!SkippedExecution)
                 if (!PostLink())
                     return false;
 
             return true;
         }
 
         protected bool PostLink()
         {
             if (IsPNaCl())
             {
+                if (!Finalize())
+                    return false;
+
                 if (TranslateX64 && !Translate("64", "x86-64"))
                     return false;
 
                 if (TranslateX86 && !Translate("32", "i686"))
                     return false;
 
                 if (TranslateARM && !Translate("arm"))
                     return false;
             }
 
@@ skipping 32 matching lines @@
 
                     foreach (var arch in new string []{ "arm", "32", "64" })
                     {
                         string nexe = PexeToNexe(OutputFile, arch);
                         if (File.Exists(nexe))
                             cmd += " \"" + nexe + "\"";
                     }
                 }
                 else
                 {
-                    if (ToolchainName == "glibc")
-                    {
-                        string bindir = Path.GetDirectoryName(NaClLinkerPath);
-                        string tcroot = Path.GetDirectoryName(bindir);
-                        cmd += " -D \"" + Path.Combine(bindir, "x86_64-nacl-objdump.exe") + "\"";
-                        cmd += " -L \"" + Path.Combine(tcroot, "x86_64-nacl", "lib") + "\"";
-                        cmd += " -L \"" + Path.Combine(tcroot, "x86_64-nacl", "lib32") + "\"";
-                    }
                     cmd += " \"" + OutputFile + "\"";
                 }
 
                 if (!OutputCommandLine)
                     Log.LogMessage("CreateNMF -> {0}", Path.GetFileName(nmfPath));
 
                 if (ExecuteTool("python", string.Empty, cmd) != 0)
-                {
                     return false;
-                }
             }
 
             return true;
         }
 
         protected override int ExecuteTool(string pathToTool, string responseFileCommands, string commandLineCommands)
         {
             if (OutputCommandLine)
-            {
                 Log.LogMessage(MessageImportance.High, pathToTool + "  " + responseFileCommands + " " + commandLineCommands);
-            }
 
             return base.ExecuteTool(pathToTool, responseFileCommands, commandLineCommands);
         }
 
         protected override Encoding ResponseFileEncoding
         {
             get
             {
                 return Encoding.ASCII;
             }
@@ skipping 25 matching lines @@
 
         protected override string WriteTLogFilename
         {
             get
             {
                 return BaseTool() + ".link.write.1.tlog";
             }
         }
     }
 }