Add a switch for using PNaCl Subzero and use it for -O0 translation.

components/nacl/renderer/ppb_nacl_private_impl.cc

 // Copyright 2013 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.
 
 #include "components/nacl/renderer/ppb_nacl_private_impl.h"
 
 #include <numeric>
 #include <string>
 #include <vector>
 
@@ skipping 249 matching lines @@
           base::Bind(callback, base::Passed(base::File()), 0, 0));
       return;
     }
 
     std::string url;
     // TODO(teravest): Clean up pnacl_options logic in JsonManifest so we don't
     // have to initialize it like this here.
     PP_PNaClOptions pnacl_options;
     pnacl_options.translate = PP_FALSE;
     pnacl_options.is_debug = PP_FALSE;
+    pnacl_options.use_subzero = PP_FALSE;
     pnacl_options.opt_level = 2;
     bool is_helper_process = process_type_ == kPNaClTranslatorProcessType;
     if (!ManifestResolveKey(pp_instance_, is_helper_process, key, &url,
                             &pnacl_options)) {
       base::MessageLoop::current()->PostTask(
           FROM_HERE,
           base::Bind(callback, base::Passed(base::File()), 0, 0));
       return;
     }
 
@@ skipping 771 matching lines @@
   if (manifest == NULL)
     return PP_FALSE;
 
   bool uses_nonsfi_mode;
   std::string full_url;
   JsonManifest::ErrorInfo error_info;
   if (manifest->GetProgramURL(&full_url, pnacl_options, &uses_nonsfi_mode,
                               &error_info)) {
     *pp_full_url = ppapi::StringVar::StringToPPVar(full_url);
     *pp_uses_nonsfi_mode = PP_FromBool(uses_nonsfi_mode);
+    // Check if we should use Subzero (x86-32 / non-debugging case for now).
+    if (pnacl_options->opt_level == 0 && !pnacl_options->is_debug &&
+        strcmp(GetSandboxArch(), "x86-32") == 0 &&
+        base::CommandLine::ForCurrentProcess()->HasSwitch(
+            switches::kEnablePNaClSubzero)) {
+      pnacl_options->use_subzero = PP_TRUE;
+      // Subzero -O2 is closer to LLC -O0, so indicate -O2.
+      pnacl_options->opt_level = 2;
+    }
     return PP_TRUE;
   }
 
   if (load_manager)
     load_manager->ReportLoadError(error_info.error, error_info.string);
   return PP_FALSE;
 }
 
 bool ManifestResolveKey(PP_Instance instance,
                         bool is_helper_process,
@@ skipping 21 matching lines @@
 
   JsonManifest* manifest = GetJsonManifest(instance);
   if (manifest == NULL)
     return false;
 
   return manifest->ResolveKey(key, full_url, pnacl_options);
 }
 
 PP_Bool GetPNaClResourceInfo(PP_Instance instance,
                              PP_Var* llc_tool_name,
-                             PP_Var* ld_tool_name) {
+                             PP_Var* ld_tool_name,
+                             PP_Var* subzero_tool_name) {
   static const char kFilename[] = "chrome://pnacl-translator/pnacl.json";
   NexeLoadManager* load_manager = GetNexeLoadManager(instance);
   DCHECK(load_manager);
   if (!load_manager)
     return PP_FALSE;
 
   uint64_t nonce_lo = 0;
   uint64_t nonce_hi = 0;
   base::File file(GetReadonlyPnaclFd(kFilename, false /* is_executable */,
                                      &nonce_lo, &nonce_hi));
@@ skipping 56 matching lines @@
   if (!json_data.isObject()) {
     load_manager->ReportLoadError(
         PP_NACL_ERROR_PNACL_RESOURCE_FETCH,
         "Parsing resource info failed: Malformed JSON dictionary");
     return PP_FALSE;
   }
 
   if (json_data.isMember("pnacl-llc-name")) {
     Json::Value json_name = json_data["pnacl-llc-name"];
     if (json_name.isString()) {
-      std::string llc_tool_name_str = json_name.asString();
-      *llc_tool_name = ppapi::StringVar::StringToPPVar(llc_tool_name_str);
+      *llc_tool_name = ppapi::StringVar::StringToPPVar(json_name.asString());
     }
   }
 
   if (json_data.isMember("pnacl-ld-name")) {
     Json::Value json_name = json_data["pnacl-ld-name"];
     if (json_name.isString()) {
-      std::string ld_tool_name_str = json_name.asString();
-      *ld_tool_name = ppapi::StringVar::StringToPPVar(ld_tool_name_str);
+      *ld_tool_name = ppapi::StringVar::StringToPPVar(json_name.asString());
     }
   }
+
+  if (json_data.isMember("pnacl-sz-name")) {
+    Json::Value json_name = json_data["pnacl-sz-name"];
+    if (json_name.isString()) {
+      *subzero_tool_name =
+          ppapi::StringVar::StringToPPVar(json_name.asString());
+    }
+  } else {
+    // TODO(jvoung): remove fallback after one chrome release
+    // or when we bump the kMinPnaclVersion.
+    // TODO(jvoung): Just use strings instead of PP_Var!
+    *subzero_tool_name = ppapi::StringVar::StringToPPVar("pnacl-sz.nexe");
+  }
+
   return PP_TRUE;
 }
 
 PP_Var GetCpuFeatureAttrs() {
   return ppapi::StringVar::StringToPPVar(GetCpuFeatures());
 }
 
 // Encapsulates some of the state for a call to DownloadNexe to prevent
 // argument lists from getting too long.
 struct DownloadNexeRequest {
@@ skipping 478 matching lines @@
   &StreamPexe
 };
 
 }  // namespace
 
 const PPB_NaCl_Private* GetNaClPrivateInterface() {
   return &nacl_interface;
 }
 
 }  // namespace nacl