[gn build] Add libclang_rt.ios.a, libclang_rt.iossim.a to the build

[thakis]

Summary

It's built with just-built clang, like all other compiler-rt parts
in the GN build.

This requires adding some cross build support to the mac toolchain.

Also add explicit mmacosx-version-min and miphoneos-version-min
flags to the build.

ios.a is only built with the arm64 slice, iossim.a only with the
x86_64 slice for now. (The latter should maybe become host_cpu
when Arm Macs become a common iOS development platform.)

With this, it's possible to build chromium/iOS with a GN-built LLVM.

[aeubanks]

llvm/utils/gn/build/BUILD.gn

70

compiler-rt/cmake/config-ix.cmake sets this to 10.10, do we want to be different from that?

[thakis]

llvm/utils/gn/build/BUILD.gn

70

Huh, no idea where I got 10.9 from. Thanks, fixed.

llvm/utils/gn/build/BUILD.gn

config("compiler_defaults") {
   if (llvm_enable_expensive_checks) {
     defines += [ "EXPENSIVE_CHECKS" ]
   }
 
   asmflags = target_flags
   cflags = target_flags
   ldflags = target_flags + target_ldflags
 
-  if (host_os == "mac" && clang_base_path != "") {
+  if ((current_os == "ios" || current_os == "mac") && clang_base_path != "") {
+    if (current_os == "ios" && current_cpu == "arm64") {
+      sdk_path = ios_sdk_path
+    } else if (current_os == "ios" && current_cpu == "x64") {
+      sdk_path = iossim_sdk_path
+    } else if (current_os == "mac") {
+      sdk_path = mac_sdk_path
+    }
     cflags += [
       "-isysroot",
-      mac_sdk_path,
+      sdk_path,
     ]
     ldflags += [
       "-isysroot",
-      mac_sdk_path,
+      sdk_path,
     ]
   }
 
+  # Mostly for compiler-rt, see compiler-rt/cmake/config-ix.cmake
+  if (current_os == "ios") {
+    asmflags += [ "-miphoneos-version-min=8.0" ]
+    cflags += [ "-miphoneos-version-min=8.0" ]
+    ldflags += [ "-miphoneos-version-min=8.0" ]
+  }
+  if (current_os == "mac") {
+    asmflags += [ "-mmacosx-version-min=10.10" ]
+    cflags += [ "-mmacosx-version-min=10.10" ]
+    ldflags += [ "-mmacosx-version-min=10.10" ]
+  }
+
   if (host_os != "win") {
     if (is_debug) {
       cflags += [ "-g" ]
     }
     if (is_optimized) {
       cflags += [ "-O3" ]
     }
     cflags += [ "-fdiagnostics-color" ]
config("no_rtti") {
   } else {
     cflags_cc = [ "-fno-rtti" ]
   }
 }
 
 # To make an archive that can be distributed, you need to remove this config and
 # set complete_static_lib.
 config("thin_archive") {
-  if (current_os != "win" && current_os != "mac") {
+  if (current_os != "ios" && current_os != "mac" && current_os != "win") {
     arflags = [ "-T" ]
   }
 }
 
 config("llvm_code") {
   include_dirs = [
     "//llvm/include",
     "$root_gen_dir/llvm/include",

llvm/utils/gn/build/mac_sdk.gni

 declare_args() {
   # Set to true if you don't have Xcode installed, but do have the commandline
   # tools.
   mac_use_commandline_tools_sdk = false
 }
 
 # Location of the mac sdk.
 # The correct way to do this is to call xcrun (https://reviews.llvm.org/D70835),
 # but that makes `gn gen` take twice as long and almost everyone has Xcode
 # installed.  So require that people who don't have it installed set a gn arg.
 if (mac_use_commandline_tools_sdk) {
+  ios_sdk_path = "/Library/Developer/CommandLineTools/SDKs/iPhoneOS.sdk"
+  iossim_sdk_path =
+      "/Library/Developer/CommandLineTools/SDKs/iPhoneSimulator.sdk"
   mac_sdk_path = "/Library/Developer/CommandLineTools/SDKs/MacOSX.sdk"
 } else {
+  ios_sdk_path = "/Applications/Xcode.app/Contents/Developer/Platforms/iPhoneOS.platform/Developer/SDKs/iPhoneOS.sdk"
+  iossim_sdk_path = "/Applications/Xcode.app/Contents/Developer/Platforms/iPhoneSimulator.platform/Developer/SDKs/iPhoneSimulator.sdk"
   mac_sdk_path = "/Applications/Xcode.app/Contents/Developer/Platforms/MacOSX.platform/Developer/SDKs/MacOSX.sdk"
 }

llvm/utils/gn/build/toolchain/BUILD.gn

tool("asm") {
       depfile = "{{output}}.d"
       command = "$cc -MMD -MF $depfile -o {{output}} -c {{source}} {{defines}} {{include_dirs}} {{asmflags}}"
       depsformat = "gcc"
       description = "ASM {{output}}"
       outputs = [ "{{source_out_dir}}/{{label_name}}.{{source_name_part}}.o" ]
     }
 
     tool("alink") {
-      if (current_os == "mac") {
+      if (current_os == "ios" || current_os == "mac") {
         command = "libtool -D -static -no_warning_for_no_symbols {{arflags}} -o {{output}} {{inputs}}"
       } else {
         # Remove the output file first so that ar doesn't try to modify the
         # existing file.
         command =
             "rm -f {{output}} && $ar rcsD {{arflags}} {{output}} {{inputs}}"
       }
       description = "AR {{output}}"
       outputs = [ "{{output_dir}}/{{target_output_name}}.a" ]
       output_prefix = "lib"
       default_output_dir = "{{root_out_dir}}/lib"
     }
 
-    if (current_os == "mac") {
+    if (current_os == "ios" || current_os == "mac") {
       # gn < 1693 (e214b5d35898) doesn't support |frameworks|, requiring
       # frameworks to be listed in |libs|, but gn >= 1808 (3028c6a426a4) forbids
       # frameworks from appearing in |libs|. This assertion provides a helpful
       # cue to upgrade, and is much more user-friendly than the failure that
       # occurs when an older gn encounters |frameworks|.
       #
       # gn_version doesn’t actually exist in gn < 1709 (52cb644a3fb4), and
       # defined(gn_version) doesn't actually work as expected
       # (https://crbug.com/gn/183), so 1709 is the true minimum enforced by
       # this construct, and if gn_version is not available, this line will still
       # be blamed, making the resolution somewhat discoverable.
       assert(gn_version >= 1693,
              "Your GN is too old! " +
                  "Update it, perhaps by running llvm/utils/gn/get.py")
     }
 
     tool("solink") {
       outfile = "{{output_dir}}/{{target_output_name}}{{output_extension}}"
-      if (current_os == "mac") {
+      if (current_os == "ios" || current_os == "mac") {
         command = "$ld -shared {{ldflags}} -o $outfile {{inputs}} {{libs}} {{frameworks}}"
         default_output_extension = ".dylib"
       } else {
         command = "$ld -shared {{ldflags}} -Wl,-z,defs -Wl,-soname,{{target_output_name}}{{output_extension}} -o $outfile {{inputs}} {{libs}}"
         default_output_extension = ".so"
       }
       description = "SOLINK $outfile"
       outputs = [ outfile ]
       lib_switch = "-l"
       output_prefix = "lib"
       default_output_dir = "{{root_out_dir}}/lib"
     }
 
     tool("solink_module") {
       outfile = "{{output_dir}}/{{target_output_name}}{{output_extension}}"
-      if (current_os == "mac") {
+      if (current_os == "ios" || current_os == "mac") {
         command = "$ld -shared {{ldflags}} -Wl,-flat_namespace -Wl,-undefined,suppress -o $outfile {{inputs}} {{libs}} {{frameworks}}"
         default_output_extension = ".dylib"
       } else {
         command = "$ld -shared {{ldflags}} -Wl,-soname,{{target_output_name}}{{output_extension}} -o $outfile {{inputs}} {{libs}}"
         default_output_extension = ".so"
       }
       description = "SOLINK $outfile"
       outputs = [ outfile ]
       lib_switch = "-l"
       default_output_dir = "{{root_out_dir}}/lib"
     }
 
     tool("link") {
       outfile = "{{output_dir}}/{{target_output_name}}{{output_extension}}"
-      if (current_os == "mac") {
+      if (current_os == "ios" || current_os == "mac") {
         command =
             "$ld {{ldflags}} -o $outfile {{inputs}} {{libs}} {{frameworks}}"
       } else {
         command = "$ld {{ldflags}} -o $outfile -Wl,--start-group {{inputs}} -Wl,--end-group {{libs}}"
       }
       description = "LINK $outfile"
       outputs = [ outfile ]
       lib_switch = "-l"
 
       # Setting this allows targets to override the default executable output by
       # setting output_dir.
       default_output_dir = "{{root_out_dir}}/bin"
     }
 
     copy_command = "ln -f {{source}} {{output}} 2>/dev/null || (rm -rf {{output}} && cp -af {{source}} {{output}})"
     tool("copy") {
       command = copy_command
       description = "COPY {{source}} {{output}}"
     }
 
-    if (current_os == "mac") {
+    if (current_os == "ios" || current_os == "mac") {
       tool("copy_bundle_data") {
         # http://serverfault.com/q/209888/43689
         _copydir = "mkdir -p {{output}} && cd {{source}} && " +
                    "pax -rwl . \"\$OLDPWD\"/{{output}}"
         command = "rm -rf {{output}} && if [[ -d {{source}} ]]; then " +
                   _copydir + "; else " + copy_command + "; fi"
         description = "COPY_BUNDLE_DATA {{source}} {{output}}"
       }
       tool("compile_xcassets") {
         command = "false"
         description = "The LLVM build doesn't use any xcasset files"
       }
     }
 
     tool("stamp") {
       command = "touch {{output}}"
       description = "STAMP {{output}}"
     }
   }
 }
 
 unix_toolchain("unix") {
-  if (current_os != "mac") {
+  if (current_os != "ios" && current_os != "mac") {
     ar = "ar"
   }
 
   toolchain_args = {
     current_os = host_os
     current_cpu = host_cpu
   }
 }
 
 # This template defines a toolchain that uses just-built clang and lld
 # as compiler and linker.
 template("stage2_unix_toolchain") {
   unix_toolchain(target_name) {
     toolchain_args = {
       forward_variables_from(invoker.toolchain_args, "*")
 
       clang_base_path = "."
       use_goma = false
     }
 
     deps = [
       "//:clang($host_toolchain)",
       "//:lld($host_toolchain)",
     ]
-    if (current_os != "mac") {
+    if (current_os != "ios" && current_os != "mac") {
       ar = "bin/llvm-ar"
       deps += [ "//:llvm-ar($host_toolchain)" ]
     }
   }
 }
 
 stage2_unix_toolchain("stage2_unix") {
   toolchain_args = {
if (android_ndk_path != "") {
   stage2_unix_toolchain("stage2_android_arm") {
     toolchain_args = {
       current_os = "android"
       current_cpu = "arm"
     }
   }
 }
 
+if (host_os == "mac") {
+  stage2_unix_toolchain("stage2_ios_aarch64") {
+    toolchain_args = {
+      current_os = "ios"
+      current_cpu = "arm64"
+    }
+  }
+
+  stage2_unix_toolchain("stage2_iossim_x64") {
+    toolchain_args = {
+      current_os = "ios"
+      current_cpu = "x64"
+    }
+  }
+}
+
 toolchain("win") {
   cl = "cl"
   link = "link"
 
   if (clang_base_path != "") {
     cl = "$clang_base_path/bin/clang-cl"
     if (use_lld) {
       link = "$clang_base_path/bin/lld-link"

llvm/utils/gn/build/toolchain/target_flags.gni

 import("//llvm/triples.gni")
 import("//llvm/utils/gn/build/toolchain/compiler.gni")
 
+# Flags in this file are passed both to the compiler that's building
+# compiler-rt at build time (via normal gn cflags/ldflags), as well as to the
+# compiler building compiler-rt test programs at test time (via
+# COMPILER_RT_TEST_COMPILER_CFLAGS).
+
 target_flags = []
 target_ldflags = []
 
 if (current_os == "android") {
   target_flags += [
     "--target=$llvm_current_triple",
     "--sysroot=$android_ndk_path/toolchains/llvm/prebuilt/linux-x86_64/sysroot",
     "-B$android_ndk_path/toolchains/llvm/prebuilt/linux-x86_64",
   ]
   target_ldflags += [ "-static-libstdc++" ]
   if (current_cpu == "arm") {
     target_flags += [ "-march=armv7-a" ]
   }
+} else if (current_os == "ios") {
+  if (current_cpu == "arm64") {
+    target_flags += [
+      "-arch",
+      "arm64",
+    ]
+    target_ldflags += [
+      "-arch",
+      "arm64",
+    ]
+  } else if (current_cpu == "x64") {
+    target_flags += [
+      "-arch",
+      "x86_64",
+    ]
+    target_ldflags += [
+      "-arch",
+      "x86_64",
+    ]
+  }
 }
 
 if (current_cpu == "x86") {
   target_flags = [ "-m32" ]
 }

llvm/utils/gn/secondary/compiler-rt/BUILD.gn

+import("//llvm/lib/Target/targets.gni")
 import("//llvm/utils/gn/build/toolchain/compiler.gni")
 
 # In the GN build, compiler-rt is always built by just-built clang and lld.
 # FIXME: For macOS and iOS builds, depend on lib in all needed target arch
 # toolchains and then lipo them together for the final output.
 supported_toolchains = [ "//llvm/utils/gn/build/toolchain:stage2_unix" ]
 if (android_ndk_path != "") {
   supported_toolchains += [
     "//llvm/utils/gn/build/toolchain:stage2_android_aarch64",
     "//llvm/utils/gn/build/toolchain:stage2_android_arm",
   ]
 }
-
 group("compiler-rt") {
   deps = []
   foreach(toolchain, supported_toolchains) {
     deps += [ "//compiler-rt/lib($toolchain)" ]
   }
+
+  # FIXME: Do this only if a gn arg compiler_rt_enable_ios is set?
+  # That would match the cmake build.
+  if (host_os == "mac") {
+    if (llvm_build_AArch64) {
+      deps += [ "//compiler-rt/lib/builtins(//llvm/utils/gn/build/toolchain:stage2_ios_aarch64)" ]
+    }
+    if (llvm_build_X86) {
+      deps += [ "//compiler-rt/lib/builtins(//llvm/utils/gn/build/toolchain:stage2_iossim_x64)" ]
+    }
+  }
 }

llvm/utils/gn/secondary/compiler-rt/lib/builtins/BUILD.gn

 import("//compiler-rt/target.gni")
 import("//llvm/utils/gn/build/buildflags.gni")
 
 declare_args() {
   # Skip the atomic builtin (should normally be provided by a shared library).
   compiler_rt_exclude_atomic_builtin = true
 
   # Compile builtins for baremetal.
   compiler_rt_baremetal_build = false
 }
 
 static_library("builtins") {
   output_dir = crt_current_out_dir
   if (current_os == "mac") {
     output_name = "clang_rt.osx"
+  } else if (current_os == "ios" && current_cpu == "arm64") {
+    output_name = "clang_rt.ios"
+  } else if (current_os == "ios" && current_cpu == "x64") {
+    output_name = "clang_rt.iossim"
   } else {
     output_name = "clang_rt.builtins$crt_current_target_suffix"
   }
 
   complete_static_lib = true
   configs -= [ "//llvm/utils/gn/build:thin_archive" ]
 
   cflags = [
sources += [
       "eprintf.c",
     ]
   }
 
   if (current_os != "fuchsia" && !compiler_rt_baremetal_build) {
     sources += [ "clear_cache.c" ]
   }
 
-  if (current_os == "mac") {
+  if (current_os == "mac" || current_os == "ios") {
     sources += [
       "atomic_flag_clear.c",
       "atomic_flag_clear_explicit.c",
       "atomic_flag_test_and_set.c",
       "atomic_flag_test_and_set_explicit.c",
       "atomic_signal_fence.c",
       "atomic_thread_fence.c",
     ]
if (current_cpu == "ve") {
     ]
   }
 
   if (!compiler_rt_exclude_atomic_builtin) {
     sources += [ "atomic.c" ]
   }
 }
 
-# Currently unused but necessary to make the sync_source_lists_from_cmake.py
-# happy.
+# Currently unused but necessary to make sync_source_lists_from_cmake.py happy.
 source_set("_unused") {
   sources = [
     # Thumb1
     "arm/addsf3.S",
     "arm/comparesf2.S",
     "arm/divsi3.S",
     "arm/udivsi3.S",
   ]
 }

llvm/utils/gn/secondary/compiler-rt/target.gni

if (clang_enable_per_target_runtime_dir) {
   crt_current_target_suffix = ""
 } else if (current_os == "linux" || current_os == "android") {
   crt_current_out_dir = "$clang_resource_dir/lib/linux"
 
   crt_current_target_suffix = "-$crt_current_target_arch"
   if (current_os == "android") {
     crt_current_target_suffix += "-android"
   }
-} else if (current_os == "mac") {
+} else if (current_os == "ios" || current_os == "mac") {
   crt_current_out_dir = "$clang_resource_dir/lib/darwin"
 } else {
   assert(false, "unimplemented current_os " + current_os)
 }

llvm/utils/gn/secondary/llvm/triples.gni

 if (current_cpu == "x86") {
   if (current_os == "linux") {
     llvm_current_triple = "i386-unknown-linux-gnu"
   }
 } else if (current_cpu == "x64") {
   if (current_os == "freebsd") {
     llvm_current_triple = "x86_64-unknown-freebsd"
   } else if (current_os == "linux") {
     llvm_current_triple = "x86_64-unknown-linux-gnu"
-  } else if (current_os == "mac") {
+  } else if (current_os == "ios" || current_os == "mac") {
     llvm_current_triple = "x86_64-apple-darwin"
   } else if (current_os == "win") {
     llvm_current_triple = "x86_64-pc-windows-msvc"
   }
 } else if (current_cpu == "arm") {
   if (current_os == "android") {
     llvm_current_triple = "arm-linux-androideabi29"
   }
 } else if (current_cpu == "arm64") {
   if (current_os == "android") {
     llvm_current_triple = "aarch64-linux-android29"
-  } else if (current_os == "mac") {
+  } else if (current_os == "ios" || current_os == "mac") {
     llvm_current_triple = "arm64-apple-darwin"
   }
 } else if (current_cpu == "ppc64") {
   if (current_os == "linux") {
     llvm_current_triple = "powerpc64le-unknown-linux-gnu"
   }
 }
 
 if (!defined(llvm_current_triple)) {
   assert(false, "unimplemented cpu/os " + current_cpu + "/" + current_os)
 }
 
 declare_args() {
   # The default target triple.
   llvm_target_triple = llvm_current_triple
 }