Update pnacl toolchain build

ports/nacl-spawn/nacl_spawn.cc

 // Copyright (c) 2014 The Native Client Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 // Emulates spawning/waiting process by asking JavaScript to do so.
 
 // Include quoted spawn.h first so we can build in the presence of an installed
 // copy of nacl-spawn.
 #define IN_NACL_SPAWN_CC
 #include "spawn.h"
@@ skipping 222 matching lines @@
       nspawn_var_release(args_var);
     } else {
       // If the path does not contain a slash and we cannot find it
       // from PATH, we use NMF served with the JavaScript.
       return true;
     }
   }
   return false;
 }
 
-// Check if a file is a pnacl type file.
-// If the file can't be read, return false.
-static bool IsPNaClType(const std::string& filename) {
-  // Open script.
+static bool CheckFileMagic(const std::string& filename,
+    const std::string& magic) {
   int fh = open(filename.c_str(), O_RDONLY);
   if (fh < 0) {
-    // Default to nacl type if the file can't be read.
     return false;
   }
   // Read first 4 bytes.
   char buffer[4];
   ssize_t len = read(fh, buffer, sizeof buffer);
   close(fh);
   // Decide based on the header.
-  return len == 4 && memcmp(buffer, "PEXE", sizeof buffer) == 0;
+  return len == 4 && memcmp(buffer, magic.c_str(), sizeof buffer) == 0;
+}
+
+// Check if a file contains finalised PNaCl bitcode
+static bool IsPNaClType(const std::string& filename) {
+  return CheckFileMagic(filename, "PEXE");
+}
+
+// Check if a file contains LLVM bitcode
+static bool IsBitcode(const std::string& filename) {
+  return CheckFileMagic(filename, "BC\xc0\xde");
 }
 
 // Adds a NMF to the request if |prog| is stored in HTML5 filesystem.
 static bool AddNmfToRequest(std::string prog, struct PP_Var req_var) {
   if (UseBuiltInFallback(&prog, req_var)) {
     return true;
   }
   if (access(prog.c_str(), R_OK) != 0) {
     errno = ENOENT;
     return false;
   }
 
   if (!ExpandShBang(&prog, req_var)) {
     return false;
   }
 
   // Check fallback again in case of #! expanded to something else.
   if (UseBuiltInFallback(&prog, req_var)) {
     return true;
   }
 
+  bool debug = getenv("LD_DEBUG") != NULL;
+
   // Check for pnacl.
   if (IsPNaClType(prog)) {
+    if (debug) {
+      fprintf(stderr, "%s: loading PNaCl bitcode: %s\n",
+          LOADER_NAME, prog.c_str());
+    }
     AddNmfToRequestForPNaCl(prog, req_var);
     return true;
   }
 
+  if (IsBitcode(prog)) {
+    fprintf(stderr, "%s: cannot execute unfinalized bitcode\n", prog.c_str());
+    return false;
+  }
+
   std::string arch;
   std::vector<std::string> dependencies;
   if (!nspawn_find_arch_and_library_deps(prog, &arch, &dependencies))
     return false;
 
   if (!dependencies.empty()) {
     AddNmfToRequestForShared(prog, arch, dependencies, req_var);
   } else  {
     // No dependencies means the main binary is statically linked.
     AddNmfToRequestForStatic(prog, arch, req_var);
@@ skipping 512 matching lines @@
 }
 
 int execlpe(const char *path, const char *arg, ...) {  /* char* const envp[] */
   NSPAWN_LOG("execlpe: %s", path);
   VARG_TO_ARGV_ENVP;
   // TODO(bradnelson): Limit path resolution to 'p' variants.
   return spawnve_impl(P_OVERLAY, path, argv, envp);
 }
 
 };  // extern "C"