Revert "[Arguments] Merge (7442,7496] from bleeding_edge."

SConstruct

 # Copyright 2010 the V8 project authors. All rights reserved.
 # Redistribution and use in source and binary forms, with or without
 # modification, are permitted provided that the following conditions are
 # met:
 #
 #     * Redistributions of source code must retain the above copyright
 #       notice, this list of conditions and the following disclaimer.
 #     * Redistributions in binary form must reproduce the above
 #       copyright notice, this list of conditions and the following
 #       disclaimer in the documentation and/or other materials provided
 #       with the distribution.
 #     * Neither the name of Google Inc. nor the names of its
 #       contributors may be used to endorse or promote products derived
 #       from this software without specific prior written permission.
 #
 # THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 # "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
 # LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
 # A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
 # OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
 # SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
 # LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 # DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 # THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 # (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 # OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 import platform
 import re
-import subprocess
 import sys
 import os
 from os.path import join, dirname, abspath
 from types import DictType, StringTypes
 root_dir = dirname(File('SConstruct').rfile().abspath)
 sys.path.insert(0, join(root_dir, 'tools'))
 import js2c, utils
 
 # ANDROID_TOP is the top of the Android checkout, fetched from the environment
 # variable 'TOP'.   You will also need to set the CXX, CC, AR and RANLIB
@@ skipping 98 matching lines @@
   },
   'gcc': {
     'all': {
       'CCFLAGS':      ['$DIALECTFLAGS', '$WARNINGFLAGS'],
       'CXXFLAGS':     ['$CCFLAGS', '-fno-rtti', '-fno-exceptions'],
     },
     'visibility:hidden': {
       # Use visibility=default to disable this.
       'CXXFLAGS':     ['-fvisibility=hidden']
     },
-    'strictaliasing:off': {
-      'CCFLAGS':      ['-fno-strict-aliasing']
-    },
     'mode:debug': {
       'CCFLAGS':      ['-g', '-O0'],
       'CPPDEFINES':   ['ENABLE_DISASSEMBLER', 'DEBUG'],
       'os:android': {
         'CCFLAGS':    ['-mthumb']
       }
     },
     'mode:release': {
       'CCFLAGS':      ['-O3', '-fomit-frame-pointer', '-fdata-sections',
                        '-ffunction-sections'],
@@ skipping 661 matching lines @@
   'release': '',
   'debug': '_g'
 }
 
 
 def Abort(message):
   print message
   sys.exit(1)
 
 
-def GuessOS(env):
-  return utils.GuessOS()
-
-
-def GuessArch(env):
-  return utils.GuessArchitecture()
-
-
-def GuessToolchain(env):
-  tools = env['TOOLS']
+def GuessToolchain(os):
+  tools = Environment()['TOOLS']
   if 'gcc' in tools:
     return 'gcc'
   elif 'msvc' in tools:
     return 'msvc'
   else:
     return None
 
 
-def GuessVisibility(env):
-  os = env['os']
-  toolchain = env['toolchain'];
+def GuessVisibility(os, toolchain):
   if (os == 'win32' or os == 'cygwin') and toolchain == 'gcc':
     # MinGW / Cygwin can't do it.
     return 'default'
   elif os == 'solaris':
     return 'default'
   else:
     return 'hidden'
 
 
-def GuessStrictAliasing(env):
-  # There seems to be a problem with gcc 4.5.x.
-  # See http://code.google.com/p/v8/issues/detail?id=884
-  # It can be worked around by disabling strict aliasing.
-  toolchain = env['toolchain'];
-  if toolchain == 'gcc':
-    env = Environment(tools=['gcc'])
-    # The gcc version should be available in env['CCVERSION'],
-    # but when scons detects msvc this value is not set.
-    version = subprocess.Popen([env['CC'], '-dumpversion'],
-        stdout=subprocess.PIPE).communicate()[0]
-    if version.find('4.5') == 0:
-      return 'off'
-  return 'default'
+OS_GUESS = utils.GuessOS()
+TOOLCHAIN_GUESS = GuessToolchain(OS_GUESS)
+ARCH_GUESS = utils.GuessArchitecture()
+VISIBILITY_GUESS = GuessVisibility(OS_GUESS, TOOLCHAIN_GUESS)
 
 
-PLATFORM_OPTIONS = {
-  'arch': {
-    'values': ['arm', 'ia32', 'x64', 'mips'],
-    'guess': GuessArch,
-    'help': 'the architecture to build for'
+SIMPLE_OPTIONS = {
+  'toolchain': {
+    'values': ['gcc', 'msvc'],
+    'default': TOOLCHAIN_GUESS,
+    'help': 'the toolchain to use (%s)' % TOOLCHAIN_GUESS
   },
   'os': {
     'values': ['freebsd', 'linux', 'macos', 'win32', 'android', 'openbsd', 'solaris', 'cygwin'],
-    'guess': GuessOS,
-    'help': 'the os to build for'
+    'default': OS_GUESS,
+    'help': 'the os to build for (%s)' % OS_GUESS
   },
-  'toolchain': {
-    'values': ['gcc', 'msvc'],
-    'guess': GuessToolchain,
-    'help': 'the toolchain to use'
-  }
-}
-
-SIMPLE_OPTIONS = {
+  'arch': {
+    'values':['arm', 'ia32', 'x64', 'mips'],
+    'default': ARCH_GUESS,
+    'help': 'the architecture to build for (%s)' % ARCH_GUESS
+  },
   'regexp': {
     'values': ['native', 'interpreted'],
     'default': 'native',
     'help': 'Whether to use native or interpreted regexp implementation'
   },
   'snapshot': {
     'values': ['on', 'off', 'nobuild'],
     'default': 'off',
     'help': 'build using snapshots for faster start-up'
   },
@@ skipping 93 matching lines @@
     'default': 'dumb',
     'help': 'the console to use for the d8 shell'
   },
   'verbose': {
     'values': ['on', 'off'],
     'default': 'off',
     'help': 'more output from compiler and linker'
   },
   'visibility': {
     'values': ['default', 'hidden'],
-    'guess': GuessVisibility,
-    'help': 'shared library symbol visibility'
-  },
-  'strictaliasing': {
-    'values': ['default', 'off'],
-    'guess': GuessStrictAliasing,
-    'help': 'assume strict aliasing while optimizing'
+    'default': VISIBILITY_GUESS,
+    'help': 'shared library symbol visibility (%s)' % VISIBILITY_GUESS
   },
   'pgo': {
     'values': ['off', 'instrument', 'optimize'],
     'default': 'off',
     'help': 'select profile guided optimization variant',
   },
   'mipsabi': {
     'values': ['hardfloat', 'softfloat', 'none'],
     'default': 'hardfloat',
     'help': 'generate calling conventiont according to selected mips ABI'
   },
   'mips_arch_variant': {
     'values': ['mips32r2', 'mips32r1'],
     'default': 'mips32r2',
     'help': 'mips variant'
   }
 }
 
-ALL_OPTIONS = dict(PLATFORM_OPTIONS, **SIMPLE_OPTIONS)
-
-
-def AddOptions(options, result):
-  guess_env = Environment(options=result)
-  for (name, option) in options.iteritems():
-    if 'guess' in option:
-      # Option has a guess function
-      guess = option.get('guess')
-      default = guess(guess_env)
-    else:
-      # Option has a fixed default
-      default = option.get('default')
-    help = '%s (%s)' % (option.get('help'), ", ".join(option['values']))
-    result.Add(name, help, default)
-
 
 def GetOptions():
   result = Options()
   result.Add('mode', 'compilation mode (debug, release)', 'release')
   result.Add('sample', 'build sample (shell, process, lineprocessor)', '')
   result.Add('cache', 'directory to use for scons build cache', '')
   result.Add('env', 'override environment settings (NAME0:value0,NAME1:value1,...)', '')
   result.Add('importenv', 'import environment settings (NAME0,NAME1,...)', '')
-  AddOptions(PLATFORM_OPTIONS, result)
-  AddOptions(SIMPLE_OPTIONS, result)
+  for (name, option) in SIMPLE_OPTIONS.iteritems():
+    help = '%s (%s)' % (name, ", ".join(option['values']))
+    result.Add(name, help, option.get('default'))
   return result
 
 
-def GetTools(opts):
-  env = Environment(options=opts)
-  os = env['os']
-  toolchain = env['toolchain']
-  if os == 'win32' and toolchain == 'gcc':
-    return ['mingw']
-  elif os == 'win32' and toolchain == 'msvc':
-    return ['msvc', 'mslink', 'mslib', 'msvs']
-  else:
-    return ['default']
-
-
 def GetVersionComponents():
   MAJOR_VERSION_PATTERN = re.compile(r"#define\s+MAJOR_VERSION\s+(.*)")
   MINOR_VERSION_PATTERN = re.compile(r"#define\s+MINOR_VERSION\s+(.*)")
   BUILD_NUMBER_PATTERN = re.compile(r"#define\s+BUILD_NUMBER\s+(.*)")
   PATCH_LEVEL_PATTERN = re.compile(r"#define\s+PATCH_LEVEL\s+(.*)")
 
   patterns = [MAJOR_VERSION_PATTERN,
               MINOR_VERSION_PATTERN,
               BUILD_NUMBER_PATTERN,
               PATCH_LEVEL_PATTERN]
@@ skipping 59 matching lines @@
   if env['soname'] == 'on' and env['library'] == 'static':
     Abort("Shared Object soname not applicable for static library.")
   if env['os'] != 'win32' and env['pgo'] != 'off':
     Abort("Profile guided optimization only supported on Windows.")
   if env['cache'] and not os.path.isdir(env['cache']):
     Abort("The specified cache directory does not exist.")
   if not (env['arch'] == 'arm' or env['simulator'] == 'arm') and ('unalignedaccesses' in ARGUMENTS):
     print env['arch']
     print env['simulator']
     Abort("Option unalignedaccesses only supported for the ARM architecture.")
-  for (name, option) in ALL_OPTIONS.iteritems():
-    if (not name in env):
+  for (name, option) in SIMPLE_OPTIONS.iteritems():
+    if (not option.get('default')) and (name not in ARGUMENTS):
       message = ("A value for option %s must be specified (%s)." %
           (name, ", ".join(option['values'])))
       Abort(message)
     if not env[name] in option['values']:
       message = ("Unknown %s value '%s'.  Possible values are (%s)." %
           (name, env[name], ", ".join(option['values'])))
       Abort(message)
 
 
 class BuildContext(object):
@@ skipping 109 matching lines @@
     if var in os.environ:
       overrides[var] = os.environ[var]
   for override in arg.split(','):
     pos = override.find(':')
     if pos == -1:
       continue
     overrides[override[:pos].strip()] = override[pos+1:].strip()
   return overrides
 
 
-def BuildSpecific(env, mode, env_overrides, tools):
+def BuildSpecific(env, mode, env_overrides):
   options = {'mode': mode}
-  for option in ALL_OPTIONS:
+  for option in SIMPLE_OPTIONS:
     options[option] = env[option]
   PostprocessOptions(options, env['os'])
 
   context = BuildContext(options, env_overrides, samples=SplitList(env['sample']))
 
   # Remove variables which can't be imported from the user's external
   # environment into a construction environment.
   user_environ = os.environ.copy()
   try:
     del user_environ['ENV']
@@ skipping 33 matching lines @@
   if context.options['soname'] == 'on':
     soname = GetSpecificSONAME()
     if soname == '':
       soname = 'lib' + library_name + '.so'
     env['SONAME'] = soname
 
   # Build the object files by invoking SCons recursively.
   (object_files, shell_files, mksnapshot, preparser_files) = env.SConscript(
     join('src', 'SConscript'),
     build_dir=join('obj', target_id),
-    exports='context tools',
+    exports='context',
     duplicate=False
   )
 
   context.mksnapshot_targets.append(mksnapshot)
 
   # Link the object files into a library.
   env.Replace(**context.flags['v8'])
 
   context.ApplyEnvOverrides(env)
   if context.options['library'] == 'static':
     library = env.StaticLibrary(library_name, object_files)
     preparser_library = env.StaticLibrary(preparser_library_name,
                                           preparser_files)
   else:
     # There seems to be a glitch in the way scons decides where to put
     # PDB files when compiling using MSVC so we specify it manually.
     # This should not affect any other platforms.
     pdb_name = library_name + '.dll.pdb'
     library = env.SharedLibrary(library_name, object_files, PDB=pdb_name)
     preparser_pdb_name = preparser_library_name + '.dll.pdb';
     preparser_library = env.SharedLibrary(preparser_library_name,
                                           preparser_files,
                                           PDB=preparser_pdb_name)
   context.library_targets.append(library)
   context.library_targets.append(preparser_library)
 
-  d8_env = Environment(tools=tools)
+  d8_env = Environment()
   d8_env.Replace(**context.flags['d8'])
   context.ApplyEnvOverrides(d8_env)
   shell = d8_env.Program('d8' + suffix, object_files + shell_files)
   context.d8_targets.append(shell)
 
   for sample in context.samples:
-    sample_env = Environment(tools=tools)
+    sample_env = Environment()
     sample_env.Replace(**context.flags['sample'])
     sample_env.Prepend(LIBS=[library_name])
     context.ApplyEnvOverrides(sample_env)
     sample_object = sample_env.SConscript(
       join('samples', 'SConscript'),
       build_dir=join('obj', 'sample', sample, target_id),
-      exports='sample context tools',
+      exports='sample context',
       duplicate=False
     )
     sample_name = sample + suffix
     sample_program = sample_env.Program(sample_name, sample_object)
     sample_env.Depends(sample_program, library)
     context.sample_targets.append(sample_program)
 
   cctest_env = env.Copy()
   cctest_env.Prepend(LIBS=[library_name])
   cctest_program = cctest_env.SConscript(
     join('test', 'cctest', 'SConscript'),
     build_dir=join('obj', 'test', target_id),
-    exports='context object_files tools',
+    exports='context object_files',
     duplicate=False
   )
   context.cctest_targets.append(cctest_program)
 
   preparser_env = env.Copy()
   preparser_env.Replace(**context.flags['preparser'])
   preparser_env.Prepend(LIBS=[preparser_library_name])
   context.ApplyEnvOverrides(preparser_env)
   preparser_object = preparser_env.SConscript(
     join('preparser', 'SConscript'),
     build_dir=join('obj', 'preparser', target_id),
     exports='context',
     duplicate=False
   )
-  preparser_name = join('obj', 'preparser', target_id, 'preparser')
+  preparser_name = join('obj', 'preparser', target_id, 'preparser' + suffix)
   preparser_program = preparser_env.Program(preparser_name, preparser_object);
   preparser_env.Depends(preparser_program, preparser_library)
   context.preparser_targets.append(preparser_program)
 
   return context
 
 
 def Build():
   opts = GetOptions()
-  tools = GetTools(opts)
-  env = Environment(options=opts, tools=tools)
-
+  env = Environment(options=opts)
   Help(opts.GenerateHelpText(env))
   VerifyOptions(env)
   env_overrides = ParseEnvOverrides(env['env'], env['importenv'])
 
   SourceSignatures(env['sourcesignatures'])
 
   libraries = []
   mksnapshots = []
   cctests = []
   samples = []
   preparsers = []
   d8s = []
   modes = SplitList(env['mode'])
   for mode in modes:
-    context = BuildSpecific(env.Copy(), mode, env_overrides, tools)
+    context = BuildSpecific(env.Copy(), mode, env_overrides)
     libraries += context.library_targets
     mksnapshots += context.mksnapshot_targets
     cctests += context.cctest_targets
     samples += context.sample_targets
     preparsers += context.preparser_targets
     d8s += context.d8_targets
 
   env.Alias('library', libraries)
   env.Alias('mksnapshot', mksnapshots)
   env.Alias('cctests', cctests)
@@ skipping 14 matching lines @@
 # version of scons.  Also, there's a bug in some revisions that
 # doesn't allow this flag to be set, so we swallow any exceptions.
 # Lovely.
 try:
   SetOption('warn', 'no-deprecated')
 except:
   pass
 
 
 Build()