ndk/toolchains.py - platform/ndk.git - Git at Google

 #
 # Copyright (C) 2019 The Android Open Source Project
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
 # You may obtain a copy of the License at
 #
 #      http://www.apache.org/licenses/LICENSE-2.0
 #
 # Unless required by applicable law or agreed to in writing, software
 # distributed under the License is distributed on an "AS IS" BASIS,
 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 # See the License for the specific language governing permissions and
 # limitations under the License.
 #
 """APIs for accessing toolchains."""
 import enum
 from pathlib import Path
 import subprocess
 from typing import List

 from ndk.hosts import Host, get_default_host
 import ndk.paths


 # When updating this, also update:
 #
 # 1. get_llvm_toolchain_binprefix in build/tools/prebuilt-common.sh
 # 2. CMAKE_C_COMPILER_VERSION and CMAKE_CXX_COMPILER_VERSION in
 #    build/cmake/android.toolchain.cmake
 CLANG_VERSION = 'clang-r365631c1'


 HOST_TRIPLE_MAP = {
     Host.Darwin: 'x86_64-apple-darwin',
     Host.Linux: 'x86_64-linux-gnu',
     Host.Windows64: 'x86_64-w64-mingw32',
 }


 @enum.unique
 class LinkerOption(enum.Enum):
     Default = 'default'
     Lld = 'lld'


 class DarwinSdk:
     """The Darwin SDK."""
     MACOSX_TARGET = '10.9'

     def __init__(self) -> None:
         proc_result = subprocess.run(['xcrun', '--show-sdk-path'],
                                      stdout=subprocess.PIPE,
                                      check=True, encoding='utf-8')
         self.mac_sdk_path = Path(proc_result.stdout.strip())

         self.ar = self.sdk_tool('ar')
         self.asm = self.sdk_tool('as')
         self.ld = self.sdk_tool('ld')
         self.nm = self.sdk_tool('nm')
         self.ranlib = self.sdk_tool('ranlib')
         self.strings = self.sdk_tool('strings')
         self.strip = self.sdk_tool('strip')

     @property
     def flags(self) -> List[str]:
         """The default flags to be used with the SDK."""
         return [
             f'-mmacosx-version-min={self.MACOSX_TARGET}',
             f'-DMACOSX_DEPLOYMENT_TARGET={self.MACOSX_TARGET}',
             f'-isysroot{self.mac_sdk_path}',
             f'-Wl,-syslibroot,{self.mac_sdk_path}',
         ]

     def sdk_tool(self, name: str) -> Path:
         """Returns the path to the given SDK tool."""
         proc_result = subprocess.run(['xcrun', '--find', name],
                                      stdout=subprocess.PIPE,
                                      check=True, encoding='utf-8')
         return Path(proc_result.stdout.strip())


 class Toolchain:
     """A compiler toolchain.

     Describes the directories, executables, and default flags needed to use a
     toolchain.
     """

     def __init__(self, target: Host, host: Host = get_default_host()) -> None:
         if host.is_windows:
             raise NotImplementedError
         self.host = host
         self.target = target

         if self.target == Host.Darwin:
             self.darwin_sdk = DarwinSdk()

     @property
     def ar(self) -> Path:
         """The path to the archiver."""
         raise NotImplementedError

     @property
     def asm(self) -> Path:
         """The path to the assembler."""
         raise NotImplementedError

     @property
     def bin_paths(self) -> List[Path]:
         """The path to the toolchain binary directories for use with PATH."""
         raise NotImplementedError

     @property
     def cc(self) -> Path:
         """The path to the C compiler."""
         raise NotImplementedError

     @property
     def cxx(self) -> Path:
         """The path to the C++ compiler."""
         raise NotImplementedError

     @property
     def flags(self) -> List[str]:
         """The default flags to be used with the compiler."""
         raise NotImplementedError

     @property
     def ld(self) -> Path:
         """The path to the linker."""
         raise NotImplementedError

     @property
     def nm(self) -> Path:
         """The path to nm."""
         raise NotImplementedError

     @property
     def path(self) -> Path:
         """The path to the top level toolchain directory."""
         raise NotImplementedError

     @property
     def ranlib(self) -> Path:
         """The path to ranlib."""
         raise NotImplementedError

     @property
     def rescomp(self) -> Path:
         """The path to the resource compiler."""
         raise NotImplementedError

     @property
     def strip(self) -> Path:
         """The path to strip."""
         raise NotImplementedError

     @property
     def strings(self) -> Path:
         """The path to strings."""
         raise NotImplementedError


 class GccToolchain(Toolchain):
     """A GCC compiler toolchain."""

     def gcc_tool(self, tool_name: str) -> Path:
         """Returns the path to the GCC tool targeting the given host."""
         return self.path / 'bin' / f'{self.triple}-{tool_name}'

     @property
     def ar(self) -> Path:
         """The path to the archiver."""
         if self.target == Host.Darwin:
             return self.darwin_sdk.ar
         return self.gcc_tool('ar')

     @property
     def asm(self) -> Path:
         """The path to the assembler."""
         if self.target == Host.Darwin:
             return self.darwin_sdk.asm
         return self.gcc_tool('as')

     @property
     def bin_paths(self) -> List[Path]:
         """The path to the toolchain binary directories for use with PATH."""
         return [self.path / 'bin']

     @property
     def cc(self) -> Path:
         """The path to the C compiler."""
         return self.gcc_tool('gcc')

     @property
     def cxx(self) -> Path:
         """The path to the C++ compiler."""
         return self.gcc_tool('g++')

     @property
     def flags(self) -> List[str]:
         """The default flags to be used with the compiler."""
         if self.target == Host.Darwin:
             return self.darwin_sdk.flags
         return []

     @property
     def ld(self) -> Path:
         """The path to the linker."""
         if self.target == Host.Darwin:
             return self.darwin_sdk.ld
         return self.gcc_tool('ld')

     @property
     def lib_dirs(self) -> List[Path]:
         """Returns the paths to the GCC library directories for the given host.

         The GCC library directory contains libgcc and other compiler runtime
         libraries. These may be split across multiple directories.
         """
         lib_dirs = [self.path / {
             Host.Darwin: 'lib/gcc/i686-apple-darwin11/4.2.1',
             Host.Linux: 'lib/gcc/x86_64-linux/4.8.3',
             Host.Windows64: 'lib/gcc/x86_64-w64-mingw32/4.8.3',
         }[self.target]]
         if self.target != Host.Darwin:
             lib_dirs.append(self.path / self.triple / 'lib64')
         return lib_dirs

     @property
     def nm(self) -> Path:
         """The path to nm."""
         if self.target == Host.Darwin:
             return self.darwin_sdk.nm
         return self.gcc_tool('nm')

     @property
     def path(self) -> Path:
         """Returns the path to the top level toolchain directory."""
         if self.target == Host.Darwin:
             return (ndk.paths.ANDROID_DIR /
                     'prebuilts/gcc/darwin-x86/host/i686-apple-darwin-4.2.1')
         elif self.target == Host.Linux:
             return (ndk.paths.ANDROID_DIR /
                     'prebuilts/gcc/linux-x86/host/x86_64-linux-glibc2.17-4.8')
         else:
             return (ndk.paths.ANDROID_DIR /
                     'prebuilts/gcc/linux-x86/host/x86_64-w64-mingw32-4.8')

     @property
     def ranlib(self) -> Path:
         """The path to ranlib."""
         if self.target == Host.Darwin:
             return self.darwin_sdk.ranlib
         return self.gcc_tool('ranlib')

     @property
     def rescomp(self) -> Path:
         """The path to the resource compiler."""
         if not self.target.is_windows:
             raise NotImplementedError
         return self.gcc_tool('windres')

     @property
     def strip(self) -> Path:
         """The path to strip."""
         if self.target == Host.Darwin:
             return self.darwin_sdk.strip
         return self.gcc_tool('strip')

     @property
     def strings(self) -> Path:
         """The path to strings."""
         if self.target == Host.Darwin:
             return self.darwin_sdk.strings
         return self.gcc_tool('strings')

     @property
     def sysroot(self) -> Path:
         """The path to the GCC sysroot."""
         if self.target == Host.Linux:
             return self.path / 'sysroot'
         return self.path / self.triple

     @property
     def triple(self) -> str:
         """Returns the GCC triple for the host toolchain."""
         return {
             Host.Darwin: 'x86_64-apple-darwin11',
             Host.Linux: 'x86_64-linux',
             Host.Windows64: 'x86_64-w64-mingw32',
         }[self.target]


 class ClangToolchain(Toolchain):
     """A Clang compiler toolchain."""

     def __init__(self, target: Host, host: Host = get_default_host()) -> None:
         super().__init__(target, host=host)
         self.gcc_toolchain = GccToolchain(target, host=host)

     @staticmethod
     def path_for_host(host: Host) -> Path:
         """Returns the path to the Clang directory for the given host."""
         host_tag = {
             Host.Darwin: 'darwin-x86',
             Host.Linux: 'linux-x86',
             Host.Windows64: 'windows-x86',
         }[host]
         return (ndk.paths.ANDROID_DIR / 'prebuilts/clang/host' / host_tag /
                 CLANG_VERSION)

     @property
     def path(self) -> Path:
         """Returns the path to the top level toolchain directory."""
         return self.path_for_host(self.host)

     def clang_tool(self, tool_name: str) -> Path:
         """Returns the path to the Clang tool for the build host."""
         return self.path / 'bin' / tool_name

     @property
     def ar(self) -> Path:
         """The path to the archiver."""
         return self.gcc_toolchain.ar

     @property
     def asm(self) -> Path:
         """The path to the assembler."""
         return self.gcc_toolchain.asm

     @property
     def bin_paths(self) -> List[Path]:
         """The path to the toolchain binary directories for use with PATH."""
         return self.gcc_toolchain.bin_paths + [self.path / 'bin']

     @property
     def cc(self) -> Path:
         return self.clang_tool('clang')

     @property
     def cxx(self) -> Path:
         return self.clang_tool('clang++')

     @property
     def lib_dirs(self) -> List[Path]:
         lib_dirs = self.gcc_toolchain.lib_dirs
         # libc++ library path. Static only for Windows.
         if self.target.is_windows:
             lib_dirs.append(self.path_for_host(self.target) / 'lib64')
         else:
             lib_dirs.append(self.path / 'lib64')
         return lib_dirs

     @property
     def flags(self) -> List[str]:
         host_triple = HOST_TRIPLE_MAP[self.target]
         toolchain_bin = (
             self.gcc_toolchain.path / self.gcc_toolchain.triple / 'bin')
         flags = [
             f'--target={host_triple}',
             f'-B{toolchain_bin}',
         ]

         if self.target.is_windows:
             flags.append('-I' + str(self.path_for_host(self.target) / 'include/c++/v1'))

         if self.target == Host.Darwin:
             flags.extend(self.darwin_sdk.flags)
         else:
             flags.append(f'--sysroot={self.gcc_toolchain.sysroot}')

             for lib_dir in self.lib_dirs:
                 # Both -L and -B because Clang only searches for CRT
                 # objects in -B directories.
                 flags.extend([
                     f'-L{lib_dir}',
                     f'-B{lib_dir}',
                 ])

         return flags

     @property
     def ld(self) -> Path:
         """The path to the linker."""
         return self.gcc_toolchain.ld

     @property
     def nm(self) -> Path:
         """The path to nm."""
         return self.gcc_toolchain.nm

     @property
     def ranlib(self) -> Path:
         """The path to ranlib."""
         return self.gcc_toolchain.ranlib

     @property
     def rescomp(self) -> Path:
         """The path to the resource compiler."""
         return self.gcc_toolchain.rescomp

     @property
     def strip(self) -> Path:
         """The path to strip."""
         return self.gcc_toolchain.strip

     @property
     def strings(self) -> Path:
         """The path to strings."""
         return self.gcc_toolchain.strings
	#
	# Copyright (C) 2019 The Android Open Source Project
	#
	# Licensed under the Apache License, Version 2.0 (the "License");
	# you may not use this file except in compliance with the License.
	# You may obtain a copy of the License at
	#
	# http://www.apache.org/licenses/LICENSE-2.0
	#
	# Unless required by applicable law or agreed to in writing, software
	# distributed under the License is distributed on an "AS IS" BASIS,
	# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	# See the License for the specific language governing permissions and
	# limitations under the License.
	#
	"""APIs for accessing toolchains."""
	import enum
	from pathlib import Path
	import subprocess
	from typing import List

	from ndk.hosts import Host, get_default_host
	import ndk.paths


	# When updating this, also update:
	#
	# 1. get_llvm_toolchain_binprefix in build/tools/prebuilt-common.sh
	# 2. CMAKE_C_COMPILER_VERSION and CMAKE_CXX_COMPILER_VERSION in
	# build/cmake/android.toolchain.cmake
	CLANG_VERSION = 'clang-r365631c1'


	HOST_TRIPLE_MAP = {
	Host.Darwin: 'x86_64-apple-darwin',
	Host.Linux: 'x86_64-linux-gnu',
	Host.Windows64: 'x86_64-w64-mingw32',
	}


	@enum.unique
	class LinkerOption(enum.Enum):
	Default = 'default'
	Lld = 'lld'


	class DarwinSdk:
	"""The Darwin SDK."""
	MACOSX_TARGET = '10.9'

	def __init__(self) -> None:
	proc_result = subprocess.run(['xcrun', '--show-sdk-path'],
	stdout=subprocess.PIPE,
	check=True, encoding='utf-8')
	self.mac_sdk_path = Path(proc_result.stdout.strip())

	self.ar = self.sdk_tool('ar')
	self.asm = self.sdk_tool('as')
	self.ld = self.sdk_tool('ld')
	self.nm = self.sdk_tool('nm')
	self.ranlib = self.sdk_tool('ranlib')
	self.strings = self.sdk_tool('strings')
	self.strip = self.sdk_tool('strip')

	@property
	def flags(self) -> List[str]:
	"""The default flags to be used with the SDK."""
	return [
	f'-mmacosx-version-min={self.MACOSX_TARGET}',
	f'-DMACOSX_DEPLOYMENT_TARGET={self.MACOSX_TARGET}',
	f'-isysroot{self.mac_sdk_path}',
	f'-Wl,-syslibroot,{self.mac_sdk_path}',
	]

	def sdk_tool(self, name: str) -> Path:
	"""Returns the path to the given SDK tool."""
	proc_result = subprocess.run(['xcrun', '--find', name],
	stdout=subprocess.PIPE,
	check=True, encoding='utf-8')
	return Path(proc_result.stdout.strip())


	class Toolchain:
	"""A compiler toolchain.

	Describes the directories, executables, and default flags needed to use a
	toolchain.
	"""

	def __init__(self, target: Host, host: Host = get_default_host()) -> None:
	if host.is_windows:
	raise NotImplementedError
	self.host = host
	self.target = target

	if self.target == Host.Darwin:
	self.darwin_sdk = DarwinSdk()

	@property
	def ar(self) -> Path:
	"""The path to the archiver."""
	raise NotImplementedError

	@property
	def asm(self) -> Path:
	"""The path to the assembler."""
	raise NotImplementedError

	@property
	def bin_paths(self) -> List[Path]:
	"""The path to the toolchain binary directories for use with PATH."""
	raise NotImplementedError

	@property
	def cc(self) -> Path:
	"""The path to the C compiler."""
	raise NotImplementedError

	@property
	def cxx(self) -> Path:
	"""The path to the C++ compiler."""
	raise NotImplementedError

	@property
	def flags(self) -> List[str]:
	"""The default flags to be used with the compiler."""
	raise NotImplementedError

	@property
	def ld(self) -> Path:
	"""The path to the linker."""
	raise NotImplementedError

	@property
	def nm(self) -> Path:
	"""The path to nm."""
	raise NotImplementedError

	@property
	def path(self) -> Path:
	"""The path to the top level toolchain directory."""
	raise NotImplementedError

	@property
	def ranlib(self) -> Path:
	"""The path to ranlib."""
	raise NotImplementedError

	@property
	def rescomp(self) -> Path:
	"""The path to the resource compiler."""
	raise NotImplementedError

	@property
	def strip(self) -> Path:
	"""The path to strip."""
	raise NotImplementedError

	@property
	def strings(self) -> Path:
	"""The path to strings."""
	raise NotImplementedError


	class GccToolchain(Toolchain):
	"""A GCC compiler toolchain."""

	def gcc_tool(self, tool_name: str) -> Path:
	"""Returns the path to the GCC tool targeting the given host."""
	return self.path / 'bin' / f'{self.triple}-{tool_name}'

	@property
	def ar(self) -> Path:
	"""The path to the archiver."""
	if self.target == Host.Darwin:
	return self.darwin_sdk.ar
	return self.gcc_tool('ar')

	@property
	def asm(self) -> Path:
	"""The path to the assembler."""
	if self.target == Host.Darwin:
	return self.darwin_sdk.asm
	return self.gcc_tool('as')

	@property
	def bin_paths(self) -> List[Path]:
	"""The path to the toolchain binary directories for use with PATH."""
	return [self.path / 'bin']

	@property
	def cc(self) -> Path:
	"""The path to the C compiler."""
	return self.gcc_tool('gcc')

	@property
	def cxx(self) -> Path:
	"""The path to the C++ compiler."""
	return self.gcc_tool('g++')

	@property
	def flags(self) -> List[str]:
	"""The default flags to be used with the compiler."""
	if self.target == Host.Darwin:
	return self.darwin_sdk.flags
	return []

	@property
	def ld(self) -> Path:
	"""The path to the linker."""
	if self.target == Host.Darwin:
	return self.darwin_sdk.ld
	return self.gcc_tool('ld')

	@property
	def lib_dirs(self) -> List[Path]:
	"""Returns the paths to the GCC library directories for the given host.

	The GCC library directory contains libgcc and other compiler runtime
	libraries. These may be split across multiple directories.
	"""
	lib_dirs = [self.path / {
	Host.Darwin: 'lib/gcc/i686-apple-darwin11/4.2.1',
	Host.Linux: 'lib/gcc/x86_64-linux/4.8.3',
	Host.Windows64: 'lib/gcc/x86_64-w64-mingw32/4.8.3',
	}[self.target]]
	if self.target != Host.Darwin:
	lib_dirs.append(self.path / self.triple / 'lib64')
	return lib_dirs

	@property
	def nm(self) -> Path:
	"""The path to nm."""
	if self.target == Host.Darwin:
	return self.darwin_sdk.nm
	return self.gcc_tool('nm')

	@property
	def path(self) -> Path:
	"""Returns the path to the top level toolchain directory."""
	if self.target == Host.Darwin:
	return (ndk.paths.ANDROID_DIR /
	'prebuilts/gcc/darwin-x86/host/i686-apple-darwin-4.2.1')
	elif self.target == Host.Linux:
	return (ndk.paths.ANDROID_DIR /
	'prebuilts/gcc/linux-x86/host/x86_64-linux-glibc2.17-4.8')
	else:
	return (ndk.paths.ANDROID_DIR /
	'prebuilts/gcc/linux-x86/host/x86_64-w64-mingw32-4.8')

	@property
	def ranlib(self) -> Path:
	"""The path to ranlib."""
	if self.target == Host.Darwin:
	return self.darwin_sdk.ranlib
	return self.gcc_tool('ranlib')

	@property
	def rescomp(self) -> Path:
	"""The path to the resource compiler."""
	if not self.target.is_windows:
	raise NotImplementedError
	return self.gcc_tool('windres')

	@property
	def strip(self) -> Path:
	"""The path to strip."""
	if self.target == Host.Darwin:
	return self.darwin_sdk.strip
	return self.gcc_tool('strip')

	@property
	def strings(self) -> Path:
	"""The path to strings."""
	if self.target == Host.Darwin:
	return self.darwin_sdk.strings
	return self.gcc_tool('strings')

	@property
	def sysroot(self) -> Path:
	"""The path to the GCC sysroot."""
	if self.target == Host.Linux:
	return self.path / 'sysroot'
	return self.path / self.triple

	@property
	def triple(self) -> str:
	"""Returns the GCC triple for the host toolchain."""
	return {
	Host.Darwin: 'x86_64-apple-darwin11',
	Host.Linux: 'x86_64-linux',
	Host.Windows64: 'x86_64-w64-mingw32',
	}[self.target]


	class ClangToolchain(Toolchain):
	"""A Clang compiler toolchain."""

	def __init__(self, target: Host, host: Host = get_default_host()) -> None:
	super().__init__(target, host=host)
	self.gcc_toolchain = GccToolchain(target, host=host)

	@staticmethod
	def path_for_host(host: Host) -> Path:
	"""Returns the path to the Clang directory for the given host."""
	host_tag = {
	Host.Darwin: 'darwin-x86',
	Host.Linux: 'linux-x86',
	Host.Windows64: 'windows-x86',
	}[host]
	return (ndk.paths.ANDROID_DIR / 'prebuilts/clang/host' / host_tag /
	CLANG_VERSION)

	@property
	def path(self) -> Path:
	"""Returns the path to the top level toolchain directory."""
	return self.path_for_host(self.host)

	def clang_tool(self, tool_name: str) -> Path:
	"""Returns the path to the Clang tool for the build host."""
	return self.path / 'bin' / tool_name

	@property
	def ar(self) -> Path:
	"""The path to the archiver."""
	return self.gcc_toolchain.ar

	@property
	def asm(self) -> Path:
	"""The path to the assembler."""
	return self.gcc_toolchain.asm

	@property
	def bin_paths(self) -> List[Path]:
	"""The path to the toolchain binary directories for use with PATH."""
	return self.gcc_toolchain.bin_paths + [self.path / 'bin']

	@property
	def cc(self) -> Path:
	return self.clang_tool('clang')

	@property
	def cxx(self) -> Path:
	return self.clang_tool('clang++')

	@property
	def lib_dirs(self) -> List[Path]:
	lib_dirs = self.gcc_toolchain.lib_dirs
	# libc++ library path. Static only for Windows.
	if self.target.is_windows:
	lib_dirs.append(self.path_for_host(self.target) / 'lib64')
	else:
	lib_dirs.append(self.path / 'lib64')
	return lib_dirs

	@property
	def flags(self) -> List[str]:
	host_triple = HOST_TRIPLE_MAP[self.target]
	toolchain_bin = (
	self.gcc_toolchain.path / self.gcc_toolchain.triple / 'bin')
	flags = [
	f'--target={host_triple}',
	f'-B{toolchain_bin}',
	]

	if self.target.is_windows:
	flags.append('-I' + str(self.path_for_host(self.target) / 'include/c++/v1'))

	if self.target == Host.Darwin:
	flags.extend(self.darwin_sdk.flags)
	else:
	flags.append(f'--sysroot={self.gcc_toolchain.sysroot}')

	for lib_dir in self.lib_dirs:
	# Both -L and -B because Clang only searches for CRT
	# objects in -B directories.
	flags.extend([
	f'-L{lib_dir}',
	f'-B{lib_dir}',
	])

	return flags

	@property
	def ld(self) -> Path:
	"""The path to the linker."""
	return self.gcc_toolchain.ld

	@property
	def nm(self) -> Path:
	"""The path to nm."""
	return self.gcc_toolchain.nm

	@property
	def ranlib(self) -> Path:
	"""The path to ranlib."""
	return self.gcc_toolchain.ranlib

	@property
	def rescomp(self) -> Path:
	"""The path to the resource compiler."""
	return self.gcc_toolchain.rescomp

	@property
	def strip(self) -> Path:
	"""The path to strip."""
	return self.gcc_toolchain.strip

	@property
	def strings(self) -> Path:
	"""The path to strings."""
	return self.gcc_toolchain.strings