| #!/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) |
| |
| CLANG_VER = '3.7.0' |
| |
| 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): |
| 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]) |
| 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): |
| return [ tool + '_FOR_TARGET=' + PnaclTool(name, arch=arch, msys=True) |
| for tool, name in TOOL_ENV_NAMES.iteritems() ] |
| |
| |
| 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): |
| include_arch = MultilibArch(bias_arch) |
| return ' '.join([ |
| '-isystem', |
| command.path.join('%(' + GSDJoin('abs_newlib', 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 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=[]): |
| flags = ['-Wall', '-Werror', '-O2', '-c'] + extra_flags |
| if IsBiasedBCArch(bias_arch): |
| flags.extend(BiasedBitcodeTargetFlag(bias_arch)) |
| flags.extend(NewlibIsystemCflags(bias_arch).split()) |
| return command.Command( |
| [PnaclTool('clang', arch=bias_arch, msys=False)] + 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): |
| # 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) |
| 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_newlib_raw' |
| |
| 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') |
| ] |
| }, |
| '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 |
| |
| |
| 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): |
| def TL(lib): |
| return GSDJoin(lib, pynacl.platform.GetArch3264(bias_arch)) |
| def TranslatorFile(lib, filename): |
| return os.path.join('%(' + TL(lib) + ')s', filename) |
| 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), |
| 'RANLIB=' + PnaclTool('ranlib', arch=bias_arch), |
| 'CC=' + PnaclTool('clang', arch=bias_arch), 'clang_nacl', |
| 'EXTRA_CFLAGS=' + NewlibIsystemCflags(bias_arch)]), |
| 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('libgcc_eh', '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), |
| BuildTargetObjectCmd('crtend.c', 'crtend.o', |
| bias_arch, output_dir=clang_libdir), |
| ] |
| 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) |
| target_triple = TripleFromArch(bias_arch) |
| newlib_triple = target_triple if not IsBCArch(bias_arch) else 'le32-nacl' |
| newlib_cpp_flags = '' |
| if IsBCArch(bias_arch): |
| # This avoids putting the body of memcpy in libc for bitcode |
| newlib_cpp_flags = ' -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_cpp_flags = ' -D__ARM_FEATURE_UNALIGNED' |
| |
| clang_libdir = os.path.join( |
| '%(output)s', 'lib', 'clang', 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) + |
| ['CFLAGS_FOR_TARGET=' + |
| TargetLibCflags(bias_arch) + |
| newlib_cpp_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=' + 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.PrebuiltCmake(), '-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 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. |
| |
| # 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. |
| def TL(lib): |
| return GSDJoin(lib, pynacl.platform.GetArch3264(bias_arch)) |
| 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 whitelist, 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 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': [ |
| # 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), |
| BuildLibgccEhCmd('unwind-dw2-fde-glibc.c', |
| 'unwind-dw2-fde-glibc.o', arch, no_nacl_gcc), |
| command.Command([PnaclTool('ar'), 'rc', |
| command.path.join('%(output)s', 'libgcc_eh.a'), |
| 'unwind-dw2.o', 'unwind-dw2-fde-glibc.o']), |
| ], |
| }, |
| }) |
| 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]) |
| 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], |
| }, |
| } |
| return compiler |
| |
| |
| def SDKLibs(arch, is_canonical, extra_flags=[]): |
| scons_flags = ['--verbose', 'MODE=nacl', '-j%(cores)s', 'naclsdk_validate=0', |
| 'pnacl_newlib_dir=%(abs_sdk_compiler)s', |
| '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) |
| 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'), |
| '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, |
| cwd=NACL_DIR), |
| ], |
| } |
| } |
| return libs |
