Home | History | Annotate | Download | only in config 
      1 // Copyright 2016 Google Inc. All rights reserved.
      2 //
      3 // Licensed under the Apache License, Version 2.0 (the "License");
      4 // you may not use this file except in compliance with the License.
      5 // You may obtain a copy of the License at
      6 //
      7 //     http://www.apache.org/licenses/LICENSE-2.0
      8 //
      9 // Unless required by applicable law or agreed to in writing, software
     10 // distributed under the License is distributed on an "AS IS" BASIS,
     11 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
     12 // See the License for the specific language governing permissions and
     13 // limitations under the License.
     14 
     15 package config
     16 
     17 import (
     18 	"fmt"
     19 	"os/exec"
     20 	"path/filepath"
     21 	"strings"
     22 
     23 	"android/soong/android"
     24 )
     25 
     26 var (
     27 	darwinCflags = []string{
     28 		"-fno-exceptions", // from build/core/combo/select.mk
     29 		"-Wno-multichar",  // from build/core/combo/select.mk
     30 
     31 		"-fdiagnostics-color",
     32 
     33 		"-fPIC",
     34 		"-funwind-tables",
     35 
     36 		// Workaround differences in inttypes.h between host and target.
     37 		//See bug 12708004.
     38 		"-D__STDC_FORMAT_MACROS",
     39 		"-D__STDC_CONSTANT_MACROS",
     40 
     41 		// HOST_RELEASE_CFLAGS
     42 		"-O2", // from build/core/combo/select.mk
     43 		"-g",  // from build/core/combo/select.mk
     44 		"-fno-strict-aliasing", // from build/core/combo/select.mk
     45 		"-isysroot ${macSdkRoot}",
     46 		"-mmacosx-version-min=${macMinVersion}",
     47 		"-DMACOSX_DEPLOYMENT_TARGET=${macMinVersion}",
     48 	}
     49 
     50 	darwinLdflags = []string{
     51 		"-isysroot ${macSdkRoot}",
     52 		"-Wl,-syslibroot,${macSdkRoot}",
     53 		"-mmacosx-version-min=${macMinVersion}",
     54 	}
     55 
     56 	// Extended cflags
     57 	darwinX86Cflags = []string{
     58 		"-m32",
     59 	}
     60 
     61 	darwinX8664Cflags = []string{
     62 		"-m64",
     63 	}
     64 
     65 	darwinX86Ldflags = []string{
     66 		"-m32",
     67 	}
     68 
     69 	darwinX8664Ldflags = []string{
     70 		"-m64",
     71 	}
     72 
     73 	darwinClangCflags = append(ClangFilterUnknownCflags(darwinCflags), []string{
     74 		"-integrated-as",
     75 		"-fstack-protector-strong",
     76 	}...)
     77 
     78 	darwinX86ClangCflags = append(ClangFilterUnknownCflags(darwinX86Cflags), []string{
     79 		"-msse3",
     80 	}...)
     81 
     82 	darwinClangLdflags = ClangFilterUnknownCflags(darwinLdflags)
     83 
     84 	darwinX86ClangLdflags = ClangFilterUnknownCflags(darwinX86Ldflags)
     85 
     86 	darwinX8664ClangLdflags = ClangFilterUnknownCflags(darwinX8664Ldflags)
     87 
     88 	darwinSupportedSdkVersions = []string{
     89 		"10.10",
     90 		"10.11",
     91 		"10.12",
     92 	}
     93 
     94 	darwinAvailableLibraries = append(
     95 		addPrefix([]string{
     96 			"c",
     97 			"dl",
     98 			"m",
     99 			"ncurses",
    100 			"objc",
    101 			"pthread",
    102 			"z",
    103 		}, "-l"),
    104 		"-framework AppKit",
    105 		"-framework CoreFoundation",
    106 		"-framework Foundation",
    107 		"-framework IOKit",
    108 		"-framework Security",
    109 	)
    110 )
    111 
    112 const (
    113 	darwinGccVersion = "4.2.1"
    114 )
    115 
    116 func init() {
    117 	pctx.VariableFunc("macSdkPath", func(config interface{}) (string, error) {
    118 		xcodeselect := config.(android.Config).HostSystemTool("xcode-select")
    119 		bytes, err := exec.Command(xcodeselect, "--print-path").Output()
    120 		return strings.TrimSpace(string(bytes)), err
    121 	})
    122 	pctx.VariableFunc("macSdkRoot", func(config interface{}) (string, error) {
    123 		return xcrunSdk(config.(android.Config), "--show-sdk-path")
    124 	})
    125 	pctx.StaticVariable("macMinVersion", "10.8")
    126 	pctx.VariableFunc("MacArPath", func(config interface{}) (string, error) {
    127 		return xcrun(config.(android.Config), "--find", "ar")
    128 	})
    129 
    130 	pctx.VariableFunc("MacStripPath", func(config interface{}) (string, error) {
    131 		return xcrun(config.(android.Config), "--find", "strip")
    132 	})
    133 
    134 	pctx.VariableFunc("MacToolPath", func(config interface{}) (string, error) {
    135 		path, err := xcrun(config.(android.Config), "--find", "ld")
    136 		return filepath.Dir(path), err
    137 	})
    138 
    139 	pctx.StaticVariable("DarwinGccVersion", darwinGccVersion)
    140 	pctx.SourcePathVariable("DarwinGccRoot",
    141 		"prebuilts/gcc/${HostPrebuiltTag}/host/i686-apple-darwin-${DarwinGccVersion}")
    142 
    143 	pctx.StaticVariable("DarwinGccTriple", "i686-apple-darwin11")
    144 
    145 	pctx.StaticVariable("DarwinCflags", strings.Join(darwinCflags, " "))
    146 	pctx.StaticVariable("DarwinLdflags", strings.Join(darwinLdflags, " "))
    147 
    148 	pctx.StaticVariable("DarwinClangCflags", strings.Join(darwinClangCflags, " "))
    149 	pctx.StaticVariable("DarwinClangLdflags", strings.Join(darwinClangLdflags, " "))
    150 
    151 	// Extended cflags
    152 	pctx.StaticVariable("DarwinX86Cflags", strings.Join(darwinX86Cflags, " "))
    153 	pctx.StaticVariable("DarwinX8664Cflags", strings.Join(darwinX8664Cflags, " "))
    154 	pctx.StaticVariable("DarwinX86Ldflags", strings.Join(darwinX86Ldflags, " "))
    155 	pctx.StaticVariable("DarwinX8664Ldflags", strings.Join(darwinX8664Ldflags, " "))
    156 
    157 	pctx.StaticVariable("DarwinX86ClangCflags", strings.Join(darwinX86ClangCflags, " "))
    158 	pctx.StaticVariable("DarwinX8664ClangCflags",
    159 		strings.Join(ClangFilterUnknownCflags(darwinX8664Cflags), " "))
    160 	pctx.StaticVariable("DarwinX86ClangLdflags", strings.Join(darwinX86ClangLdflags, " "))
    161 	pctx.StaticVariable("DarwinX8664ClangLdflags", strings.Join(darwinX8664ClangLdflags, " "))
    162 	pctx.StaticVariable("DarwinX86YasmFlags", "-f macho -m x86")
    163 	pctx.StaticVariable("DarwinX8664YasmFlags", "-f macho -m amd64")
    164 }
    165 
    166 func xcrun(config android.Config, args ...string) (string, error) {
    167 	xcrun := config.HostSystemTool("xcrun")
    168 	bytes, err := exec.Command(xcrun, args...).Output()
    169 	return strings.TrimSpace(string(bytes)), err
    170 }
    171 
    172 func xcrunSdk(config android.Config, arg string) (string, error) {
    173 	xcrun := config.HostSystemTool("xcrun")
    174 	if selected := config.Getenv("MAC_SDK_VERSION"); selected != "" {
    175 		if !inList(selected, darwinSupportedSdkVersions) {
    176 			return "", fmt.Errorf("MAC_SDK_VERSION %s isn't supported: %q", selected, darwinSupportedSdkVersions)
    177 		}
    178 
    179 		bytes, err := exec.Command(xcrun, "--sdk", "macosx"+selected, arg).Output()
    180 		if err == nil {
    181 			return strings.TrimSpace(string(bytes)), err
    182 		}
    183 		return "", fmt.Errorf("MAC_SDK_VERSION %s is not installed", selected)
    184 	}
    185 
    186 	for _, sdk := range darwinSupportedSdkVersions {
    187 		bytes, err := exec.Command(xcrun, "--sdk", "macosx"+sdk, arg).Output()
    188 		if err == nil {
    189 			return strings.TrimSpace(string(bytes)), err
    190 		}
    191 	}
    192 	return "", fmt.Errorf("Could not find a supported mac sdk: %q", darwinSupportedSdkVersions)
    193 }
    194 
    195 type toolchainDarwin struct {
    196 	cFlags, ldFlags string
    197 }
    198 
    199 type toolchainDarwinX86 struct {
    200 	toolchain32Bit
    201 	toolchainDarwin
    202 }
    203 
    204 type toolchainDarwinX8664 struct {
    205 	toolchain64Bit
    206 	toolchainDarwin
    207 }
    208 
    209 func (t *toolchainDarwinX86) Name() string {
    210 	return "x86"
    211 }
    212 
    213 func (t *toolchainDarwinX8664) Name() string {
    214 	return "x86_64"
    215 }
    216 
    217 func (t *toolchainDarwin) GccRoot() string {
    218 	return "${config.DarwinGccRoot}"
    219 }
    220 
    221 func (t *toolchainDarwin) GccTriple() string {
    222 	return "${config.DarwinGccTriple}"
    223 }
    224 
    225 func (t *toolchainDarwin) GccVersion() string {
    226 	return darwinGccVersion
    227 }
    228 
    229 func (t *toolchainDarwin) Cflags() string {
    230 	return "${config.DarwinCflags} ${config.DarwinX86Cflags}"
    231 }
    232 
    233 func (t *toolchainDarwinX8664) Cflags() string {
    234 	return "${config.DarwinCflags} ${config.DarwinX8664Cflags}"
    235 }
    236 
    237 func (t *toolchainDarwin) Cppflags() string {
    238 	return ""
    239 }
    240 
    241 func (t *toolchainDarwinX86) Ldflags() string {
    242 	return "${config.DarwinLdflags} ${config.DarwinX86Ldflags}"
    243 }
    244 
    245 func (t *toolchainDarwinX8664) Ldflags() string {
    246 	return "${config.DarwinLdflags} ${config.DarwinX8664Ldflags}"
    247 }
    248 
    249 func (t *toolchainDarwin) IncludeFlags() string {
    250 	return ""
    251 }
    252 
    253 func (t *toolchainDarwinX86) ClangTriple() string {
    254 	return "i686-apple-darwin"
    255 }
    256 
    257 func (t *toolchainDarwinX86) ClangCflags() string {
    258 	return "${config.DarwinClangCflags} ${config.DarwinX86ClangCflags}"
    259 }
    260 
    261 func (t *toolchainDarwinX8664) ClangTriple() string {
    262 	return "x86_64-apple-darwin"
    263 }
    264 
    265 func (t *toolchainDarwinX8664) ClangCflags() string {
    266 	return "${config.DarwinClangCflags} ${config.DarwinX8664ClangCflags}"
    267 }
    268 
    269 func (t *toolchainDarwin) ClangCppflags() string {
    270 	return ""
    271 }
    272 
    273 func (t *toolchainDarwinX86) ClangLdflags() string {
    274 	return "${config.DarwinClangLdflags} ${config.DarwinX86ClangLdflags}"
    275 }
    276 
    277 func (t *toolchainDarwinX8664) ClangLdflags() string {
    278 	return "${config.DarwinClangLdflags} ${config.DarwinX8664ClangLdflags}"
    279 }
    280 
    281 func (t *toolchainDarwinX86) YasmFlags() string {
    282 	return "${config.DarwinX86YasmFlags}"
    283 }
    284 
    285 func (t *toolchainDarwinX8664) YasmFlags() string {
    286 	return "${config.DarwinX8664YasmFlags}"
    287 }
    288 
    289 func (t *toolchainDarwin) ShlibSuffix() string {
    290 	return ".dylib"
    291 }
    292 
    293 func (t *toolchainDarwin) AvailableLibraries() []string {
    294 	return darwinAvailableLibraries
    295 }
    296 
    297 func (t *toolchainDarwin) Bionic() bool {
    298 	return false
    299 }
    300 
    301 func (t *toolchainDarwin) ToolPath() string {
    302 	return "${config.MacToolPath}"
    303 }
    304 
    305 var toolchainDarwinX86Singleton Toolchain = &toolchainDarwinX86{}
    306 var toolchainDarwinX8664Singleton Toolchain = &toolchainDarwinX8664{}
    307 
    308 func darwinX86ToolchainFactory(arch android.Arch) Toolchain {
    309 	return toolchainDarwinX86Singleton
    310 }
    311 
    312 func darwinX8664ToolchainFactory(arch android.Arch) Toolchain {
    313 	return toolchainDarwinX8664Singleton
    314 }
    315 
    316 func init() {
    317 	registerToolchainFactory(android.Darwin, android.X86, darwinX86ToolchainFactory)
    318 	registerToolchainFactory(android.Darwin, android.X86_64, darwinX8664ToolchainFactory)
    319 }
    320