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 384 matching lines @@
   return sender->Send(new NaClHostMsg_NaClGetNumProcessors(&num_processors)) ?
       num_processors : 1;
 }
 
 void GetNexeFd(PP_Instance instance,
                const std::string& pexe_url,
                uint32_t opt_level,
                const base::Time& last_modified_time,
                const std::string& etag,
                bool has_no_store_header,
+               bool use_subzero,
                base::Callback<void(int32_t, bool, PP_FileHandle)> callback) {
   if (!InitializePnaclResourceHost()) {
     ppapi::PpapiGlobals::Get()->GetMainThreadMessageLoop()->PostTask(
         FROM_HERE,
         base::Bind(callback,
                    static_cast<int32_t>(PP_ERROR_FAILED),
                    false,
                    PP_kInvalidFileHandle));
     return;
   }
 
   PnaclCacheInfo cache_info;
   cache_info.pexe_url = GURL(pexe_url);
   // TODO(dschuff): Get this value from the pnacl json file after it
   // rolls in from NaCl.
   cache_info.abi_version = 1;
   cache_info.opt_level = opt_level;
   cache_info.last_modified = last_modified_time;
   cache_info.etag = etag;
   cache_info.has_no_store_header = has_no_store_header;
+  cache_info.use_subzero = use_subzero;
   cache_info.sandbox_isa = GetSandboxArch();
   cache_info.extra_flags = GetCpuFeatures();
 
   g_pnacl_resource_host.Get()->RequestNexeFd(
       GetRoutingID(instance),
       instance,
       cache_info,
       callback);
 }
 
 void ReportTranslationFinished(PP_Instance instance,
                                PP_Bool success,
                                int32_t opt_level,
+                               PP_Bool use_subzero,
                                int64_t pexe_size,
                                int64_t compile_time_us) {
+  // TODO(jvoung): Log use_subzero stat in UMA.
+  (void)use_subzero;
   if (success == PP_TRUE) {
     static const int32_t kUnknownOptLevel = 4;
     if (opt_level < 0 || opt_level > 3)
       opt_level = kUnknownOptLevel;
     HistogramEnumerate("NaCl.Options.PNaCl.OptLevel",
                        opt_level,
                        kUnknownOptLevel + 1);
     HistogramKBPerSec("NaCl.Perf.PNaClLoadTime.CompileKBPerSec",
                       pexe_size / 1024,
                       compile_time_us);
@@ skipping 332 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 283 matching lines @@
 }
 
 // PexeDownloader is responsible for deleting itself when the download
 // finishes.
 class PexeDownloader : public blink::WebURLLoaderClient {
  public:
   PexeDownloader(PP_Instance instance,
                  scoped_ptr<blink::WebURLLoader> url_loader,
                  const std::string& pexe_url,
                  int32_t pexe_opt_level,
+                 bool use_subzero,
                  const PPP_PexeStreamHandler* stream_handler,
                  void* stream_handler_user_data)
       : instance_(instance),
         url_loader_(url_loader.Pass()),
         pexe_url_(pexe_url),
         pexe_opt_level_(pexe_opt_level),
+        use_subzero_(use_subzero),
         stream_handler_(stream_handler),
         stream_handler_user_data_(stream_handler_user_data),
         success_(false),
         expected_content_length_(-1),
-        weak_factory_(this) { }
+        weak_factory_(this) {}
 
   void Load(const blink::WebURLRequest& request) {
     url_loader_->loadAsynchronously(request, this);
   }
 
  private:
   virtual void didReceiveResponse(blink::WebURLLoader* loader,
                                   const blink::WebURLResponse& response) {
     success_ = (response.httpStatusCode() == 200);
     if (!success_)
@@ skipping 17 matching lines @@
 
     std::vector<std::string> values;
     base::SplitString(cache_control, ',', &values);
     for (std::vector<std::string>::const_iterator it = values.begin();
          it != values.end();
          ++it) {
       if (base::StringToLowerASCII(*it) == "no-store")
         has_no_store_header = true;
     }
 
-    GetNexeFd(instance_,
-              pexe_url_,
-              pexe_opt_level_,
-              last_modified_time,
-              etag,
-              has_no_store_header,
-              base::Bind(&PexeDownloader::didGetNexeFd,
-                         weak_factory_.GetWeakPtr()));
+    GetNexeFd(
+        instance_, pexe_url_, pexe_opt_level_, last_modified_time, etag,
+        has_no_store_header, use_subzero_,
+        base::Bind(&PexeDownloader::didGetNexeFd, weak_factory_.GetWeakPtr()));
   }
 
   virtual void didGetNexeFd(int32_t pp_error,
                             bool cache_hit,
                             PP_FileHandle file_handle) {
     if (!content::PepperPluginInstance::Get(instance_)) {
       delete this;
       return;
     }
 
@@ skipping 39 matching lines @@
 
   virtual void didFail(blink::WebURLLoader* loader,
                        const blink::WebURLError& error) {
     success_ = false;
   }
 
   PP_Instance instance_;
   scoped_ptr<blink::WebURLLoader> url_loader_;
   std::string pexe_url_;
   int32_t pexe_opt_level_;
+  bool use_subzero_;
   const PPP_PexeStreamHandler* stream_handler_;
   void* stream_handler_user_data_;
   bool success_;
   int64_t expected_content_length_;
   base::WeakPtrFactory<PexeDownloader> weak_factory_;
 };
 
 void StreamPexe(PP_Instance instance,
                 const char* pexe_url,
                 int32_t opt_level,
+                PP_Bool use_subzero,
                 const PPP_PexeStreamHandler* handler,
                 void* handler_user_data) {
   content::PepperPluginInstance* plugin_instance =
       content::PepperPluginInstance::Get(instance);
   if (!plugin_instance) {
     base::MessageLoop::current()->PostTask(
         FROM_HERE,
         base::Bind(handler->DidFinishStream,
                    handler_user_data,
                    static_cast<int32_t>(PP_ERROR_FAILED)));
     return;
   }
 
   GURL gurl(pexe_url);
   const blink::WebDocument& document =
       plugin_instance->GetContainer()->element().document();
   scoped_ptr<blink::WebURLLoader> url_loader(
       CreateWebURLLoader(document, gurl));
-  PexeDownloader* downloader = new PexeDownloader(instance,
-                                                  url_loader.Pass(),
-                                                  pexe_url,
-                                                  opt_level,
-                                                  handler,
-                                                  handler_user_data);
+  PexeDownloader* downloader =
+      new PexeDownloader(instance, url_loader.Pass(), pexe_url, opt_level,
+                         PP_ToBool(use_subzero), handler, handler_user_data);
 
   blink::WebURLRequest url_request = CreateWebURLRequest(document, gurl);
   // Mark the request as requesting a PNaCl bitcode file,
   // so that component updater can detect this user action.
   url_request.addHTTPHeaderField(
       blink::WebString::fromUTF8("Accept"),
       blink::WebString::fromUTF8("application/x-pnacl, */*"));
   url_request.setRequestContext(blink::WebURLRequest::RequestContextObject);
   downloader->Load(url_request);
 }
@@ skipping 26 matching lines @@
   &StreamPexe
 };
 
 }  // namespace
 
 const PPB_NaCl_Private* GetNaClPrivateInterface() {
   return &nacl_interface;
 }
 
 }  // namespace nacl