blob: 949421c4c95d5529c77606c03a3ec4f7f162efcf [file] [log] [blame]
#!/usr/bin/python
# Copyright (c) 2013 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.
"""Recipes for PNaCl target libs."""
import fnmatch
import os
import sys
sys.path.append(os.path.join(os.path.dirname(__file__), '..'))
import pynacl.gsd_storage
import pynacl.platform
import command
import pnacl_commands
SCRIPT_DIR = os.path.dirname(os.path.abspath(__file__))
NACL_DIR = os.path.dirname(SCRIPT_DIR)
GCLIENT_ROOT = os.path.dirname(NACL_DIR)
NINJA_PATH = os.path.join(GCLIENT_ROOT, 'third_party', 'ninja', 'ninja')
CLANG_VER = '3.7.0'
SAIGO_CLANG_VER = '18'
# Return the file name with the appropriate suffix for an executable file.
def Exe(file):
if pynacl.platform.IsWindows():
return file + '.exe'
else:
return file
def ToolName(name):
return 'pnacl-' + name
# Return the path to a tool to build target libraries
# msys should be false if the path will be called directly rather than passed to
# an msys or cygwin tool such as sh or make.
def PnaclTool(toolname, arch='le32', msys=True, saigo=False):
if not msys and pynacl.platform.IsWindows():
ext = '.bat'
else:
ext = ''
if toolname in ['llvm-mc']:
# Some tools, like llvm-mc, don't need or have a special pnacl- prefix
# binary.
base = toolname
elif IsBCArch(arch):
base = ToolName(toolname)
else:
base = '-'.join([TargetArch(arch), 'nacl', toolname])
if saigo:
return command.path.join('%(abs_target_lib_compiler_saigo)s',
'bin', base + ext)
return command.path.join('%(abs_target_lib_compiler)s',
'bin', base + ext)
# PNaCl tools for newlib's environment, e.g. CC_FOR_TARGET=/path/to/pnacl-clang
TOOL_ENV_NAMES = { 'CC': 'clang', 'CXX': 'clang++', 'AR': 'ar', 'NM': 'nm',
'RANLIB': 'ranlib', 'READELF': 'readelf', 'AS': 'as' }
def TargetTools(arch, saigo):
return [ tool + '_FOR_TARGET='
+ PnaclTool(name, arch=arch, msys=True, saigo=saigo)
for tool, name in TOOL_ENV_NAMES.items() ]
def MakeCommand():
make_command = ['make']
if not pynacl.platform.IsWindows():
# The make that ships with msys sometimes hangs when run with -j.
# The ming32-make that comes with the compiler itself reportedly doesn't
# have this problem, but it has issues with pathnames with LLVM's build.
make_command.append('-j%(cores)s')
return make_command
# Return the component name to use for a component name with
# a host triple. GNU configuration triples contain dashes, which are converted
# to underscores so the names are legal for Google Storage.
def GSDJoin(*args):
return '_'.join([pynacl.gsd_storage.LegalizeName(arg) for arg in args])
def TripleFromArch(bias_arch):
return bias_arch + '-nacl'
def IsBiasedBCArch(arch):
return arch.endswith('_bc')
def IsBCArch(arch):
return IsBiasedBCArch(arch) or arch == 'le32'
def IsNonSFIArch(arch):
return arch.endswith('-nonsfi')
# Return the target arch recognized by the compiler (e.g. i686) from an arch
# string which might be a biased-bitcode-style arch (e.g. i686_bc)
def TargetArch(bias_arch):
if IsBiasedBCArch(bias_arch):
return bias_arch[:bias_arch.index('_bc')]
return bias_arch
def MultilibArch(bias_arch):
return 'x86_64' if bias_arch == 'i686' else bias_arch
def MultilibLibDir(bias_arch):
suffix = '32' if bias_arch == 'i686' else ''
return os.path.join(TripleFromArch(MultilibArch(bias_arch)), 'lib' + suffix)
def BiasedBitcodeTargetFlag(bias_arch):
arch = TargetArch(bias_arch)
flagmap = {
# Arch Target Extra flags.
'x86_64': ('x86_64-unknown-nacl', []),
'i686': ('i686-unknown-nacl', []),
'arm': ('armv7-unknown-nacl-gnueabihf', ['-mfloat-abi=hard']),
'mipsel': ('mipsel-unknown-nacl', []),
}
# The -emit-llvm flag is only needed for native Clang drivers since
# pnacl-clang already passes that option to every Clang invocation.
# TODO(phosek): Refactor the per-toolchain options into a separate class.
return ['--target=%s' % flagmap[arch][0], '-emit-llvm'] + flagmap[arch][1]
def TranslatorArchToBiasArch(arch):
archmap = {'x86-32': 'i686',
'x86-32-nonsfi': 'i686',
'x86-64': 'x86_64',
'arm': 'arm',
'arm-nonsfi': 'arm',
'mips32': 'mipsel'}
return archmap[arch]
def TargetLibCflags(bias_arch):
flags = '-g -O2'
if IsBCArch(bias_arch):
flags += ' -mllvm -inline-threshold=5'
else:
# Use sections for the library builds to allow better GC for the IRT.
flags += ' -ffunction-sections -fdata-sections'
if bias_arch != 'arm':
# Newlib target libs need to be build with the LLVM assembler on x86-64
# because it uses the sandbox base address-hiding form of calls, which
# we need in the IRT. On x86-32 that doesn't matter but the LLVM assembler
# sometimes generates slightly better code and it's good to be consistent.
flags += ' -integrated-as'
if IsBiasedBCArch(bias_arch):
flags += ' ' + ' '.join(BiasedBitcodeTargetFlag(bias_arch))
return flags
def NewlibIsystemCflags(bias_arch, saigo=False):
include_arch = MultilibArch(bias_arch)
lib_name = 'abs_newlib'
if saigo:
lib_name = 'abs_newlib_saigo'
return ' '.join([
'-isystem',
command.path.join('%(' + GSDJoin(lib_name, include_arch) +')s',
TripleFromArch(include_arch), 'include')])
def LibCxxCflags(bias_arch):
# HAS_THREAD_LOCAL is used by libc++abi's exception storage, the fallback is
# pthread otherwise.
return ' '.join([TargetLibCflags(bias_arch), NewlibIsystemCflags(bias_arch),
'-fexceptions', '-DHAS_THREAD_LOCAL=1',
'-D__ARM_DWARF_EH__'])
def LibCxxSaigoCflags(bias_arch):
return ' '.join([TargetLibCflags(bias_arch),
NewlibIsystemCflags(bias_arch, saigo=True),
'-DHAS_THREAD_LOCAL=1', '-D__ARM_DWARF_EH__',
'-D_NEWLIB_VERSION="2.1.0"',
'-D_LIBCPP_HAS_THREAD_API_PTHREAD', '-D_POSIX_TIMERS=1'])
def NativeTargetFlag(bias_arch):
arch = TargetArch(bias_arch)
flagmap = {
# Arch Target Extra flags.
'x86_64': ('x86_64-linux-gnu', []),
'i686': ('i686-linux-gnu', []),
'arm': ('armv7a-linux-gnueabihf', []),
'mipsel': ('mipsel-linux-gnu', []),
}
return ['--target=%s' % flagmap[arch][0]] + flagmap[arch][1]
def NonSFITargetLibCflags(bias_arch):
flags = '-D__native_client_nonsfi__ -fPIC -nostdinc '
flags += ' '.join([
'-isystem',
command.path.join('%(abs_target_lib_compiler)s',
'lib', 'clang', CLANG_VER, 'include')])
if bias_arch == 'i686':
flags += ' -malign-double -mllvm -mtls-use-call'
flags += ' ' + ' '.join(NativeTargetFlag(bias_arch))
return flags
# Build a single object file for the target.
def BuildTargetObjectCmd(source, output, bias_arch, output_dir='%(cwd)s',
extra_flags=[], saigo=False):
flags = ['-Wall', '-Werror', '-O2', '-c'] + extra_flags
if IsBiasedBCArch(bias_arch):
flags.extend(BiasedBitcodeTargetFlag(bias_arch))
flags.extend(NewlibIsystemCflags(bias_arch, saigo=saigo).split())
return command.Command(
[PnaclTool('clang', arch=bias_arch, msys=False, saigo=saigo)] + flags + [
command.path.join('%(src)s', source),
'-o', command.path.join(output_dir, output)])
# Build a single object file as native code for the translator.
def BuildTargetTranslatorCmd(sourcefile, output, arch, extra_flags=[],
source_dir='%(src)s', output_dir='%(cwd)s'):
bias_arch = TranslatorArchToBiasArch(arch)
flags = ['-Wall', '-Werror', '-O3', '-integrated-as', '-c'] + extra_flags
if IsNonSFIArch(arch):
flags.extend(NonSFITargetLibCflags(bias_arch).split())
return command.Command(
[PnaclTool('clang', arch=bias_arch, msys=False)] + flags +
# TODO(dschuff): this include breaks the input encapsulation for build
# rules.
['-I%(top_srcdir)s/..'] +
NewlibIsystemCflags('le32').split() +
[command.path.join(source_dir, sourcefile),
'-o', command.path.join(output_dir, output)])
def BuildLibgccEhCmd(sourcefile, output, arch, no_nacl_gcc, saigo):
# Return a command to compile a file from libgcc_eh (see comments in at the
# rule definition below).
flags_common = ['-DENABLE_RUNTIME_CHECKING', '-g', '-O2', '-W', '-Wall',
'-Wwrite-strings', '-Wcast-qual', '-Wstrict-prototypes',
'-Wmissing-prototypes', '-Wold-style-definition',
'-DIN_GCC', '-DCROSS_DIRECTORY_STRUCTURE', '-DIN_LIBGCC2',
'-D__GCC_FLOAT_NOT_NEEDED', '-Dinhibit_libc',
'-DHAVE_CC_TLS', '-DHIDE_EXPORTS',
'-fno-stack-protector', '-fexceptions',
'-fvisibility=hidden',
'-I.', '-I../.././gcc', '-I%(abs_gcc_src)s/gcc/libgcc',
'-I%(abs_gcc_src)s/gcc', '-I%(abs_gcc_src)s/include',
'-isystem', './include']
# For x86 we use nacl-gcc to build libgcc_eh because of some issues with
# LLVM's handling of the gcc intrinsics used in the library. See
# https://code.google.com/p/nativeclient/issues/detail?id=1933
# and http://llvm.org/bugs/show_bug.cgi?id=8541
# For ARM, LLVM does work and we use it to avoid dealing with the fact that
# arm-nacl-gcc uses different libgcc support functions than PNaCl.
if arch in ('arm', 'mips32'):
cc = PnaclTool('clang', arch=TranslatorArchToBiasArch(arch),
msys=False, saigo=saigo)
flags_naclcc = []
else:
if no_nacl_gcc:
return command.WriteData('', output)
os_name = pynacl.platform.GetOS()
arch_name = pynacl.platform.GetArch()
platform_dir = '%s_%s' % (os_name, arch_name)
newlib_dir = 'nacl_x86_glibc'
nnacl_dir = os.path.join(NACL_DIR, 'toolchain', platform_dir,
newlib_dir, 'bin')
gcc_binaries = {
'x86-32': 'i686-nacl-gcc',
'x86-64': 'x86_64-nacl-gcc',
}
cc = os.path.join(nnacl_dir, gcc_binaries[arch])
flags_naclcc = []
return command.Command([cc] + flags_naclcc + flags_common +
['-c',
command.path.join('%(gcc_src)s', 'gcc', sourcefile),
'-o', output])
def TargetLibsSrc(GitSyncCmds):
newlib_sys_nacl = command.path.join('%(output)s',
'newlib', 'libc', 'sys', 'nacl')
source = {
'newlib_src': {
'type': 'source',
'output_dirname': 'pnacl-newlib',
'commands': [
# Clean any headers exported from the NaCl tree before syncing.
command.CleanGitWorkingDir(
'%(output)s',
reset=False,
path=os.path.join('newlib', 'libc', 'include'))] +
GitSyncCmds('nacl-newlib') +
# Remove newlib versions of headers that will be replaced by
# headers from the NaCl tree.
[command.RemoveDirectory(command.path.join(newlib_sys_nacl,
dirname))
for dirname in ['bits', 'sys', 'machine']] + [
command.Command([
sys.executable,
command.path.join('%(top_srcdir)s', 'src', 'trusted',
'service_runtime', 'export_header.py'),
command.path.join('%(top_srcdir)s', 'src', 'trusted',
'service_runtime', 'include'),
newlib_sys_nacl],
cwd='%(abs_output)s',
)] + [
command.Copy(
os.path.join('%(top_srcdir)s', 'src', 'untrusted', 'pthread',
header),
os.path.join('%(output)s', 'newlib', 'libc', 'include',
header))
for header in ('pthread.h', 'semaphore.h')
]
},
'libcxx_src': {
'type': 'source',
'output_dirname': 'libcxx',
'commands': GitSyncCmds('libcxx'),
},
'libcxxabi_src': {
'type': 'source',
'output_dirname': 'libcxxabi',
'commands': GitSyncCmds('libcxxabi'),
},
'compiler_rt_src': {
'type': 'source',
'output_dirname': 'compiler-rt',
'commands': GitSyncCmds('compiler-rt'),
},
'gcc_src': {
'type': 'source',
'output_dirname': 'pnacl-gcc',
'commands': GitSyncCmds('gcc'),
},
}
return source
def NewlibLibcScript(arch, elfclass_x86_64='elf32'):
template = """/*
* This is a linker script that gets installed as libc.a for the
* newlib-based NaCl toolchain. It brings in the constituent
* libraries that make up what -lc means semantically.
*/
OUTPUT_FORMAT(%s)
GROUP ( libnacl.a libcrt_common.a )
"""
if arch == 'arm':
# Listing three formats instead of one makes -EL/-EB switches work
# for the endian-switchable ARM backend.
format_list = ['elf32-littlearm-nacl',
'elf32-bigarm-nacl',
'elf32-littlearm-nacl']
elif arch == 'i686':
format_list = ['elf32-i386-nacl']
elif arch == 'x86_64':
format_list = ['%s-x86-64-nacl' % elfclass_x86_64]
elif arch == 'mipsel' :
format_list = ['elf32-tradlittlemips-nacl']
else:
raise Exception('TODO(mcgrathr): OUTPUT_FORMAT for %s' % arch)
return template % ', '.join(['"' + fmt + '"' for fmt in format_list])
def NewlibDirectoryCmds(bias_arch, newlib_triple):
commands = []
def NewlibLib(name):
return os.path.join('%(output)s', newlib_triple, 'lib', name)
if not IsBCArch(bias_arch):
commands.extend([
command.Rename(NewlibLib('libc.a'), NewlibLib('libcrt_common.a')),
command.WriteData(NewlibLibcScript(bias_arch, 'elf64'),
NewlibLib('libc.a'))])
target_triple = TripleFromArch(bias_arch)
if bias_arch != 'i686':
commands.extend([
# For biased bitcode builds, we configured newlib with target=le32-nacl
# to get its pure C implementation, so rename its output dir (which
# matches the target to the output dir for the package we are building)
command.Rename(os.path.join('%(output)s', newlib_triple),
os.path.join('%(output)s', target_triple)),
# Copy nacl_random.h, used by libc++. It uses the IRT, so should
# be safe to include in the toolchain.
command.Mkdir(
os.path.join('%(output)s', target_triple, 'include', 'nacl')),
command.Copy(os.path.join('%(top_srcdir)s', 'src', 'untrusted',
'nacl', 'nacl_random.h'),
os.path.join('%(output)s', target_triple, 'include',
'nacl', 'nacl_random.h'))
])
else:
# Use multilib-style directories for i686
multilib_triple = TripleFromArch(MultilibArch(bias_arch))
commands.extend([
command.Rename(os.path.join('%(output)s', newlib_triple),
os.path.join('%(output)s', multilib_triple)),
command.RemoveDirectory(
os.path.join('%(output)s', multilib_triple, 'include')),
command.Rename(
os.path.join('%(output)s', multilib_triple, 'lib'),
os.path.join('%(output)s', multilib_triple, 'lib32')),
])
# Remove the 'share' directory from the biased builds; the data is
# duplicated exactly and takes up 2MB per package.
if bias_arch != 'le32':
commands.append(command.RemoveDirectory(os.path.join('%(output)s','share')))
return commands
# For saigo, we build newlib with le32-nacl as a target, which does not compile
# setjmp.S. Instead, we pull in setjmp from the native_client repo.
def NewlibSaigoCmds(bias_arch):
lib = 'lib'
if bias_arch == 'i686':
lib = 'lib32'
archive_path = command.path.join('%(output)s',
'%s-nacl' % MultilibArch(bias_arch), lib)
return [
command.Command([PnaclTool('clang', arch=bias_arch, saigo=True),
'-Wall', '-Werror', '-O2', '-fintegrated-as',
'-c', '%(setjmp)s',
'-o', command.path.join('%(cwd)s', 'lib_a-setjmp.o')]),
command.Command([PnaclTool('ar', arch=bias_arch, saigo=True), 'r',
command.path.join(archive_path, 'libcrt_common.a'),
command.path.join('%(cwd)s', 'lib_a-setjmp.o')])
]
def LibcxxDirectoryCmds(bias_arch):
if bias_arch != 'i686':
return []
lib_dir = os.path.join('%(output)s', MultilibLibDir(bias_arch))
return [
# Use the multlib-style lib dir and shared headers for i686
command.Mkdir(os.path.dirname(lib_dir)),
command.Rename(os.path.join('%(output)s', 'i686-nacl', 'lib'),
lib_dir),
# The only thing left in i686-nacl is the headers
command.RemoveDirectory(os.path.join('%(output)s', 'i686-nacl')),
]
def D2NLibsSupportCommands(bias_arch, clang_libdir, saigo=False):
def TL(lib):
return GSDJoin(lib, pynacl.platform.GetArch3264(bias_arch))
def TranslatorFile(lib, filename):
return os.path.join('%(' + TL(lib) + ')s', filename)
extra_cflags = ''
libname = 'libgcc_eh'
if saigo:
libname = 'libgcc_eh_saigo'
extra_cflags = NewlibIsystemCflags(bias_arch, saigo=saigo)
commands = [
# Build compiler_rt which is now also used for the PNaCl
# translator.
command.Command(MakeCommand() + [
'-C', '%(abs_compiler_rt_src)s', 'ProjObjRoot=%(cwd)s',
'VERBOSE=1',
'AR=' + PnaclTool('ar', arch=bias_arch, saigo=saigo),
'RANLIB=' + PnaclTool('ranlib', arch=bias_arch, saigo=saigo),
'CC=' + PnaclTool('clang', arch=bias_arch, saigo=saigo),
'clang_nacl',
'EXTRA_CFLAGS=' + extra_cflags]),
command.Mkdir(clang_libdir, parents=True),
command.Copy(os.path.join(
'clang_nacl',
'full-' + bias_arch.replace('i686', 'i386')
.replace('mipsel', 'mips32'),
'libcompiler_rt.a'),
os.path.join('%(output)s', clang_libdir,
'libgcc.a')),
command.Copy(TranslatorFile(libname, 'libgcc_eh.a'),
os.path.join('%(output)s', clang_libdir, 'libgcc_eh.a')),
BuildTargetObjectCmd('clang_direct/crtbegin.c', 'crtbeginT.o',
bias_arch, output_dir=clang_libdir,
saigo=saigo),
BuildTargetObjectCmd('crtend.c', 'crtend.o',
bias_arch, output_dir=clang_libdir,
saigo=saigo),
]
if bias_arch == "mipsel":
commands.extend([
BuildTargetObjectCmd('bitcode/pnaclmm.c', 'pnaclmm.o', bias_arch),
BuildTargetObjectCmd('clang_direct/nacl-tp-offset.c',
'nacl_tp_offset.o', bias_arch,
extra_flags=['-I%(top_srcdir)s/..']),
command.Command([PnaclTool('ar'), 'rc',
command.path.join(clang_libdir, 'libpnacl_legacy.a'),
command.path.join('pnaclmm.o'),
command.path.join('nacl_tp_offset.o')])
])
return commands
def TargetLibBuildType(is_canonical):
return 'build' if is_canonical else 'build_noncanonical'
def TargetLibs(bias_arch, is_canonical):
def T(component_name):
return GSDJoin(component_name, bias_arch)
if not IsBCArch(bias_arch):
# Translate from bias_arch's triple-style (i686) names to the translator's
# style (x86-32). We don't change the translator's naming scheme to avoid
# churning the in-browser translator.
arch = pynacl.platform.GetArch3264(bias_arch)
def TL(lib):
return GSDJoin(lib, arch)
target_triple = TripleFromArch(bias_arch)
newlib_triple = target_triple if not IsBCArch(bias_arch) else 'le32-nacl'
newlib_cflags = ' -std=gnu89'
if IsBCArch(bias_arch):
# This avoids putting the body of memcpy in libc for bitcode
newlib_cflags += ' -DPNACL_BITCODE'
elif bias_arch == 'arm':
# This ensures that nacl gets the asm version of memcpy (gcc defines this
# macro for armv7a but clang does not)
newlib_cflags += ' -D__ARM_FEATURE_UNALIGNED'
clang_libdir = os.path.join(
'%(output)s', 'lib', 'clang', CLANG_VER, 'lib', target_triple)
saigo_clang_libdir = os.path.join(
'%(output)s', 'lib', 'clang', SAIGO_CLANG_VER, 'lib', target_triple)
libc_libdir = os.path.join('%(output)s', MultilibLibDir(bias_arch))
libs = {
T('newlib'): {
'type': TargetLibBuildType(is_canonical),
'dependencies': [ 'newlib_src', 'target_lib_compiler'],
'commands' : [
command.SkipForIncrementalCommand(
['sh', '%(newlib_src)s/configure'] +
TargetTools(bias_arch, saigo=False) +
['CFLAGS_FOR_TARGET=' +
TargetLibCflags(bias_arch) +
newlib_cflags,
'--prefix=',
'--disable-newlib-supplied-syscalls',
'--disable-texinfo',
'--disable-libgloss',
'--enable-newlib-iconv',
'--enable-newlib-iconv-from-encodings=' +
'UTF-8,UTF-16LE,UCS-4LE,UTF-16,UCS-4',
'--enable-newlib-iconv-to-encodings=' +
'UTF-8,UTF-16LE,UCS-4LE,UTF-16,UCS-4',
'--enable-newlib-io-long-long',
'--enable-newlib-io-long-double',
'--enable-newlib-io-c99-formats',
'--enable-newlib-mb',
'--target=' + newlib_triple
]),
command.Command(MakeCommand()),
command.Command(['make', 'DESTDIR=%(abs_output)s', 'install']),
] + NewlibDirectoryCmds(bias_arch, newlib_triple)
},
T('libcxx'): {
'type': TargetLibBuildType(is_canonical),
'dependencies': ['libcxx_src', 'libcxxabi_src', 'llvm_src', 'gcc_src',
'target_lib_compiler', T('newlib'),
GSDJoin('newlib', MultilibArch(bias_arch)),
T('libs_support')],
'commands' :
[command.SkipForIncrementalCommand(
[pnacl_commands.PrebuiltCMakeBin(), '-G', 'Unix Makefiles',
'-DCMAKE_C_COMPILER_WORKS=1',
'-DCMAKE_CXX_COMPILER_WORKS=1',
'-DCMAKE_INSTALL_PREFIX=',
'-DCMAKE_BUILD_TYPE=Release',
'-DCMAKE_C_COMPILER=' + PnaclTool('clang', bias_arch),
'-DCMAKE_CXX_COMPILER=' + PnaclTool('clang++', bias_arch),
'-DCMAKE_SYSTEM_NAME=nacl',
'-DCMAKE_AR=' + PnaclTool('ar', bias_arch),
'-DCMAKE_NM=' + PnaclTool('nm', bias_arch),
'-DCMAKE_RANLIB=' + PnaclTool('ranlib', bias_arch),
'-DCMAKE_LD=' + PnaclTool('illegal', bias_arch),
'-DCMAKE_AS=' + PnaclTool('as', bias_arch),
'-DCMAKE_OBJDUMP=' + PnaclTool('illegal', bias_arch),
'-DCMAKE_C_FLAGS=-std=gnu11 ' + LibCxxCflags(bias_arch),
'-DCMAKE_CXX_FLAGS=-std=gnu++11 ' + LibCxxCflags(bias_arch),
'-DLIT_EXECUTABLE=' + command.path.join(
'%(llvm_src)s', 'utils', 'lit', 'lit.py'),
# The lit flags are used by the libcxx testsuite, which is
# currenty driven by an external script.
'-DLLVM_LIT_ARGS=--verbose --param shell_prefix="' +
os.path.join(NACL_DIR,'run.py') +' -arch env --retries=1" '+
'--param exe_suffix=".pexe" --param use_system_lib=true ' +
'--param cxx_under_test="' + os.path.join(NACL_DIR,
'toolchain/linux_x86/pnacl_newlib',
'bin/pnacl-clang++') +
'" '+
'--param link_flags="-std=gnu++11 --pnacl-exceptions=sjlj"',
'-DLIBCXX_ENABLE_CXX0X=0',
'-DLIBCXX_ENABLE_SHARED=0',
'-DLIBCXX_CXX_ABI=libcxxabi',
'-DLIBCXX_LIBCXXABI_INCLUDE_PATHS=' + command.path.join(
'%(abs_libcxxabi_src)s', 'include'),
'%(libcxx_src)s']),
command.Copy(os.path.join('%(gcc_src)s', 'gcc',
'unwind-generic.h'),
os.path.join('include', 'unwind.h')),
command.Command(MakeCommand() + ['VERBOSE=1']),
command.Command([
'make',
'DESTDIR=' + os.path.join('%(abs_output)s', target_triple),
'VERBOSE=1',
'install']),
] + LibcxxDirectoryCmds(bias_arch)
},
}
if bias_arch == 'i686' or bias_arch == 'x86_64' or bias_arch == 'arm':
saigo_newlib_c_flags = \
' -Wno-deprecated-non-prototype -Wno-implicit-function-declaration'
libs.update({
T('newlib_saigo'): {
'type': TargetLibBuildType(is_canonical),
'dependencies': [ 'newlib_src', 'target_lib_compiler_saigo'],
'inputs': {
'setjmp': os.path.join(NACL_DIR, 'pnacl', 'support',
'setjmp_%s.S' % arch.replace('-', '_'))
},
'commands' : [
command.SkipForIncrementalCommand(
['sh', '%(newlib_src)s/configure'] +
TargetTools(bias_arch, saigo=True) +
['CFLAGS_FOR_TARGET=' +
TargetLibCflags(bias_arch) +
newlib_cflags +
saigo_newlib_c_flags,
'--prefix=',
'--disable-newlib-supplied-syscalls',
'--disable-texinfo',
'--disable-libgloss',
'--enable-newlib-iconv',
'--enable-newlib-iconv-from-encodings=' +
'UTF-8,UTF-16LE,UCS-4LE,UTF-16,UCS-4',
'--enable-newlib-iconv-to-encodings=' +
'UTF-8,UTF-16LE,UCS-4LE,UTF-16,UCS-4',
'--enable-newlib-io-long-long',
'--enable-newlib-io-long-double',
'--enable-newlib-io-c99-formats',
'--enable-newlib-mb',
'--target=le32-nacl'
]),
command.Command(MakeCommand()),
command.Command(['make', 'DESTDIR=%(abs_output)s', 'install']),
]
+ NewlibDirectoryCmds(bias_arch, 'le32-nacl')
+ NewlibSaigoCmds(bias_arch)
},
T('libs_support_saigo'): {
'type': TargetLibBuildType(is_canonical),
'dependencies': [ 'compiler_rt_src',
GSDJoin('newlib_saigo', MultilibArch(bias_arch)),
TL('libgcc_eh_saigo'),
'target_lib_compiler_saigo'],
'inputs': { 'src': os.path.join(NACL_DIR, 'pnacl', 'support'),
'tls_params': os.path.join(NACL_DIR, 'src', 'untrusted',
'nacl', 'tls_params.h')},
'commands': D2NLibsSupportCommands(bias_arch,
saigo_clang_libdir,
saigo=True)
},
T('libcxx_saigo'): {
'type': TargetLibBuildType(is_canonical),
'dependencies': ['llvm_saigo_src', 'gcc_src',
'target_lib_compiler_saigo', T('newlib_saigo'),
GSDJoin('newlib_saigo', MultilibArch(bias_arch)),
T('libs_support_saigo')],
'commands' :
[command.SkipForIncrementalCommand(
[pnacl_commands.PrebuiltCMakeBin(), '-G', 'Ninja',
'-B', '.',
'-DCMAKE_C_COMPILER_WORKS=1',
'-DCMAKE_CXX_COMPILER_WORKS=1',
'-DCMAKE_INSTALL_PREFIX=' +
os.path.join('%(abs_output)s', target_triple),
'-DCMAKE_BUILD_TYPE=Release',
'-DCMAKE_C_COMPILER=' +
PnaclTool('clang', bias_arch, saigo=True),
'-DCMAKE_CXX_COMPILER=' +
PnaclTool('clang++', bias_arch, saigo=True),
'-DCMAKE_NM=' + PnaclTool('nm', bias_arch, saigo=True),
'-DCMAKE_RANLIB=' +
PnaclTool('ranlib', bias_arch, saigo=True),
'-DCMAKE_LD=' + PnaclTool('illegal', bias_arch, saigo=True),
'-DCMAKE_AS=' + PnaclTool('as', bias_arch, saigo=True),
'-DCMAKE_AR=' + PnaclTool('ar', bias_arch, saigo=True),
'-DCMAKE_OBJDUMP=' +
PnaclTool('illegal', bias_arch, saigo=True),
'-DCMAKE_LIBTOOL=' + PnaclTool('ar', bias_arch, saigo=True),
'-DCMAKE_SYSTEM_NAME=nacl',
'-DLLVM_ENABLE_RUNTIMES=libcxx;libcxxabi',
'-DLLVM_DEFAULT_TARGET_TRIPLE=' + target_triple,
'-DLLVM_ENABLE_PER_TARGET_RUNTIME_DIR=0',
'-DLLVM_ENABLE_PIC=OFF',
'-DLLVM_HAS_ATOMICS=ON',
'-DLLVM_LIBSTDCXX_MIN=1',
'-DLLVM_TEMPORARILY_ALLOW_OLD_TOOLCHAIN=1',
'-DLLVM_INCLUDE_BENCHMARKS=OFF',
'-DLIBCXX_INCLUDE_BENCHMARKS=OFF',
'-DLIBCXX_ENABLE_SHARED=0',
'-DLIBCXX_ENABLE_FILESYSTEM=0',
'-DLIBCXX_CXX_ABI=libcxxabi',
'-DLIBCXX_ENABLE_STATIC_ABI_LIBRARY=1',
'-DLIBCXXABI_ENABLE_SHARED=0',
'-DCMAKE_POSITION_INDEPENDENT_CODE=OFF',
'-DCMAKE_C_FLAGS=' + LibCxxSaigoCflags(bias_arch),
'-DCMAKE_CXX_FLAGS=' + LibCxxSaigoCflags(bias_arch),
'%(llvm_saigo_src)s/runtimes']),
command.Copy(os.path.join('%(gcc_src)s', 'gcc',
'unwind-generic.h'),
os.path.join('include', 'unwind.h')),
command.Command([NINJA_PATH, '-v', 'cxx', 'cxxabi']),
command.Command([NINJA_PATH,
'install-cxx',
'install-cxxabi',
'install-cxx-headers']),
] + LibcxxDirectoryCmds(bias_arch)
},
})
if IsBCArch(bias_arch):
libs.update({
T('compiler_rt_bc'): {
'type': TargetLibBuildType(is_canonical),
'dependencies': ['compiler_rt_src', 'target_lib_compiler'],
'commands': [
command.Mkdir(clang_libdir, parents=True),
command.Command(MakeCommand() + [
'-f',
command.path.join('%(compiler_rt_src)s', 'lib', 'builtins',
'Makefile-pnacl-bitcode'),
'libgcc.a', 'CC=' + PnaclTool('clang'),
'AR=' + PnaclTool('ar')] +
['SRC_DIR=' + command.path.join('%(abs_compiler_rt_src)s',
'lib', 'builtins'),
'CFLAGS=' + ' '.join([
'-DPNACL_' + TargetArch(bias_arch).replace('-', '_')])
]),
command.Copy('libgcc.a', os.path.join(clang_libdir, 'libgcc.a')),
],
},
T('libs_support'): {
'type': TargetLibBuildType(is_canonical),
'dependencies': [ T('newlib'), 'target_lib_compiler'],
'inputs': { 'src': os.path.join(NACL_DIR,
'pnacl', 'support', 'bitcode')},
'commands': [
command.Mkdir(clang_libdir, parents=True),
command.Mkdir(libc_libdir, parents=True),
# Two versions of crt1.x exist, for different scenarios (with and
# without EH). See:
# https://code.google.com/p/nativeclient/issues/detail?id=3069
command.Copy(command.path.join('%(src)s', 'crt1.x'),
command.path.join(libc_libdir, 'crt1.x')),
command.Copy(command.path.join('%(src)s', 'crt1_for_eh.x'),
command.path.join(libc_libdir, 'crt1_for_eh.x')),
# Install crti.bc (empty _init/_fini)
BuildTargetObjectCmd('crti.c', 'crti.bc', bias_arch,
output_dir=libc_libdir),
# Install crtbegin bitcode (__cxa_finalize for C++)
BuildTargetObjectCmd('crtbegin.c', 'crtbegin.bc', bias_arch,
output_dir=clang_libdir),
# Stubs for _Unwind_* functions when libgcc_eh is not included in
# the native link).
BuildTargetObjectCmd('unwind_stubs.c', 'unwind_stubs.bc',
bias_arch, output_dir=clang_libdir),
BuildTargetObjectCmd('sjlj_eh_redirect.cc',
'sjlj_eh_redirect.bc', bias_arch,
output_dir=clang_libdir),
# libpnaclmm.a (__atomic_* library functions).
BuildTargetObjectCmd('pnaclmm.c', 'pnaclmm.bc', bias_arch),
command.Command([
PnaclTool('ar'), 'rc',
command.path.join(clang_libdir, 'libpnaclmm.a'),
'pnaclmm.bc']),
]
}
})
else:
# For now some of the D2N support libs currently come from our native
# translator libs (libgcc_eh). crti/crtn and crt1
# come from libnacl, built by scons/gyp. TODO(dschuff): Do D2N libgcc_eh.
libs.update({
T('libs_support'): {
'type': TargetLibBuildType(is_canonical),
'dependencies': [ 'compiler_rt_src',
GSDJoin('newlib', MultilibArch(bias_arch)),
TL('libgcc_eh'),
'target_lib_compiler'],
'inputs': { 'src': os.path.join(NACL_DIR, 'pnacl', 'support'),
'tls_params': os.path.join(NACL_DIR, 'src', 'untrusted',
'nacl', 'tls_params.h')},
'commands': D2NLibsSupportCommands(bias_arch, clang_libdir),
}
})
return libs
def SubzeroRuntimeCommands(arch, out_dir):
"""Returns a list of commands to build the Subzero runtime.
When the commands are executed, temporary files are created in the current
directory, and .o files are created in the out_dir directory. If arch isn't
among a allowlist, an empty list of commands is returned.
"""
AsmSourceBase = None
# LlcArchArgs contains arguments extracted from pnacl-translate.py.
if arch == 'x86-32-linux':
Triple = 'i686-linux-gnu'
LlcArchArgs = [ '-mcpu=pentium4m']
elif arch == 'x86-32':
Triple = 'i686-none-nacl-gnu'
LlcArchArgs = [ '-mcpu=pentium4m']
elif arch == 'x86-32-nonsfi':
Triple = 'i686-linux-gnu'
LlcArchArgs = [ '-mcpu=pentium4m', '-relocation-model=pic',
'-force-tls-non-pic', '-malign-double']
AsmSourceBase = 'szrt_asm_x8632'
elif arch == 'x86-64-linux':
Triple = 'x86_64-none-linux-gnux32'
LlcArchArgs = [ '-mcpu=x86-64']
elif arch == 'x86-64':
Triple = 'x86_64-none-nacl'
LlcArchArgs = [ '-mcpu=x86-64']
elif arch == 'arm-linux':
Triple = 'arm-linux-gnu'
LlcArchArgs = [ '-mcpu=cortex-a9', '-float-abi=hard', '-mattr=+neon']
elif arch == 'arm':
Triple = 'armv7a-none-nacl'
LlcArchArgs = [ '-mcpu=cortex-a9', '-float-abi=hard', '-mattr=+neon']
elif arch == 'arm-nonsfi':
Triple = 'armv7a-none-linux-gnueabihf'
LlcArchArgs = [ '-mcpu=cortex-a9', '-float-abi=hard', '-mattr=+neon',
'-relocation-model=pic', '-force-tls-non-pic',
'-malign-double']
AsmSourceBase = 'szrt_asm_arm32'
else:
return []
LlcArchArgs.append('-mtriple=' + Triple)
return [
command.Command([
PnaclTool('clang'), '-O2',
'-c', command.path.join('%(subzero_src)s', 'runtime', 'szrt.c'),
'-o', 'szrt.tmp.bc']),
command.Command([
PnaclTool('opt'), '-pnacl-abi-simplify-preopt',
'-pnacl-abi-simplify-postopt', '-pnaclabi-allow-debug-metadata',
'szrt.tmp.bc', '-S', '-o', 'szrt.ll']),
command.Command([
PnaclTool('llc'), '-externalize', '-function-sections', '-O2',
'-filetype=obj', '-bitcode-format=llvm',
'-o', os.path.join(out_dir, 'szrt.o'),
'szrt.ll'] +
LlcArchArgs),
command.Command([
PnaclTool('llc'), '-externalize', '-function-sections', '-O2',
'-filetype=obj', '-bitcode-format=llvm',
'-o', os.path.join(out_dir, 'szrt_ll.o'),
command.path.join('%(subzero_src)s', 'runtime', 'szrt_ll.ll')] +
LlcArchArgs),
] + ([
command.Command([
PnaclTool('llvm-mc'),
'-filetype=obj',
'-triple=' + Triple,
'--defsym', 'NONSFI=1',
'-o', os.path.join(out_dir, AsmSourceBase + '.o'),
command.path.join('%(subzero_src)s', 'runtime', AsmSourceBase + '.s')])
] if IsNonSFIArch(arch) else [])
def LibgccEhCommands(arch, no_nacl_gcc, saigo=False):
pnacl_tool_arch = 'le32'
if saigo:
pnacl_tool_arch = TranslatorArchToBiasArch(arch)
return [
# Instead of trying to use gcc's build system to build only
# libgcc_eh, we just build the C files and archive them manually.
command.RemoveDirectory('include'),
command.Mkdir('include'),
command.Copy(os.path.join('%(gcc_src)s', 'gcc',
'unwind-generic.h'),
os.path.join('include', 'unwind.h')),
command.Copy(os.path.join('%(scripts)s', 'libgcc-tconfig.h'),
'tconfig.h'),
command.WriteData('', 'tm.h'),
BuildLibgccEhCmd('unwind-dw2.c', 'unwind-dw2.o', arch,
no_nacl_gcc, saigo),
BuildLibgccEhCmd('unwind-dw2-fde-glibc.c',
'unwind-dw2-fde-glibc.o',
arch, no_nacl_gcc, saigo),
command.Command([PnaclTool('ar', arch=pnacl_tool_arch, saigo=saigo),
'rc',
command.path.join('%(output)s', 'libgcc_eh.a'),
'unwind-dw2.o', 'unwind-dw2-fde-glibc.o']),
]
def TranslatorLibs(arch, is_canonical, no_nacl_gcc):
setjmp_arch = arch
if setjmp_arch.endswith('-nonsfi'):
setjmp_arch = setjmp_arch[:-len('-nonsfi')]
bias_arch = TranslatorArchToBiasArch(arch)
translator_lib_dir = os.path.join('translator', arch, 'lib')
arch_cmds = []
if arch == 'arm':
arch_cmds.append(
BuildTargetTranslatorCmd('aeabi_read_tp.S', 'aeabi_read_tp.o', arch))
elif arch == 'x86-32-nonsfi':
arch_cmds.extend(
[BuildTargetTranslatorCmd('entry_linux.c', 'entry_linux.o', arch),
BuildTargetTranslatorCmd('entry_linux_x86_32.S', 'entry_linux_asm.o',
arch)])
elif arch == 'arm-nonsfi':
arch_cmds.extend(
[BuildTargetTranslatorCmd('entry_linux.c', 'entry_linux.o', arch),
BuildTargetTranslatorCmd('entry_linux_arm.S', 'entry_linux_asm.o',
arch)])
if not IsNonSFIArch(arch):
def ClangLib(lib):
return GSDJoin(lib, bias_arch)
clang_deps = [ ClangLib('newlib'), ClangLib('libs_support') ]
# Extract the object files from the newlib archive into our working dir.
# libcrt_platform.a is later created by archiving all the object files
# there.
crt_objs = ['memmove', 'memcmp', 'memset', 'memcpy']
if arch == 'mips32':
crt_objs.extend(['memset-stub', 'memcpy-stub'])
libcrt_platform_string_cmds = [command.Command([
PnaclTool('ar'), 'x',
os.path.join('%(' + ClangLib('newlib') + ')s',
MultilibLibDir(bias_arch), 'libcrt_common.a'),
] + ['lib_a-%s.o' % f for f in crt_objs])]
# Copy compiler_rt from nacl-clang
clang_libdir = os.path.join(
'lib', 'clang', CLANG_VER, 'lib', TripleFromArch(bias_arch))
compiler_rt_cmds = [command.Copy(
os.path.join('%(' + ClangLib('libs_support') + ')s',
clang_libdir, 'libgcc.a'),
os.path.join('%(output)s', 'libgcc.a'))]
else:
clang_deps = []
extra_flags = NonSFITargetLibCflags(bias_arch).split()
libcrt_platform_string_cmds = [BuildTargetTranslatorCmd(
'string.c', 'string.o', arch, ['-std=c99'],
source_dir='%(newlib_subset)s')]
# Build compiler_rt with PNaCl
compiler_rt_cmds = [
command.Command(MakeCommand() + [
'-C', '%(abs_compiler_rt_src)s', 'ProjObjRoot=%(cwd)s',
'VERBOSE=1',
'CC=' + PnaclTool('clang', arch=bias_arch), 'clang_nacl',
'EXTRA_CFLAGS=' + (NewlibIsystemCflags('le32') + ' ' +
' '.join(extra_flags))]),
command.Copy(os.path.join(
'clang_nacl',
'full-' + bias_arch.replace('i686', 'i386')
.replace('mipsel', 'mips32'),
'libcompiler_rt.a'),
os.path.join('%(output)s', 'libgcc.a')),
]
libs = {
GSDJoin('libs_support_translator', arch): {
'type': TargetLibBuildType(is_canonical),
'output_subdir': translator_lib_dir,
'dependencies': [ 'newlib_src', 'compiler_rt_src', 'subzero_src',
'target_lib_compiler', 'newlib_le32'] + clang_deps,
# These libs include
# arbitrary stuff from native_client/src/{include,untrusted,trusted}
'inputs': { 'src': os.path.join(NACL_DIR, 'pnacl', 'support'),
'include': os.path.join(NACL_DIR, 'src'),
'newlib_subset': os.path.join(
NACL_DIR, 'src', 'third_party',
'pnacl_native_newlib_subset')},
'commands': SubzeroRuntimeCommands(arch, '.') + [
BuildTargetTranslatorCmd('crtbegin.c', 'crtbegin.o', arch,
output_dir='%(output)s'),
BuildTargetTranslatorCmd('crtbegin.c', 'crtbegin_for_eh.o', arch,
['-DLINKING_WITH_LIBGCC_EH'],
output_dir='%(output)s'),
BuildTargetTranslatorCmd('crtend.c', 'crtend.o', arch,
output_dir='%(output)s'),
# libcrt_platform.a
BuildTargetTranslatorCmd('pnacl_irt.c', 'pnacl_irt.o', arch),
BuildTargetTranslatorCmd('relocate.c', 'relocate.o', arch),
BuildTargetTranslatorCmd(
'setjmp_%s.S' % setjmp_arch.replace('-', '_'),
'setjmp.o', arch),
# Pull in non-errno __ieee754_fmod from newlib and rename it to
# fmod. This is to support the LLVM frem instruction.
BuildTargetTranslatorCmd(
'e_fmod.c', 'e_fmod.o', arch,
['-std=c99', '-I%(abs_newlib_src)s/newlib/libm/common/',
'-D__ieee754_fmod=fmod'],
source_dir='%(abs_newlib_src)s/newlib/libm/math'),
BuildTargetTranslatorCmd(
'ef_fmod.c', 'ef_fmod.o', arch,
['-std=c99', '-I%(abs_newlib_src)s/newlib/libm/common/',
'-D__ieee754_fmodf=fmodf'],
source_dir='%(abs_newlib_src)s/newlib/libm/math')] +
arch_cmds + libcrt_platform_string_cmds + [
command.Command(' '.join([
PnaclTool('ar'), 'rc',
command.path.join('%(output)s', 'libcrt_platform.a'),
'*.o']), shell=True),
# Dummy IRT shim
BuildTargetTranslatorCmd(
'dummy_shim_entry.c', 'dummy_shim_entry.o', arch),
command.Command([PnaclTool('ar'), 'rc',
command.path.join('%(output)s',
'libpnacl_irt_shim_dummy.a'),
'dummy_shim_entry.o']),
] + compiler_rt_cmds,
},
}
if not arch.endswith('-nonsfi'):
libs.update({
GSDJoin('libgcc_eh', arch): {
'type': TargetLibBuildType(is_canonical),
'output_subdir': translator_lib_dir,
'dependencies': [ 'gcc_src', 'target_lib_compiler'],
'inputs': { 'scripts': os.path.join(NACL_DIR, 'pnacl', 'scripts')},
'commands': LibgccEhCommands(arch, no_nacl_gcc),
},
})
if arch == 'x86-32' or arch == 'x86-64' or arch == 'arm':
libs.update({
GSDJoin('libgcc_eh_saigo', arch): {
'type': TargetLibBuildType(is_canonical),
'output_subdir': translator_lib_dir,
'dependencies': [ 'gcc_src', 'target_lib_compiler_saigo'],
'inputs': { 'scripts': os.path.join(NACL_DIR, 'pnacl', 'scripts')},
'commands': LibgccEhCommands(arch, no_nacl_gcc, saigo=True),
},
})
return libs
def UnsandboxedRuntime(arch, is_canonical):
assert arch in ('arm-linux', 'x86-32-linux', 'x86-32-mac', 'x86-64-linux')
compiler = {
'arm-linux': 'arm-linux-gnueabihf-gcc',
'x86-32-linux': 'gcc',
'x86-32-mac': 'gcc',
# x86-64 can't use gcc because the gcc available in the bots does not
# support x32. clang is good enough for the task, and it is available in
# the bots.
'x86-64-linux': '%(abs_target_lib_compiler)s/bin/clang',
}[arch]
arch_cflags = {
'arm-linux': ['-mcpu=cortex-a9', '-D__arm_nonsfi_linux__'],
'x86-32-linux': ['-m32'],
'x86-32-mac': ['-m32'],
'x86-64-linux': ['-mx32'],
}[arch]
libs = {
GSDJoin('unsandboxed_runtime', arch): {
'type': TargetLibBuildType(is_canonical),
'output_subdir': os.path.join('translator', arch, 'lib'),
'dependencies': [ 'subzero_src', 'target_lib_compiler'],
# This lib #includes
# arbitrary stuff from native_client/src/{include,untrusted,trusted}
'inputs': { 'support': os.path.join(NACL_DIR, 'src', 'nonsfi', 'irt'),
'untrusted': os.path.join(
NACL_DIR, 'src', 'untrusted', 'irt'),
'include': os.path.join(NACL_DIR, 'src'), },
'commands': [
# The NaCl headers insist on having a platform macro such as
# NACL_LINUX defined, but src/nonsfi/irt_interfaces.c does not
# itself use any of these macros, so defining NACL_LINUX here
# even on non-Linux systems is OK.
# TODO(dschuff): this include path breaks the input encapsulation
# for build rules.
command.Command([compiler] + arch_cflags + ['-O2', '-Wall',
'-Werror', '-I%(top_srcdir)s/..',
'-DNACL_LINUX=1', '-DDEFINE_MAIN',
'-c', command.path.join('%(support)s', 'irt_interfaces.c'),
'-o', command.path.join('%(output)s', 'unsandboxed_irt.o')]),
command.Command([compiler] + arch_cflags + ['-O2', '-Wall',
'-Werror', '-I%(top_srcdir)s/..',
'-c', command.path.join('%(support)s', 'irt_random.c'),
'-o', command.path.join('%(output)s', 'irt_random.o')]),
command.Command([compiler] + arch_cflags + ['-O2', '-Wall',
'-Werror', '-I%(top_srcdir)s/..',
'-c', command.path.join('%(untrusted)s', 'irt_query_list.c'),
'-o', command.path.join('%(output)s', 'irt_query_list.o')]),
] + SubzeroRuntimeCommands(arch, '%(output)s'),
},
}
return libs
def SDKCompiler(arches):
arch_packages = ([GSDJoin('newlib', arch) for arch in arches] +
[GSDJoin('libcxx', arch) for arch in arches])
saigo_packages = [GSDJoin('newlib_saigo', 'i686'),
GSDJoin('newlib_saigo', 'x86_64'),
GSDJoin('newlib_saigo', 'arm'),
GSDJoin('libcxx_saigo', 'i686'),
GSDJoin('libcxx_saigo', 'x86_64'),
GSDJoin('libcxx_saigo', 'arm')]
compiler = {
'sdk_compiler': {
'type': 'work',
'output_subdir': 'sdk_compiler',
'dependencies': ['target_lib_compiler'] + arch_packages,
'commands': [
command.CopyRecursive('%(' + t + ')s', '%(output)s')
for t in ['target_lib_compiler'] + arch_packages],
},
'sdk_compiler_saigo': {
'type': 'work',
'output_subdir': 'sdk_compiler_saigo',
'dependencies': ['target_lib_compiler_saigo'] + saigo_packages,
'commands': [
command.CopyRecursive('%(' + t + ')s', '%(output)s')
for t in ['target_lib_compiler_saigo'] + saigo_packages]
},
}
return compiler
def SDKLibs(arch, is_canonical, extra_flags=[]):
scons_flags = ['--verbose', 'MODE=nacl', '-j%(cores)s', 'naclsdk_validate=0',
'DESTINATION_ROOT=%(work_dir)s']
scons_flags.extend(extra_flags)
if arch == 'le32':
scons_flags.extend(['bitcode=1', 'platform=x86-32'])
elif not IsBCArch(arch):
scons_flags.extend(['nacl_clang=1',
'platform=' + pynacl.platform.GetArch3264(arch)])
else:
raise ValueError('Should not be building SDK libs for', arch)
if arch == 'mipsel':
scons_flags.append('--no-clang')
scons_flags_pnacl = ['pnacl_newlib_dir=%(abs_sdk_compiler)s']
scons_flags_saigo = ['saigo_newlib_dir=%(abs_sdk_compiler_saigo)s', 'saigo=1']
libs = {
GSDJoin('core_sdk_libs', arch): {
'type': TargetLibBuildType(is_canonical),
'dependencies': ['sdk_compiler', 'target_lib_compiler'],
'inputs': {
'src_untrusted': os.path.join(NACL_DIR, 'src', 'untrusted'),
'src_include': os.path.join(NACL_DIR, 'src', 'include'),
'scons.py': os.path.join(NACL_DIR, 'scons.py'),
'SConstruct': os.path.join(NACL_DIR, 'SConstruct'),
'site_scons': os.path.join(NACL_DIR, 'site_scons'),
},
'commands': [
command.Command(
[sys.executable, '%(scons.py)s',
'includedir=' +os.path.join('%(output)s',
TripleFromArch(MultilibArch(arch)),
'include'),
'libdir=' + os.path.join('%(output)s', MultilibLibDir(arch)),
'install'] + scons_flags + scons_flags_pnacl,
cwd=NACL_DIR),
],
}
}
if arch == 'i686' or arch == 'x86_64' or arch == 'arm':
libs[GSDJoin('core_sdk_libs_saigo', arch)] = {
'type': TargetLibBuildType(is_canonical),
'dependencies': ['sdk_compiler_saigo', 'target_lib_compiler_saigo'],
'inputs': {
'src_untrusted': os.path.join(NACL_DIR, 'src', 'untrusted'),
'src_include': os.path.join(NACL_DIR, 'src', 'include'),
'scons.py': os.path.join(NACL_DIR, 'scons.py'),
'SConstruct': os.path.join(NACL_DIR, 'SConstruct'),
'site_scons': os.path.join(NACL_DIR, 'site_scons'),
},
'commands': [
command.Command(
[sys.executable, '%(scons.py)s',
'includedir=' +os.path.join('%(output)s',
TripleFromArch(MultilibArch(arch)),
'include'),
'libdir=' + os.path.join('%(output)s', MultilibLibDir(arch)),
'install'] + scons_flags + scons_flags_saigo,
cwd=NACL_DIR),
],
}
return libs