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       command = "$cc -MMD -MF $depfile {{defines}} {{include_dirs}} {{cflags}} {{cflags_c}} -c {{source}} -o {{output}}"
  54       depsformat = "gcc"
  55       description = "CC {{output}}"
  56       outputs = [
  57         "{{target_out_dir}}/{{target_output_name}}/{{source_name_part}}.o",
  58       ]
  59     }
  60
  61     tool("cxx") {
  62       depfile = "{{output}}.d"
  63       command = "$cxx -MMD -MF $depfile {{defines}} {{include_dirs}} {{cflags}} {{cflags_cc}} -c {{source}} -o {{output}}"
  64       depsformat = "gcc"
  65       description = "CXX {{output}}"
  66       outputs = [
  67         "{{target_out_dir}}/{{target_output_name}}/{{source_name_part}}.o",
  68       ]
  69     }
  70
  71     tool("asm") {
  72       # For GCC we can just use the C compiler to compile assembly.
  73       depfile = "{{output}}.d"
  74       command = "$cc -MMD -MF $depfile {{defines}} {{include_dirs}} {{cflags}} {{cflags_c}} -c {{source}} -o {{output}}"
  75       depsformat = "gcc"
  76       description = "ASM {{output}}"
  77       outputs = [
  78         "{{target_out_dir}}/{{target_output_name}}/{{source_name_part}}.o",
  79       ]
  80     }
  81
  82     tool("objc") {
  83       depfile = "{{output}}.d"
  84       command = "$cxx -MMD -MF $depfile {{defines}} {{include_dirs}} {{cflags}} {{cflags_objc}} -c {{source}} -o {{output}}"
  85       depsformat = "gcc"
  86       description = "OBJC {{output}}"
  87       outputs = [
  88         "{{target_out_dir}}/{{target_output_name}}/{{source_name_part}}.o",
  89       ]
  90     }
  91
  92     tool("objcxx") {
  93       depfile = "{{output}}.d"
  94       command = "$cxx -MMD -MF $depfile {{defines}} {{include_dirs}} {{cflags}} {{cflags_objcc}} -c {{source}} -o {{output}}"
  95       depsformat = "gcc"
  96       description = "OBJCXX {{output}}"
  97       outputs = [
  98         "{{target_out_dir}}/{{target_output_name}}/{{source_name_part}}.o",
  99       ]
 100     }
 101
 102     tool("alink") {
 103       command = "rm -f {{output}} && ./gyp-mac-tool filter-libtool libtool -static -o {{output}} {{inputs}}"
 104       description = "LIBTOOL-STATIC {{output}}"
 105       outputs = [
 106         "{{target_out_dir}}/{{target_output_name}}{{output_extension}}",
 107       ]
 108       default_output_extension = ".a"
 109       output_prefix = "lib"
 110     }
 111
 112     tool("solink") {
 113       dylib = "{{root_out_dir}}/{{target_output_name}}{{output_extension}}"  # eg "./libfoo.dylib"
 114       rspfile = dylib + ".rsp"
 115
 116       # These variables are not built into GN but are helpers that implement
 117       # (1) linking to produce a .so, (2) extracting the symbols from that file
 118       # to a temporary file, (3) if the temporary file has differences from the
 119       # existing .TOC file, overwrite it, otherwise, don't change it.
 120       #
 121       # As a special case, if the library reexports symbols from other dynamic
 122       # libraries, we always update the .TOC and skip the temporary file and
 123       # diffing steps, since that library always needs to be re-linked.
 124       tocname = dylib + ".TOC"
 125       temporary_tocname = dylib + ".tmp"
 126
 127       does_reexport_command = "[ ! -e $dylib -o ! -e $tocname ] || otool -l $dylib | grep -q LC_REEXPORT_DYLIB"
 128
 129       link_command = "$ld -shared {{ldflags}} -o $dylib -Wl,-filelist,$rspfile"
 130       if (is_component_build) {
 131         link_command += " -Wl,-install_name,@rpath/{{target_output_name}}{{output_extension}}"
 132       }
 133       link_command += " {{solibs}} {{libs}}"
 134
 135       replace_command = "if ! cmp -s $temporary_tocname $tocname; then mv $temporary_tocname $tocname"
 136       extract_toc_command = "{ otool -l $dylib | grep LC_ID_DYLIB -A 5; nm -gP $dylib | cut -f1-2 -d' ' | grep -v U\$\$; true; }"
 137
 138       command = "if $does_reexport_command ; then $link_command && $extract_toc_command > $tocname; else $link_command && $extract_toc_command > $temporary_tocname && $replace_command ; fi; fi"
 139
 140       rspfile_content = "{{inputs_newline}}"
 141
 142       description = "SOLINK {{output}}"
 143
 144       # Use this for {{output_extension}} expansions unless a target manually
 145       # overrides it (in which case {{output_extension}} will be what the target
 146       # specifies).
 147       default_output_extension = ".dylib"
 148
 149       output_prefix = "lib"
 150
 151       # Since the above commands only updates the .TOC file when it changes, ask
 152       # Ninja to check if the timestamp actually changed to know if downstream
 153       # dependencies should be recompiled.
 154       restat = true
 155
 156       # Tell GN about the output files. It will link to the dylib but use the
 157       # tocname for dependency management.
 158       outputs = [
 159         dylib,
 160         tocname,
 161       ]
 162       link_output = dylib
 163       depend_output = tocname
 164     }
 165
 166     tool("link") {
 167       outfile = "{{root_out_dir}}/{{target_output_name}}{{output_extension}}"
 168       rspfile = "$outfile.rsp"
 169       command = "$ld {{ldflags}} -o $outfile -Wl,-filelist,$rspfile {{solibs}} {{libs}}"
 170       description = "LINK $outfile"
 171       rspfile_content = "{{inputs_newline}}"
 172       outputs = [
 173         outfile,
 174       ]
 175     }
 176
 177     tool("stamp") {
 178       command = "touch {{output}}"
 179       description = "STAMP {{output}}"
 180     }
 181
 182     tool("copy") {
 183       command = "ln -f {{source}} {{output}} 2>/dev/null || (rm -rf {{output}} && cp -af {{source}} {{output}})"
 184       description = "COPY {{source}} {{output}}"
 185     }
 186
 187     toolchain_args() {
 188       current_cpu = invoker.toolchain_cpu
 189       current_os = invoker.toolchain_os
 190
 191       # These values need to be passed through unchanged.
 192       target_os = target_os
 193       target_cpu = target_cpu
 194
 195       if (defined(invoker.is_clang)) {
 196         is_clang = invoker.is_clang
 197       }
 198     }
 199   }
 200 }
 201
 202 mac_toolchain("clang_arm") {
 203   toolchain_cpu = "arm"
 204   toolchain_os = "mac"
 205   prefix = rebase_path("//third_party/llvm-build/Release+Asserts/bin",
 206                        root_build_dir)
 207   cc = "${goma_prefix}$prefix/clang"
 208   cxx = "${goma_prefix}$prefix/clang++"
 209   ld = cxx
 210   is_clang = true
 211 }
 212
 213 mac_toolchain("ios_clang_arm") {
 214   # TODO(GYP): Do we need ios_clang_armv7 and ios_clang_arm64 ?
 215   toolchain_cpu = "arm"
 216   toolchain_os = "mac"
 217
 218   # TODO(GYP): We need to support being able to use the version of clang
 219   # shipped w/ XCode instead of the one pulled from upstream.
 220   prefix = rebase_path("//third_party/llvm-build/Release+Asserts/bin",
 221                        root_build_dir)
 222   cc = "${goma_prefix}$prefix/clang"
 223   cxx = "${goma_prefix}$prefix/clang++"
 224   ld = cxx
 225   is_clang = true
 226 }
 227
 228 mac_toolchain("arm") {
 229   toolchain_cpu = "arm"
 230   toolchain_os = "mac"
 231   cc = "${goma_prefix}/gcc"
 232   cxx = "${goma_prefix}/g++"
 233   ld = cxx
 234   is_clang = false
 235 }
 236
 237 mac_toolchain("clang_x64") {
 238   toolchain_cpu = "x64"
 239   toolchain_os = "mac"
 240   prefix = rebase_path("//third_party/llvm-build/Release+Asserts/bin",
 241                        root_build_dir)
 242   cc = "${goma_prefix}$prefix/clang"
 243   cxx = "${goma_prefix}$prefix/clang++"
 244   ld = cxx
 245   is_clang = true
 246 }
 247
 248 mac_toolchain("x64") {
 249   toolchain_cpu = "x64"
 250   toolchain_os = "mac"
 251   cc = "${goma_prefix}/gcc"
 252   cxx = "${goma_prefix}/g++"
 253   ld = cxx
 254   is_clang = false
 255 }