Version 3.2.6

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
@@ skipping 206 matching lines @@
       'unalignedaccesses:off' : {
         'CPPDEFINES' : ['CAN_USE_UNALIGNED_ACCESSES=0']
       }
     },
     'simulator:arm': {
       'CCFLAGS':      ['-m32'],
       'LINKFLAGS':    ['-m32'],
     },
     'arch:mips': {
       'CPPDEFINES':   ['V8_TARGET_ARCH_MIPS'],
+      'mips_arch_variant:mips32r2': {
+        'CPPDEFINES':    ['_MIPS_ARCH_MIPS32R2']
+      },
       'simulator:none': {
-        'CCFLAGS':      ['-EL', '-mips32r2', '-Wa,-mips32r2', '-fno-inline'],
-        'LDFLAGS':      ['-EL']
+        'CCFLAGS':      ['-EL'],
+        'LINKFLAGS':    ['-EL'],
+        'mips_arch_variant:mips32r2': {
+          'CCFLAGS':      ['-mips32r2', '-Wa,-mips32r2']
+        },
+        'mips_arch_variant:mips32r1': {
+          'CCFLAGS':      ['-mips32', '-Wa,-mips32']
+        },
+        'library:static': {
+          'LINKFLAGS':    ['-static', '-static-libgcc']
+        },
+        'mipsabi:softfloat': {
+          'CCFLAGS':      ['-msoft-float'],
+          'LINKFLAGS':    ['-msoft-float']
+        },
+        'mipsabi:hardfloat': {
+          'CCFLAGS':      ['-mhard-float'],
+          'LINKFLAGS':    ['-mhard-float']
+        }
       }
     },
     'simulator:mips': {
       'CCFLAGS':      ['-m32'],
       'LINKFLAGS':    ['-m32'],
+      'mipsabi:softfloat': {
+        'CPPDEFINES':    ['__mips_soft_float=1'],
+      }
     },
     'arch:x64': {
       'CPPDEFINES':   ['V8_TARGET_ARCH_X64'],
       'CCFLAGS':      ['-m64'],
       'LINKFLAGS':    ['-m64'],
     },
     'gdbjit:on': {
       'CPPDEFINES':   ['ENABLE_GDB_JIT_INTERFACE']
     }
   },
@@ skipping 93 matching lines @@
       'LIBS': ['winmm', 'ws2_32']
     },
     'arch:arm': {
       'CPPDEFINES':   ['V8_TARGET_ARCH_ARM'],
       # /wd4996 is to silence the warning about sscanf
       # used by the arm simulator.
       'WARNINGFLAGS': ['/wd4996']
     },
     'arch:mips': {
       'CPPDEFINES':   ['V8_TARGET_ARCH_MIPS'],
+      'mips_arch_variant:mips32r2': {
+        'CPPDEFINES':    ['_MIPS_ARCH_MIPS32R2']
+      },
     },
     'disassembler:on': {
       'CPPDEFINES':   ['ENABLE_DISASSEMBLER']
     }
   }
 }
 
 
 MKSNAPSHOT_EXTRA_FLAGS = {
   'gcc': {
@@ skipping 113 matching lines @@
       'LIBPATH': ['.'],
       'CCFLAGS': ['-fno-rtti', '-fno-exceptions']
     },
     'os:linux': {
       'LIBS':         ['pthread'],
     },
     'os:macos': {
       'LIBS':         ['pthread'],
     },
     'os:freebsd': {
-      'LIBPATH' : ['/usr/local/lib'],
-      'LIBS':     ['execinfo', 'pthread']
+      'LIBPATH' :     ['/usr/local/lib'],
+      'LIBS':         ['execinfo', 'pthread']
     },
     'os:solaris': {
-      'LIBPATH' : ['/usr/local/lib'],
-      'LIBS':     ['m', 'pthread', 'socket', 'nsl', 'rt'],
-      'LINKFLAGS': ['-mt']
+      'LIBPATH' :     ['/usr/local/lib'],
+      'LIBS':         ['m', 'pthread', 'socket', 'nsl', 'rt'],
+      'LINKFLAGS':    ['-mt']
     },
     'os:openbsd': {
-      'LIBPATH' : ['/usr/local/lib'],
-      'LIBS':     ['execinfo', 'pthread']
+      'LIBPATH' :     ['/usr/local/lib'],
+      'LIBS':         ['execinfo', 'pthread']
     },
     'os:win32': {
       'LIBS':         ['winmm', 'ws2_32']
     },
     'os:android': {
       'CPPDEFINES':   ['ANDROID', '__ARM_ARCH_5__', '__ARM_ARCH_5T__',
                        '__ARM_ARCH_5E__', '__ARM_ARCH_5TE__'],
       'CCFLAGS':      ANDROID_FLAGS,
       'CPPPATH':      ANDROID_INCLUDES,
       'LIBPATH':     [ANDROID_TOP + '/out/target/product/generic/obj/lib',
@@ skipping 94 matching lines @@
         'CCFLAGS':  ['/MTd']
       },
       'msvcrt:shared': {
         'CCFLAGS':  ['/MDd']
       }
     }
   }
 }
 
 
+PREPARSER_FLAGS = {
+  'all': {
+    'CPPPATH': [join(abspath('.'), 'include'), join(abspath('.'), 'src')]
+  },
+  'gcc': {
+    'all': {
+      'LIBPATH': ['.'],
+      'CCFLAGS': ['-fno-rtti', '-fno-exceptions']
+    },
+    'os:win32': {
+      'LIBS':         ['winmm', 'ws2_32']
+    },
+    'os:android': {
+      'CPPDEFINES':   ['ANDROID', '__ARM_ARCH_5__', '__ARM_ARCH_5T__',
+                       '__ARM_ARCH_5E__', '__ARM_ARCH_5TE__'],
+      'CCFLAGS':      ANDROID_FLAGS,
+      'CPPPATH':      ANDROID_INCLUDES,
+      'LIBPATH':     [ANDROID_TOP + '/out/target/product/generic/obj/lib',
+                      ANDROID_TOP + '/prebuilt/linux-x86/toolchain/arm-eabi-4.4.0/lib/gcc/arm-eabi/4.4.0/interwork'],
+      'LINKFLAGS':    ANDROID_LINKFLAGS,
+      'LIBS':         ['log', 'c', 'stdc++', 'm', 'gcc'],
+      'mode:release': {
+        'CPPDEFINES': ['SK_RELEASE', 'NDEBUG']
+      }
+    },
+    'arch:arm': {
+      'LINKFLAGS':   ARM_LINK_FLAGS
+    },
+    'arch:ia32': {
+      'CCFLAGS':      ['-m32'],
+      'LINKFLAGS':    ['-m32']
+    },
+    'arch:x64': {
+      'CCFLAGS':      ['-m64'],
+      'LINKFLAGS':    ['-m64']
+    },
+    'arch:mips': {
+      'CPPDEFINES':   ['V8_TARGET_ARCH_MIPS'],
+      'mips_arch_variant:mips32r2': {
+        'CPPDEFINES':    ['_MIPS_ARCH_MIPS32R2']
+      },
+      'simulator:none': {
+        'CCFLAGS':      ['-EL'],
+        'LINKFLAGS':    ['-EL'],
+        'mips_arch_variant:mips32r2': {
+          'CCFLAGS':      ['-mips32r2', '-Wa,-mips32r2']
+        },
+        'mips_arch_variant:mips32r1': {
+          'CCFLAGS':      ['-mips32', '-Wa,-mips32']
+        },
+        'library:static': {
+          'LINKFLAGS':    ['-static', '-static-libgcc']
+        },
+        'mipsabi:softfloat': {
+          'CCFLAGS':      ['-msoft-float'],
+          'LINKFLAGS':    ['-msoft-float']
+        },
+        'mipsabi:hardfloat': {
+          'CCFLAGS':      ['-mhard-float'],
+          'LINKFLAGS':    ['-mhard-float']
+        }
+      }
+    },
+    'simulator:arm': {
+      'CCFLAGS':      ['-m32'],
+      'LINKFLAGS':    ['-m32']
+    },
+    'simulator:mips': {
+      'CCFLAGS':      ['-m32'],
+      'LINKFLAGS':    ['-m32'],
+      'mipsabi:softfloat': {
+        'CPPDEFINES':    ['__mips_soft_float=1'],
+      }
+    },
+    'mode:release': {
+      'CCFLAGS':      ['-O2']
+    },
+    'mode:debug': {
+      'CCFLAGS':      ['-g', '-O0'],
+      'CPPDEFINES':   ['DEBUG']
+    },
+  },
+  'msvc': {
+    'all': {
+      'LIBS': ['winmm', 'ws2_32']
+    },
+    'verbose:off': {
+      'CCFLAGS': ['/nologo'],
+      'LINKFLAGS': ['/NOLOGO']
+    },
+    'verbose:on': {
+      'LINKFLAGS': ['/VERBOSE']
+    },
+    'library:shared': {
+      'CPPDEFINES': ['USING_V8_SHARED']
+    },
+    'prof:on': {
+      'LINKFLAGS': ['/MAP']
+    },
+    'mode:release': {
+      'CCFLAGS':   ['/O2'],
+      'LINKFLAGS': ['/OPT:REF', '/OPT:ICF'],
+      'msvcrt:static': {
+        'CCFLAGS': ['/MT']
+      },
+      'msvcrt:shared': {
+        'CCFLAGS': ['/MD']
+      },
+      'msvcltcg:on': {
+        'CCFLAGS':      ['/GL'],
+        'pgo:off': {
+          'LINKFLAGS':    ['/LTCG'],
+        },
+      },
+      'pgo:instrument': {
+        'LINKFLAGS':    ['/LTCG:PGI']
+      },
+      'pgo:optimize': {
+        'LINKFLAGS':    ['/LTCG:PGO']
+      }
+    },
+    'arch:ia32': {
+      'CPPDEFINES': ['V8_TARGET_ARCH_IA32', 'WIN32'],
+      'LINKFLAGS': ['/MACHINE:X86']
+    },
+    'arch:x64': {
+      'CPPDEFINES': ['V8_TARGET_ARCH_X64', 'WIN32'],
+      'LINKFLAGS': ['/MACHINE:X64', '/STACK:2091752']
+    },
+    'mode:debug': {
+      'CCFLAGS':    ['/Od'],
+      'LINKFLAGS':  ['/DEBUG'],
+      'CPPDEFINES': ['DEBUG'],
+      'msvcrt:static': {
+        'CCFLAGS':  ['/MTd']
+      },
+      'msvcrt:shared': {
+        'CCFLAGS':  ['/MDd']
+      }
+    }
+  }
+}
+
+
 D8_FLAGS = {
   'gcc': {
     'console:readline': {
       'LIBS': ['readline']
     },
     'os:linux': {
       'LIBS': ['pthread'],
     },
     'os:macos': {
       'LIBS': ['pthread'],
@@ skipping 195 matching lines @@
   },
   'visibility': {
     'values': ['default', 'hidden'],
     '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'
   }
 }
 
 
 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,...)', '')
@@ skipping 98 matching lines @@
 
   def __init__(self, options, env_overrides, samples):
     self.library_targets = []
     self.mksnapshot_targets = []
     self.cctest_targets = []
     self.sample_targets = []
     self.d8_targets = []
     self.options = options
     self.env_overrides = env_overrides
     self.samples = samples
+    self.preparser_targets = []
     self.use_snapshot = (options['snapshot'] != 'off')
     self.build_snapshot = (options['snapshot'] == 'on')
     self.flags = None
 
   def AddRelevantFlags(self, initial, flags):
     result = initial.copy()
     toolchain = self.options['toolchain']
     if toolchain in flags:
       self.AppendFlags(result, flags[toolchain].get('all'))
       for option in sorted(self.options.keys()):
@@ skipping 58 matching lines @@
       print "Warning: forcing architecture to match simulator (%s)" % options['simulator']
     options['arch'] = options['simulator']
   if (options['prof'] != 'off') and (options['profilingsupport'] == 'off'):
     # Print a warning if profiling is enabled without profiling support
     print "Warning: forcing profilingsupport on when prof is on"
     options['profilingsupport'] = 'on'
   if os == 'win32' and options['pgo'] != 'off' and options['msvcltcg'] == 'off':
     if 'msvcltcg' in ARGUMENTS:
       print "Warning: forcing msvcltcg on as it is required for pgo (%s)" % options['pgo']
     options['msvcltcg'] = 'on'
-  if options['arch'] == 'mips':
-    if ('regexp' in ARGUMENTS) and options['regexp'] == 'native':
-      # Print a warning if native regexp is specified for mips
-      print "Warning: forcing regexp to interpreted for mips"
-    options['regexp'] = 'interpreted'
+    if (options['simulator'] == 'mips' and options['mipsabi'] != 'softfloat'):
+      # Print a warning if soft-float ABI is not selected for mips simulator
+      print "Warning: forcing soft-float mips ABI when running on simulator"
+      options['mipsabi'] = 'softfloat'
+    if (options['mipsabi'] != 'none') and (options['arch'] != 'mips') and (options['simulator'] != 'mips'):
+      options['mipsabi'] = 'none'
   if options['liveobjectlist'] == 'on':
     if (options['debuggersupport'] != 'on') or (options['mode'] == 'release'):
       # Print a warning that liveobjectlist will implicitly enable the debugger
       print "Warning: forcing debuggersupport on for liveobjectlist"
     options['debuggersupport'] = 'on'
     options['inspector'] = 'on'
     options['objectprint'] = 'on'
 
 
 def ParseEnvOverrides(arg, imports):
@@ skipping 26 matching lines @@
     del user_environ['ENV']
   except KeyError:
     pass
 
   library_flags = context.AddRelevantFlags(user_environ, LIBRARY_FLAGS)
   v8_flags = context.AddRelevantFlags(library_flags, V8_EXTRA_FLAGS)
   mksnapshot_flags = context.AddRelevantFlags(library_flags, MKSNAPSHOT_EXTRA_FLAGS)
   dtoa_flags = context.AddRelevantFlags(library_flags, DTOA_EXTRA_FLAGS)
   cctest_flags = context.AddRelevantFlags(v8_flags, CCTEST_EXTRA_FLAGS)
   sample_flags = context.AddRelevantFlags(user_environ, SAMPLE_FLAGS)
+  preparser_flags = context.AddRelevantFlags(user_environ, PREPARSER_FLAGS)
   d8_flags = context.AddRelevantFlags(library_flags, D8_FLAGS)
 
   context.flags = {
     'v8': v8_flags,
     'mksnapshot': mksnapshot_flags,
     'dtoa': dtoa_flags,
     'cctest': cctest_flags,
     'sample': sample_flags,
-    'd8': d8_flags
+    'd8': d8_flags,
+    'preparser': preparser_flags
   }
 
   # Generate library base name.
   target_id = mode
   suffix = SUFFIXES[target_id]
   library_name = 'v8' + suffix
+  preparser_library_name = 'v8preparser' + suffix
   version = GetVersion()
   if context.options['soname'] == 'on':
     # When building shared object with SONAME version the library name.
     library_name += '-' + version
 
   # Generate library SONAME if required by the build.
   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) = env.SConscript(
+  (object_files, shell_files, mksnapshot, preparser_files) = env.SConscript(
     join('src', 'SConscript'),
     build_dir=join('obj', target_id),
     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()
   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()
     sample_env.Replace(**context.flags['sample'])
@@ skipping 13 matching lines @@
   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',
     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' + 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()
   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)
     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)
   env.Alias('sample', samples)
   env.Alias('d8', d8s)
+  env.Alias('preparser', preparsers)
 
   if env['sample']:
     env.Default('sample')
   else:
     env.Default('library')
 
   if env['cache']:
     CacheDir(env['cache'])
 
 # We disable deprecation warnings because we need to be able to use
 # env.Copy without getting warnings for compatibility with older
 # 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()