build/toolchain/mac/BUILD.gn

   1 # Copyright (c) 2013 The Chromium Authors. All rights reserved.
   2 # Use of this source code is governed by a BSD-style license that can be
   3 # found in the LICENSE file.
   4
   5 # TODO(brettw) Use "gcc_toolchain.gni" like the Linux toolchains. This requires
   6 # some enhancements since the commands on Mac are slightly different than on
   7 # Linux.
   8
   9 import("../goma.gni")
  10 import("//build/config/ios/ios_sdk.gni")
  11
  12 assert(host_os == "mac")
  13
  14 import("//build/toolchain/goma.gni")
  15
  16 if (use_goma) {
  17   goma_prefix = "$goma_dir/gomacc "
  18 } else {
  19   goma_prefix = ""
  20 }
  21
  22 # This will copy the gyp-mac-tool to the build directory. We pass in the source
  23 # file of the win tool.
  24 gyp_mac_tool_source =
  25     rebase_path("//tools/gyp/pylib/gyp/mac_tool.py", root_build_dir)
  26 exec_script("setup_toolchain.py", [ gyp_mac_tool_source ])
  27
  28 # Shared toolchain definition. Invocations should set toolchain_os to set the
  29 # build args in this definition.
  30 template("mac_toolchain") {
  31   toolchain(target_name) {
  32     assert(defined(invoker.cc), "mac_toolchain() must specify a \"cc\" value")
  33     assert(defined(invoker.cxx), "mac_toolchain() must specify a \"cxx\" value")
  34     assert(defined(invoker.ld), "mac_toolchain() must specify a \"ld\" value")
  35     assert(defined(invoker.toolchain_cpu),
  36            "mac_toolchain() must specify a \"toolchain_cpu\"")
  37     assert(defined(invoker.toolchain_os),
  38            "mac_toolchain() must specify a \"toolchain_os\"")
  39
  40     # We can't do string interpolation ($ in strings) on things with dots in
  41     # them. To allow us to use $cc below, for example, we create copies of
  42     # these values in our scope.
  43     cc = invoker.cc
  44     cxx = invoker.cxx
  45     ld = invoker.ld
  46
  47     # Make these apply to all tools below.
  48     lib_switch = "-l"
  49     lib_dir_switch = "-L"
  50
  51     tool("cc") {
  52       depfile = "{{output}}.d"
  53
  54       # TODO:(andybons): enable this when GCC PCH support in the binary has been
  55       # rolled.
  56       #precompiled_header_type = "gcc"
  57       command = "$cc -MMD -MF $depfile {{defines}} {{include_dirs}} {{cflags}} {{cflags_c}} -c {{source}} -o {{output}}"
  58       depsformat = "gcc"
  59       description = "CC {{output}}"
  60       outputs = [
  61         "{{target_out_dir}}/{{target_output_name}}/{{source_name_part}}.o",
  62       ]
  63     }
  64
  65     tool("cxx") {
  66       depfile = "{{output}}.d"
  67
  68       # TODO:(andybons): enable this when GCC PCH support in the binary has been
  69       # rolled.
  70       #precompiled_header_type = "gcc"
  71       command = "$cxx -MMD -MF $depfile {{defines}} {{include_dirs}} {{cflags}} {{cflags_cc}} -c {{source}} -o {{output}}"
  72       depsformat = "gcc"
  73       description = "CXX {{output}}"
  74       outputs = [
  75         "{{target_out_dir}}/{{target_output_name}}/{{source_name_part}}.o",
  76       ]
  77     }
  78
  79     tool("asm") {
  80       # For GCC we can just use the C compiler to compile assembly.
  81       depfile = "{{output}}.d"
  82       command = "$cc -MMD -MF $depfile {{defines}} {{include_dirs}} {{cflags}} {{cflags_c}} -c {{source}} -o {{output}}"
  83       depsformat = "gcc"
  84       description = "ASM {{output}}"
  85       outputs = [
  86         "{{target_out_dir}}/{{target_output_name}}/{{source_name_part}}.o",
  87       ]
  88     }
  89
  90     tool("objc") {
  91       depfile = "{{output}}.d"
  92       command = "$cxx -MMD -MF $depfile {{defines}} {{include_dirs}} {{cflags}} {{cflags_objc}} -c {{source}} -o {{output}}"
  93
  94       # TODO:(andybons): enable this when GCC PCH support in the binary has been
  95       # rolled.
  96       #precompiled_header_type = "gcc"
  97       command = "$cxx -MMD -MF $depfile {{defines}} {{include_dirs}} {{cflags}} {{cflags_c}} {{cflags_objc}} -c {{source}} -o {{output}}"
  98       depsformat = "gcc"
  99       description = "OBJC {{output}}"
 100       outputs = [
 101         "{{target_out_dir}}/{{target_output_name}}/{{source_name_part}}.o",
 102       ]
 103     }
 104
 105     tool("objcxx") {
 106       depfile = "{{output}}.d"
 107       command = "$cxx -MMD -MF $depfile {{defines}} {{include_dirs}} {{cflags}} {{cflags_objcc}} -c {{source}} -o {{output}}"
 108
 109       # TODO:(andybons): enable this when GCC PCH support in the binary has been
 110       # rolled.
 111       #precompiled_header_type = "gcc"
 112       depsformat = "gcc"
 113       description = "OBJCXX {{output}}"
 114       outputs = [
 115         "{{target_out_dir}}/{{target_output_name}}/{{source_name_part}}.o",
 116       ]
 117     }
 118
 119     tool("alink") {
 120       command = "rm -f {{output}} && ./gyp-mac-tool filter-libtool libtool -static -o {{output}} {{inputs}}"
 121       description = "LIBTOOL-STATIC {{output}}"
 122       outputs = [
 123         "{{target_out_dir}}/{{target_output_name}}{{output_extension}}",
 124       ]
 125       default_output_extension = ".a"
 126       output_prefix = "lib"
 127     }
 128
 129     tool("solink") {
 130       dylib = "{{root_out_dir}}/{{target_output_name}}{{output_extension}}"  # eg "./libfoo.dylib"
 131       rspfile = dylib + ".rsp"
 132
 133       # These variables are not built into GN but are helpers that implement
 134       # (1) linking to produce a .so, (2) extracting the symbols from that file
 135       # to a temporary file, (3) if the temporary file has differences from the
 136       # existing .TOC file, overwrite it, otherwise, don't change it.
 137       #
 138       # As a special case, if the library reexports symbols from other dynamic
 139       # libraries, we always update the .TOC and skip the temporary file and
 140       # diffing steps, since that library always needs to be re-linked.
 141       tocname = dylib + ".TOC"
 142       temporary_tocname = dylib + ".tmp"
 143
 144       does_reexport_command = "[ ! -e $dylib -o ! -e $tocname ] || otool -l $dylib | grep -q LC_REEXPORT_DYLIB"
 145
 146       link_command = "$ld -shared {{ldflags}} -o $dylib -Wl,-filelist,$rspfile"
 147       if (is_component_build) {
 148         link_command += " -Wl,-install_name,@rpath/{{target_output_name}}{{output_extension}}"
 149       }
 150       link_command += " {{solibs}} {{libs}}"
 151
 152       replace_command = "if ! cmp -s $temporary_tocname $tocname; then mv $temporary_tocname $tocname"
 153       extract_toc_command = "{ otool -l $dylib | grep LC_ID_DYLIB -A 5; nm -gP $dylib | cut -f1-2 -d' ' | grep -v U\$\$; true; }"
 154
 155       command = "if $does_reexport_command ; then $link_command && $extract_toc_command > $tocname; else $link_command && $extract_toc_command > $temporary_tocname && $replace_command ; fi; fi"
 156
 157       rspfile_content = "{{inputs_newline}}"
 158
 159       description = "SOLINK {{output}}"
 160
 161       # Use this for {{output_extension}} expansions unless a target manually
 162       # overrides it (in which case {{output_extension}} will be what the target
 163       # specifies).
 164       default_output_extension = ".dylib"
 165
 166       output_prefix = "lib"
 167
 168       # Since the above commands only updates the .TOC file when it changes, ask
 169       # Ninja to check if the timestamp actually changed to know if downstream
 170       # dependencies should be recompiled.
 171       restat = true
 172
 173       # Tell GN about the output files. It will link to the dylib but use the
 174       # tocname for dependency management.
 175       outputs = [
 176         dylib,
 177         tocname,
 178       ]
 179       link_output = dylib
 180       depend_output = tocname
 181     }
 182
 183     tool("link") {
 184       outfile = "{{root_out_dir}}/{{target_output_name}}{{output_extension}}"
 185       rspfile = "$outfile.rsp"
 186       command = "$ld {{ldflags}} -o $outfile -Wl,-filelist,$rspfile {{solibs}} {{libs}}"
 187       description = "LINK $outfile"
 188       rspfile_content = "{{inputs_newline}}"
 189       outputs = [
 190         outfile,
 191       ]
 192     }
 193
 194     tool("stamp") {
 195       command = "touch {{output}}"
 196       description = "STAMP {{output}}"
 197     }
 198
 199     tool("copy") {
 200       command = "ln -f {{source}} {{output}} 2>/dev/null || (rm -rf {{output}} && cp -af {{source}} {{output}})"
 201       description = "COPY {{source}} {{output}}"
 202     }
 203
 204     toolchain_args() {
 205       current_cpu = invoker.toolchain_cpu
 206       current_os = invoker.toolchain_os
 207
 208       # These values need to be passed through unchanged.
 209       target_os = target_os
 210       target_cpu = target_cpu
 211
 212       if (defined(invoker.is_clang)) {
 213         is_clang = invoker.is_clang
 214       }
 215     }
 216   }
 217 }
 218
 219 mac_toolchain("clang_arm") {
 220   toolchain_cpu = "arm"
 221   toolchain_os = "mac"
 222   prefix = rebase_path("//third_party/llvm-build/Release+Asserts/bin",
 223                        root_build_dir)
 224   cc = "${goma_prefix}$prefix/clang"
 225   cxx = "${goma_prefix}$prefix/clang++"
 226   ld = cxx
 227   is_clang = true
 228 }
 229
 230 mac_toolchain("ios_clang_arm") {
 231   # TODO(GYP): Do we need ios_clang_armv7 and ios_clang_arm64 ?
 232   toolchain_cpu = "arm"
 233   toolchain_os = "mac"
 234
 235   # TODO(GYP): We need to support being able to use the version of clang
 236   # shipped w/ XCode instead of the one pulled from upstream.
 237   prefix = rebase_path("//third_party/llvm-build/Release+Asserts/bin",
 238                        root_build_dir)
 239   cc = "${goma_prefix}$prefix/clang"
 240   cxx = "${goma_prefix}$prefix/clang++"
 241   ld = cxx
 242   is_clang = true
 243 }
 244
 245 mac_toolchain("arm") {
 246   toolchain_cpu = "arm"
 247   toolchain_os = "mac"
 248   cc = "${goma_prefix}/gcc"
 249   cxx = "${goma_prefix}/g++"
 250   ld = cxx
 251   is_clang = false
 252 }
 253
 254 mac_toolchain("clang_x64") {
 255   toolchain_cpu = "x64"
 256   toolchain_os = "mac"
 257   prefix = rebase_path("//third_party/llvm-build/Release+Asserts/bin",
 258                        root_build_dir)
 259   cc = "${goma_prefix}$prefix/clang"
 260   cxx = "${goma_prefix}$prefix/clang++"
 261   ld = cxx
 262   is_clang = true
 263 }
 264
 265 mac_toolchain("x64") {
 266   toolchain_cpu = "x64"
 267   toolchain_os = "mac"
 268   cc = "${goma_prefix}/gcc"
 269   cxx = "${goma_prefix}/g++"
 270   ld = cxx
 271   is_clang = false
 272 }