Adjust pnacl-translate sbtc flag override mechanism to append.

pnacl/driver/pnacl-translate.py

 #!/usr/bin/python
 # Copyright (c) 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.
 #
 # IMPORTANT NOTE: If you make local mods to this file, you must run:
 #   %  pnacl/build.sh driver
 # in order for them to take effect in the scons build.  This command
 # updates the copy in the toolchain/ tree.
 #
@@ skipping 106 matching lines @@
     ('-arm-reserve-r9 -sfi-disable-cp ' +
      '-sfi-load -sfi-store -sfi-stack -sfi-branch -sfi-data ' +
      '-no-inline-jumptables -float-abi=hard'),
 
   'LLC_FLAGS_X8632' : '',
   'LLC_FLAGS_X8664' : '',
 
   'LLC_FLAGS_MIPS32': '-sfi-load -sfi-store -sfi-stack -sfi-branch -sfi-data',
 
   # LLC flags which set the target and output type.
   # These are handled separately by libLTO.

[Derek Schuff, 2013/03/06 21:10:12]

this line of the comment still relevant?

[jvoung (off chromium), 2013/03/06 21:26:58]

Probably not (the libLTO part?).  It sounds like libLTO is referring to
LTOModule.cpp, which is used during bitcode linking.  That really only reads the
triple mentioned in the bitcode file itself (or a default if no triple string
exists in the bitcode file), so we never set the commandline for libLTO.

Removed.

-  'LLC_FLAGS_TARGET' : '-mcpu=${LLC_MCPU} ' +
-                       '-mtriple=${TRIPLE} ' +
+  'LLC_FLAGS_TARGET' : '-mtriple=${TRIPLE} ' +
                        '-filetype=${filetype}',
   # Append additional non-default flags here.
-  'LLC_FLAGS_EXTRA' : '${#OPT_LEVEL ? -O${OPT_LEVEL}} ' +
+  'LLC_FLAGS_EXTRA' : '${FAST_TRANSLATION ? ${LLC_FLAGS_FAST}} ' +
+                      '${#OPT_LEVEL ? -O${OPT_LEVEL}} ' +
                       '${OPT_LEVEL == 0 ? -disable-fp-elim}',
 
   # Opt level from command line (if any)
   'OPT_LEVEL' : '',
 
-  # slower translation == faster code
-  'LLC_FLAGS_SLOW':
-  # Due to a quadratic algorithm used for tail merging
-  # capping it at 50 helps speed up translation
-                     '-tail-merge-threshold=50',
-
   # faster translation == slower code
   'LLC_FLAGS_FAST' : '${LLC_FLAGS_FAST_%ARCH%}',
 
-  'LLC_FLAGS_FAST_X8632':
-                          '-O0 ' +
-  # This, surprisingly, makes a measurable difference
+  'LLC_FLAGS_FAST_X8632': '-O0 ' +
+                          # This, surprisingly, makes a measurable difference
                           '-tail-merge-threshold=20',
-  'LLC_FLAGS_FAST_X8664':
-                          '-O0 ' +
+  'LLC_FLAGS_FAST_X8664': '-O0 ' +
                           '-tail-merge-threshold=20',
-  'LLC_FLAGS_FAST_ARM':
-  # due to slow turn around times ARM settings have not been explored in depth
-                          '-O0 ' +
+  'LLC_FLAGS_FAST_ARM':   '-O0 ' +
                           '-tail-merge-threshold=20',
   'LLC_FLAGS_FAST_MIPS32': '-fast-isel -tail-merge-threshold=20',
 
-  'LLC_FLAGS': '${LLC_FLAGS_TARGET} ' +
-               '${LLC_FLAGS_COMMON} ' +
-               '${LLC_FLAGS_%ARCH%} ' +
-               '${FAST_TRANSLATION ? ${LLC_FLAGS_FAST} : ${LLC_FLAGS_SLOW}} ' +
+  'LLC_FLAGS': '${LLC_FLAGS_TARGET} ${LLC_FLAGS_COMMON} ${LLC_FLAGS_%ARCH%} ' +
                '${LLC_FLAGS_EXTRA}',
 
   # CPU that is representative of baseline feature requirements for NaCl
   # and/or chrome.  We may want to make this more like "-mtune"
   # by specifying both "-mcpu=X" and "-mattr=+feat1,-feat2,...".
   # Note: this may be different from the in-browser translator, which may
   # do auto feature detection based on CPUID, but constrained by what is
   # accepted by NaCl validators.
-  'LLC_MCPU'        : '${LLC_MCPU_%ARCH%}',
+  'LLC_MCPU'        : '-mcpu=${LLC_MCPU_%ARCH%}',
   'LLC_MCPU_ARM'    : 'cortex-a8',
   'LLC_MCPU_X8632'  : 'pentium4',
   'LLC_MCPU_X8664'  : 'core2',
   'LLC_MCPU_MIPS32' : 'mips32r2',
 
   # Note: this is only used in the unsandboxed case
-  'RUN_LLC'       : '${LLVM_LLC} ${LLC_FLAGS} ${input} -o ${output} ' +
+  'RUN_LLC'       : '${LLVM_LLC} ${LLC_FLAGS} ${LLC_MCPU} '
+                    '${input} -o ${output} ' +
                     '-metadata-text ${output}.meta',
   # Rate in bits/sec to stream the bitcode from sel_universal over SRPC
   # for testing. Defaults to 1Gbps (effectively unlimited).
   'BITCODE_STREAM_RATE' : '1000000000',
 }
 
 TranslatorPatterns = [
   ( '-o(.+)',          "env.set('OUTPUT', pathtools.normalize($0))"),
   ( ('-o', '(.+)'),    "env.set('OUTPUT', pathtools.normalize($0))"),
 
   ( '-S',              "env.set('OUTPUT_TYPE', 's')"), # Stop at .s
   ( '-c',              "env.set('OUTPUT_TYPE', 'o')"), # Stop at .o
 
   # Expose a very limited set of llc flags.
   ( '(-sfi-.+)',        "env.append('LLC_FLAGS_EXTRA', $0)"),
   ( '(-mtls-use-call)', "env.append('LLC_FLAGS_EXTRA', $0)"),
   # These flags are usually used for linktime dead code/data
   # removal but also help with reloc overflows on ARM
   ( '(-fdata-sections)',     "env.append('LLC_FLAGS_EXTRA', $0)"),
   ( '(-ffunction-sections)', "env.append('LLC_FLAGS_EXTRA', $0)"),
   ( '(--gc-sections)',       "env.append('LD_FLAGS', $0)"),
   ( '(-mattr=.*)', "env.append('LLC_FLAGS_EXTRA', $0)"),
-  ( '-mcpu=(.*)', "env.set('LLC_MCPU', $0)"),
+  ( '(-mcpu=.*)', "env.set('LLC_MCPU', '')\n"
+                  "env.append('LLC_FLAGS_EXTRA', $0)"),
   # Allow overriding the -O level.
   ( '-O([0-3])', "env.set('OPT_LEVEL', $0)"),
 
   # This adds arch specific flags to the llc invocation aimed at
   # improving translation speed at the expense of code quality.
   ( '-translate-fast',  "env.set('FAST_TRANSLATION', '1')"),
 
   # If translating a .pexe which was linked statically against
   # glibc, then you must do pnacl-translate -static. This will
   # be removed once GLibC is actually statically linked.
@@ skipping 245 matching lines @@
 
 def ToggleDefaultCommandlineLD(inputs, infile):
   if env.getbool('USE_DEFAULT_CMD_LINE'):
     reason, non_standard = RequiresNonStandardLDCommandline(inputs, infile)
     if non_standard:
       Log.Info(reason + ' -- not using default SRPC commandline for LD!')
       inputs.append('--pnacl-driver-set-USE_DEFAULT_CMD_LINE=0')
 
 
 def RequiresNonStandardLLCCommandline():
-  if env.getbool('FAST_TRANSLATION'):
-    return ('FAST_TRANSLATION', True)
-
   extra_flags = env.get('LLC_FLAGS_EXTRA')
   if extra_flags != []:
     reason = 'Has additional llc flags: %s' % extra_flags
     return (reason, True)
 
   return (None, False)
 
 
 def UseDefaultCommandlineLLC():
   if not env.getbool('USE_DEFAULT_CMD_LINE'):
@@ skipping 35 matching lines @@
     # As a side effect, this creates a temporary file
     if not env.getbool('SAVE_TEMPS'):
       TempFiles.add(outfile + '.meta')
     env.pop()
   return 0
 
 def RunLLCSandboxed():
   driver_tools.CheckTranslatorPrerequisites()
   infile = env.getone('input')
   outfile = env.getone('output')
-  flags = env.get('LLC_FLAGS')
   if not driver_tools.IsBitcode(infile):
     Log.Fatal('Input to sandboxed translator must be bitcode')
-  script = MakeSelUniversalScriptForLLC(infile, outfile, flags)
+  script = MakeSelUniversalScriptForLLC(infile, outfile)
   command = ('${SEL_UNIVERSAL_PREFIX} ${SEL_UNIVERSAL} ${SEL_UNIVERSAL_FLAGS} '
     '-- ${LLC_SB}')
   _, stdout, _  = driver_tools.Run(command,
                                 stdin_contents=script,
                                 # stdout/stderr will be automatically dumped
                                 # upon failure
                                 redirect_stderr=subprocess.PIPE,
                                 redirect_stdout=subprocess.PIPE)
   # Get the values returned from the llc RPC to use in input to ld
   is_shared = re.search(r'output\s+0:\s+i\(([0|1])\)', stdout).group(1)
   is_shared = (is_shared == '1')
   soname = re.search(r'output\s+1:\s+s\("(.*)"\)', stdout).group(1)
   needed_str = re.search(r'output\s+2:\s+s\("(.*)"\)', stdout).group(1)
   # If the delimiter changes, this line needs to change
   needed_libs = [ lib for lib in needed_str.split(r'\n') if lib]
   return is_shared, soname, needed_libs
 
-def BuildLLCCommandLine(flags):
+def BuildOverrideLLCCommandLine():
+  extra_flags = env.get('LLC_FLAGS_EXTRA')
+  # The mcpu is not part of the default flags, so append that too.
+  mcpu = env.getone('LLC_MCPU')
+  if mcpu:
+    extra_flags.append(mcpu)
   # command_line is a NUL (\x00) terminated sequence.
   kTerminator = '\0'
-  command_line = kTerminator.join(['llc'] + flags) + kTerminator
+  command_line = kTerminator.join(extra_flags) + kTerminator
   command_line_escaped = command_line.replace(kTerminator, '\\x00')
   return len(command_line), command_line_escaped
 
-def MakeSelUniversalScriptForLLC(infile, outfile, flags):
+def MakeSelUniversalScriptForLLC(infile, outfile):
   script = []
   script.append('readwrite_file objfile %s' % outfile)
   stream_rate = int(env.getraw('BITCODE_STREAM_RATE'))
   assert stream_rate != 0
   if UseDefaultCommandlineLLC():
     script.append('rpc StreamInit h(objfile) * s()')
   else:
-    cmdline_len, cmdline_escaped = BuildLLCCommandLine(flags)
-    script.append('rpc StreamInitWithCommandLine h(objfile) C(%d,%s) * s()' %
+    cmdline_len, cmdline_escaped = BuildOverrideLLCCommandLine()
+    script.append('rpc StreamInitWithOverrides h(objfile) C(%d,%s) * s()' %
                   (cmdline_len, cmdline_escaped))
   # specify filename, chunk size and rate in bits/s
   script.append('stream_file %s %s %s' % (infile, 64 * 1024, stream_rate))
   script.append('rpc StreamEnd * i() s() s() s()')
   script.append('echo "llc complete"')
   script.append('')
   return '\n'.join(script)
 
 def get_help(argv):
   return """
@@ skipping 16 matching lines @@
 
 ADVANCED OPTIONS:
   -mattr=<+feat1,-feat2>  Toggle specific cpu features on and off.
   -mcpu=<cpu-name>        Target a specific cpu type.  Tunes code as well as
                           turns cpu features on and off.
   -S                      Generate native assembly only.
   -c                      Generate native object file only.
   --pnacl-sb              Use the translator which runs inside the NaCl sandbox.
   -O[0-3]                 Change translation-time optimization level.
 """