Add an RPC to LLC.nexe to init with appended flags (vs set all flags).

tools/llc/nacl_file.cpp

 /* Copyright 2012 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.
  *
  * This file provides wrappers to open() to use pre-opened file descriptors
  * for the input bitcode and the output file.
  *
  * It also has the SRPC interfaces, but that should probably be refactored
  * into a separate file.
  */
 
 #if defined(__native_client__) && defined(NACL_SRPC)
 
 #include <argz.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 // Headers which are not properly part of the SDK are included by their
 // path in the nacl tree
 #include "native_client/src/shared/srpc/nacl_srpc.h"
 #ifdef __pnacl__
 #include <nacl/pnacl.h>
 #endif
 #include "SRPCStreamer.h"
 
-
 #include <string>
 #include <map>
 #include <vector>
 
 #include "llvm/ADT/OwningPtr.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/Support/MemoryBuffer.h"
 #include "llvm/Support/system_error.h"
 
 
@@ skipping 76 matching lines @@
   return llc_main(static_cast<int>(argc), argv);
 }
 
 string_vector* CommandLineFromArgz(char* str, size_t str_len) {
   char* entry = str;
   string_vector* vec = new string_vector;
   while (entry != NULL) {
     vec->push_back(entry);
     entry = argz_next(str, str_len, entry);
   }
+  return vec;
+}
+
+void AddFixedArguments(string_vector* vec) {
   // Add fixed arguments to the command line.  These specify the bitcode
   // and object code filenames, removing them from the contract with the
   // coordinator.
   vec->push_back(kBitcodeFilename);
   vec->push_back("-o");
   vec->push_back(kObjectFilename);
-  return vec;
+}
+
+bool AddDefaultCPU(string_vector* vec) {
+#if defined (__pnacl__)
+  switch (__builtin_nacl_target_arch()) {
+    case PnaclTargetArchitectureX86_32: {
+      vec->push_back("-mcpu=pentium4");
+      break;
+    }
+    case PnaclTargetArchitectureX86_64: {
+      vec->push_back("-mcpu=core2");
+      break;
+    }
+    case PnaclTargetArchitectureARM_32: {
+      vec->push_back("-mcpu=cortex-a8");
+      break;
+    }
+    default:
+      printerr("no target architecture match.\n");
+      return false;
+  }
+// Some cases for building this with nacl-gcc.
+#elif defined (__i386__)
+  vec->push_back("-mcpu=pentium4");
+#elif defined (__x86_64__)
+  vec->push_back("-mcpu=core2");
+#elif defined (__arm__)
+  vec->push_back("-mcpu=cortex-a8");
+#error "Unknown architecture"
+#endif
+  return true;
+}
+
+bool HadCPUOverride(string_vector* vec) {

[Derek Schuff, 2013/03/06 17:45:27]

s/Had/Has?

[jvoung (off chromium), 2013/03/06 18:24:44]

Done.

+  std::string mcpu = std::string("-mcpu=");
+  size_t len = mcpu.length();
+  for (size_t i = 0; i < vec->size(); ++i) {
+    std::string prefix = (*vec)[i].substr(0, len);
+    if (prefix.compare(mcpu) == 0)
+      return true;
+  }
+  return false;
 }
 
 string_vector* GetDefaultCommandLine() {
   string_vector* command_line = new string_vector;
   size_t i;
   // First, those common to all architectures.
   static const char* common_args[] = { "pnacl_translator",
-                                       "-filetype=obj",
-                                       kBitcodeFilename,
-                                       "-o",
-                                       kObjectFilename };
+                                       "-filetype=obj" };
   for (i = 0; i < ARRAY_SIZE(common_args); ++i) {
     command_line->push_back(common_args[i]);
   }
   // Then those particular to a platform.
-  static const char* llc_args_x8632[] = { "-march=x86",
-                                          "-mcpu=pentium4",
-                                          "-mtriple=i686-none-nacl-gnu",
+  static const char* llc_args_x8632[] = { "-mtriple=i686-none-nacl-gnu",
                                           NULL };
-  static const char* llc_args_x8664[] = { "-march=x86-64",
-                                          "-mcpu=core2",
-                                          "-mtriple=x86_64-none-nacl-gnu",
+  static const char* llc_args_x8664[] = { "-mtriple=x86_64-none-nacl-gnu",
                                           NULL };
-  static const char* llc_args_arm[] = { "-mcpu=cortex-a8",
-                                        "-mtriple=armv7a-none-nacl-gnueabi",
+  static const char* llc_args_arm[] = { "-mtriple=armv7a-none-nacl-gnueabi",
                                         "-arm-reserve-r9",
                                         "-sfi-disable-cp",
                                         "-sfi-store",
                                         "-sfi-load",
                                         "-sfi-stack",
                                         "-sfi-branch",
                                         "-sfi-data",
                                         "-no-inline-jumptables",
                                         "-float-abi=hard",
                                         NULL };
 
   const char **llc_args = NULL;
 #if defined (__pnacl__)
   switch (__builtin_nacl_target_arch()) {
     case PnaclTargetArchitectureX86_32: {
       llc_args = llc_args_x8632;
       break;
     }
     case PnaclTargetArchitectureX86_64: {
       llc_args = llc_args_x8664;
       break;
     }
     case PnaclTargetArchitectureARM_32: {
       llc_args = llc_args_arm;
       break;
     }
     default:
       printerr("no target architecture match.\n");
       delete command_line;
-      command_line = NULL;
-      break;
+      return NULL;
   }
+// Some cases for building this with nacl-gcc.
 #elif defined (__i386__)
   llc_args = llc_args_x8632;
 #elif defined (__x86_64__)
   llc_args = llc_args_x8664;
+#elif defined (__arm__)
+  llc_args = llc_args_arm;
 #else
-#error
+#error "Unknown architecture"
 #endif
   for (i = 0; llc_args[i] != NULL; i++) command_line->push_back(llc_args[i]);
   return command_line;
 }
 
 // Data passed from main thread to compile thread.
 // Takes ownership of the commandline vector.
 class StreamingThreadData {
  public:
   StreamingThreadData(int object_fd, string_vector* cmd_line_vec) :
@@ skipping 43 matching lines @@
 // Under the hood it forks a new thread at starts the llc_main, which sets
 // up the compilation and blocks when it tries to start reading the bitcode.
 // Input arg is a file descriptor to write the output object file to.
 // Returns a string, containing an error message if the call fails.
 void stream_init(NaClSrpcRpc *rpc,
                  NaClSrpcArg **in_args,
                  NaClSrpcArg **out_args,
                  NaClSrpcClosure *done) {
   // cmd_line_vec allocated by GetDefaultCommandLine() is freed by the
   // translation thread in run_streamed()
-  do_stream_init(rpc, in_args, out_args, done, GetDefaultCommandLine());
+  string_vector* cmd_line_vec = GetDefaultCommandLine();
+  if (!cmd_line_vec || !AddDefaultCPU(cmd_line_vec)) {
+    NaClSrpcClosureRunner runner(done);
+    rpc->result = NACL_SRPC_RESULT_APP_ERROR;
+    out_args[0]->arrays.str = strdup("Failed to get default commandline.");
+    return;
+  }
+  AddFixedArguments(cmd_line_vec);
+  do_stream_init(rpc, in_args, out_args, done, cmd_line_vec);
 }
 
 // Invoked by StreamInitWithCommandLine RPC. Same as stream_init, but
 // provides a command line to use instead of the default.
 void stream_init_with_command_line(NaClSrpcRpc *rpc,
                                    NaClSrpcArg **in_args,
                                    NaClSrpcArg **out_args,
                                    NaClSrpcClosure *done) {
   char* command_line = in_args[1]->arrays.carr;
   size_t command_line_len = in_args[1]->u.count;
   string_vector* cmd_line_vec =
       CommandLineFromArgz(command_line, command_line_len);
+  AddFixedArguments(cmd_line_vec);
   // cmd_line_vec is freed by the translation thread in run_streamed
   do_stream_init(rpc, in_args, out_args, done, cmd_line_vec);
 }
 
+// Invoked by StreamInitWithOverrides RPC. Same as stream_init, but
+// provides commandline flag overrides (appended to the default).
+void stream_init_with_overrides(NaClSrpcRpc *rpc,
+                                NaClSrpcArg **in_args,
+                                NaClSrpcArg **out_args,
+                                NaClSrpcClosure *done) {
+  string_vector* cmd_line_vec = GetDefaultCommandLine();
+  if (!cmd_line_vec) {
+    NaClSrpcClosureRunner runner(done);
+    rpc->result = NACL_SRPC_RESULT_APP_ERROR;
+    out_args[0]->arrays.str = strdup("Failed to get default commandline.");
+    return;
+  }
+  AddFixedArguments(cmd_line_vec);
+
+  char* command_line = in_args[1]->arrays.carr;
+  size_t command_line_len = in_args[1]->u.count;
+  llvm::OwningPtr<string_vector> extra_vec(
+      CommandLineFromArgz(command_line, command_line_len));
+  cmd_line_vec->insert(cmd_line_vec->end(),
+                       extra_vec->begin(), extra_vec->end());
+  // Make sure some -mcpu override exists for now to prevent
+  // auto-cpu feature detection from triggering instructions that
+  // we do not validate yet.
+  if (!HadCPUOverride(extra_vec.get())) {
+    AddDefaultCPU(cmd_line_vec);
+  }
+  extra_vec.reset(NULL);
+  // cmd_line_vec is freed by the translation thread in run_streamed.
+  do_stream_init(rpc, in_args, out_args, done, cmd_line_vec);
+}
+
 // Invoked by the StreamChunk RPC. Receives a chunk of the bitcode and
 // buffers it for later retrieval by the compilation thread.
 void stream_chunk(NaClSrpcRpc *rpc,
                  NaClSrpcArg **in_args,
                  NaClSrpcArg **out_args,
                  NaClSrpcClosure *done) {
   NaClSrpcClosureRunner runner(done);
   rpc->result = NACL_SRPC_RESULT_APP_ERROR;
   size_t len = in_args[0]->u.count;
   unsigned char *bytes = reinterpret_cast<unsigned char*>(
@@ skipping 28 matching lines @@
 }
 
 const struct NaClSrpcHandlerDesc srpc_methods[] = {
   // Protocol for streaming:
   // (StreamInit(obj_fd) -> error_str |
   //    StreamInitWIthCommandLine(obj_fd, escaped_cmdline) -> error_str)
   // StreamChunk(data) +
   // StreamEnd() -> (is_shared_lib,soname,dependencies,error_str)
   { "StreamInit:h:s", stream_init },
   { "StreamInitWithCommandLine:hC:s:", stream_init_with_command_line },
+  { "StreamInitWithOverrides:hC:s:", stream_init_with_overrides },
   { "StreamChunk:C:", stream_chunk },
   { "StreamEnd::isss", stream_end },
   { NULL, NULL },
 };
 
 }  // namespace
 
 int
 main() {
   if (!NaClSrpcModuleInit()) {
     return 1;
   }
 
   if (!NaClSrpcAcceptClientConnection(srpc_methods)) {
     return 1;
   }
   NaClSrpcModuleFini();
   return 0;
 }
 
 #endif