| # This source file is part of the Swift.org open source project |
| # |
| # Copyright (c) 2014 - 2015 Apple Inc. and the Swift project authors |
| # Licensed under Apache License v2.0 with Runtime Library Exception |
| # |
| # See http://swift.org/LICENSE.txt for license information |
| # See http://swift.org/CONTRIBUTORS.txt for the list of Swift project authors |
| # |
| |
| from .config import Configuration |
| import platform |
| |
| class ArchType: |
| UnknownArch = 0 |
| armv7 = 1 |
| armeb = 2 |
| aarch64 = 3 |
| aarch64_be = 4 |
| bpfel = 5 |
| bpfeb = 6 |
| hexagon = 7 |
| mips = 8 |
| mipsel = 9 |
| mips64 = 10 |
| mips64el = 11 |
| msp430 = 12 |
| ppc = 13 |
| ppc64 = 14 |
| ppc64le = 15 |
| r600 = 16 |
| amdgcn = 17 |
| sparc = 18 |
| sparcv9 = 19 |
| sparcel = 20 |
| systemz = 21 |
| tce = 22 |
| thumb = 23 |
| thumbeb = 24 |
| x86 = 25 |
| x86_64 = 26 |
| xcore = 27 |
| nvptx = 28 |
| nvptx64 = 29 |
| le32 = 30 |
| le64 = 31 |
| amdil = 32 |
| amdil64 = 33 |
| hsail = 34 |
| hsail64 = 35 |
| spir = 36 |
| spir64 = 37 |
| kalimba = 38 |
| shave = 39 |
| armv6 = 40 |
| s390x = 41 |
| # Do not assume that these are 1:1 mapping. This should follow |
| # canonical naming conventions for arm, etc. architectures. |
| # See apple/swift PR #608 |
| @staticmethod |
| def to_string(value): |
| if value == ArchType.armv7: |
| return "armv7" |
| if value == ArchType.armv6: |
| return "armv6" |
| if value == ArchType.armeb: |
| return "armeb" |
| if value == ArchType.aarch64: |
| return "aarch64" |
| if value == ArchType.aarch64_be: |
| return "aarch64_be" |
| if value == ArchType.bpfel: |
| return "bpfel" |
| if value == ArchType.bpfeb: |
| return "bpfeb" |
| if value == ArchType.hexagon: |
| return "hexagon" |
| if value == ArchType.mips: |
| return "mips" |
| if value == ArchType.mipsel: |
| return "mipsel" |
| if value == ArchType.mips64: |
| return "mips64" |
| if value == ArchType.mips64el: |
| return "mips64el" |
| if value == ArchType.msp430: |
| return "msp430" |
| if value == ArchType.ppc: |
| return "powerpc" |
| if value == ArchType.ppc64: |
| return "powerpc64" |
| if value == ArchType.ppc64le: |
| return "powerpc64le" |
| if value == ArchType.r600: |
| return "r600" |
| if value == ArchType.amdgcn: |
| return "amdgcn" |
| if value == ArchType.sparc: |
| return "sparc" |
| if value == ArchType.sparcv9: |
| return "sparcv9" |
| if value == ArchType.sparcel: |
| return "sparcel" |
| if value == ArchType.systemz: |
| return "systemz" |
| if value == ArchType.tce: |
| return "tce" |
| if value == ArchType.thumb: |
| return "armv7" |
| if value == ArchType.thumbeb: |
| return "thumbeb" |
| if value == ArchType.x86: |
| return "i386" |
| if value == ArchType.x86_64: |
| return "x86_64" |
| if value == ArchType.xcore: |
| return "xcore" |
| if value == ArchType.nvptx: |
| return "nvptx" |
| if value == ArchType.nvptx64: |
| return "nvptx64" |
| if value == ArchType.le32: |
| return "le32" |
| if value == ArchType.le64: |
| return "le64" |
| if value == ArchType.amdil: |
| return "amdil" |
| if value == ArchType.amdil64: |
| return "amdil64" |
| if value == ArchType.hsail: |
| return "hsail" |
| if value == ArchType.hsail64: |
| return "hsail64" |
| if value == ArchType.spir: |
| return "spir" |
| if value == ArchType.spir64: |
| return "spir64" |
| if value == ArchType.kalimba: |
| return "kalimba" |
| if value == ArchType.shave: |
| return "shave" |
| if value == ArchType.s390x: |
| return "s390x" |
| return "unknown" |
| # Not 1:1, See to_string |
| @staticmethod |
| def from_string(string): |
| if string == "armeb": |
| return ArchType.armeb |
| if string == "arm": |
| return ArchType.armv7 |
| if string == "armv7": |
| return ArchType.armv7 |
| if string == "armv7l": |
| return ArchType.armv7 |
| if string == "armv6": |
| return ArchType.armv6 |
| if string == "armv6l": |
| return ArchType.armv6 |
| if string == "aarch64": |
| return ArchType.aarch64 |
| if string == "aarch64_be": |
| return ArchType.aarch64_be |
| if string == "bpfel": |
| return ArchType.bpfel |
| if string == "bpfeb": |
| return ArchType.bpfeb |
| if string == "hexagon": |
| return ArchType.hexagon |
| if string == "mips": |
| return ArchType.mips |
| if string == "mipsel": |
| return ArchType.mipsel |
| if string == "mips64": |
| return ArchType.mips64 |
| if string == "mips64el": |
| return ArchType.mips64el |
| if string == "msp430": |
| return ArchType.msp430 |
| if string == "ppc" or string == "powerpc": |
| return ArchType.ppc |
| if string == "ppc64" or string == "powerpc64": |
| return ArchType.ppc64 |
| if string == "ppc64le" or string == "powerpc64le": |
| return ArchType.ppc64le |
| if string == "r600": |
| return ArchType.r600 |
| if string == "amdgcn": |
| return ArchType.amdgcn |
| if string == "sparc": |
| return ArchType.sparc |
| if string == "sparcv9": |
| return ArchType.sparcv9 |
| if string == "sparcel": |
| return ArchType.sparcel |
| if string == "systemz": |
| return ArchType.systemz |
| if string == "tce": |
| return ArchType.tce |
| if string == "thumb": |
| return ArchType.thumb |
| if string == "thumbeb": |
| return ArchType.thumbeb |
| if string == "x86": |
| return ArchType.x86 |
| if string == "x86_64": |
| return ArchType.x86_64 |
| if string == "xcore": |
| return ArchType.xcore |
| if string == "nvptx": |
| return ArchType.nvptx |
| if string == "nvptx64": |
| return ArchType.nvptx64 |
| if string == "le32": |
| return ArchType.le32 |
| if string == "le64": |
| return ArchType.le64 |
| if string == "amdil": |
| return ArchType.amdil |
| if string == "amdil64": |
| return ArchType.amdil64 |
| if string == "hsail": |
| return ArchType.hsail |
| if string == "hsail64": |
| return ArchType.hsail64 |
| if string == "spir": |
| return ArchType.spir |
| if string == "spir64": |
| return ArchType.spir64 |
| if string == "kalimba": |
| return ArchType.kalimba |
| if string == "shave": |
| return ArchType.shave |
| if string == "s390x": |
| return ArchType.s390x |
| |
| return ArchType.UnknownArch |
| |
| |
| class ArchSubType: |
| NoSubArch = 0 |
| ARMSubArch_v8_1a = 1 |
| ARMSubArch_v8 = 2 |
| ARMSubArch_v7 = 3 |
| ARMSubArch_v7em = 4 |
| ARMSubArch_v7m = 5 |
| ARMSubArch_v7s = 6 |
| ARMSubArch_v6 = 7 |
| ARMSubArch_v6m = 8 |
| ARMSubArch_v6k = 9 |
| ARMSubArch_v6t2 = 10 |
| ARMSubArch_v5 = 11 |
| ARMSubArch_v5te = 12 |
| ARMSubArch_v4t = 13 |
| KalimbaSubArch_v3 = 14 |
| KalimbaSubArch_v4 = 15 |
| KalimbaSubArch_v5 = 16 |
| |
| |
| class OSType: |
| UnknownOS = 0 |
| CloudABI = 1 |
| Darwin = 2 |
| DragonFly = 3 |
| FreeBSD = 4 |
| IOS = 5 |
| KFreeBSD = 6 |
| Linux = 7 |
| Lv2 = 8 |
| MacOSX = 9 |
| NetBSD = 10 |
| OpenBSD = 11 |
| Solaris = 12 |
| Win32 = 13 |
| Haiku = 14 |
| Minix = 15 |
| RTEMS = 16 |
| NaCl = 17 |
| CNK = 18 |
| Bitrig = 19 |
| AIX = 20 |
| CUDA = 21 |
| NVCL = 22 |
| AMDHSA = 23 |
| PS4 = 24 |
| |
| |
| class ObjectFormat: |
| UnknownObjectFormat = 0 |
| COFF = 1 |
| ELF = 2 |
| MachO = 3 |
| |
| |
| class EnvironmentType: |
| UnknownEnvironment = 0 |
| GNU = 1 |
| GNUEABI = 2 |
| GNUEABIHF = 3 |
| GNUX32 = 4 |
| CODE16 = 5 |
| EABI = 6 |
| EABIHF = 7 |
| Android = 8 |
| MSVC = 9 |
| Itanium = 10 |
| Cygnus = 11 |
| |
| |
| class Vendor: |
| UnknownVendor = 0 |
| Apple = 1 |
| PC = 2 |
| SCEI = 3 |
| BGP = 4 |
| BGQ = 5 |
| Freescale = 6 |
| IBM = 7 |
| ImaginationTechnologies = 8 |
| MipsTechnologies = 9 |
| NVIDIA = 10 |
| CSR = 11 |
| |
| |
| class Target: |
| triple = None |
| sdk = None |
| arch = None |
| environ = None |
| executable_suffix = "" |
| dynamic_library_prefix = "lib" |
| dynamic_library_suffix = ".dylib" |
| static_library_prefix = "lib" |
| static_library_suffix = ".a" |
| fat_binaries = False |
| |
| def __init__(self, triple): |
| if "linux" in triple: |
| self.sdk = OSType.Linux |
| self.dynamic_library_suffix = ".so" |
| elif "freebsd" in triple: |
| self.sdk = OSType.FreeBSD |
| self.dynamic_library_suffix = ".so" |
| elif "windows" in triple or "win32" in triple: |
| self.sdk = OSType.Win32 |
| self.dynamic_library_suffix = ".dll" |
| self.executable_suffix = ".exe" |
| if "cygnus" in triple: |
| self.environ = EnvironmentType.Cygnus |
| else: |
| self.environ = EnvironmentType.UnknownEnvironment |
| elif "darwin" in triple: |
| self.sdk = OSType.MacOSX |
| self.fat_binaries = True |
| else: |
| print("Unknown platform") |
| |
| self.triple = triple |
| |
| comps = triple.split('-') |
| self.arch = ArchType.from_string(comps[0]) |
| |
| @staticmethod |
| def default(): |
| arch = ArchType.from_string(platform.machine()) |
| triple = ArchType.to_string(arch) |
| if platform.system() == "Linux": |
| if (arch == ArchType.armv6) or (arch == ArchType.armv7): |
| triple += "-linux-gnueabihf" |
| else: |
| triple += "-linux-gnu" |
| elif platform.system() == "Darwin": |
| triple += "-apple-darwin" |
| elif platform.system() == "FreeBSD": |
| # Make this work on 10 as well. |
| triple += "-freebsd11.0" |
| elif platform.system() == "CYGWIN_NT-10.0": |
| triple += "-windows-cygnus" |
| else: |
| # TODO: This should be a bit more exhaustive |
| print("unknown host os") |
| return None |
| return triple |
| |
| @property |
| def swift_triple(self): |
| triple = ArchType.to_string(self.arch) |
| if self.sdk == OSType.MacOSX: |
| return None |
| elif self.sdk == OSType.Linux: |
| # FIXME: It would be nice to detect the host ABI here |
| if (self.arch == ArchType.armv6) or (self.arch == ArchType.armv7): |
| if Configuration.current.target.triple == "armv7-none-linux-androideabi": |
| triple = Configuration.current.target.triple |
| else: |
| triple += "-unknown-linux-gnueabihf" |
| else: |
| triple += "-unknown-linux" |
| elif self.sdk == OSType.FreeBSD: |
| triple += "-unknown-freebsd" |
| elif self.sdk == OSType.Win32 and self.environ == EnvironmentType.Cygnus: |
| triple += "-unknown-windows-cygnus" |
| else: |
| print("unknown sdk for swift") |
| return None |
| |
| return triple |
| |
| @property |
| def swift_sdk_name(self): |
| if self.sdk == OSType.MacOSX: |
| return "macosx" |
| elif self.sdk == OSType.Linux and "android" in self.triple: |
| return "android" |
| elif self.sdk == OSType.Linux: |
| return "linux" |
| elif self.sdk == OSType.FreeBSD: |
| return "freebsd" |
| elif self.sdk == OSType.Win32: |
| return "cygwin" |
| else: |
| print("unknown sdk for swift") |
| return None |
| |
| |
| @property |
| def swift_arch(self): |
| return ArchType.to_string(self.arch) |
| |
| class TargetConditional: |
| _sdk = None |
| _arch = None |
| _default = None |
| def __init__(self, sdk = None, arch = None, default = None): |
| self._sdk = sdk |
| self._arch = arch |
| self._default = default |
| |
| def evalulate(self, target): |
| if self._sdk is not None and target.sdk in self._sdk: |
| return self._sdk[target.sdk] |
| if self._arch is not None and target.arch in self._arch: |
| return self._arch[target.arch] |
| return self._default |
| |
| @staticmethod |
| def value(value): |
| if type(value) is TargetConditional: |
| return value.evalulate(Configuration.current.target) |
| return value |
