[Driver] Push multiarch path setup to individual drivers

[phosek]

Summary

Different platforms use different rules for multiarch triples so
it's difficult to provide a single method for all platforms. We
instead move the getMultiarchTriple to the ToolChain class and let
individual platforms override it and provide their custom logic.

[MaskRay]

Different platforms use different rules for multiarch triples so it's difficult to provide a single method for all platforms.

Guess this is a Linux/Hurd/Fuchsia specific thing. I don't know much about the runtime build but I hope the Linux hierarchy is not set in stone.

Can you dump a diff how addPathIfExists(D, getStdlibPath(), Paths); and a similar call will change -L paths in the linking stage?
You can use clang ... '-###' |& sed -E 's/ "?-L/\n&/g; s/ "?-[iI]/\n&/g' to break -L into multiple lines.

[phosek]

In D101194#2714206, @MaskRay wrote:

Different platforms use different rules for multiarch triples so it's difficult to provide a single method for all platforms.

Guess this is a Linux/Hurd/Fuchsia specific thing. I don't know much about the runtime build but I hope the Linux hierarchy is not set in stone.

Can you dump a diff how addPathIfExists(D, getStdlibPath(), Paths); and a similar call will change -L paths in the linking stage?
You can use clang ... '-###' |& sed -E 's/ "?-L/\n&/g; s/ "?-[iI]/\n&/g' to break -L into multiple lines.

There's no difference, current behavior is already covered by tests and those are still passing. The difference is that ToolChain::getRuntimePath() and ToolChain::getStdlibPath() currently try various possible spellings of triples whereas with this patch that's no longer needed because each platform controls its own spelling so we save a few syscalls.

I checked and the multiarch runtimes layout is currently only used by Fuchsia, Linux and WebAssembly, other platforms use their own custom logic. If other platforms decide to pickup this layout as well, they can follow the same pattern.

[MaskRay]

In D101194#2714991, @phosek wrote:

In D101194#2714206, @MaskRay wrote:

Different platforms use different rules for multiarch triples so it's difficult to provide a single method for all platforms.

Guess this is a Linux/Hurd/Fuchsia specific thing. I don't know much about the runtime build but I hope the Linux hierarchy is not set in stone.

Can you dump a diff how addPathIfExists(D, getStdlibPath(), Paths); and a similar call will change -L paths in the linking stage?
You can use clang ... '-###' |& sed -E 's/ "?-L/\n&/g; s/ "?-[iI]/\n&/g' to break -L into multiple lines.

There's no difference, current behavior is already covered by tests and those are still passing. The difference is that ToolChain::getRuntimePath() and ToolChain::getStdlibPath() currently try various possible spellings of triples whereas with this patch that's no longer needed because each platform controls its own spelling so we save a few syscalls.

I checked and the multiarch runtimes layout is currently only used by Fuchsia, Linux and WebAssembly, other platforms use their own custom logic. If other platforms decide to pickup this layout as well, they can follow the same pattern.

Hope you can dump the current behavior.

[bjope]

Got some problems with my builds after this commit.

My cmake commands looks like this (well, this is after having tried to fix the problem by replacing x86_64-unknown-linux-gnu by x86_64-linux-gnu as I figured that might be needed after looking at the changes in this patch):

cmake /repo/uabbpet/llvm-upstream/llvm --debug-trycompile -G Ninja -DCMAKE_MAKE_PROGRAM=/app/ninja/1.8.2/SLED11-64/bin/ninja -DCMAKE_BUILD_TYPE=Release -DCMAKE_EXPORT_COMPILE_COMMANDS=ON -DCMAKE_INSTALL_PREFIX=/compiler-clang -DLLVM_APPEND_VC_REV=OFF  -DLLVM_ENABLE_ASSERTIONS=ON -DLLVM_ENABLE_PROJECTS='clang;clang-tools-extra;lld' -DLLVM_BUILTIN_TARGETS=default -DLLVM_ENABLE_PER_TARGET_RUNTIME_DIR=ON -DLLVM_ENABLE_RUNTIMES='compiler-rt;libcxx;libcxxabi;libunwind' -DRUNTIMES_x86_64-linux-gnu_SANITIZER_USE_STATIC_LLVM_UNWINDER=ON -DRUNTIMES_x86_64-linux-gnu_SANITIZER_USE_STATIC_CXX_ABI=ON -DRUNTIMES_x86_64-linux-gnu_COMPILER_RT_USE_BUILTINS_LIBRARY=ON -DRUNTIMES_x86_64-linux-gnu_COMPILER_RT_CAN_EXECUTE_TESTS=OFF -DRUNTIMES_x86_64-linux-gnu_LIBCXX_HAS_ATOMIC_LIB=0 -DRUNTIMES_x86_64-linux-gnu_COMPILER_RT_BUILD_XRAY=OFF -DLLVM_RUNTIME_TARGETS='x86_64-linux-gnu' -DLLVM_ENABLE_LIBPFM=OFF -DCLANG_TOOLING_BUILD_AST_INTROSPECTION=OFF -DCLANG_ROUND_TRIP_CC1_ARGS=OFF

But my build fails, and it seems to be related to the message -- Failed to find compiler-rt builtins library for x86_64-linux-gnu, and later I get

-- Compiler-RT supported architectures: x86_64
CMake Error at /repo/uabbpet/llvm-upstream/compiler-rt/cmake/Modules/AddCompilerRT.cmake:258 (message):
  Cannot find builtins library for the target architecture
Call Stack (most recent call first):
  /repo/uabbpet/llvm-upstream/compiler-rt/lib/stats/CMakeLists.txt:23 (add_compiler_rt_runtime)

It tries to find libclang using a path like this my_build_dir/lib/clang/13.0.0/lib/linux/libclang_rt.builtins-x86_64.a (which is what I get if manually run my_build_dir/bin/clang --rtlib=compiler-rt -print-libgcc-file-name as well). But what I get when building is my_build_dir/lib/clang/13.0.0/lib/x86_64-unknown-linux-gnu/libclang_rt.builtins.a and `my_build_dir/lib/clang/13.0.0/lib/i386-unknown-linux-gnu/libclang_rt.builtins.a.

Not sure exactly what I'm doing wrong here. Looks like some kind of mismatch. I assume the layout with separate dirs for the libs is due to -DLLVM_ENABLE_PER_TARGET_RUNTIME_DIR=ON, but the just built clang does not seem to know about that. Should it know about that? Is it no longer allowed to use -DLLVM_ENABLE_PER_TARGET_RUNTIME_DIR=ON in combination with COMPILER_RT_USE_BUILTINS_LIBRARY=ON?

Or maybe the problem is that we use -DLLVM_BUILTIN_TARGETS=default?

[phosek]

In D101194#2720761, @bjope wrote:

Got some problems with my builds after this commit.

My cmake commands looks like this (well, this is after having tried to fix the problem by replacing x86_64-unknown-linux-gnu by x86_64-linux-gnu as I figured that might be needed after looking at the changes in this patch):

cmake /repo/uabbpet/llvm-upstream/llvm --debug-trycompile -G Ninja -DCMAKE_MAKE_PROGRAM=/app/ninja/1.8.2/SLED11-64/bin/ninja -DCMAKE_BUILD_TYPE=Release -DCMAKE_EXPORT_COMPILE_COMMANDS=ON -DCMAKE_INSTALL_PREFIX=/compiler-clang -DLLVM_APPEND_VC_REV=OFF  -DLLVM_ENABLE_ASSERTIONS=ON -DLLVM_ENABLE_PROJECTS='clang;clang-tools-extra;lld' -DLLVM_BUILTIN_TARGETS=default -DLLVM_ENABLE_PER_TARGET_RUNTIME_DIR=ON -DLLVM_ENABLE_RUNTIMES='compiler-rt;libcxx;libcxxabi;libunwind' -DRUNTIMES_x86_64-linux-gnu_SANITIZER_USE_STATIC_LLVM_UNWINDER=ON -DRUNTIMES_x86_64-linux-gnu_SANITIZER_USE_STATIC_CXX_ABI=ON -DRUNTIMES_x86_64-linux-gnu_COMPILER_RT_USE_BUILTINS_LIBRARY=ON -DRUNTIMES_x86_64-linux-gnu_COMPILER_RT_CAN_EXECUTE_TESTS=OFF -DRUNTIMES_x86_64-linux-gnu_LIBCXX_HAS_ATOMIC_LIB=0 -DRUNTIMES_x86_64-linux-gnu_COMPILER_RT_BUILD_XRAY=OFF -DLLVM_RUNTIME_TARGETS='x86_64-linux-gnu' -DLLVM_ENABLE_LIBPFM=OFF -DCLANG_TOOLING_BUILD_AST_INTROSPECTION=OFF -DCLANG_ROUND_TRIP_CC1_ARGS=OFF

But my build fails, and it seems to be related to the message -- Failed to find compiler-rt builtins library for x86_64-linux-gnu, and later I get

-- Compiler-RT supported architectures: x86_64
CMake Error at /repo/uabbpet/llvm-upstream/compiler-rt/cmake/Modules/AddCompilerRT.cmake:258 (message):
  Cannot find builtins library for the target architecture
Call Stack (most recent call first):
  /repo/uabbpet/llvm-upstream/compiler-rt/lib/stats/CMakeLists.txt:23 (add_compiler_rt_runtime)

It tries to find libclang using a path like this my_build_dir/lib/clang/13.0.0/lib/linux/libclang_rt.builtins-x86_64.a (which is what I get if manually run my_build_dir/bin/clang --rtlib=compiler-rt -print-libgcc-file-name as well). But what I get when building is my_build_dir/lib/clang/13.0.0/lib/x86_64-unknown-linux-gnu/libclang_rt.builtins.a and `my_build_dir/lib/clang/13.0.0/lib/i386-unknown-linux-gnu/libclang_rt.builtins.a.

Not sure exactly what I'm doing wrong here. Looks like some kind of mismatch. I assume the layout with separate dirs for the libs is due to -DLLVM_ENABLE_PER_TARGET_RUNTIME_DIR=ON, but the just built clang does not seem to know about that. Should it know about that? Is it no longer allowed to use -DLLVM_ENABLE_PER_TARGET_RUNTIME_DIR=ON in combination with COMPILER_RT_USE_BUILTINS_LIBRARY=ON?

Or maybe the problem is that we use -DLLVM_BUILTIN_TARGETS=default?

The use of default is the issue, the problem is that the target triple "guessed" by config.guess doesn't necessarily match the multiarch triple used by Clang. I think that ideally we would stop relying on LLVM_DEFAULT_TARGET_TRIPLE and instead we would get the path directly from Clang. I can look into it but that might take a while to implement so we should probably revert the change for now?

I'm a bit surprised that you're using -DLLVM_BUILTIN_TARGETS=default but -DLLVM_RUNTIME_TARGETS='x86_64-linux-gnu', usually I'd expect these to match.

[bjope]

In D101194#2720787, @phosek wrote:

In D101194#2720761, @bjope wrote:

Or maybe the problem is that we use -DLLVM_BUILTIN_TARGETS=default?

The use of default is the issue, the problem is that the target triple "guessed" by config.guess doesn't necessarily match the multiarch triple used by Clang. I think that ideally we would stop relying on LLVM_DEFAULT_TARGET_TRIPLE and instead we would get the path directly from Clang. I can look into it but that might take a while to implement so we should probably revert the change for now?

I'm a bit surprised that you're using -DLLVM_BUILTIN_TARGETS=default but -DLLVM_RUNTIME_TARGETS='x86_64-linux-gnu', usually I'd expect these to match.

Well, maybe that is for historical reasons. Or our downstream branch we use more targets, but I guess we got some problems on the main branch at some time and limited LLVM_RUNTIME_TARGETS to only do x86_64 (while normally we also build i386). And LLVM_BUILTIN_TARGETS=default happens to produce both x86_64 and i386 builtins.

Anyway I've tried changing to LLVM_BUILTIN_TARGETS='x86_64-linux-gnu' (and also LLVM_BUILTIN_TARGETS='i386-linux-gnu;x86_64-linux-gnu') and that seems to work fine. So I think I'm back on track. Thanks!
(Crossing my fingers and hopefully I'll get things working on the downstream branch with additional downstream targets.)

[MaskRay]

FWIW I have played -DLLVM_ENABLE_PER_TARGET_RUNTIME_DIR=on

I see lib/clang/13.0.0/lib/x86_64-unknown-linux-gnu/libclang_rt.*. The directory name is x86_64-unknown-linux-gnu, which actually looks good to me.
We don't necessarily copy the GCC x86_64-linux-gnu multiarch name. Preserving the default target triple as-is gives users more choices (e.g. if they want to make use of the vendor part to have multiple builds with the same architecture).

[MaskRay]

I thought this was NFC:(

Yeah, personally I think the previous behavior (lib/clang/13.0.0/lib/x86_64-unknown-linux-gnu/libclang_rt.asan.a) is slightly better than the new lib/clang/13.0.0/lib/x86_64-linux-gnu/libclang_rt.asan.a.
multiarch paths are suitable for GCC specific directories (lib/$triple, libstdc++ aarch64-linux-gnu/include/c++/10, etc) but llvm specific libraries don't necessarily use that.

[phosek]

In D101194#2721390, @MaskRay wrote:

I thought this was NFC:(

Yeah, personally I think the previous behavior (lib/clang/13.0.0/lib/x86_64-unknown-linux-gnu/libclang_rt.asan.a) is slightly better than the new lib/clang/13.0.0/lib/x86_64-linux-gnu/libclang_rt.asan.a.
multiarch paths are suitable for GCC specific directories (lib/$triple, libstdc++ aarch64-linux-gnu/include/c++/10, etc) but llvm specific libraries don't necessarily use that.

I should have been clear, sorry about that. I think there are three separate issues:

1. Rather than trying various triple versions, we should use one canonical spelling when searching for Clang's standard and runtime libraries. That means less system calls and better error messages, this is what this change was primarily intended to do.
2. Following from the previous point, we need to decide which canonical spelling to use. Since we're trying to use the multiarch layout, I was following the Debian documentation which is closest thing to a spec I'm aware of. The alternative would be to use the normalized target, the main disadvantage being that we would be diverging from existing quasi standard.
3. -DLLVM_ENABLE_PER_TARGET_RUNTIME_DIR=ON gives you a different result depending on how you spell the targets in -DLLVM_BUILTIN_TARGETS= and -DLLVM_RUNTIME_TARGETS=, this is what @bjope ran into and I'd consider that a bug since the directory layout is an implementation detail and we should be able to change it without users having to change their build.

I'm working on a solution for #3 and I should have a patch ready soon. I'm curious about your thoughts on #2.

[MaskRay]

In D101194#2721597, @phosek wrote:

In D101194#2721390, @MaskRay wrote:

I thought this was NFC:(

Yeah, personally I think the previous behavior (lib/clang/13.0.0/lib/x86_64-unknown-linux-gnu/libclang_rt.asan.a) is slightly better than the new lib/clang/13.0.0/lib/x86_64-linux-gnu/libclang_rt.asan.a.
multiarch paths are suitable for GCC specific directories (lib/$triple, libstdc++ aarch64-linux-gnu/include/c++/10, etc) but llvm specific libraries don't necessarily use that.

I should have been clear, sorry about that. I think there are three separate issues:

1. Rather than trying various triple versions, we should use one canonical spelling when searching for Clang's standard and runtime libraries. That means less system calls and better error messages, this is what this change was primarily intended to do.
2. Following from the previous point, we need to decide which canonical spelling to use. Since we're trying to use the multiarch layout, I was following the Debian documentation which is closest thing to a spec I'm aware of. The alternative would be to use the normalized target, the main disadvantage being that we would be diverging from existing quasi standard.
3. -DLLVM_ENABLE_PER_TARGET_RUNTIME_DIR=ON gives you a different result depending on how you spell the targets in -DLLVM_BUILTIN_TARGETS= and -DLLVM_RUNTIME_TARGETS=, this is what @bjope ran into and I'd consider that a bug since the directory layout is an implementation detail and we should be able to change it without users having to change their build.

I'm working on a solution for #3 and I should have a patch ready soon. I'm curious about your thoughts on #2.

multiarch is not consistent within GCC, either (also note that not all GCC installations are configured with multiarch. --print-multiarch prints an empty line).
I have tried various GCC installations and made a summary https://maskray.me/blog/2021-03-28-compiler-driver-and-cross-compilation : even if the multiarch triple for x86_64 Linux is x86_64-linux-gnu, there are a few x86_64-pc-linux-gnu paths. (You can configure and get x86_64-pc-linux-gnu-gcc or x86_64-unknown-linux-gnu-gcc)
For musl systems (*-linux-musl), multiarch doesn't make sense. If we use multiarch, we'll need to invent *-linux-musl for them.

For some GCC related paths, we have no choice but to detect their paths. For entirely clang internal stuff (runtime library paths), I actually appreciate that we have a useful, un-normalized 'vendor' part.
It gives users a choice if they want to have x86_64-pc[12345]-linux-gnu. This argument is weak, but the other arguments are probably stronger. My viewpoint is: if we can avoid multiarch, just avoid it.

---

I haven't figured out how to do a proper runtime build...

-DLLVM_ENABLE_PER_TARGET_RUNTIME_DIR=on -DLLVM_RUNTIME_TARGETS=default -DLLVM_ENABLE_RUNTIMES='compiler-rt;libcxx;libunwind' gives me

CMake Error at /usr/share/cmake-3.18/Modules/ExternalProject.cmake:3152 (add_custom_target):                                                                                                                                                                                                
  add_custom_target cannot create target "builtins" because another target                                                                                                                                                                                                                  
  with the same name already exists.  The existing target is a custom target                                                                                                                                                                                                                
  created in source directory                                                                                                                                                                                                                                                               
  "/home/maskray/llvm/compiler-rt/lib/builtins".  See                                                                                                                                                                                                                      
  documentation for policy CMP0002 for more details.                                                                                                                                                                                                                                        
Call Stack (most recent call first):                                                                                                                                                                                                                                                        
  cmake/modules/LLVMExternalProjectUtils.cmake:283 (ExternalProject_Add)                                                                                                                                                                                                                    
  runtimes/CMakeLists.txt:81 (llvm_ExternalProject_Add)                                                                                                                                                                                                                                     
  runtimes/CMakeLists.txt:134 (builtin_default_target)

[phosek]

In D101194#2721643, @MaskRay wrote:

multiarch is not consistent within GCC, either (also note that not all GCC installations are configured with multiarch. --print-multiarch prints an empty line).
I have tried various GCC installations and made a summary https://maskray.me/blog/2021-03-28-compiler-driver-and-cross-compilation : even if the multiarch triple for x86_64 Linux is x86_64-linux-gnu, there are a few x86_64-pc-linux-gnu paths. (You can configure and get x86_64-pc-linux-gnu-gcc or x86_64-unknown-linux-gnu-gcc)
For musl systems (*-linux-musl), multiarch doesn't make sense. If we use multiarch, we'll need to invent *-linux-musl for them.

For some GCC related paths, we have no choice but to detect their paths. For entirely clang internal stuff (runtime library paths), I actually appreciate that we have a useful, un-normalized 'vendor' part.
It gives users a choice if they want to have x86_64-pc[12345]-linux-gnu. This argument is weak, but the other arguments are probably stronger. My viewpoint is: if we can avoid multiarch, just avoid it.

SGTM, I'll partially revert this change and switch back to using normalized triples if that's fine with you.

I haven't figured out how to do a proper runtime build...

-DLLVM_ENABLE_PER_TARGET_RUNTIME_DIR=on -DLLVM_RUNTIME_TARGETS=default -DLLVM_ENABLE_RUNTIMES='compiler-rt;libcxx;libunwind' gives me

CMake Error at /usr/share/cmake-3.18/Modules/ExternalProject.cmake:3152 (add_custom_target):                                                                                                                                                                                                
  add_custom_target cannot create target "builtins" because another target                                                                                                                                                                                                                  
  with the same name already exists.  The existing target is a custom target                                                                                                                                                                                                                
  created in source directory                                                                                                                                                                                                                                                               
  "/home/maskray/llvm/compiler-rt/lib/builtins".  See                                                                                                                                                                                                                      
  documentation for policy CMP0002 for more details.                                                                                                                                                                                                                                        
Call Stack (most recent call first):                                                                                                                                                                                                                                                        
  cmake/modules/LLVMExternalProjectUtils.cmake:283 (ExternalProject_Add)                                                                                                                                                                                                                    
  runtimes/CMakeLists.txt:81 (llvm_ExternalProject_Add)                                                                                                                                                                                                                                     
  runtimes/CMakeLists.txt:134 (builtin_default_target)

You also need -DLLVM_BUILTIN_TARGETS=default.

[MaskRay]

In D101194#2721682, @phosek wrote:

In D101194#2721643, @MaskRay wrote:

multiarch is not consistent within GCC, either (also note that not all GCC installations are configured with multiarch. --print-multiarch prints an empty line).
I have tried various GCC installations and made a summary https://maskray.me/blog/2021-03-28-compiler-driver-and-cross-compilation : even if the multiarch triple for x86_64 Linux is x86_64-linux-gnu, there are a few x86_64-pc-linux-gnu paths. (You can configure and get x86_64-pc-linux-gnu-gcc or x86_64-unknown-linux-gnu-gcc)
For musl systems (*-linux-musl), multiarch doesn't make sense. If we use multiarch, we'll need to invent *-linux-musl for them.

For some GCC related paths, we have no choice but to detect their paths. For entirely clang internal stuff (runtime library paths), I actually appreciate that we have a useful, un-normalized 'vendor' part.
It gives users a choice if they want to have x86_64-pc[12345]-linux-gnu. This argument is weak, but the other arguments are probably stronger. My viewpoint is: if we can avoid multiarch, just avoid it.

SGTM, I'll partially revert this change and switch back to using normalized triples if that's fine with you.

LG, thanks!

I haven't figured out how to do a proper runtime build...

-DLLVM_ENABLE_PER_TARGET_RUNTIME_DIR=on -DLLVM_RUNTIME_TARGETS=default -DLLVM_ENABLE_RUNTIMES='compiler-rt;libcxx;libunwind' gives me

CMake Error at /usr/share/cmake-3.18/Modules/ExternalProject.cmake:3152 (add_custom_target):                                                                                                                                                                                                
  add_custom_target cannot create target "builtins" because another target                                                                                                                                                                                                                  
  with the same name already exists.  The existing target is a custom target                                                                                                                                                                                                                
  created in source directory                                                                                                                                                                                                                                                               
  "/home/maskray/llvm/compiler-rt/lib/builtins".  See                                                                                                                                                                                                                      
  documentation for policy CMP0002 for more details.                                                                                                                                                                                                                                        
Call Stack (most recent call first):                                                                                                                                                                                                                                                        
  cmake/modules/LLVMExternalProjectUtils.cmake:283 (ExternalProject_Add)                                                                                                                                                                                                                    
  runtimes/CMakeLists.txt:81 (llvm_ExternalProject_Add)                                                                                                                                                                                                                                     
  runtimes/CMakeLists.txt:134 (builtin_default_target)

You also need -DLLVM_BUILTIN_TARGETS=default.

Yes, -DLLVM_ENABLE_PER_TARGET_RUNTIME_DIR=on -DLLVM_RUNTIME_TARGETS=default -DLLVM_ENABLE_RUNTIMES='compiler-rt;libcxx;libunwind' -DLLVM_BUILTIN_TARGETS=default -DLLVM_ENABLE_PROJECTS='clang;lld' works.

clang/cmake/caches/Fuchsia-stage2.cmake

if(WIN32)
   set(RUNTIMES_${target}_LIBCXX_ABI_VERSION 2 CACHE STRING "")
   set(RUNTIMES_${target}_LIBCXX_ENABLE_EXPERIMENTAL_LIBRARY OFF CACHE BOOL "")
   set(RUNTIMES_${target}_LIBCXX_ENABLE_FILESYSTEM OFF CACHE BOOL "")
   set(RUNTIMES_${target}_LIBCXX_ENABLE_ABI_LINKER_SCRIPT OFF CACHE BOOL "")
   set(RUNTIMES_${target}_LIBCXX_ENABLE_SHARED OFF CACHE BOOL "")
   set(RUNTIMES_${target}_LLVM_ENABLE_RUNTIMES "compiler-rt;libcxx" CACHE STRING "")
 endif()
 
-foreach(target aarch64-unknown-linux-gnu;armv7-unknown-linux-gnueabihf;i386-unknown-linux-gnu;x86_64-unknown-linux-gnu)
+foreach(target aarch64-linux-gnu;armv7-linux-gnueabihf;i386-linux-gnu;x86_64-linux-gnu)
   if(LINUX_${target}_SYSROOT)
     # Set the per-target builtins options.
     list(APPEND BUILTIN_TARGETS "${target}")
     set(BUILTINS_${target}_CMAKE_SYSTEM_NAME Linux CACHE STRING "")
     set(BUILTINS_${target}_CMAKE_BUILD_TYPE RelWithDebInfo CACHE STRING "")
     set(BUILTINS_${target}_CMAKE_C_FLAGS "--target=${target}" CACHE STRING "")
     set(BUILTINS_${target}_CMAKE_CXX_FLAGS "--target=${target}" CACHE STRING "")
     set(BUILTINS_${target}_CMAKE_ASM_FLAGS "--target=${target}" CACHE STRING "")
if(LINUX_${target}_SYSROOT)
     set(RUNTIMES_${target}_LLVM_ENABLE_RUNTIMES "compiler-rt;libcxx;libcxxabi;libunwind" CACHE STRING "")
 
     # Use .build-id link.
     list(APPEND RUNTIME_BUILD_ID_LINK "${target}")
   endif()
 endforeach()
 
 if(FUCHSIA_SDK)
-  set(FUCHSIA_aarch64_NAME arm64)
-  set(FUCHSIA_i386_NAME x64)
-  set(FUCHSIA_x86_64_NAME x64)
-  set(FUCHSIA_riscv64_NAME riscv64)
-  foreach(target i386;x86_64;aarch64;riscv64)
-    set(FUCHSIA_${target}_COMPILER_FLAGS "--target=${target}-unknown-fuchsia -I${FUCHSIA_SDK}/pkg/fdio/include")
+  set(FUCHSIA_aarch64-fuchsia_NAME arm64)
+  set(FUCHSIA_i386-fuchsia_NAME x64)
+  set(FUCHSIA_x86_64-fuchsia_NAME x64)
+  set(FUCHSIA_riscv64-fuchsia_NAME riscv64)
+  foreach(target i386-fuchsia;x86_64-fuchsia;aarch64-fuchsia;riscv64-fuchsia)
+    set(FUCHSIA_${target}_COMPILER_FLAGS "--target=${target} -I${FUCHSIA_SDK}/pkg/fdio/include")
     set(FUCHSIA_${target}_LINKER_FLAGS "-L${FUCHSIA_SDK}/arch/${FUCHSIA_${target}_NAME}/lib")
     set(FUCHSIA_${target}_SYSROOT "${FUCHSIA_SDK}/arch/${FUCHSIA_${target}_NAME}/sysroot")
   endforeach()
 
-  foreach(target i386;x86_64;aarch64;riscv64)
+  foreach(target i386-fuchsia;x86_64-fuchsia;aarch64-fuchsia;riscv64-fuchsia)
     # Set the per-target builtins options.
-    list(APPEND BUILTIN_TARGETS "${target}-unknown-fuchsia")
-    set(BUILTINS_${target}-unknown-fuchsia_CMAKE_SYSTEM_NAME Fuchsia CACHE STRING "")
-    set(BUILTINS_${target}-unknown-fuchsia_CMAKE_BUILD_TYPE RelWithDebInfo CACHE STRING "")
-    set(BUILTINS_${target}-unknown-fuchsia_CMAKE_ASM_FLAGS ${FUCHSIA_${target}_COMPILER_FLAGS} CACHE STRING "")
-    set(BUILTINS_${target}-unknown-fuchsia_CMAKE_C_FLAGS ${FUCHSIA_${target}_COMPILER_FLAGS} CACHE STRING "")
-    set(BUILTINS_${target}-unknown-fuchsia_CMAKE_CXX_FLAGS ${FUCHSIA_${target}_COMPILER_FLAGS} CACHE STRING "")
-    set(BUILTINS_${target}-unknown-fuchsia_CMAKE_SHARED_LINKER_FLAGS ${FUCHSIA_${target}_LINKER_FLAGS} CACHE STRING "")
-    set(BUILTINS_${target}-unknown-fuchsia_CMAKE_MODULE_LINKER_FLAGS ${FUCHSIA_${target}_LINKER_FLAGS} CACHE STRING "")
-    set(BUILTINS_${target}-unknown-fuchsia_CMAKE_EXE_LINKER_FLAGS ${FUCHSIA_${target}_LINKER_FLAGS} CACHE STRING "")
-    set(BUILTINS_${target}-unknown-fuchsia_CMAKE_SYSROOT ${FUCHSIA_${target}_SYSROOT} CACHE PATH "")
+    list(APPEND BUILTIN_TARGETS "${target}")
+    set(BUILTINS_${target}_CMAKE_SYSTEM_NAME Fuchsia CACHE STRING "")
+    set(BUILTINS_${target}_CMAKE_BUILD_TYPE RelWithDebInfo CACHE STRING "")
+    set(BUILTINS_${target}_CMAKE_ASM_FLAGS ${FUCHSIA_${target}_COMPILER_FLAGS} CACHE STRING "")
+    set(BUILTINS_${target}_CMAKE_C_FLAGS ${FUCHSIA_${target}_COMPILER_FLAGS} CACHE STRING "")
+    set(BUILTINS_${target}_CMAKE_CXX_FLAGS ${FUCHSIA_${target}_COMPILER_FLAGS} CACHE STRING "")
+    set(BUILTINS_${target}_CMAKE_SHARED_LINKER_FLAGS ${FUCHSIA_${target}_LINKER_FLAGS} CACHE STRING "")
+    set(BUILTINS_${target}_CMAKE_MODULE_LINKER_FLAGS ${FUCHSIA_${target}_LINKER_FLAGS} CACHE STRING "")
+    set(BUILTINS_${target}_CMAKE_EXE_LINKER_FLAGS ${FUCHSIA_${target}_LINKER_FLAGS} CACHE STRING "")
+    set(BUILTINS_${target}_CMAKE_SYSROOT ${FUCHSIA_${target}_SYSROOT} CACHE PATH "")
   endforeach()
 
-  foreach(target x86_64;aarch64)
+  foreach(target x86_64-fuchsia;aarch64-fuchsia)
     # Set the per-target runtimes options.
-    list(APPEND RUNTIME_TARGETS "${target}-unknown-fuchsia")
-    set(RUNTIMES_${target}-unknown-fuchsia_CMAKE_SYSTEM_NAME Fuchsia CACHE STRING "")
-    set(RUNTIMES_${target}-unknown-fuchsia_CMAKE_BUILD_TYPE RelWithDebInfo CACHE STRING "")
-    set(RUNTIMES_${target}-unknown-fuchsia_CMAKE_BUILD_WITH_INSTALL_RPATH ON CACHE BOOL "")
-    set(RUNTIMES_${target}-unknown-fuchsia_CMAKE_ASM_FLAGS ${FUCHSIA_${target}_COMPILER_FLAGS} CACHE STRING "")
-    set(RUNTIMES_${target}-unknown-fuchsia_CMAKE_C_FLAGS ${FUCHSIA_${target}_COMPILER_FLAGS} CACHE STRING "")
-    set(RUNTIMES_${target}-unknown-fuchsia_CMAKE_CXX_FLAGS ${FUCHSIA_${target}_COMPILER_FLAGS} CACHE STRING "")
-    set(RUNTIMES_${target}-unknown-fuchsia_CMAKE_SHARED_LINKER_FLAGS ${FUCHSIA_${target}_LINKER_FLAGS} CACHE STRING "")
-    set(RUNTIMES_${target}-unknown-fuchsia_CMAKE_MODULE_LINKER_FLAGS ${FUCHSIA_${target}_LINKER_FLAGS} CACHE STRING "")
-    set(RUNTIMES_${target}-unknown-fuchsia_CMAKE_EXE_LINKER_FLAGS ${FUCHSIA_${target}_LINKER_FLAGS} CACHE STRING "")
-    set(RUNTIMES_${target}-unknown-fuchsia_CMAKE_SYSROOT ${FUCHSIA_${target}_SYSROOT} CACHE PATH "")
-    set(RUNTIMES_${target}-unknown-fuchsia_COMPILER_RT_USE_BUILTINS_LIBRARY ON CACHE BOOL "")
-    set(RUNTIMES_${target}-unknown-fuchsia_LIBUNWIND_USE_COMPILER_RT ON CACHE BOOL "")
-    set(RUNTIMES_${target}-unknown-fuchsia_LIBUNWIND_HIDE_SYMBOLS ON CACHE BOOL "")
-    set(RUNTIMES_${target}-unknown-fuchsia_LIBUNWIND_INSTALL_STATIC_LIBRARY OFF CACHE BOOL "")
-    set(RUNTIMES_${target}-unknown-fuchsia_LIBCXXABI_USE_COMPILER_RT ON CACHE BOOL "")
-    set(RUNTIMES_${target}-unknown-fuchsia_LIBCXXABI_USE_LLVM_UNWINDER ON CACHE BOOL "")
-    set(RUNTIMES_${target}-unknown-fuchsia_LIBCXXABI_ENABLE_STATIC_UNWINDER ON CACHE BOOL "")
-    set(RUNTIMES_${target}-unknown-fuchsia_LIBCXXABI_HERMETIC_STATIC_LIBRARY ON CACHE BOOL "")
-    set(RUNTIMES_${target}-unknown-fuchsia_LIBCXXABI_INSTALL_STATIC_LIBRARY OFF CACHE BOOL "")
-    set(RUNTIMES_${target}-unknown-fuchsia_LIBCXXABI_STATICALLY_LINK_UNWINDER_IN_SHARED_LIBRARY OFF CACHE BOOL "")
-    set(RUNTIMES_${target}-unknown-fuchsia_LIBCXX_USE_COMPILER_RT ON CACHE BOOL "")
-    set(RUNTIMES_${target}-unknown-fuchsia_LIBCXX_ENABLE_STATIC_ABI_LIBRARY ON CACHE BOOL "")
-    set(RUNTIMES_${target}-unknown-fuchsia_LIBCXX_HERMETIC_STATIC_LIBRARY ON CACHE BOOL "")
-    set(RUNTIMES_${target}-unknown-fuchsia_LIBCXX_STATICALLY_LINK_ABI_IN_SHARED_LIBRARY OFF CACHE BOOL "")
-    set(RUNTIMES_${target}-unknown-fuchsia_LIBCXX_ABI_VERSION 2 CACHE STRING "")
-    set(RUNTIMES_${target}-unknown-fuchsia_LLVM_ENABLE_ASSERTIONS ON CACHE BOOL "")
-    set(RUNTIMES_${target}-unknown-fuchsia_LLVM_ENABLE_RUNTIMES "compiler-rt;libcxx;libcxxabi;libunwind" CACHE STRING "")
-
-    set(RUNTIMES_${target}-unknown-fuchsia+asan_LLVM_BUILD_COMPILER_RT OFF CACHE BOOL "")
-    set(RUNTIMES_${target}-unknown-fuchsia+asan_LLVM_USE_SANITIZER "Address" CACHE STRING "")
-    set(RUNTIMES_${target}-unknown-fuchsia+asan_LIBCXXABI_ENABLE_NEW_DELETE_DEFINITIONS OFF CACHE BOOL "")
-    set(RUNTIMES_${target}-unknown-fuchsia+asan_LIBCXX_ENABLE_NEW_DELETE_DEFINITIONS OFF CACHE BOOL "")
-
-    set(RUNTIMES_${target}-unknown-fuchsia+noexcept_LLVM_BUILD_COMPILER_RT OFF CACHE BOOL "")
-    set(RUNTIMES_${target}-unknown-fuchsia+noexcept_LIBCXXABI_ENABLE_EXCEPTIONS OFF CACHE BOOL "")
-    set(RUNTIMES_${target}-unknown-fuchsia+noexcept_LIBCXX_ENABLE_EXCEPTIONS OFF CACHE BOOL "")
-
-    set(RUNTIMES_${target}-unknown-fuchsia+asan+noexcept_LLVM_BUILD_COMPILER_RT OFF CACHE BOOL "")
-    set(RUNTIMES_${target}-unknown-fuchsia+asan+noexcept_LLVM_USE_SANITIZER "Address" CACHE STRING "")
-    set(RUNTIMES_${target}-unknown-fuchsia+asan+noexcept_LIBCXXABI_ENABLE_NEW_DELETE_DEFINITIONS OFF CACHE BOOL "")
-    set(RUNTIMES_${target}-unknown-fuchsia+asan+noexcept_LIBCXX_ENABLE_NEW_DELETE_DEFINITIONS OFF CACHE BOOL "")
-    set(RUNTIMES_${target}-unknown-fuchsia+asan+noexcept_LIBCXXABI_ENABLE_EXCEPTIONS OFF CACHE BOOL "")
-    set(RUNTIMES_${target}-unknown-fuchsia+asan+noexcept_LIBCXX_ENABLE_EXCEPTIONS OFF CACHE BOOL "")
-
-    set(RUNTIMES_${target}-unknown-fuchsia+relative-vtables_LLVM_BUILD_COMPILER_RT OFF CACHE BOOL "")
-    set(RUNTIMES_${target}-unknown-fuchsia+relative-vtables_CMAKE_CXX_FLAGS "${RUNTIMES_${target}-unknown-fuchsia+relative-vtables_CMAKE_CXX_FLAGS} -Xclang -fexperimental-relative-c++-abi-vtables" CACHE STRING "")
-
-    set(RUNTIMES_${target}-unknown-fuchsia+relative-vtables+asan_LLVM_BUILD_COMPILER_RT OFF CACHE BOOL "")
-    set(RUNTIMES_${target}-unknown-fuchsia+relative-vtables+asan_LLVM_USE_SANITIZER "Address" CACHE STRING "")
-    set(RUNTIMES_${target}-unknown-fuchsia+relative-vtables+asan_LIBCXXABI_ENABLE_NEW_DELETE_DEFINITIONS OFF CACHE BOOL "")
-    set(RUNTIMES_${target}-unknown-fuchsia+relative-vtables+asan_LIBCXX_ENABLE_NEW_DELETE_DEFINITIONS OFF CACHE BOOL "")
-    set(RUNTIMES_${target}-unknown-fuchsia+relative-vtables+asan_CMAKE_CXX_FLAGS "${RUNTIMES_${target}-unknown-fuchsia+relative-vtables+asan_CMAKE_CXX_FLAGS} -Xclang -fexperimental-relative-c++-abi-vtables" CACHE STRING "")
-
-    set(RUNTIMES_${target}-unknown-fuchsia+relative-vtables+noexcept_LLVM_BUILD_COMPILER_RT OFF CACHE BOOL "")
-    set(RUNTIMES_${target}-unknown-fuchsia+relative-vtables+noexcept_CMAKE_CXX_FLAGS "${RUNTIMES_${target}-unknown-fuchsia+relative-vtables+noexcept_CMAKE_CXX_FLAGS} -Xclang -fexperimental-relative-c++-abi-vtables" CACHE STRING "")
-    set(RUNTIMES_${target}-unknown-fuchsia+relative-vtables+noexcept_LIBCXXABI_ENABLE_EXCEPTIONS OFF CACHE BOOL "")
-    set(RUNTIMES_${target}-unknown-fuchsia+relative-vtables+noexcept_LIBCXX_ENABLE_EXCEPTIONS OFF CACHE BOOL "")
-
-    set(RUNTIMES_${target}-unknown-fuchsia+relative-vtables+asan+noexcept_LLVM_BUILD_COMPILER_RT OFF CACHE BOOL "")
-    set(RUNTIMES_${target}-unknown-fuchsia+relative-vtables+asan+noexcept_LLVM_USE_SANITIZER "Address" CACHE STRING "")
-    set(RUNTIMES_${target}-unknown-fuchsia+relative-vtables+asan+noexcept_LIBCXXABI_ENABLE_NEW_DELETE_DEFINITIONS OFF CACHE BOOL "")
-    set(RUNTIMES_${target}-unknown-fuchsia+relative-vtables+asan+noexcept_LIBCXX_ENABLE_NEW_DELETE_DEFINITIONS OFF CACHE BOOL "")
-    set(RUNTIMES_${target}-unknown-fuchsia+relative-vtables+asan+noexcept_LIBCXXABI_ENABLE_EXCEPTIONS OFF CACHE BOOL "")
-    set(RUNTIMES_${target}-unknown-fuchsia+relative-vtables+asan+noexcept_LIBCXX_ENABLE_EXCEPTIONS OFF CACHE BOOL "")
-    set(RUNTIMES_${target}-unknown-fuchsia+relative-vtables+asan+noexcept_CMAKE_CXX_FLAGS "${RUNTIMES_${target}-unknown-fuchsia+relative-vtables+asan+noexcept_CMAKE_CXX_FLAGS} -Xclang -fexperimental-relative-c++-abi-vtables" CACHE STRING "")
+    list(APPEND RUNTIME_TARGETS "${target}")
+    set(RUNTIMES_${target}_CMAKE_SYSTEM_NAME Fuchsia CACHE STRING "")
+    set(RUNTIMES_${target}_CMAKE_BUILD_TYPE RelWithDebInfo CACHE STRING "")
+    set(RUNTIMES_${target}_CMAKE_BUILD_WITH_INSTALL_RPATH ON CACHE BOOL "")
+    set(RUNTIMES_${target}_CMAKE_ASM_FLAGS ${FUCHSIA_${target}_COMPILER_FLAGS} CACHE STRING "")
+    set(RUNTIMES_${target}_CMAKE_C_FLAGS ${FUCHSIA_${target}_COMPILER_FLAGS} CACHE STRING "")
+    set(RUNTIMES_${target}_CMAKE_CXX_FLAGS ${FUCHSIA_${target}_COMPILER_FLAGS} CACHE STRING "")
+    set(RUNTIMES_${target}_CMAKE_SHARED_LINKER_FLAGS ${FUCHSIA_${target}_LINKER_FLAGS} CACHE STRING "")
+    set(RUNTIMES_${target}_CMAKE_MODULE_LINKER_FLAGS ${FUCHSIA_${target}_LINKER_FLAGS} CACHE STRING "")
+    set(RUNTIMES_${target}_CMAKE_EXE_LINKER_FLAGS ${FUCHSIA_${target}_LINKER_FLAGS} CACHE STRING "")
+    set(RUNTIMES_${target}_CMAKE_SYSROOT ${FUCHSIA_${target}_SYSROOT} CACHE PATH "")
+    set(RUNTIMES_${target}_COMPILER_RT_USE_BUILTINS_LIBRARY ON CACHE BOOL "")
+    set(RUNTIMES_${target}_LIBUNWIND_USE_COMPILER_RT ON CACHE BOOL "")
+    set(RUNTIMES_${target}_LIBUNWIND_HIDE_SYMBOLS ON CACHE BOOL "")
+    set(RUNTIMES_${target}_LIBUNWIND_INSTALL_STATIC_LIBRARY OFF CACHE BOOL "")
+    set(RUNTIMES_${target}_LIBCXXABI_USE_COMPILER_RT ON CACHE BOOL "")
+    set(RUNTIMES_${target}_LIBCXXABI_USE_LLVM_UNWINDER ON CACHE BOOL "")
+    set(RUNTIMES_${target}_LIBCXXABI_ENABLE_STATIC_UNWINDER ON CACHE BOOL "")
+    set(RUNTIMES_${target}_LIBCXXABI_HERMETIC_STATIC_LIBRARY ON CACHE BOOL "")
+    set(RUNTIMES_${target}_LIBCXXABI_INSTALL_STATIC_LIBRARY OFF CACHE BOOL "")
+    set(RUNTIMES_${target}_LIBCXXABI_STATICALLY_LINK_UNWINDER_IN_SHARED_LIBRARY OFF CACHE BOOL "")
+    set(RUNTIMES_${target}_LIBCXX_USE_COMPILER_RT ON CACHE BOOL "")
+    set(RUNTIMES_${target}_LIBCXX_ENABLE_STATIC_ABI_LIBRARY ON CACHE BOOL "")
+    set(RUNTIMES_${target}_LIBCXX_HERMETIC_STATIC_LIBRARY ON CACHE BOOL "")
+    set(RUNTIMES_${target}_LIBCXX_STATICALLY_LINK_ABI_IN_SHARED_LIBRARY OFF CACHE BOOL "")
+    set(RUNTIMES_${target}_LIBCXX_ABI_VERSION 2 CACHE STRING "")
+    set(RUNTIMES_${target}_LLVM_ENABLE_ASSERTIONS ON CACHE BOOL "")
+    set(RUNTIMES_${target}_LLVM_ENABLE_RUNTIMES "compiler-rt;libcxx;libcxxabi;libunwind" CACHE STRING "")
+
+    set(RUNTIMES_${target}+asan_LLVM_BUILD_COMPILER_RT OFF CACHE BOOL "")
+    set(RUNTIMES_${target}+asan_LLVM_USE_SANITIZER "Address" CACHE STRING "")
+    set(RUNTIMES_${target}+asan_LIBCXXABI_ENABLE_NEW_DELETE_DEFINITIONS OFF CACHE BOOL "")
+    set(RUNTIMES_${target}+asan_LIBCXX_ENABLE_NEW_DELETE_DEFINITIONS OFF CACHE BOOL "")
+
+    set(RUNTIMES_${target}+noexcept_LLVM_BUILD_COMPILER_RT OFF CACHE BOOL "")
+    set(RUNTIMES_${target}+noexcept_LIBCXXABI_ENABLE_EXCEPTIONS OFF CACHE BOOL "")
+    set(RUNTIMES_${target}+noexcept_LIBCXX_ENABLE_EXCEPTIONS OFF CACHE BOOL "")
+
+    set(RUNTIMES_${target}+asan+noexcept_LLVM_BUILD_COMPILER_RT OFF CACHE BOOL "")
+    set(RUNTIMES_${target}+asan+noexcept_LLVM_USE_SANITIZER "Address" CACHE STRING "")
+    set(RUNTIMES_${target}+asan+noexcept_LIBCXXABI_ENABLE_NEW_DELETE_DEFINITIONS OFF CACHE BOOL "")
+    set(RUNTIMES_${target}+asan+noexcept_LIBCXX_ENABLE_NEW_DELETE_DEFINITIONS OFF CACHE BOOL "")
+    set(RUNTIMES_${target}+asan+noexcept_LIBCXXABI_ENABLE_EXCEPTIONS OFF CACHE BOOL "")
+    set(RUNTIMES_${target}+asan+noexcept_LIBCXX_ENABLE_EXCEPTIONS OFF CACHE BOOL "")
+
+    set(RUNTIMES_${target}+relative-vtables_LLVM_BUILD_COMPILER_RT OFF CACHE BOOL "")
+    set(RUNTIMES_${target}+relative-vtables_CMAKE_CXX_FLAGS "${RUNTIMES_${target}+relative-vtables_CMAKE_CXX_FLAGS} -Xclang -fexperimental-relative-c++-abi-vtables" CACHE STRING "")
+
+    set(RUNTIMES_${target}+relative-vtables+asan_LLVM_BUILD_COMPILER_RT OFF CACHE BOOL "")
+    set(RUNTIMES_${target}+relative-vtables+asan_LLVM_USE_SANITIZER "Address" CACHE STRING "")
+    set(RUNTIMES_${target}+relative-vtables+asan_LIBCXXABI_ENABLE_NEW_DELETE_DEFINITIONS OFF CACHE BOOL "")
+    set(RUNTIMES_${target}+relative-vtables+asan_LIBCXX_ENABLE_NEW_DELETE_DEFINITIONS OFF CACHE BOOL "")
+    set(RUNTIMES_${target}+relative-vtables+asan_CMAKE_CXX_FLAGS "${RUNTIMES_${target}+relative-vtables+asan_CMAKE_CXX_FLAGS} -Xclang -fexperimental-relative-c++-abi-vtables" CACHE STRING "")
+
+    set(RUNTIMES_${target}+relative-vtables+noexcept_LLVM_BUILD_COMPILER_RT OFF CACHE BOOL "")
+    set(RUNTIMES_${target}+relative-vtables+noexcept_CMAKE_CXX_FLAGS "${RUNTIMES_${target}+relative-vtables+noexcept_CMAKE_CXX_FLAGS} -Xclang -fexperimental-relative-c++-abi-vtables" CACHE STRING "")
+    set(RUNTIMES_${target}+relative-vtables+noexcept_LIBCXXABI_ENABLE_EXCEPTIONS OFF CACHE BOOL "")
+    set(RUNTIMES_${target}+relative-vtables+noexcept_LIBCXX_ENABLE_EXCEPTIONS OFF CACHE BOOL "")
+
+    set(RUNTIMES_${target}+relative-vtables+asan+noexcept_LLVM_BUILD_COMPILER_RT OFF CACHE BOOL "")
+    set(RUNTIMES_${target}+relative-vtables+asan+noexcept_LLVM_USE_SANITIZER "Address" CACHE STRING "")
+    set(RUNTIMES_${target}+relative-vtables+asan+noexcept_LIBCXXABI_ENABLE_NEW_DELETE_DEFINITIONS OFF CACHE BOOL "")
+    set(RUNTIMES_${target}+relative-vtables+asan+noexcept_LIBCXX_ENABLE_NEW_DELETE_DEFINITIONS OFF CACHE BOOL "")
+    set(RUNTIMES_${target}+relative-vtables+asan+noexcept_LIBCXXABI_ENABLE_EXCEPTIONS OFF CACHE BOOL "")
+    set(RUNTIMES_${target}+relative-vtables+asan+noexcept_LIBCXX_ENABLE_EXCEPTIONS OFF CACHE BOOL "")
+    set(RUNTIMES_${target}+relative-vtables+asan+noexcept_CMAKE_CXX_FLAGS "${RUNTIMES_${target}+relative-vtables+asan+noexcept_CMAKE_CXX_FLAGS} -Xclang -fexperimental-relative-c++-abi-vtables" CACHE STRING "")
 
     # Use .build-id link.
-    list(APPEND RUNTIME_BUILD_ID_LINK "${target}-unknown-fuchsia")
+    list(APPEND RUNTIME_BUILD_ID_LINK "${target}")
   endforeach()
 
   set(LLVM_RUNTIME_MULTILIBS "asan;noexcept;asan+noexcept;relative-vtables;relative-vtables+noexcept;relative-vtables+asan;relative-vtables+asan+noexcept" CACHE STRING "")
-  set(LLVM_RUNTIME_MULTILIB_asan_TARGETS "x86_64-unknown-fuchsia;aarch64-unknown-fuchsia" CACHE STRING "")
-  set(LLVM_RUNTIME_MULTILIB_noexcept_TARGETS "x86_64-unknown-fuchsia;aarch64-unknown-fuchsia" CACHE STRING "")
-  set(LLVM_RUNTIME_MULTILIB_asan+noexcept_TARGETS "x86_64-unknown-fuchsia;aarch64-unknown-fuchsia" CACHE STRING "")
-  set(LLVM_RUNTIME_MULTILIB_relative-vtables_TARGETS "x86_64-unknown-fuchsia;aarch64-unknown-fuchsia" CACHE STRING "")
-  set(LLVM_RUNTIME_MULTILIB_relative-vtables+noexcept_TARGETS "x86_64-unknown-fuchsia;aarch64-unknown-fuchsia" CACHE STRING "")
-  set(LLVM_RUNTIME_MULTILIB_relative-vtables+asan_TARGETS "x86_64-unknown-fuchsia;aarch64-unknown-fuchsia" CACHE STRING "")
-  set(LLVM_RUNTIME_MULTILIB_relative-vtables+asan+noexcept_TARGETS "x86_64-unknown-fuchsia;aarch64-unknown-fuchsia" CACHE STRING "")
+  set(LLVM_RUNTIME_MULTILIB_asan_TARGETS "x86_64-fuchsia;aarch64-fuchsia" CACHE STRING "")
+  set(LLVM_RUNTIME_MULTILIB_noexcept_TARGETS "x86_64-fuchsia;aarch64-fuchsia" CACHE STRING "")
+  set(LLVM_RUNTIME_MULTILIB_asan+noexcept_TARGETS "x86_64-fuchsia;aarch64-fuchsia" CACHE STRING "")
+  set(LLVM_RUNTIME_MULTILIB_relative-vtables_TARGETS "x86_64-fuchsia;aarch64-fuchsia" CACHE STRING "")
+  set(LLVM_RUNTIME_MULTILIB_relative-vtables+noexcept_TARGETS "x86_64-fuchsia;aarch64-fuchsia" CACHE STRING "")
+  set(LLVM_RUNTIME_MULTILIB_relative-vtables+asan_TARGETS "x86_64-fuchsia;aarch64-fuchsia" CACHE STRING "")
+  set(LLVM_RUNTIME_MULTILIB_relative-vtables+asan+noexcept_TARGETS "x86_64-fuchsia;aarch64-fuchsia" CACHE STRING "")
 endif()
 
 set(LLVM_BUILTIN_TARGETS "${BUILTIN_TARGETS}" CACHE STRING "")
 set(LLVM_RUNTIME_TARGETS "${RUNTIME_TARGETS}" CACHE STRING "")
 
 # Setup toolchain.
 set(LLVM_INSTALL_TOOLCHAIN_ONLY ON CACHE BOOL "")
 set(LLVM_TOOLCHAIN_TOOLS

clang/include/clang/Driver/ToolChain.h

protected:
 
   void setTripleEnvironment(llvm::Triple::EnvironmentType Env);
 
   virtual Tool *buildAssembler() const;
   virtual Tool *buildLinker() const;
   virtual Tool *buildStaticLibTool() const;
   virtual Tool *getTool(Action::ActionClass AC) const;
 
+  virtual std::string getMultiarchTriple(const Driver &D,
+                                         const llvm::Triple &TargetTriple,
+                                         StringRef SysRoot) const {
+    return TargetTriple.str();
+  }
+
   virtual std::string buildCompilerRTBasename(const llvm::opt::ArgList &Args,
                                               StringRef Component,
                                               FileType Type,
                                               bool AddArch) const;
 
   /// \name Utilities for implementing subclasses.
   ///@{
   static void addSystemInclude(const llvm::opt::ArgList &DriverArgs,
public:
   getCompilerRTArgString(const llvm::opt::ArgList &Args, StringRef Component,
                          FileType Type = ToolChain::FT_Static) const;
 
   std::string getCompilerRTBasename(const llvm::opt::ArgList &Args,
                                     StringRef Component,
                                     FileType Type = ToolChain::FT_Static) const;
 
   // Returns target specific runtime path if it exists.
-  virtual Optional<std::string> getRuntimePath() const;
+  virtual std::string getRuntimePath() const;
 
   // Returns target specific standard library path if it exists.
-  virtual Optional<std::string> getStdlibPath() const;
+  virtual std::string getStdlibPath() const;
 
   // Returns <ResourceDir>/lib/<OSName>/<arch>.  This is used by runtimes (such
   // as OpenMP) to find arch-specific libraries.
   std::string getArchSpecificLibPath() const;
 
   // Returns <OSname> part of above.
   virtual StringRef getOSLibName() const;
 

clang/lib/Driver/Driver.cpp

for (const std::string &Path : TC.getFilePaths()) {
       else
         llvm::outs() << Path;
     }
     llvm::outs() << "\n";
     return false;
   }
 
   if (C.getArgs().hasArg(options::OPT_print_runtime_dir)) {
-    if (auto RuntimePath = TC.getRuntimePath()) {
-      llvm::outs() << *RuntimePath << '\n';
-      return false;
-    }
+    std::string CandidateRuntimePath = TC.getRuntimePath();
+    if (getVFS().exists(CandidateRuntimePath))
+      llvm::outs() << CandidateRuntimePath << '\n';
+    else
       llvm::outs() << TC.getCompilerRTPath() << '\n';
     return false;
   }
 
   // FIXME: The following handlers should use a callback mechanism, we don't
   // know what the client would like to do.
   if (Arg *A = C.getArgs().getLastArg(options::OPT_print_file_name_EQ)) {
     llvm::outs() << GetFilePath(A->getValue(), TC) << "\n";
     return false;

clang/lib/Driver/ToolChain.cpp

static ToolChain::RTTIMode CalculateRTTIMode(const ArgList &Args,
   // -frtti is default, except for the PS4 CPU.
   return (Triple.isPS4CPU()) ? ToolChain::RM_Disabled : ToolChain::RM_Enabled;
 }
 
 ToolChain::ToolChain(const Driver &D, const llvm::Triple &T,
                      const ArgList &Args)
     : D(D), Triple(T), Args(Args), CachedRTTIArg(GetRTTIArgument(Args)),
       CachedRTTIMode(CalculateRTTIMode(Args, Triple, CachedRTTIArg)) {
-  if (auto StdlibPath = getStdlibPath())
-    getFilePaths().push_back(*StdlibPath);
-
-  if (auto RuntimePath = getRuntimePath())
-    getLibraryPaths().push_back(*RuntimePath);
-
   std::string CandidateLibPath = getArchSpecificLibPath();
   if (getVFS().exists(CandidateLibPath))
     getFilePaths().push_back(CandidateLibPath);
 }
 
 void ToolChain::setTripleEnvironment(llvm::Triple::EnvironmentType Env) {
   Triple.setEnvironment(Env);
   if (EffectiveTriple != llvm::Triple())

 }
 
 const char *ToolChain::getCompilerRTArgString(const llvm::opt::ArgList &Args,
                                               StringRef Component,
                                               FileType Type) const {
   return Args.MakeArgString(getCompilerRT(Args, Component, Type));
 }
 
-
-Optional<std::string> ToolChain::getRuntimePath() const {
-  SmallString<128> P;
-
-  // First try the triple passed to driver as --target=<triple>.
-  P.assign(D.ResourceDir);
-  llvm::sys::path::append(P, "lib", D.getTargetTriple());
-  if (getVFS().exists(P))
-    return llvm::Optional<std::string>(std::string(P.str()));
-
-  // Second try the normalized triple.
-  P.assign(D.ResourceDir);
-  llvm::sys::path::append(P, "lib", Triple.str());
-  if (getVFS().exists(P))
-    return llvm::Optional<std::string>(std::string(P.str()));
-
-  return None;
+std::string ToolChain::getRuntimePath() const {
+  SmallString<128> P(D.ResourceDir);
+  llvm::sys::path::append(P, "lib", getMultiarchTriple(D, Triple, D.SysRoot));
+  return std::string(P.str());
 }
 
-Optional<std::string> ToolChain::getStdlibPath() const {
-  SmallString<128> P;
-
-  // First try the triple passed to driver as --target=<triple>.
-  P.assign(D.Dir);
-  llvm::sys::path::append(P, "..", "lib", D.getTargetTriple());
-  if (getVFS().exists(P))
-    return llvm::Optional<std::string>(std::string(P.str()));
-
-  // Second try the normalized triple.
-  P.assign(D.Dir);
-  llvm::sys::path::append(P, "..", "lib", Triple.str());
-  if (getVFS().exists(P))
-    return llvm::Optional<std::string>(std::string(P.str()));
-
-  return None;
+std::string ToolChain::getStdlibPath() const {
+  SmallString<128> P(D.Dir);
+  llvm::sys::path::append(P, "..", "lib",
+                          getMultiarchTriple(D, Triple, D.SysRoot));
+  return std::string(P.str());
 }
 
 std::string ToolChain::getArchSpecificLibPath() const {
   SmallString<128> Path(getDriver().ResourceDir);
   llvm::sys::path::append(Path, "lib", getOSLibName(),
                           llvm::Triple::getArchTypeName(getArch()));
   return std::string(Path.str());
 }

clang/lib/Driver/ToolChains/Fuchsia.h

void AddCXXStdlibLibArgs(const llvm::opt::ArgList &Args,
                            llvm::opt::ArgStringList &CmdArgs) const override;
 
   const char *getDefaultLinker() const override {
     return "ld.lld";
   }
 
 protected:
   Tool *buildLinker() const override;
+
+  std::string getMultiarchTriple(const Driver &D,
+                                 const llvm::Triple &TargetTriple,
+                                 StringRef SysRoot) const override;
 };
 
 } // end namespace toolchains
 } // end namespace driver
 } // end namespace clang
 
 #endif // LLVM_CLANG_LIB_DRIVER_TOOLCHAINS_FUCHSIA_H

clang/lib/Driver/ToolChains/Fuchsia.cpp

 
 using namespace clang::driver;
 using namespace clang::driver::toolchains;
 using namespace clang::driver::tools;
 using namespace clang;
 using namespace llvm::opt;
 
 using tools::addMultilibFlag;
+using tools::addPathIfExists;
 
 void fuchsia::Linker::ConstructJob(Compilation &C, const JobAction &JA,
                                    const InputInfo &Output,
                                    const InputInfoList &Inputs,
                                    const ArgList &Args,
                                    const char *LinkingOutput) const {
   const toolchains::Fuchsia &ToolChain =
       static_cast<const toolchains::Fuchsia &>(getToolChain());

 
 Fuchsia::Fuchsia(const Driver &D, const llvm::Triple &Triple,
                  const ArgList &Args)
     : ToolChain(D, Triple, Args) {
   getProgramPaths().push_back(getDriver().getInstalledDir());
   if (getDriver().getInstalledDir() != D.Dir)
     getProgramPaths().push_back(D.Dir);
 
+  addPathIfExists(D, getRuntimePath(), getLibraryPaths());
+
+  addPathIfExists(D, getStdlibPath(), getFilePaths());
+
   if (!D.SysRoot.empty()) {
     SmallString<128> P(D.SysRoot);
     llvm::sys::path::append(P, "lib");
     getFilePaths().push_back(std::string(P.str()));
   }
 
   auto FilePaths = [&](const Multilib &M) -> std::vector<std::string> {
     std::vector<std::string> FP;
-    if (auto StdlibPath = getStdlibPath()) {
-      SmallString<128> P(*StdlibPath);
-      llvm::sys::path::append(P, M.gccSuffix());
-      FP.push_back(std::string(P.str()));
-    }
+    SmallString<128> P(getStdlibPath());
     return FP;
   };
 
   Multilibs.push_back(Multilib());
   // Use the noexcept variant with -fno-exceptions to avoid the extra overhead.
   Multilibs.push_back(Multilib("noexcept", {}, {}, 1)
                           .flag("-fexceptions")
                           .flag("+fno-exceptions"));
Fuchsia::Fuchsia(const Driver &D, const llvm::Triple &Triple,
   if (Multilibs.select(Flags, SelectedMultilib))
     if (!SelectedMultilib.isDefault())
       if (const auto &PathsCallback = Multilibs.filePathsCallback())
         for (const auto &Path : PathsCallback(SelectedMultilib))
           // Prepend the multilib path to ensure it takes the precedence.
           getFilePaths().insert(getFilePaths().begin(), Path);
 }
 
+/// Following the conventions in https://wiki.debian.org/Multiarch/Tuples,
+/// we remove the vendor field to form the multiarch triple.
+std::string Fuchsia::getMultiarchTriple(const Driver &D,
+                                        const llvm::Triple &TargetTriple,
+                                        StringRef SysRoot) const {
+    return (TargetTriple.getArchName() + "-" +
+            TargetTriple.getOSAndEnvironmentName()).str();
+}
+
 std::string Fuchsia::ComputeEffectiveClangTriple(const ArgList &Args,
                                                  types::ID InputType) const {
   llvm::Triple Triple(ComputeLLVMTriple(Args, InputType));
   return Triple.str();
 }
 
 Tool *Fuchsia::buildLinker() const {
   return new tools::fuchsia::Linker(*this);

clang/lib/Driver/ToolChains/Gnu.h

public:
   TranslateArgs(const llvm::opt::DerivedArgList &Args, StringRef BoundArch,
                 Action::OffloadKind DeviceOffloadKind) const override;
 
 protected:
   Tool *getTool(Action::ActionClass AC) const override;
   Tool *buildAssembler() const override;
   Tool *buildLinker() const override;
 
-  virtual std::string getMultiarchTriple(const Driver &D,
-                                         const llvm::Triple &TargetTriple,
-                                         StringRef SysRoot) const
-  { return TargetTriple.str(); }
-
   /// \name ToolChain Implementation Helper Functions
   /// @{
 
   /// Check whether the target triple's architecture is 64-bits.
   bool isTarget64Bit() const { return getTriple().isArch64Bit(); }
 
   /// Check whether the target triple's architecture is 32-bits.
   bool isTarget32Bit() const { return getTriple().isArch32Bit(); }

clang/lib/Driver/ToolChains/Linux.cpp

 
 #ifdef ENABLE_LINKER_BUILD_ID
   ExtraOpts.push_back("--build-id");
 #endif
 
   if (IsAndroid || Distro.IsOpenSUSE())
     ExtraOpts.push_back("--enable-new-dtags");
 
+  addPathIfExists(D, getRuntimePath(), getLibraryPaths());
+
   // The selection of paths to try here is designed to match the patterns which
   // the GCC driver itself uses, as this is part of the GCC-compatible driver.
   // This was determined by running GCC in a fake filesystem, creating all
   // possible permutations of these directories, and seeing which ones it added
   // to the link paths.
   path_list &Paths = getFilePaths();
 
+  addPathIfExists(D, getStdlibPath(), Paths);
+
   const std::string OSLibDir = std::string(getOSLibDir(Triple, Args));
   const std::string MultiarchTriple = getMultiarchTriple(D, Triple, SysRoot);
 
   Generic_GCC::AddMultilibPaths(D, SysRoot, OSLibDir, MultiarchTriple, Paths);
 
   addPathIfExists(D, SysRoot + "/lib/" + MultiarchTriple, Paths);
   addPathIfExists(D, SysRoot + "/lib/../" + OSLibDir, Paths);
 

clang/lib/Driver/ToolChains/WebAssembly.h

void AddClangCXXStdlibIncludeArgs(
       llvm::opt::ArgStringList &CC1Args) const override;
   void AddCXXStdlibLibArgs(const llvm::opt::ArgList &Args,
                            llvm::opt::ArgStringList &CmdArgs) const override;
   SanitizerMask getSupportedSanitizers() const override;
 
   const char *getDefaultLinker() const override { return "wasm-ld"; }
 
   Tool *buildLinker() const override;
+
+  std::string getMultiarchTriple(const Driver &D,
+                                 const llvm::Triple &TargetTriple,
+                                 StringRef SysRoot) const override;
 };
 
 } // end namespace toolchains
 } // end namespace driver
 } // end namespace clang
 
 #endif // LLVM_CLANG_LIB_DRIVER_TOOLCHAINS_WEBASSEMBLY_H

clang/lib/Driver/ToolChains/WebAssembly.cpp

 using namespace clang::driver;
 using namespace clang::driver::tools;
 using namespace clang::driver::toolchains;
 using namespace clang;
 using namespace llvm::opt;
 
 /// Following the conventions in https://wiki.debian.org/Multiarch/Tuples,
 /// we remove the vendor field to form the multiarch triple.
-static std::string getMultiarchTriple(const Driver &D,
+std::string WebAssembly::getMultiarchTriple(const Driver &D,
                                             const llvm::Triple &TargetTriple,
-                                      StringRef SysRoot) {
+                                            StringRef SysRoot) const {
     return (TargetTriple.getArchName() + "-" +
             TargetTriple.getOSAndEnvironmentName()).str();
 }
 
 std::string wasm::Linker::getLinkerPath(const ArgList &Args) const {
   const ToolChain &ToolChain = getToolChain();
   if (const Arg* A = Args.getLastArg(options::OPT_fuse_ld_EQ)) {
     StringRef UseLinker = A->getValue();

libcxx/utils/ci/run-buildbot

runtimes-build)
     echo "--- Generating CMake"
     cmake -S "${MONOREPO_ROOT}/llvm" \
           -B "${BUILD_DIR}" \
           -GNinja \
           -DCMAKE_BUILD_TYPE=RelWithDebInfo \
           -DCMAKE_INSTALL_PREFIX="${INSTALL_DIR}" \
           -DLLVM_ENABLE_PROJECTS="clang" \
           -DLLVM_ENABLE_RUNTIMES="libcxx;libcxxabi" \
-          -DLLVM_RUNTIME_TARGETS="x86_64-unknown-linux-gnu"
+          -DLLVM_RUNTIME_TARGETS="x86_64-linux-gnu"
 
     echo "+++ Running the libc++ and libc++abi tests"
     ${NINJA} -C "${BUILD_DIR}" check-runtimes
 
     echo "--- Installing libc++ and libc++abi to a fake location"
     ${NINJA} -C "${BUILD_DIR}" install-cxx install-cxxabi
 ;;
 legacy-standalone)