gn build: Fix support for building the builtins for baremetal.

[pcc]

Summary

Our support for building for baremetal was conditional on a default
off arg and would have failed to build if you had somehow arranged
to pass the correct --target flag; presumably nobody noticed because
nobody was turning it on. A better approach is to model baremetal
as a separate "OS" called "baremetal" and build it in the same way
as we cross-compile for other targets. That's what this patch does.
I only hooked up the arm64 target but others can be added.

[thakis]

Seems fine. Not sure if the dep commented below should be behind a toggle. I suppose it probably builds quickly, so maybe not worth it.

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

16

Will we now always build these, unconditionally?

[pcc]

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

16

Yes, if the aarch64 backend is enabled. We can add a toggle if we need it but it doesn't seem necessary at this point as it builds quickly and it should help avoid bitrot.

[thakis]

This broke building on non-linux: http://45.33.8.238/macm1/32578/step_4.txt

Ptal and revert if it takes a while to fix.

[pcc]

In D122862#3433839, @thakis wrote:

This broke building on non-linux: http://45.33.8.238/macm1/32578/step_4.txt

Ptal and revert if it takes a while to fix.

D123244 fixed the problem on my M1 Mac.

[thakis]

This breaks building with use_asan = true afaict:

[0/1] Regenerating ninja files
ERROR at //llvm/utils/gn/build/BUILD.gn:347:5 (//llvm/utils/gn/build/toolchain:stage2_baremetal_aarch64): Assertion failed.
    assert(is_clang && (current_os == "ios" || current_os == "linux" ||
    ^-----
asan only supported on iOS/Clang, Linux/Clang, and macOS/Clang, got baremetal

(I locally added , got $current_os to the assert string)

[thakis]

Which one is the right fix? Should we allow asan for baremetal? Or should we force off asan for the baremetal toolchain? (Diff for 2nd option would be

diff --git a/llvm/utils/gn/build/toolchain/BUILD.gn b/llvm/utils/gn/build/toolchain/BUILD.gn
index 29da00c29fca..6bf5febf3d39 100644
--- a/llvm/utils/gn/build/toolchain/BUILD.gn
+++ b/llvm/utils/gn/build/toolchain/BUILD.gn
@@ -253,6 +253,7 @@ stage2_unix_toolchain("stage2_baremetal_aarch64") {
   toolchain_args = {
     current_os = "baremetal"
     current_cpu = "arm64"
+    use_asan = false
   }
 }

)

[thakis]

Third option, I suppose: Don't build anything in the baremetal toolchain if use_asan is true.

[pcc]

I don't think I would expect the stage 2 runtimes to be built with a sanitizer even if use_asan is set. The sanitizer runtimes themselves don't support being built with sanitizers, and they might be compiled to depend on the builtins, which would create a circular dependency. So I think use_asan and such should only affect the stage 1 compiler. I think I would favor adding use_asan = false to the stage2_unix_toolchain template.

[phosek]

In D122862#3587325, @pcc wrote:

I don't think I would expect the stage 2 runtimes to be built with a sanitizer even if use_asan is set. The sanitizer runtimes themselves don't support being built with sanitizers, and they might be compiled to depend on the builtins, which would create a circular dependency. So I think use_asan and such should only affect the stage 1 compiler. I think I would favor adding use_asan = false to the stage2_unix_toolchain template.

While it doesn't make sense to build compiler-rt with ASan, it's useful for other runtimes like libc++abi and libc++, so I'd like to avoid adding use_asan = false to the stage2_unix_toolchain template.

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

if (host_os == "mac") {
   stage2_unix_toolchain("stage2_iossim_x64") {
     toolchain_args = {
       current_os = "ios"
       current_cpu = "x64"
     }
   }
 }
 
+stage2_unix_toolchain("stage2_baremetal_aarch64") {
+  toolchain_args = {
+    current_os = "baremetal"
+    current_cpu = "arm64"
+  }
+}
+
 template("win_toolchain") {
   toolchain(target_name) {
     # https://groups.google.com/a/chromium.org/d/msg/gn-dev/F_lv5T-tNDM
     forward_variables_from(invoker.toolchain_args, "*")
     not_needed("*")
 
     forward_variables_from(invoker, "*")
 

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

target_flags += [
       "-arch",
       "x86_64",
     ]
     target_ldflags += [
       "-arch",
       "x86_64",
     ]
   }
+} else if (current_os == "baremetal") {
+  target_flags += [ "--target=$llvm_current_triple" ]
 }
 
 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/mac_sdk.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.
 if (current_os == "win") {
   supported_toolchains = [ "//llvm/utils/gn/build/toolchain:stage2_win" ]
   supported_toolchains += [ "//llvm/utils/gn/build/toolchain:stage2_win_x86" ]
 } else {
   supported_toolchains = [ "//llvm/utils/gn/build/toolchain:stage2_unix" ]
 }
 supported_toolchains += supported_android_toolchains
+if (llvm_build_AArch64) {
+  supported_toolchains += [ "//llvm/utils/gn/build/toolchain:stage2_baremetal_aarch64" ]
+}
 group("compiler-rt") {
   deps = [ "//compiler-rt/include($host_toolchain)" ]
   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.

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

 group("lib") {
   deps = [
     "//compiler-rt/lib/asan:ignorelist($host_toolchain)",
     "//compiler-rt/lib/cfi:ignorelist($host_toolchain)",
-    "//compiler-rt/lib/profile",
   ]
   if (current_os == "linux") {
     deps += [ "//compiler-rt/lib/msan" ]
   }
   if (current_os == "linux" || current_os == "android") {
     deps += [ "//compiler-rt/lib/ubsan_minimal" ]
   }
-  if (current_os != "win") {
-    deps += [
-      "//compiler-rt/lib/asan",
-      "//compiler-rt/lib/builtins",
-    ]
+  if (current_os != "win" && current_os != "baremetal") {
+    deps += [ "//compiler-rt/lib/asan" ]
     if (current_cpu == "x64" || current_cpu == "arm64") {
       deps += [ "//compiler-rt/lib/tsan/rtl" ]
     }
   }
+  if (current_os != "win") {
+    deps += [ "//compiler-rt/lib/builtins" ]
+  }
+  if (current_os != "baremetal") {
+    deps += [ "//compiler-rt/lib/profile" ]
+  }
 }

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"
sources = [
 
     # This depends on unwind.h which is present in Clang headers. We should
     # reconsider this if we ever decide to support building builtins with
     # other compilers.
     "gcc_personality_v0.c",
   ]
 
   if (current_os != "fuchsia") {
+    sources += [ "clear_cache.c" ]
+  }
+
+  if (current_os != "fuchsia" && current_os != "baremetal") {
     sources += [
       "emutls.c",
       "enable_execute_stack.c",
       "eprintf.c",
     ]
   }
 
-  if (current_os != "fuchsia" && !compiler_rt_baremetal_build) {
-    sources += [ "clear_cache.c" ]
-  }
-
   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",

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

if (clang_enable_per_target_runtime_dir) {
   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 == "ios" || current_os == "mac") {
   crt_current_out_dir = "$clang_resource_dir/lib/darwin"
+} else if (current_os == "baremetal") {
+  crt_current_out_dir = "$clang_resource_dir/lib/baremetal"
+  crt_current_target_suffix = "-$crt_current_target_arch"
 } else if (current_os == "win") {
   crt_current_out_dir = "$clang_resource_dir/lib/windows"
   crt_current_target_suffix = "-$crt_current_target_arch"
 } else {
   assert(false, "unimplemented current_os " + current_os)
 }

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

if (current_cpu == "x86") {
   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 == "ios" || current_os == "mac") {
     llvm_current_triple = "arm64-apple-darwin"
+  } else if (current_os == "baremetal") {
+    llvm_current_triple = "aarch64-elf"
   } else if (current_os == "linux") {
     llvm_current_triple = "aarch64-unknown-linux-gnu"
   }
 } else if (current_cpu == "ppc64") {
   if (current_os == "linux") {
     llvm_current_triple = "powerpc64le-unknown-linux-gnu"
   }
 }