patch from chinmaygarde@ to make progress on mac, ios.

build/toolchain/mac/BUILD.gn

 # Copyright (c) 2013 The Chromium Authors. All rights reserved.
 # Use of this source code is governed by a BSD-style license that can be
 # found in the LICENSE file.
 
 # TODO(brettw) Use "gcc_toolchain.gni" like the Linux toolchains. This requires
 # some enhancements since the commands on Mac are slightly different than on
 # Linux.
 
 import("../goma.gni")
+import("//build/config/ios/ios_sdk.gni")
 
 assert(host_os == "mac")
 
 import("//build/toolchain/clang.gni")
 import("//build/toolchain/goma.gni")
+import("//build/config/sysroot.gni")
 
 if (use_goma) {
   goma_prefix = "$goma_dir/gomacc "
 } else {
   goma_prefix = ""
 }
 
 # This will copy the gyp-mac-tool to the build directory. We pass in the source
 # file of the win tool.
 gyp_mac_tool_source =
     rebase_path("//tools/gyp/pylib/gyp/mac_tool.py", root_build_dir)
 exec_script("setup_toolchain.py", [ gyp_mac_tool_source ])
 
 # Shared toolchain definition. Invocations should set toolchain_os to set the
 # build args in this definition.
 template("mac_toolchain") {
   toolchain(target_name) {
     assert(defined(invoker.cc), "mac_toolchain() must specify a \"cc\" value")
     assert(defined(invoker.cxx), "mac_toolchain() must specify a \"cxx\" value")
     assert(defined(invoker.ld), "mac_toolchain() must specify a \"ld\" value")
     assert(defined(invoker.toolchain_cpu),
            "mac_toolchain() must specify a \"toolchain_cpu\"")
     assert(defined(invoker.toolchain_os),
            "mac_toolchain() must specify a \"toolchain_os\"")
+    assert(defined(invoker.switch_sysroot),
+           "mac_toolchain() must specify a \"switch_sysroot\"")
 
     # We can't do string interpolation ($ in strings) on things with dots in
     # them. To allow us to use $cc below, for example, we create copies of
     # these values in our scope.
     cc = invoker.cc
     cxx = invoker.cxx
     ld = invoker.ld
 
     # Make these apply to all tools below.
     lib_switch = "-l"
     lib_dir_switch = "-L"
 
+    sysroot_flags = ""
+
+    if (invoker.switch_sysroot) {
+      version_flags = ""
+
+      if (use_ios_simulator) {
+        version_flags = "-mios-simulator-version-min=$ios_deployment_target"

[brettw, 2015/08/04 18:07:29]

I wonder if this can be more like Linux?

There we have a config "//build/config/linux:sdk" that gets added by default in
BUILDCONFIG.gn to all binary targets. That sets up the sysroot and related flags
when necessary.

This use of the sysroot variable is also not quite right. The toolchain
definitions are executed in the context of the default toolchain, so this might
not always refer to the thing you want. Using the above pattern will do the
right thing.

[Dirk Pranke, 2015/08/04 18:27:15]

I will add a comment and investigate that in a separate CL if that's okay?

[brettw, 2015/08/04 19:20:23]

This current one is definitely wrong so I'd rather not add the sysroot_flags
stuff which just needs to get deleted later. If you want to simplify this
change, I'd move this whole file's changes to a different CL.

[Dirk Pranke, 2015/08/04 19:28:06]

Okay, I'll see what I can do, one way or another.

+      } else {
+        version_flags = "-miphoneos-version-min=$ios_deployment_target"
+      }
+
+      sysroot_flags = "-isysroot $sysroot $version_flags"
+    }
+
     tool("cc") {
       depfile = "{{output}}.d"
-      command = "$cc -MMD -MF $depfile {{defines}} {{include_dirs}} {{cflags}} {{cflags_c}} -c {{source}} -o {{output}}"
+      command = "$cc -MMD -MF $depfile {{defines}} {{include_dirs}} $sysroot_flags {{cflags}} {{cflags_c}} -c {{source}} -o {{output}}"
       depsformat = "gcc"
       description = "CC {{output}}"
       outputs = [
         "{{target_out_dir}}/{{target_output_name}}/{{source_name_part}}.o",
       ]
     }
 
     tool("cxx") {
       depfile = "{{output}}.d"
-      command = "$cxx -MMD -MF $depfile {{defines}} {{include_dirs}} {{cflags}} {{cflags_cc}} -c {{source}} -o {{output}}"
+      command = "$cxx -MMD -MF $depfile {{defines}} {{include_dirs}} $sysroot_flags {{cflags}} {{cflags_cc}} -c {{source}} -o {{output}}"
       depsformat = "gcc"
       description = "CXX {{output}}"
       outputs = [
         "{{target_out_dir}}/{{target_output_name}}/{{source_name_part}}.o",
       ]
     }
 
     tool("asm") {
       # For GCC we can just use the C compiler to compile assembly.
       depfile = "{{output}}.d"
       command = "$cc -MMD -MF $depfile {{defines}} {{include_dirs}} {{cflags}} {{cflags_c}} -c {{source}} -o {{output}}"
       depsformat = "gcc"
       description = "ASM {{output}}"
       outputs = [
         "{{target_out_dir}}/{{target_output_name}}/{{source_name_part}}.o",
       ]
     }
 
     tool("objc") {
       depfile = "{{output}}.d"
-      command = "$cxx -MMD -MF $depfile {{defines}} {{include_dirs}} {{cflags}} {{cflags_objc}} -c {{source}} -o {{output}}"
+      command = "$cxx -MMD -MF $depfile {{defines}} {{include_dirs}} {{cflags}} {{cflags_c}} {{cflags_objc}} -c {{source}} -o {{output}}"
       depsformat = "gcc"
       description = "OBJC {{output}}"
       outputs = [
         "{{target_out_dir}}/{{target_output_name}}/{{source_name_part}}.o",
       ]
     }
 
     tool("objcxx") {
       depfile = "{{output}}.d"
-      command = "$cxx -MMD -MF $depfile {{defines}} {{include_dirs}} {{cflags}} {{cflags_objcc}} -c {{source}} -o {{output}}"
+      command = "$cxx -MMD -MF $depfile {{defines}} {{include_dirs}} {{cflags}} {{cflags_cc}} {{cflags_objcc}} -c {{source}} -o {{output}}"
       depsformat = "gcc"
       description = "OBJCXX {{output}}"
       outputs = [
         "{{target_out_dir}}/{{target_output_name}}/{{source_name_part}}.o",
       ]
     }
 
     tool("alink") {
       command = "rm -f {{output}} && ./gyp-mac-tool filter-libtool libtool -static -o {{output}} {{inputs}}"
       description = "LIBTOOL-STATIC {{output}}"
@@ skipping 13 matching lines @@
       # to a temporary file, (3) if the temporary file has differences from the
       # existing .TOC file, overwrite it, oterwise, don't change it.
       #
       # As a special case, if the library reexports symbols from other dynamic
       # libraries, we always update the .TOC and skip the temporary file and
       # diffing steps, since that library always needs to be re-linked.
       tocname = dylib + ".TOC"
       temporary_tocname = dylib + ".tmp"
 
       does_reexport_command = "[ ! -e $dylib -o ! -e $tocname ] || otool -l $dylib | grep -q LC_REEXPORT_DYLIB"
-      link_command = "$ld -shared {{ldflags}} -o $dylib -Wl,-filelist,$rspfile {{solibs}} {{libs}}"
+      link_command = "$ld -shared $sysroot_flags {{ldflags}} -o $dylib -Wl,-filelist,$rspfile {{solibs}} {{libs}}"
       replace_command = "if ! cmp -s $temporary_tocname $tocname; then mv $temporary_tocname $tocname"
       extract_toc_command = "{ otool -l $dylib | grep LC_ID_DYLIB -A 5; nm -gP $dylib | cut -f1-2 -d' ' | grep -v U\$\$; true; }"
 
       command = "if $does_reexport_command ; then $link_command && $extract_toc_command > $tocname; else $link_command && $extract_toc_command > $temporary_tocname && $replace_command ; fi; fi"
 
       rspfile_content = "{{inputs_newline}}"
 
       description = "SOLINK {{output}}"
 
       # Use this for {{output_extension}} expansions unless a target manually
@@ skipping 14 matching lines @@
         dylib,
         tocname,
       ]
       link_output = dylib
       depend_output = tocname
     }
 
     tool("link") {
       outfile = "{{root_out_dir}}/{{target_output_name}}{{output_extension}}"
       rspfile = "$outfile.rsp"
-      command = "$ld {{ldflags}} -o $outfile -Wl,-filelist,$rspfile {{solibs}} {{libs}}"
+      command = "$ld $sysroot_flags {{ldflags}} -o $outfile -Wl,-filelist,$rspfile {{solibs}} {{libs}}"
       description = "LINK $outfile"
       rspfile_content = "{{inputs_newline}}"
       outputs = [
         outfile,
       ]
     }
 
     tool("stamp") {
       command = "touch {{output}}"
       description = "STAMP {{output}}"
@@ skipping 21 matching lines @@
 
 mac_toolchain("clang_arm") {
   toolchain_cpu = "arm"
   toolchain_os = "mac"
   prefix = rebase_path("//third_party/llvm-build/Release+Asserts/bin",
                        root_build_dir)
   cc = "${goma_prefix}$prefix/clang"
   cxx = "${goma_prefix}$prefix/clang++"
   ld = cxx
   is_clang = true
+  switch_sysroot = false
+}
+
+mac_toolchain("ios_clang_arm") {
+  # TODO(GYP): Do we need ios_clang_armv7 and ios_clang_arm64 ?
+  toolchain_cpu = "arm"
+  toolchain_os = "mac"
+
+  # TODO(GYP): We need to support being able to use the version of clang
+  # shipped w/ XCode instead of the one pulled from upstream.
+  prefix = rebase_path("//third_party/llvm-build/Release+Asserts/bin",
+                       root_build_dir)
+  cc = "${goma_prefix}$prefix/clang"
+  cxx = "${goma_prefix}$prefix/clang++"
+  ld = cxx
+  is_clang = true
+  switch_sysroot = true
 }
 
 mac_toolchain("arm") {
   toolchain_cpu = "arm"
   toolchain_os = "mac"
   cc = "${goma_prefix}/gcc"
   cxx = "${goma_prefix}/g++"
   ld = cxx
   is_clang = false
+  switch_sysroot = false
 }
 
 mac_toolchain("clang_x64") {
   toolchain_cpu = "x64"
   toolchain_os = "mac"
   prefix = rebase_path("//third_party/llvm-build/Release+Asserts/bin",
                        root_build_dir)
   cc = "${goma_prefix}$prefix/clang"
   cxx = "${goma_prefix}$prefix/clang++"
   ld = cxx
   is_clang = true
+  switch_sysroot = false
 }
 
 mac_toolchain("x64") {
   toolchain_cpu = "x64"
   toolchain_os = "mac"
   cc = "${goma_prefix}/gcc"
   cxx = "${goma_prefix}/g++"
   ld = cxx
   is_clang = false
+  switch_sysroot = false
 }