[lldb/lit] Introduce %clang_host substitutions

[labath]

Summary

This patch addresses an ambiguity in how our existing tests invoke the
compiler. Roughly two thirds of our current "shell" tests invoke the
compiler to build the executables for the host. However, there is also
a significant number of tests which don't build a host binary (because
they don't need to run it) and instead they hardcode a certain target.

We also have code which adds a bunch of default arguments to the %clang
substitutions. However, most of these arguments only really make sense
for the host compilation. So far, this has worked mostly ok, because the
arguments we were adding were not conflicting with the target-hardcoding
tests (though they did provoke an occasional "argument unused" warning).

However, this started to break down when we wanted to use
target-hardcoding clang-cl tests (D69031) because clang-cl has a
substantially different command line, and it was getting very confused
by some of the arguments we were adding on non-windows hosts.

This patch avoid this problem by creating separate %clang(xx,_cl)_host
substutitions, which are specifically meant to be used for compiling
host binaries. All funny host-specific options are moved there. To
ensure that the regular %clang substitutions are not used for compiling
host binaries (skipping the extra arguments) I employ a little
hac^H^H^Htrick -- I add an invalid --target argument to the %clang
substitution, which means that one has to use an explicit --target in
order for the compilation to succeed.

[aprantl]

this looks like a reasonable incremental improvement. That said, I'm wondering how useful clang_host is as a concept in the LIT tests. In my own mental model the tests are grouped into

1. end-to-end tests that test lldb against a variety of user-configurable compilers and with different debug info formats
2. unit-tests/internal consistency tests where we may use a compiler for the sake of not having to check in a binary, but where we expect a specific output from the compiler and thus should always use the just-built clang.

The packages subdirectory covers category (1) and the lit subdirectory covers category (2).

Based on that I would expect that we either always hard-code a triple in the lit tests (may result in less coverage if the target isn't available), or we run them for each available target. Giving the host target preference seems arbitrary, given how extensively LLDB is used on an x86_64 host, debugging AArch64 targets, for example.

[labath]

Yes, I understand what you're saying, but I am afraid the situation is not as clear-cut as that. I would be very happy if it was, but it's definitely not the current situation, and given the complexities involved, I'm not sure if we should even aim for that goal. I mean, a lot of times these things end up being down to the personal preference of the author (or reviewer), but there are cases where writing a test of the appropriate category (based on your above classification) would be very hard. Lemme give some examples:

• there is a subclass of "dotest" tests which test lldb's python api (most of them tagged with the "pyapi" category), which test lldb's python api. These definitely don't benefit from being run with multiple compilers (in fact, a lot of them don't run the compiler at all). I don't think it makes sense to change these into "lit" tests.
• another class of "dotest" tests are those which test some interactive behavior of lldb (inferior control, thread plans, stepping and stuff). While these may touch debug info peripherally, it's usually not their main focus, and I don't think we should be relying on them on testing debug info. However, being able to run them in a more "interactive" manner is usually more convenient.
• "pexpect" tests definitely don't/shouldn't test debug info, but they currently exist only in the "dotest" suite (though they are fairly independent, and they could be extracted if we wanted to)
• on the other side of the fence, there are "lit" tests which do not test debug info, or even "debugging", but they still need a host executable, because debugging something is the only way to trigger some functionality. For instance the "register" tests need a functional executable to check that they can read/write registers from it. Unwind tests need a running executable because we can't test even basic unwind without a running process now. Reproducers need a debuggable executable too, but they don't really care about it's contents, etc.

So overall, while there definitely are tests which would be better off moved from one category or the other, I am doubtful that we'll be able to enforce a separation where all "configurable" tests are dotest tests, and all "lit" tests hardcode a triple. The one barrier we have right now is that it is not possible to run the "lit" suite with a different compiler, and that's something I think we should keep. And we can definitely change some %clang_hosts to a hard coded triple (I think that would remove some "UNSUPPORTED: windows" stanzas) and/or be stricter about using %clang_host in the future. In fact I am happy that you spoke out against %clang_host, because when I was going through these tests, I got the impression that the only tests which have a specific triple hard-coded are those that I have written myself. :)

For the test which don't need a host executable, I don't think that running them for each available target would be useful, as they generally don't care about those details. What they sometimes care about is the object file format (because of dwarf differences in elf vs. macho), so it may make sense to introduce some substitution like %elf_triple and %macho_triple, which would choose some elf flavour of one of the configured targets. However, I am afraid that even that would be of limited usefulness, as it's pretty hard to make a specific test which is target agnostic (I tried) -- there are differences in pointer sizes, and even the different assemblers can't agree on what they use as a comment character.

[aprantl]

The one barrier we have right now is that it is not possible to run the "lit" suite with a different compiler, and that's something I think we should keep.

Very much agreed.

For the test which don't need a host executable, I don't think that running them for each available target would be useful, as they generally don't care about those details.

That's plausible.

Thanks for sharing your thoughts!

[JDevlieghere]

All my thoughts have already been brought up and discussed. :-)

LGTM!

[labath]

Thanks guys.

lldb/test/Shell/Commands/command-script-import.test

 # REQUIRES: python
 # RUN: echo 'b main' > %t.in
 # RUN: echo 'run' >> %t.in
 # RUN: echo 'command script import %S/Inputs/frame.py' >> %t.in
 
-# RUN: %clang -g -O0 %S/Inputs/main.c -o %t.out
+# RUN: %clang_host -g -O0 %S/Inputs/main.c -o %t.out
 # RUN: %lldb -b -s %t.in -o 'script print("script: {}".format(lldb.frame))' %t.out | FileCheck %s
 
 # Make sure that we don't have access to lldb.frame from the Python script.
 # CHECK: frame.py: None
 
 # Make sure that we do have access to lldb.frame from the script command.
 # CHECK: script: frame #0

lldb/test/Shell/Driver/TestSingleQuote.test

 # Make sure lldb can handle filenames with single quotes in them.
-# RUN: %clang %p/Inputs/hello.c -g -o "%t-'pat"
+# RUN: %clang_host %p/Inputs/hello.c -g -o "%t-'pat"
 # RUN: %lldb -s %s "%t-'pat" | FileCheck %s
 
 br set -p return
 # CHECK: Breakpoint 1: where = TestSingleQuote.test.tmp-'pat`main

lldb/test/Shell/Driver/TestTarget.test

 # Make sure lldb resolves the target path.
 # RUN: mkdir -p %t/foo
 # RUN: cd %t/foo
-# RUN: %clang %p/Inputs/hello.c -g -o a.out
+# RUN: %clang_host %p/Inputs/hello.c -g -o a.out
 # RUN: %lldb -b a.out | FileCheck %s
 
 # CHECK: Current executable set to '{{.*}}foo{{[/\\\\]+}}a.out'

lldb/test/Shell/ExecControl/StopHook/stop-hook-threads.test

-# RUN: %clangxx -std=c++11 %p/Inputs/stop-hook-threads.cpp -g -o %t
+# RUN: %clangxx_host -std=c++11 %p/Inputs/stop-hook-threads.cpp -g -o %t
 # RUN: %lldb -b -s %p/Inputs/stop-hook-threads-1.lldbinit -s %s -f %t \
 # RUN:     | FileCheck --check-prefix=CHECK --check-prefix=CHECK-NO-FILTER %s
 # RUN: %lldb -b -s %p/Inputs/stop-hook-threads-2.lldbinit -s %s -f %t \
 # RUN:     | FileCheck --check-prefix=CHECK --check-prefix=CHECK-FILTER %s
 # XFAIL: system-netbsd
 # UNSUPPORTED: system-windows
 # This test is flakey and hangs on windows periodically: llvm.org/pr38373
 # UNSUPPORTED: system-linux, system-darwin

lldb/test/Shell/ExecControl/StopHook/stop-hook.test

-# RUN: %clang %p/Inputs/stop-hook.c -g -o %t
+# RUN: %clang_host %p/Inputs/stop-hook.c -g -o %t
 # Test setting stop-hook per-function
 # RUN: %lldb -b -s %p/Inputs/stop-hook-1.lldbinit -s %s -f %t \
 # RUN:      | FileCheck --check-prefix=CHECK --check-prefix=CHECK-FUNC %s
 # Test setting stop-hook per-line range
 # RUN: %lldb -b -s %p/Inputs/stop-hook-2.lldbinit -s %s -f %t | FileCheck %s
 # Test setting stop-hook with multi-line expression
 # RUN: %lldb -b -s %p/Inputs/stop-hook-3.lldbinit -s %s -f %t | FileCheck %s
 # This test is not "unsupported" on Windows, but it fails because "expr ptr"

lldb/test/Shell/Expr/TestIRMemoryMap.test

 # UNSUPPORTED: system-windows
 
-# RUN: %clangxx %p/Inputs/call-function.cpp -g -o %t
+# RUN: %clangxx_host %p/Inputs/call-function.cpp -g -o %t
 
 # RUN: lldb-test ir-memory-map %t %S/Inputs/ir-memory-map-basic
 # RUN: lldb-test ir-memory-map -host-only %t %S/Inputs/ir-memory-map-basic
 
 # RUN: lldb-test ir-memory-map %t %S/Inputs/ir-memory-map-overlap1
 # RUN: lldb-test ir-memory-map -host-only %t %S/Inputs/ir-memory-map-overlap1
 
 # RUN: lldb-test ir-memory-map %t %S/Inputs/ir-memory-map-mix-malloc-free
 # RUN: lldb-test ir-memory-map -host-only %t %S/Inputs/ir-memory-map-mix-malloc-free

lldb/test/Shell/Expr/TestIRMemoryMapWindows.test

 # REQUIRES: system-windows
 
-# RUN: %clang_cl /Zi /GS- %p/Inputs/call-function.cpp /c /o %t.obj
+# RUN: %clang_cl_host /Zi /GS- %p/Inputs/call-function.cpp /c /o %t.obj
 # RUN: %msvc_link /debug:full %t.obj /out:%t
 
 # RUN: lldb-test ir-memory-map %t %S/Inputs/ir-memory-map-basic
 # RUN: lldb-test ir-memory-map -host-only %t %S/Inputs/ir-memory-map-basic
 
 # RUN: lldb-test ir-memory-map %t %S/Inputs/ir-memory-map-overlap1
 # RUN: lldb-test ir-memory-map -host-only %t %S/Inputs/ir-memory-map-overlap1
 
 # RUN: lldb-test ir-memory-map %t %S/Inputs/ir-memory-map-mix-malloc-free
 # RUN: lldb-test ir-memory-map -host-only %t %S/Inputs/ir-memory-map-mix-malloc-free

lldb/test/Shell/Heap/heap-cstr.test

 # REQUIRES: system-darwin
-# RUN: %clang %p/Inputs/cstr.c -g -o %t
+# RUN: %clang_host %p/Inputs/cstr.c -g -o %t
 # RUN: %lldb -b -s %s -f %t | FileCheck %s
 
 br set -p return
 command script import lldb.macosx.heap
 run
 cstr "patatino"
 
 # CHECK: {{.*}}: malloc(    16) -> {{.*}}

lldb/test/Shell/Host/TestCustomShell.test

 # This test applies to POSIX.
 # UNSUPPORTED: system-windows
 
 # FIXME: ShellExpandArguments is unimplemented on the following targets.
 # UNSUPPORTED: system-linux
 # XFAIL: system-freebsd
 # XFAIL: system-netbsd
 # XFAIL: system-openbsd
 
-# RUN: %clang %S/Inputs/simple.c -g -o %t.out
+# RUN: %clang_host %S/Inputs/simple.c -g -o %t.out
 # RUN: SHELL=bogus %lldb %t.out -b -o 'run' 2>&1 | FileCheck %s --check-prefix ERROR
 # RUN: env -i %lldb %t.out -b -o 'run' 2>&1 | FileCheck %s
 
 # ERROR: error: shell expansion failed
 # CHECK-NOT: error: shell expansion failed

lldb/test/Shell/ObjectFile/ELF/minidebuginfo-set-and-hit-breakpoint.test

 # REQUIRES: system-linux, lzma, xz
 
 # We want to keep the symbol "multiplyByThree" in the .dynamic section and not
 # have it put the default .symtab section.
 # RUN: echo "{multiplyByThree;};" > %T/dynmic-symbols.txt
-# RUN: %clang -Wl,--dynamic-list=%T/dynmic-symbols.txt -g -o %t.binary %p/Inputs/minidebuginfo-main.c
+# RUN: %clang_host -Wl,--dynamic-list=%T/dynmic-symbols.txt -g -o %t.binary %p/Inputs/minidebuginfo-main.c
 
 # The following section is adapted from GDB's official documentation:
 # http://sourceware.org/gdb/current/onlinedocs/gdb/MiniDebugInfo.html#MiniDebugInfo
 
 # Extract the dynamic symbols from the main binary, there is no need
 # to also have these in the normal symbol table.
 
 # IGNORE: llvm-nm -D %t.binary --format=posix --defined-only | awk '{ print $1 }' | sort > %t.dynsyms

lldb/test/Shell/Process/TestEnvironment.test

 UNSUPPORTED: system-windows
 
 The double quotes around "BAR" ensure we don't match the command.
 
-RUN: %clangxx -std=c++11 %p/Inputs/env.cpp -o %t
+RUN: %clangxx_host -std=c++11 %p/Inputs/env.cpp -o %t
 RUN: %lldb %t -o 'process launch --environment FOO="BAR"' | FileCheck %s
 RUN: %lldb %t -o 'env FOO="BAR"' -o 'process launch' | FileCheck %s
 
 CHECK: FOO=BAR

lldb/test/Shell/Register/aarch64-fp-read.test

 # REQUIRES: native && target-aarch64
-# RUN: %clangxx -fomit-frame-pointer %p/Inputs/aarch64-fp-read.cpp -o %t
+# RUN: %clangxx_host -fomit-frame-pointer %p/Inputs/aarch64-fp-read.cpp -o %t
 # RUN: %lldb -b -s %s %t | FileCheck %s
 process launch
 
 register read d0
 register read d1
 register read d2
 register read d3
 register read s4

lldb/test/Shell/Register/aarch64-gp-read.test

 # REQUIRES: native && target-aarch64
-# RUN: %clangxx -fomit-frame-pointer %p/Inputs/aarch64-gp-read.cpp -o %t
+# RUN: %clangxx_host -fomit-frame-pointer %p/Inputs/aarch64-gp-read.cpp -o %t
 # RUN: %lldb -b -s %s %t | FileCheck %s
 process launch
 
 register read --all
 # CHECK-DAG: x0 = 0x0001020304050607
 # CHECK-DAG: x1 = 0x1011121314151617
 # CHECK-DAG: x2 = 0x2021222324252627
 # CHECK-DAG: x3 = 0x3031323334353637

lldb/test/Shell/Register/arm-fp-read.test

 # REQUIRES: native && target-arm
-# RUN: %clangxx -fomit-frame-pointer %p/Inputs/arm-fp-read.cpp -o %t
+# RUN: %clangxx_host -fomit-frame-pointer %p/Inputs/arm-fp-read.cpp -o %t
 # RUN: %lldb -b -s %s %t | FileCheck %s
 process launch
 
 register read d0
 register read d1
 register read d2
 register read d3
 register read s8

lldb/test/Shell/Register/arm-gp-read.test

 # REQUIRES: native && target-arm
-# RUN: %clangxx -fomit-frame-pointer %p/Inputs/arm-gp-read.cpp -o %t
+# RUN: %clangxx_host -fomit-frame-pointer %p/Inputs/arm-gp-read.cpp -o %t
 # RUN: %lldb -b -s %s %t | FileCheck %s
 process launch
 
 register read --all
 # CHECK-DAG: r0 = 0x00010203
 # CHECK-DAG: r1 = 0x10111213
 # CHECK-DAG: r2 = 0x20212223
 # CHECK-DAG: r3 = 0x30313233

lldb/test/Shell/Register/x86-64-gp-read.test

 # XFAIL: system-windows
 # REQUIRES: native && target-x86_64
-# RUN: %clangxx -fomit-frame-pointer %p/Inputs/x86-64-gp-read.cpp -o %t
+# RUN: %clangxx_host -fomit-frame-pointer %p/Inputs/x86-64-gp-read.cpp -o %t
 # RUN: %lldb -b -s %s %t | FileCheck %s
 process launch
 
 register read --all
 # CHECK-DAG: rax = 0x0102030405060708
 # CHECK-DAG: rbx = 0x1112131415161718
 # CHECK-DAG: rcx = 0x2122232425262728
 # CHECK-DAG: rdx = 0x3132333435363738

lldb/test/Shell/Register/x86-64-gp-write.test

 # UNSUPPORTED: system-darwin
 # REQUIRES: native && target-x86_64
-# RUN: %clangxx -fomit-frame-pointer %p/Inputs/x86-64-gp-write.cpp -o %t
+# RUN: %clangxx_host -fomit-frame-pointer %p/Inputs/x86-64-gp-write.cpp -o %t
 # RUN: %lldb -b -s %s %t | FileCheck %s
 process launch
 
 register write rax 0x0102030405060708
 register write rbx 0x1112131415161718
 register write rcx 0x2122232425262728
 register write rdx 0x3132333435363738
 register write rsp 0x4142434445464748

lldb/test/Shell/Register/x86-64-read.test

 # XFAIL: system-windows
 # REQUIRES: native && target-x86_64
-# RUN: %clangxx %p/Inputs/x86-64-read.cpp -o %t
+# RUN: %clangxx_host %p/Inputs/x86-64-read.cpp -o %t
 # RUN: %lldb -b -s %s %t | FileCheck %s
 process launch
 
 register read --all
 # CHECK-DAG: r8 = 0x0001020304050607
 # CHECK-DAG: r9 = 0x1011121314151617
 # CHECK-DAG: r10 = 0x2021222324252627
 # CHECK-DAG: r11 = 0x3031323334353637

lldb/test/Shell/Register/x86-64-write.test

 # XFAIL: system-darwin
 # XFAIL: system-windows
 # REQUIRES: native && (target-x86 || target-x86_64) && native-cpu-sse
-# RUN: %clangxx %p/Inputs/x86-64-write.cpp -o %t
+# RUN: %clangxx_host %p/Inputs/x86-64-write.cpp -o %t
 # RUN: %lldb -b -s %s %t | FileCheck %s
 process launch
 
 register write r8 0x0001020304050607
 register write r9 0x1011121314151617
 register write r10 0x2021222324252627
 register write r11 0x3031323334353637
 register write r12 0x4041424344454647

lldb/test/Shell/Register/x86-64-xmm16-read.test

 # XFAIL: system-freebsd
 # XFAIL: system-linux
 # XFAIL: system-netbsd
 # XFAIL: system-windows
 # XFAIL: system-darwin
 # REQUIRES: native && target-x86_64 && native-cpu-avx512f
-# RUN: %clangxx %p/Inputs/x86-zmm-read.cpp -o %t
+# RUN: %clangxx_host %p/Inputs/x86-zmm-read.cpp -o %t
 # RUN: %lldb -b -s %s %t | FileCheck %s
 process launch
 
 register read --all
 # CHECK-DAG: xmm16 = {0x10 0x11 0x12 0x13 0x14 0x15 0x16 0x17 0x18 0x19 0x1a 0x1b 0x1c 0x1d 0x1e 0x1f}
 # CHECK-DAG: xmm17 = {0x11 0x12 0x13 0x14 0x15 0x16 0x17 0x18 0x19 0x1a 0x1b 0x1c 0x1d 0x1e 0x1f 0x20}
 # CHECK-DAG: xmm18 = {0x12 0x13 0x14 0x15 0x16 0x17 0x18 0x19 0x1a 0x1b 0x1c 0x1d 0x1e 0x1f 0x20 0x21}
 # CHECK-DAG: xmm19 = {0x13 0x14 0x15 0x16 0x17 0x18 0x19 0x1a 0x1b 0x1c 0x1d 0x1e 0x1f 0x20 0x21 0x22}

lldb/test/Shell/Register/x86-64-xmm16-write.test

 # XFAIL: system-darwin
 # XFAIL: system-freebsd
 # XFAIL: system-linux
 # XFAIL: system-netbsd
 # XFAIL: system-windows
 # REQUIRES: native && target-x86 && native-cpu-avx512f
-# RUN: %clangxx %p/Inputs/x86-zmm-write.cpp -o %t
+# RUN: %clangxx_host %p/Inputs/x86-zmm-write.cpp -o %t
 # RUN: %lldb -b -s %s %t | FileCheck %s
 process launch
 
 register write xmm16 "{0x10 0x11 0x12 0x13 0x14 0x15 0x16 0x17 0x18 0x19 0x1a 0x1b 0x1c 0x1d 0x1e 0x1f}"
 register write xmm17 "{0x11 0x12 0x13 0x14 0x15 0x16 0x17 0x18 0x19 0x1a 0x1b 0x1c 0x1d 0x1e 0x1f 0x20}"
 register write xmm18 "{0x12 0x13 0x14 0x15 0x16 0x17 0x18 0x19 0x1a 0x1b 0x1c 0x1d 0x1e 0x1f 0x20 0x21}"
 register write xmm19 "{0x13 0x14 0x15 0x16 0x17 0x18 0x19 0x1a 0x1b 0x1c 0x1d 0x1e 0x1f 0x20 0x21 0x22}"
 register write xmm20 "{0x14 0x15 0x16 0x17 0x18 0x19 0x1a 0x1b 0x1c 0x1d 0x1e 0x1f 0x20 0x21 0x22 0x23}"

lldb/test/Shell/Register/x86-64-ymm-read.test

 # XFAIL: system-windows
 # REQUIRES: native && target-x86_64 && native-cpu-avx
-# RUN: %clangxx %p/Inputs/x86-ymm-read.cpp -o %t
+# RUN: %clangxx_host %p/Inputs/x86-ymm-read.cpp -o %t
 # RUN: %lldb -b -s %s %t | FileCheck %s
 process launch
 
 register read --all
 # CHECK-DAG: xmm0 = {0x00 0x01 0x02 0x03 0x04 0x05 0x06 0x07 0x08 0x09 0x0a 0x0b 0x0c 0x0d 0x0e 0x0f}
 # CHECK-DAG: xmm1 = {0x01 0x02 0x03 0x04 0x05 0x06 0x07 0x08 0x09 0x0a 0x0b 0x0c 0x0d 0x0e 0x0f 0x10}
 # CHECK-DAG: xmm2 = {0x02 0x03 0x04 0x05 0x06 0x07 0x08 0x09 0x0a 0x0b 0x0c 0x0d 0x0e 0x0f 0x10 0x11}
 # CHECK-DAG: xmm3 = {0x03 0x04 0x05 0x06 0x07 0x08 0x09 0x0a 0x0b 0x0c 0x0d 0x0e 0x0f 0x10 0x11 0x12}

lldb/test/Shell/Register/x86-64-ymm-write.test

 # XFAIL: system-darwin
 # XFAIL: system-windows
 # REQUIRES: native && target-x86_64 && native-cpu-avx
-# RUN: %clangxx %p/Inputs/x86-ymm-write.cpp -o %t
+# RUN: %clangxx_host %p/Inputs/x86-ymm-write.cpp -o %t
 # RUN: %lldb -b -s %s %t | FileCheck %s
 process launch
 
 register write ymm0 "{0x00 0x01 0x02 0x03 0x04 0x05 0x06 0x07 0x08 0x09 0x0a 0x0b 0x0c 0x0d 0x0e 0x0f 0x10 0x11 0x12 0x13 0x14 0x15 0x16 0x17 0x18 0x19 0x1a 0x1b 0x1c 0x1d 0x1e 0x1f}"
 register write ymm1 "{0x01 0x02 0x03 0x04 0x05 0x06 0x07 0x08 0x09 0x0a 0x0b 0x0c 0x0d 0x0e 0x0f 0x10 0x11 0x12 0x13 0x14 0x15 0x16 0x17 0x18 0x19 0x1a 0x1b 0x1c 0x1d 0x1e 0x1f 0x20}"
 register write ymm2 "{0x02 0x03 0x04 0x05 0x06 0x07 0x08 0x09 0x0a 0x0b 0x0c 0x0d 0x0e 0x0f 0x10 0x11 0x12 0x13 0x14 0x15 0x16 0x17 0x18 0x19 0x1a 0x1b 0x1c 0x1d 0x1e 0x1f 0x20 0x21}"
 register write ymm3 "{0x03 0x04 0x05 0x06 0x07 0x08 0x09 0x0a 0x0b 0x0c 0x0d 0x0e 0x0f 0x10 0x11 0x12 0x13 0x14 0x15 0x16 0x17 0x18 0x19 0x1a 0x1b 0x1c 0x1d 0x1e 0x1f 0x20 0x21 0x22}"
 register write ymm4 "{0x04 0x05 0x06 0x07 0x08 0x09 0x0a 0x0b 0x0c 0x0d 0x0e 0x0f 0x10 0x11 0x12 0x13 0x14 0x15 0x16 0x17 0x18 0x19 0x1a 0x1b 0x1c 0x1d 0x1e 0x1f 0x20 0x21 0x22 0x23}"

lldb/test/Shell/Register/x86-64-ymm16-read.test

 # XFAIL: system-freebsd
 # XFAIL: system-linux
 # XFAIL: system-netbsd
 # XFAIL: system-windows
 # XFAIL: system-darwin
 # REQUIRES: native && target-x86_64 && native-cpu-avx512f
-# RUN: %clangxx %p/Inputs/x86-zmm-read.cpp -o %t
+# RUN: %clangxx_host %p/Inputs/x86-zmm-read.cpp -o %t
 # RUN: %lldb -b -s %s %t | FileCheck %s
 process launch
 
 register read --all
 # CHECK-DAG: ymm16 = {0x10 0x11 0x12 0x13 0x14 0x15 0x16 0x17 0x18 0x19 0x1a 0x1b 0x1c 0x1d 0x1e 0x1f 0x20 0x21 0x22 0x23 0x24 0x25 0x26 0x27 0x28 0x29 0x2a 0x2b 0x2c 0x2d 0x2e 0x2f}
 # CHECK-DAG: ymm17 = {0x11 0x12 0x13 0x14 0x15 0x16 0x17 0x18 0x19 0x1a 0x1b 0x1c 0x1d 0x1e 0x1f 0x20 0x21 0x22 0x23 0x24 0x25 0x26 0x27 0x28 0x29 0x2a 0x2b 0x2c 0x2d 0x2e 0x2f 0x30}
 # CHECK-DAG: ymm18 = {0x12 0x13 0x14 0x15 0x16 0x17 0x18 0x19 0x1a 0x1b 0x1c 0x1d 0x1e 0x1f 0x20 0x21 0x22 0x23 0x24 0x25 0x26 0x27 0x28 0x29 0x2a 0x2b 0x2c 0x2d 0x2e 0x2f 0x30 0x31}
 # CHECK-DAG: ymm19 = {0x13 0x14 0x15 0x16 0x17 0x18 0x19 0x1a 0x1b 0x1c 0x1d 0x1e 0x1f 0x20 0x21 0x22 0x23 0x24 0x25 0x26 0x27 0x28 0x29 0x2a 0x2b 0x2c 0x2d 0x2e 0x2f 0x30 0x31 0x32}

lldb/test/Shell/Register/x86-64-ymm16-write.test

 # XFAIL: system-darwin
 # XFAIL: system-freebsd
 # XFAIL: system-linux
 # XFAIL: system-netbsd
 # XFAIL: system-windows
 # REQUIRES: native && target-x86 && native-cpu-avx512f
-# RUN: %clangxx %p/Inputs/x86-zmm-write.cpp -o %t
+# RUN: %clangxx_host %p/Inputs/x86-zmm-write.cpp -o %t
 # RUN: %lldb -b -s %s %t | FileCheck %s
 process launch
 
 register write ymm16 "{0x10 0x11 0x12 0x13 0x14 0x15 0x16 0x17 0x18 0x19 0x1a 0x1b 0x1c 0x1d 0x1e 0x1f 0x20 0x21 0x22 0x23 0x24 0x25 0x26 0x27 0x28 0x29 0x2a 0x2b 0x2c 0x2d 0x2e 0x2f}"
 register write ymm17 "{0x11 0x12 0x13 0x14 0x15 0x16 0x17 0x18 0x19 0x1a 0x1b 0x1c 0x1d 0x1e 0x1f 0x20 0x21 0x22 0x23 0x24 0x25 0x26 0x27 0x28 0x29 0x2a 0x2b 0x2c 0x2d 0x2e 0x2f 0x30}"
 register write ymm18 "{0x12 0x13 0x14 0x15 0x16 0x17 0x18 0x19 0x1a 0x1b 0x1c 0x1d 0x1e 0x1f 0x20 0x21 0x22 0x23 0x24 0x25 0x26 0x27 0x28 0x29 0x2a 0x2b 0x2c 0x2d 0x2e 0x2f 0x30 0x31}"
 register write ymm19 "{0x13 0x14 0x15 0x16 0x17 0x18 0x19 0x1a 0x1b 0x1c 0x1d 0x1e 0x1f 0x20 0x21 0x22 0x23 0x24 0x25 0x26 0x27 0x28 0x29 0x2a 0x2b 0x2c 0x2d 0x2e 0x2f 0x30 0x31 0x32}"
 register write ymm20 "{0x14 0x15 0x16 0x17 0x18 0x19 0x1a 0x1b 0x1c 0x1d 0x1e 0x1f 0x20 0x21 0x22 0x23 0x24 0x25 0x26 0x27 0x28 0x29 0x2a 0x2b 0x2c 0x2d 0x2e 0x2f 0x30 0x31 0x32 0x33}"

lldb/test/Shell/Register/x86-64-zmm-read.test

 # XFAIL: system-freebsd
 # XFAIL: system-linux
 # XFAIL: system-netbsd
 # XFAIL: system-windows
 # REQUIRES: native && target-x86_64 && native-cpu-avx512f
-# RUN: %clangxx %p/Inputs/x86-zmm-read.cpp -o %t
+# RUN: %clangxx_host %p/Inputs/x86-zmm-read.cpp -o %t
 # RUN: %lldb -b -s %s %t | FileCheck %s
 process launch
 
 register read --all
 # CHECK-DAG: zmm0 = {0x00 0x01 0x02 0x03 0x04 0x05 0x06 0x07 0x08 0x09 0x0a 0x0b 0x0c 0x0d 0x0e 0x0f 0x10 0x11 0x12 0x13 0x14 0x15 0x16 0x17 0x18 0x19 0x1a 0x1b 0x1c 0x1d 0x1e 0x1f 0x20 0x21 0x22 0x23 0x24 0x25 0x26 0x27 0x28 0x29 0x2a 0x2b 0x2c 0x2d 0x2e 0x2f 0x30 0x31 0x32 0x33 0x34 0x35 0x36 0x37 0x38 0x39 0x3a 0x3b 0x3c 0x3d 0x3e 0x3f}
 # CHECK-DAG: zmm1 = {0x01 0x02 0x03 0x04 0x05 0x06 0x07 0x08 0x09 0x0a 0x0b 0x0c 0x0d 0x0e 0x0f 0x10 0x11 0x12 0x13 0x14 0x15 0x16 0x17 0x18 0x19 0x1a 0x1b 0x1c 0x1d 0x1e 0x1f 0x20 0x21 0x22 0x23 0x24 0x25 0x26 0x27 0x28 0x29 0x2a 0x2b 0x2c 0x2d 0x2e 0x2f 0x30 0x31 0x32 0x33 0x34 0x35 0x36 0x37 0x38 0x39 0x3a 0x3b 0x3c 0x3d 0x3e 0x3f 0x40}
 # CHECK-DAG: zmm2 = {0x02 0x03 0x04 0x05 0x06 0x07 0x08 0x09 0x0a 0x0b 0x0c 0x0d 0x0e 0x0f 0x10 0x11 0x12 0x13 0x14 0x15 0x16 0x17 0x18 0x19 0x1a 0x1b 0x1c 0x1d 0x1e 0x1f 0x20 0x21 0x22 0x23 0x24 0x25 0x26 0x27 0x28 0x29 0x2a 0x2b 0x2c 0x2d 0x2e 0x2f 0x30 0x31 0x32 0x33 0x34 0x35 0x36 0x37 0x38 0x39 0x3a 0x3b 0x3c 0x3d 0x3e 0x3f 0x40 0x41}
 # CHECK-DAG: zmm3 = {0x03 0x04 0x05 0x06 0x07 0x08 0x09 0x0a 0x0b 0x0c 0x0d 0x0e 0x0f 0x10 0x11 0x12 0x13 0x14 0x15 0x16 0x17 0x18 0x19 0x1a 0x1b 0x1c 0x1d 0x1e 0x1f 0x20 0x21 0x22 0x23 0x24 0x25 0x26 0x27 0x28 0x29 0x2a 0x2b 0x2c 0x2d 0x2e 0x2f 0x30 0x31 0x32 0x33 0x34 0x35 0x36 0x37 0x38 0x39 0x3a 0x3b 0x3c 0x3d 0x3e 0x3f 0x40 0x41 0x42}

lldb/test/Shell/Register/x86-64-zmm-write.test

 # XFAIL: system-darwin
 # XFAIL: system-freebsd
 # XFAIL: system-linux
 # XFAIL: system-netbsd
 # XFAIL: system-windows
 # REQUIRES: native && target-x86_64 && native-cpu-avx512f
-# RUN: %clangxx %p/Inputs/x86-zmm-write.cpp -o %t
+# RUN: %clangxx_host %p/Inputs/x86-zmm-write.cpp -o %t
 # RUN: %lldb -b -s %s %t | FileCheck %s
 process launch
 
 register write zmm0 "{0x00 0x01 0x02 0x03 0x04 0x05 0x06 0x07 0x08 0x09 0x0a 0x0b 0x0c 0x0d 0x0e 0x0f 0x10 0x11 0x12 0x13 0x14 0x15 0x16 0x17 0x18 0x19 0x1a 0x1b 0x1c 0x1d 0x1e 0x1f 0x20 0x21 0x22 0x23 0x24 0x25 0x26 0x27 0x28 0x29 0x2a 0x2b 0x2c 0x2d 0x2e 0x2f 0x30 0x31 0x32 0x33 0x34 0x35 0x36 0x37 0x38 0x39 0x3a 0x3b 0x3c 0x3d 0x3e 0x3f}"
 register write zmm1 "{0x01 0x02 0x03 0x04 0x05 0x06 0x07 0x08 0x09 0x0a 0x0b 0x0c 0x0d 0x0e 0x0f 0x10 0x11 0x12 0x13 0x14 0x15 0x16 0x17 0x18 0x19 0x1a 0x1b 0x1c 0x1d 0x1e 0x1f 0x20 0x21 0x22 0x23 0x24 0x25 0x26 0x27 0x28 0x29 0x2a 0x2b 0x2c 0x2d 0x2e 0x2f 0x30 0x31 0x32 0x33 0x34 0x35 0x36 0x37 0x38 0x39 0x3a 0x3b 0x3c 0x3d 0x3e 0x3f 0x40}"
 register write zmm2 "{0x02 0x03 0x04 0x05 0x06 0x07 0x08 0x09 0x0a 0x0b 0x0c 0x0d 0x0e 0x0f 0x10 0x11 0x12 0x13 0x14 0x15 0x16 0x17 0x18 0x19 0x1a 0x1b 0x1c 0x1d 0x1e 0x1f 0x20 0x21 0x22 0x23 0x24 0x25 0x26 0x27 0x28 0x29 0x2a 0x2b 0x2c 0x2d 0x2e 0x2f 0x30 0x31 0x32 0x33 0x34 0x35 0x36 0x37 0x38 0x39 0x3a 0x3b 0x3c 0x3d 0x3e 0x3f 0x40 0x41}"
 register write zmm3 "{0x03 0x04 0x05 0x06 0x07 0x08 0x09 0x0a 0x0b 0x0c 0x0d 0x0e 0x0f 0x10 0x11 0x12 0x13 0x14 0x15 0x16 0x17 0x18 0x19 0x1a 0x1b 0x1c 0x1d 0x1e 0x1f 0x20 0x21 0x22 0x23 0x24 0x25 0x26 0x27 0x28 0x29 0x2a 0x2b 0x2c 0x2d 0x2e 0x2f 0x30 0x31 0x32 0x33 0x34 0x35 0x36 0x37 0x38 0x39 0x3a 0x3b 0x3c 0x3d 0x3e 0x3f 0x40 0x41 0x42}"
 register write zmm4 "{0x04 0x05 0x06 0x07 0x08 0x09 0x0a 0x0b 0x0c 0x0d 0x0e 0x0f 0x10 0x11 0x12 0x13 0x14 0x15 0x16 0x17 0x18 0x19 0x1a 0x1b 0x1c 0x1d 0x1e 0x1f 0x20 0x21 0x22 0x23 0x24 0x25 0x26 0x27 0x28 0x29 0x2a 0x2b 0x2c 0x2d 0x2e 0x2f 0x30 0x31 0x32 0x33 0x34 0x35 0x36 0x37 0x38 0x39 0x3a 0x3b 0x3c 0x3d 0x3e 0x3f 0x40 0x41 0x42 0x43}"

lldb/test/Shell/Register/x86-gp-read.test

 # XFAIL: system-windows
 # REQUIRES: native && target-x86
-# RUN: %clangxx -fomit-frame-pointer %p/Inputs/x86-gp-read.cpp -o %t
+# RUN: %clangxx_host -fomit-frame-pointer %p/Inputs/x86-gp-read.cpp -o %t
 # RUN: %lldb -b -s %s %t | FileCheck %s
 process launch
 
 register read --all
 # CHECK-DAG: eax = 0x05060708
 # CHECK-DAG: ebx = 0x15161718
 # CHECK-DAG: ecx = 0x25262728
 # CHECK-DAG: edx = 0x35363738

lldb/test/Shell/Register/x86-gp-write.test

 # XFAIL: system-windows
 # REQUIRES: native && target-x86
-# RUN: %clangxx -fomit-frame-pointer %p/Inputs/x86-gp-write.cpp -o %t
+# RUN: %clangxx_host -fomit-frame-pointer %p/Inputs/x86-gp-write.cpp -o %t
 # RUN: %lldb -b -s %s %t | FileCheck %s
 process launch
 
 register write eax 0x01020304
 register write ebx 0x11121314
 register write ecx 0x21222324
 register write edx 0x31323334
 register write esp 0x41424344

lldb/test/Shell/Register/x86-mm-xmm-read.test

 # XFAIL: system-darwin
 # XFAIL: system-windows
 # REQUIRES: native && (target-x86 || target-x86_64) && native-cpu-sse
-# RUN: %clangxx %p/Inputs/x86-mm-xmm-read.cpp -o %t
+# RUN: %clangxx_host %p/Inputs/x86-mm-xmm-read.cpp -o %t
 # RUN: %lldb -b -s %s %t | FileCheck %s
 process launch
 
 register read --all
 # CHECK-DAG: mm0 = 0x0001020304050607
 # CHECK-DAG: mm1 = 0x1011121314151617
 # CHECK-DAG: mm2 = 0x2021222324252627
 # CHECK-DAG: mm3 = 0x3031323334353637

lldb/test/Shell/Register/x86-mm-xmm-write.test

 # XFAIL: system-darwin
 # XFAIL: system-windows
 # REQUIRES: native && (target-x86 || target-x86_64) && native-cpu-sse
-# RUN: %clangxx %p/Inputs/x86-mm-xmm-write.cpp -o %t
+# RUN: %clangxx_host %p/Inputs/x86-mm-xmm-write.cpp -o %t
 # RUN: %lldb -b -s %s %t | FileCheck %s
 process launch
 
 register write mm0 0x0001020304050607
 register write mm1 0x1011121314151617
 register write mm2 0x2021222324252627
 register write mm3 0x3031323334353637
 register write mm4 0x4041424344454647

lldb/test/Shell/Register/x86-ymm-read.test

 # XFAIL: system-windows
 # REQUIRES: native && target-x86 && native-cpu-avx
-# RUN: %clangxx %p/Inputs/x86-ymm-read.cpp -o %t
+# RUN: %clangxx_host %p/Inputs/x86-ymm-read.cpp -o %t
 # RUN: %lldb -b -s %s %t | FileCheck %s
 process launch
 
 register read --all
 # CHECK-DAG: xmm0 = {0x00 0x01 0x02 0x03 0x04 0x05 0x06 0x07 0x08 0x09 0x0a 0x0b 0x0c 0x0d 0x0e 0x0f}
 # CHECK-DAG: xmm1 = {0x01 0x02 0x03 0x04 0x05 0x06 0x07 0x08 0x09 0x0a 0x0b 0x0c 0x0d 0x0e 0x0f 0x10}
 # CHECK-DAG: xmm2 = {0x02 0x03 0x04 0x05 0x06 0x07 0x08 0x09 0x0a 0x0b 0x0c 0x0d 0x0e 0x0f 0x10 0x11}
 # CHECK-DAG: xmm3 = {0x03 0x04 0x05 0x06 0x07 0x08 0x09 0x0a 0x0b 0x0c 0x0d 0x0e 0x0f 0x10 0x11 0x12}

lldb/test/Shell/Register/x86-ymm-write.test

 # XFAIL: system-windows
 # REQUIRES: native && target-x86 && native-cpu-avx
-# RUN: %clangxx %p/Inputs/x86-ymm-write.cpp -o %t
+# RUN: %clangxx_host %p/Inputs/x86-ymm-write.cpp -o %t
 # RUN: %lldb -b -s %s %t | FileCheck %s
 process launch
 
 register write ymm0 "{0x00 0x01 0x02 0x03 0x04 0x05 0x06 0x07 0x08 0x09 0x0a 0x0b 0x0c 0x0d 0x0e 0x0f 0x10 0x11 0x12 0x13 0x14 0x15 0x16 0x17 0x18 0x19 0x1a 0x1b 0x1c 0x1d 0x1e 0x1f}"
 register write ymm1 "{0x01 0x02 0x03 0x04 0x05 0x06 0x07 0x08 0x09 0x0a 0x0b 0x0c 0x0d 0x0e 0x0f 0x10 0x11 0x12 0x13 0x14 0x15 0x16 0x17 0x18 0x19 0x1a 0x1b 0x1c 0x1d 0x1e 0x1f 0x20}"
 register write ymm2 "{0x02 0x03 0x04 0x05 0x06 0x07 0x08 0x09 0x0a 0x0b 0x0c 0x0d 0x0e 0x0f 0x10 0x11 0x12 0x13 0x14 0x15 0x16 0x17 0x18 0x19 0x1a 0x1b 0x1c 0x1d 0x1e 0x1f 0x20 0x21}"
 register write ymm3 "{0x03 0x04 0x05 0x06 0x07 0x08 0x09 0x0a 0x0b 0x0c 0x0d 0x0e 0x0f 0x10 0x11 0x12 0x13 0x14 0x15 0x16 0x17 0x18 0x19 0x1a 0x1b 0x1c 0x1d 0x1e 0x1f 0x20 0x21 0x22}"
 register write ymm4 "{0x04 0x05 0x06 0x07 0x08 0x09 0x0a 0x0b 0x0c 0x0d 0x0e 0x0f 0x10 0x11 0x12 0x13 0x14 0x15 0x16 0x17 0x18 0x19 0x1a 0x1b 0x1c 0x1d 0x1e 0x1f 0x20 0x21 0x22 0x23}"

lldb/test/Shell/Register/x86-zmm-read.test

 # XFAIL: system-freebsd
 # XFAIL: system-linux
 # XFAIL: system-netbsd
 # XFAIL: system-windows
 # REQUIRES: native && target-x86 && native-cpu-avx512f
-# RUN: %clangxx %p/Inputs/x86-zmm-read.cpp -o %t
+# RUN: %clangxx_host %p/Inputs/x86-zmm-read.cpp -o %t
 # RUN: %lldb -b -s %s %t | FileCheck %s
 process launch
 
 register read --all
 # CHECK-DAG: zmm0 = {0x00 0x01 0x02 0x03 0x04 0x05 0x06 0x07 0x08 0x09 0x0a 0x0b 0x0c 0x0d 0x0e 0x0f 0x10 0x11 0x12 0x13 0x14 0x15 0x16 0x17 0x18 0x19 0x1a 0x1b 0x1c 0x1d 0x1e 0x1f 0x20 0x21 0x22 0x23 0x24 0x25 0x26 0x27 0x28 0x29 0x2a 0x2b 0x2c 0x2d 0x2e 0x2f 0x30 0x31 0x32 0x33 0x34 0x35 0x36 0x37 0x38 0x39 0x3a 0x3b 0x3c 0x3d 0x3e 0x3f}
 # CHECK-DAG: zmm1 = {0x01 0x02 0x03 0x04 0x05 0x06 0x07 0x08 0x09 0x0a 0x0b 0x0c 0x0d 0x0e 0x0f 0x10 0x11 0x12 0x13 0x14 0x15 0x16 0x17 0x18 0x19 0x1a 0x1b 0x1c 0x1d 0x1e 0x1f 0x20 0x21 0x22 0x23 0x24 0x25 0x26 0x27 0x28 0x29 0x2a 0x2b 0x2c 0x2d 0x2e 0x2f 0x30 0x31 0x32 0x33 0x34 0x35 0x36 0x37 0x38 0x39 0x3a 0x3b 0x3c 0x3d 0x3e 0x3f 0x40}
 # CHECK-DAG: zmm2 = {0x02 0x03 0x04 0x05 0x06 0x07 0x08 0x09 0x0a 0x0b 0x0c 0x0d 0x0e 0x0f 0x10 0x11 0x12 0x13 0x14 0x15 0x16 0x17 0x18 0x19 0x1a 0x1b 0x1c 0x1d 0x1e 0x1f 0x20 0x21 0x22 0x23 0x24 0x25 0x26 0x27 0x28 0x29 0x2a 0x2b 0x2c 0x2d 0x2e 0x2f 0x30 0x31 0x32 0x33 0x34 0x35 0x36 0x37 0x38 0x39 0x3a 0x3b 0x3c 0x3d 0x3e 0x3f 0x40 0x41}
 # CHECK-DAG: zmm3 = {0x03 0x04 0x05 0x06 0x07 0x08 0x09 0x0a 0x0b 0x0c 0x0d 0x0e 0x0f 0x10 0x11 0x12 0x13 0x14 0x15 0x16 0x17 0x18 0x19 0x1a 0x1b 0x1c 0x1d 0x1e 0x1f 0x20 0x21 0x22 0x23 0x24 0x25 0x26 0x27 0x28 0x29 0x2a 0x2b 0x2c 0x2d 0x2e 0x2f 0x30 0x31 0x32 0x33 0x34 0x35 0x36 0x37 0x38 0x39 0x3a 0x3b 0x3c 0x3d 0x3e 0x3f 0x40 0x41 0x42}
 # CHECK-DAG: zmm4 = {0x04 0x05 0x06 0x07 0x08 0x09 0x0a 0x0b 0x0c 0x0d 0x0e 0x0f 0x10 0x11 0x12 0x13 0x14 0x15 0x16 0x17 0x18 0x19 0x1a 0x1b 0x1c 0x1d 0x1e 0x1f 0x20 0x21 0x22 0x23 0x24 0x25 0x26 0x27 0x28 0x29 0x2a 0x2b 0x2c 0x2d 0x2e 0x2f 0x30 0x31 0x32 0x33 0x34 0x35 0x36 0x37 0x38 0x39 0x3a 0x3b 0x3c 0x3d 0x3e 0x3f 0x40 0x41 0x42 0x43}
 # CHECK-DAG: zmm5 = {0x05 0x06 0x07 0x08 0x09 0x0a 0x0b 0x0c 0x0d 0x0e 0x0f 0x10 0x11 0x12 0x13 0x14 0x15 0x16 0x17 0x18 0x19 0x1a 0x1b 0x1c 0x1d 0x1e 0x1f 0x20 0x21 0x22 0x23 0x24 0x25 0x26 0x27 0x28 0x29 0x2a 0x2b 0x2c 0x2d 0x2e 0x2f 0x30 0x31 0x32 0x33 0x34 0x35 0x36 0x37 0x38 0x39 0x3a 0x3b 0x3c 0x3d 0x3e 0x3f 0x40 0x41 0x42 0x43 0x44}
 # CHECK-DAG: zmm6 = {0x06 0x07 0x08 0x09 0x0a 0x0b 0x0c 0x0d 0x0e 0x0f 0x10 0x11 0x12 0x13 0x14 0x15 0x16 0x17 0x18 0x19 0x1a 0x1b 0x1c 0x1d 0x1e 0x1f 0x20 0x21 0x22 0x23 0x24 0x25 0x26 0x27 0x28 0x29 0x2a 0x2b 0x2c 0x2d 0x2e 0x2f 0x30 0x31 0x32 0x33 0x34 0x35 0x36 0x37 0x38 0x39 0x3a 0x3b 0x3c 0x3d 0x3e 0x3f 0x40 0x41 0x42 0x43 0x44 0x45}
 # CHECK-DAG: zmm7 = {0x07 0x08 0x09 0x0a 0x0b 0x0c 0x0d 0x0e 0x0f 0x10 0x11 0x12 0x13 0x14 0x15 0x16 0x17 0x18 0x19 0x1a 0x1b 0x1c 0x1d 0x1e 0x1f 0x20 0x21 0x22 0x23 0x24 0x25 0x26 0x27 0x28 0x29 0x2a 0x2b 0x2c 0x2d 0x2e 0x2f 0x30 0x31 0x32 0x33 0x34 0x35 0x36 0x37 0x38 0x39 0x3a 0x3b 0x3c 0x3d 0x3e 0x3f 0x40 0x41 0x42 0x43 0x44 0x45 0x46}
 
 process continue
 # CHECK: Process {{[0-9]+}} exited with status = 0

lldb/test/Shell/Register/x86-zmm-write.test

 # XFAIL: system-freebsd
 # XFAIL: system-linux
 # XFAIL: system-netbsd
 # XFAIL: system-windows
 # REQUIRES: native && target-x86 && native-cpu-avx512f
-# RUN: %clangxx %p/Inputs/x86-zmm-write.cpp -o %t
+# RUN: %clangxx_host %p/Inputs/x86-zmm-write.cpp -o %t
 # RUN: %lldb -b -s %s %t | FileCheck %s
 process launch
 
 register write zmm0 "{0x00 0x01 0x02 0x03 0x04 0x05 0x06 0x07 0x08 0x09 0x0a 0x0b 0x0c 0x0d 0x0e 0x0f 0x10 0x11 0x12 0x13 0x14 0x15 0x16 0x17 0x18 0x19 0x1a 0x1b 0x1c 0x1d 0x1e 0x1f 0x20 0x21 0x22 0x23 0x24 0x25 0x26 0x27 0x28 0x29 0x2a 0x2b 0x2c 0x2d 0x2e 0x2f 0x30 0x31 0x32 0x33 0x34 0x35 0x36 0x37 0x38 0x39 0x3a 0x3b 0x3c 0x3d 0x3e 0x3f}"
 register write zmm1 "{0x01 0x02 0x03 0x04 0x05 0x06 0x07 0x08 0x09 0x0a 0x0b 0x0c 0x0d 0x0e 0x0f 0x10 0x11 0x12 0x13 0x14 0x15 0x16 0x17 0x18 0x19 0x1a 0x1b 0x1c 0x1d 0x1e 0x1f 0x20 0x21 0x22 0x23 0x24 0x25 0x26 0x27 0x28 0x29 0x2a 0x2b 0x2c 0x2d 0x2e 0x2f 0x30 0x31 0x32 0x33 0x34 0x35 0x36 0x37 0x38 0x39 0x3a 0x3b 0x3c 0x3d 0x3e 0x3f 0x40}"
 register write zmm2 "{0x02 0x03 0x04 0x05 0x06 0x07 0x08 0x09 0x0a 0x0b 0x0c 0x0d 0x0e 0x0f 0x10 0x11 0x12 0x13 0x14 0x15 0x16 0x17 0x18 0x19 0x1a 0x1b 0x1c 0x1d 0x1e 0x1f 0x20 0x21 0x22 0x23 0x24 0x25 0x26 0x27 0x28 0x29 0x2a 0x2b 0x2c 0x2d 0x2e 0x2f 0x30 0x31 0x32 0x33 0x34 0x35 0x36 0x37 0x38 0x39 0x3a 0x3b 0x3c 0x3d 0x3e 0x3f 0x40 0x41}"
 register write zmm3 "{0x03 0x04 0x05 0x06 0x07 0x08 0x09 0x0a 0x0b 0x0c 0x0d 0x0e 0x0f 0x10 0x11 0x12 0x13 0x14 0x15 0x16 0x17 0x18 0x19 0x1a 0x1b 0x1c 0x1d 0x1e 0x1f 0x20 0x21 0x22 0x23 0x24 0x25 0x26 0x27 0x28 0x29 0x2a 0x2b 0x2c 0x2d 0x2e 0x2f 0x30 0x31 0x32 0x33 0x34 0x35 0x36 0x37 0x38 0x39 0x3a 0x3b 0x3c 0x3d 0x3e 0x3f 0x40 0x41 0x42}"
 register write zmm4 "{0x04 0x05 0x06 0x07 0x08 0x09 0x0a 0x0b 0x0c 0x0d 0x0e 0x0f 0x10 0x11 0x12 0x13 0x14 0x15 0x16 0x17 0x18 0x19 0x1a 0x1b 0x1c 0x1d 0x1e 0x1f 0x20 0x21 0x22 0x23 0x24 0x25 0x26 0x27 0x28 0x29 0x2a 0x2b 0x2c 0x2d 0x2e 0x2f 0x30 0x31 0x32 0x33 0x34 0x35 0x36 0x37 0x38 0x39 0x3a 0x3b 0x3c 0x3d 0x3e 0x3f 0x40 0x41 0x42 0x43}"

lldb/test/Shell/Reproducer/Functionalities/TestDataFormatter.test

 # UNSUPPORTED: system-windows, system-freebsd
 
 # This tests that data formatters continue to work when replaying a reproducer.
 
 # RUN: rm -rf %t.repro
-# RUN: %clangxx %S/Inputs/foo.cpp -g -o %t.out
+# RUN: %clangxx_host %S/Inputs/foo.cpp -g -o %t.out
 
 # RUN: %lldb -x -b -s %S/Inputs/DataFormatter.in --capture --capture-path %t.repro %t.out | FileCheck %s
 # RUN: %lldb --replay %t.repro | FileCheck %s
 
 # CHECK: stop reason = breakpoint 1.1
 # CHECK: (Foo) foo = (m_i = 0, m_d = 0)
 # CHECK: stop reason = step over
 # CHECK: (Foo) foo = (m_i = 1, m_d = 2)
 # CHECK: Process {{.*}} resuming
 # CHECK: Process {{.*}} exited with status = 0

lldb/test/Shell/Reproducer/Functionalities/TestImageList.test

 # UNSUPPORTED: system-windows, system-freebsd
 
 # This tests that image list works when replaying. We arbitrarily assume
 # there's at least two entries and compare that they're identical.
 
-# RUN: %clang %S/Inputs/stepping.c -g -o %t.out
+# RUN: %clang_host %S/Inputs/stepping.c -g -o %t.out
 
 # RUN: rm -rf %t.txt
 
 # RUN: echo "CAPTURE" >> %t.txt
 # RUN: %lldb -x -b  --capture --capture-path %t.repro \
 # RUN:    -o 'run' \
 # RUN:    -o 'image list' \
 # RUN:    -o 'reproducer generate' \

lldb/test/Shell/Reproducer/Functionalities/TestStepping.test

 # UNSUPPORTED: system-windows, system-freebsd
 
 # This tests that stepping continues to work when replaying a reproducer.
 
 # RUN: rm -rf %t.repro
-# RUN: %clang %S/Inputs/stepping.c -O0 -g -o %t.out
+# RUN: %clang_host %S/Inputs/stepping.c -O0 -g -o %t.out
 # RUN: grep -v '#' %s > %t.in
 
 # RUN: %lldb -x -b -s %t.in --capture --capture-path %t.repro %t.out | FileCheck %s --check-prefix CHECK
 # RUN: %lldb --replay %t.repro | FileCheck %s --check-prefix CHECK
 
 # Set breakpoints in a,b and c and verify we stop there when stepping.
 
 breakpoint set -f stepping.c -l 28

lldb/test/Shell/Reproducer/Modules/TestModuleCXX.test

 # RUN: mkdir -p %t.clang-cache
 # RUN: mkdir -p %t.lldb-cache
 # RUN: cp %S/Inputs/main.cpp %t.root
 # RUN: cp %S/Inputs/Foo.h %t.root
 # RUN: cp %S/Inputs/Bar.h %t.root
 # RUN: cp %S/Inputs/module.modulemap %t.root
 
 # Compile the test case form the temporary root.
-# RUN: %clang %t.root/main.cpp -g -fmodules -fcxx-modules -fmodules-cache-path=%t.clang-cache -o %t.root/a.out
+# RUN: %clang_host %t.root/main.cpp -g -fmodules -fcxx-modules -fmodules-cache-path=%t.clang-cache -o %t.root/a.out
 
 # Capture the debug session.
 # RUN: %lldb -x -b -o 'settings set symbols.clang-modules-cache-path %t.lldb-cache' -s %S/Inputs/ModuleCXX.in --capture --capture-path %t.repro %t.root/a.out | FileCheck %s --check-prefix CAPTURE
 # CAPTURE: (success = 0)
 
 # RUN: cat %t.repro/files.yaml | FileCheck %s --check-prefix YAML
 # YAML-DAG: Foo.h
 # YAML-DAG: Bar.h

lldb/test/Shell/Reproducer/TestDump.test

 # UNSUPPORTED: system-windows
 # This tests the reproducer dump functionality.
 
 # Generate a reproducer.
 # RUN: mkdir -p %t
 # RUN: rm -rf %t.repro
-# RUN: %clang %S/Inputs/simple.c -g -o %t/reproducer.out
+# RUN: %clang_host %S/Inputs/simple.c -g -o %t/reproducer.out
 # RUN: %lldb -x -b -s %S/Inputs/FileCapture.in -o 'reproducer dump -p files' --capture --capture-path %t.repro %t/reproducer.out
 
 # RUN: %lldb -b -o 'reproducer dump -p files -f %t.repro' | FileCheck %s --check-prefix FILES
 # FILES-DAG: 'reproducer.out'
 # FILES-DAG: 'FileCapture.in'
 
 # RUN: %lldb -b -o 'reproducer dump -p version -f %t.repro' | FileCheck %s --check-prefix VERSION
 # VERSION: lldb version

lldb/test/Shell/Reproducer/TestFileRepro.test

 # REQUIRES: system-darwin
 
 # This tests the replaying of GDB remote packets.
 #
 # We issue the same commands and ensure the output is identical to the original
 # process. To ensure we're not actually running the original binary we check
 # that the string "testing" is not printed.
 
 # RUN: rm -rf %t.repro
-# RUN: %clang %S/Inputs/simple.c -g -o %t.out
+# RUN: %clang_host %S/Inputs/simple.c -g -o %t.out
 # RUN: %lldb -x -b -s %S/Inputs/FileCapture.in --capture --capture-path %t.repro %t.out | FileCheck %s --check-prefix CHECK --check-prefix CAPTURE
 # RUN: rm %t.out
 # RUN: %lldb --replay %t.repro | FileCheck %s --check-prefix CHECK --check-prefix REPLAY
 # RUN: cat %t.repro/version.txt | FileCheck %s --check-prefix VERSION
 
 # CAPTURE: testing
 # REPLAY-NOT: testing
 
 # CHECK: Process {{.*}} exited
 
 # CAPTURE: Reproducer is in capture mode.
 # CAPTURE: Reproducer written
 
 # VERSION: lldb version

lldb/test/Shell/Reproducer/TestGDBRemoteRepro.test

 # UNSUPPORTED: system-windows, system-freebsd
 
 # This tests the replaying of GDB remote packets.
 #
 # We issue the same commands and ensure the output is identical to the original
 # process. To ensure we're not actually running the original binary we check
 # that the string "testing" is not printed.
 
 # RUN: rm -rf %t.repro
-# RUN: %clang %S/Inputs/simple.c -g -o %t.out
+# RUN: %clang_host %S/Inputs/simple.c -g -o %t.out
 # RUN: %lldb -x -b -s %S/Inputs/GDBRemoteCapture.in --capture --capture-path %t.repro %t.out | FileCheck %s --check-prefix CHECK --check-prefix CAPTURE
 # RUN: env FOO=BAR %lldb --replay %t.repro | FileCheck %s --check-prefix CHECK --check-prefix REPLAY
 
 # CHECK: Breakpoint 1
 # CHECK: Process {{.*}} stopped
 # CHECK: Process {{.*}} launched
 # CHECK: thread {{.*}} stop reason = breakpoint
 # CHECK: frame {{.*}} simple.c

lldb/test/Shell/Reproducer/TestRelativePath.test

 # This tests relative capture paths.
 
 # RUN: mkdir -p %t
 # RUN: cd %t
 # RUN: rm -rf ./foo
-# RUN: %clang %S/Inputs/simple.c -g -o %t/reproducer.out
+# RUN: %clang_host %S/Inputs/simple.c -g -o %t/reproducer.out
 # RUN: %lldb -x -b -s %S/Inputs/FileCapture.in -o 'reproducer dump -p files' --capture --capture-path ./foo %t/reproducer.out
 # RUN: %lldb --replay ./foo

lldb/test/Shell/Reproducer/TestReuseDirectory.test

 # UNSUPPORTED: system-windows, system-freebsd
 
 # Test that we can capture twice to the same directory without breaking the
 # reproducer functionality.
 
 # RUN: rm -rf %t.repro
-# RUN: %clang %S/Inputs/simple.c -g -o %t.out
+# RUN: %clang_host %S/Inputs/simple.c -g -o %t.out
 # RUN: %lldb -x -b -s %S/Inputs/GDBRemoteCapture.in --capture --capture-path %t.repro %t.out | FileCheck %S/TestGDBRemoteRepro.test --check-prefix CHECK --check-prefix CAPTURE
 # RUN: %lldb -x -b -s %S/Inputs/GDBRemoteCapture.in --capture --capture-path %t.repro %t.out | FileCheck %S/TestGDBRemoteRepro.test --check-prefix CHECK --check-prefix CAPTURE
 # RUN: %lldb --replay %t.repro | FileCheck %S/TestGDBRemoteRepro.test --check-prefix CHECK --check-prefix REPLAY
 
 # Test that we can replay from a different location, i.e. that the reproducer
 # is relocatable.
 
 # RUN: rm -rf %t.repro_moved
 # RUN: mv %t.repro %t.repro_moved
 # RUN: %lldb --replay %t.repro_moved | FileCheck %S/TestGDBRemoteRepro.test --check-prefix CHECK --check-prefix REPLAY

lldb/test/Shell/Reproducer/TestWorkingDir.test

 # XFAIL: system-windows
 
 # This tests that the reproducer can deal with relative files. We create a
 # binary in a subdirectory and pass its relative path to LLDB. The subdirectory
 # is removed before replay so that it only exists in the reproducer's VFS.
 
 # RUN: echo "CHECK: %t" > %t.check
 
 # RUN: rm -rf %t.repro
 # RUN: mkdir -p %t.repro
 # RUN: mkdir -p %t
 # RUN: mkdir -p %t/binary
 # RUN: cd %t
-# RUN: %clang %S/Inputs/simple.c -g -o binary/reproducer.out
+# RUN: %clang_host %S/Inputs/simple.c -g -o binary/reproducer.out
 # RUN: %lldb -x -b -s %S/Inputs/WorkingDir.in --capture --capture-path %t.repro binary/reproducer.out
 # RUN: rm -rf %t/binary
 
 # RUN: cat %t.repro/cwd.txt | FileCheck %t.check
 # RUN: %lldb --replay %t.repro | FileCheck %t.check

lldb/test/Shell/Settings/TestFrameFormatColor.test

-# RUN: %clang -g -O0 %S/Inputs/main.c -o %t.out
+# RUN: %clang_host -g -O0 %S/Inputs/main.c -o %t.out
 # RUN: %lldb -x -b -s %s %t.out | FileCheck %s
 settings set use-color true
 settings set -f frame-format "frame #${frame.index}: \`${ansi.fg.green}{${function.name-with-args}${ansi.normal}\n"
 b foo
 run
 bt
 c
 q
 
 # Check the ASCII escape code
 # CHECK: ␛

lldb/test/Shell/Settings/TestFrameFormatNoColor.test

-# RUN: %clang -g -O0 %S/Inputs/main.c -o %t.out
+# RUN: %clang_host -g -O0 %S/Inputs/main.c -o %t.out
 # RUN: %lldb -x -b -s %s %t.out | FileCheck %s
 settings set use-color false
 settings set -f frame-format "frame #${frame.index}: \`${ansi.fg.green}{${function.name-with-args}${ansi.normal}\n"
 b foo
 run
 bt
 c
 q
 
 # Check the ASCII escape code
 # CHECK-NOT: ␛

lldb/test/Shell/SymbolFile/DWARF/anon_class_w_and_wo_export_symbols.ll

 ;    int y;
 ;   };
 ;   struct {
 ;    int z;
 ;   } unnamed;
 ; } a;
 ;```
 ;
-; RUN: %clang++ -g -c -o %t.o %s
+; RUN: %clangxx_host -g -c -o %t.o %s
 ; RUN: lldb-test symbols -dump-clang-ast %t.o | FileCheck %s
 ; RUN: llvm-dwarfdump %t.o | FileCheck %s --check-prefix DWARFDUMP
 
 %struct.A = type { %struct.anon, %struct.anon.0, %struct.anon.1 }
 %struct.anon = type { i32 }
 %struct.anon.0 = type { i32 }
 %struct.anon.1 = type { i32 }
 

lldb/test/Shell/SymbolFile/DWARF/clang-ast-from-dwarf-unamed-and-anon-structs.cpp

 // UNSUPPORTED: system-windows
 //
 // Test to verify we are corectly generating anonymous flags when parsing
 // anonymous class and unnamed structs from DWARF to the a clang AST node.
 
-// RUN: %clang++ -g -c -o %t.o %s
+// RUN: %clangxx_host -g -c -o %t.o %s
 // RUN: lldb-test symbols -dump-clang-ast %t.o | FileCheck %s
 
 struct A {
   struct {
     int x;
   };
   struct {
     int y;
   } C;
 } a;
 
 // CHECK: A::(anonymous struct)
 // CHECK: |-DefinitionData is_anonymous pass_in_registers aggregate standard_layout trivially_copyable pod trivial literal
 // CHECK: A::(anonymous struct)
 // CHECK: |-DefinitionData pass_in_registers aggregate standard_layout trivially_copyable pod trivial literal

lldb/test/Shell/SymbolFile/DWARF/debug-types-expressions.test

 # UNSUPPORTED: system-darwin, system-windows
 
 # Make sure DWARF v4 type units work.
-# RUN: %clangxx %S/Inputs/debug-types-expressions.cpp \
+# RUN: %clangxx_host %S/Inputs/debug-types-expressions.cpp \
 # RUN:   -g -gdwarf-4 -fdebug-types-section -o %t4
 # RUN: %lldb %t4 -s %s -o exit | FileCheck %s
 
 # Now do the same for DWARF v5.
-# RUN: %clangxx %S/Inputs/debug-types-expressions.cpp \
+# RUN: %clangxx_host %S/Inputs/debug-types-expressions.cpp \
 # RUN:   -g -gdwarf-5 -fdebug-types-section -o %t5
 # RUN: %lldb %t5 -s %s -o exit | FileCheck %s
 
 # Test type units in dwo files.
-# RUN: %clangxx %S/Inputs/debug-types-expressions.cpp \
+# RUN: %clangxx_host %S/Inputs/debug-types-expressions.cpp \
 # RUN:   -g -gdwarf-4 -fdebug-types-section -o %t4dwo
 # RUN: %lldb %t4dwo -s %s -o exit | FileCheck %s
 
 # And type units+dwo+dwarf5.
-# RUN: %clangxx %S/Inputs/debug-types-expressions.cpp \
+# RUN: %clangxx_host %S/Inputs/debug-types-expressions.cpp \
 # RUN:   -g -gdwarf-5 -fdebug-types-section -o %t5dwo
 # RUN: %lldb %t5dwo -s %s -o exit | FileCheck %s
 
 breakpoint set -n foo
 process launch
 
 # CHECK: Process {{.*}} stopped
 

lldb/test/Shell/SymbolFile/DWARF/deterministic-build.cpp

 // Test that binaries linked deterministically (N_OSO has timestamp 0) can still
 // have their object files loaded by lldb. Note that the env var ZERO_AR_DATE
 // requires the ld64 linker, which clang invokes by default.
 // REQUIRES: system-darwin
-// RUN: %clang %s -g -c -o %t.o
-// RUN: ZERO_AR_DATE=1 %clang %t.o -g -o %t
+// RUN: %clang_host %s -g -c -o %t.o
+// RUN: ZERO_AR_DATE=1 %clang_host %t.o -g -o %t
 // RUN: %lldb %t -o "breakpoint set -f %s -l 11" -o run -o exit | FileCheck %s
 // CHECK: stop reason = breakpoint
 
 
 int main() { return 0; }

lldb/test/Shell/SymbolFile/PDB/function-level-linking.test

 REQUIRES: system-windows, lld
-RUN: %clang_cl /c /Zi /Gy %S/Inputs/FunctionLevelLinkingTest.cpp /o %t.obj
+RUN: %clang_cl_host /c /Zi /Gy %S/Inputs/FunctionLevelLinkingTest.cpp /o %t.obj
 RUN: lld-link /debug:full /nodefaultlib /entry:main /order:@%S/Inputs/FunctionLevelLinkingTest.ord %t.obj /out:%t.exe
 RUN: env LLDB_USE_NATIVE_PDB_READER=1 lldb-test symbols -verify %t.exe
 RUN: env LLDB_USE_NATIVE_PDB_READER=0 lldb-test symbols -verify %t.exe

lldb/test/Shell/SymbolFile/target-symbols-add-unwind.test

 # TODO: When it's possible to run "image show-unwind" without a running
 # process, we can remove the unsupported line below, and hard-code an ELF
 # triple in the test.
 # UNSUPPORTED: system-windows, system-darwin
 
 # RUN: cd %T
-# RUN: %clang %S/Inputs/target-symbols-add-unwind.c -g \
+# RUN: %clang_host %S/Inputs/target-symbols-add-unwind.c -g \
 # RUN:   -fno-unwind-tables -o target-symbols-add-unwind.debug
 # RUN: llvm-objcopy --strip-debug target-symbols-add-unwind.debug \
 # RUN:   target-symbols-add-unwind.stripped
 # RUN: %lldb target-symbols-add-unwind.stripped -s %s -o quit | FileCheck %s
 
 process launch --stop-at-entry
 image show-unwind -n main
 # CHECK-LABEL: image show-unwind -n main

lldb/test/Shell/Unwind/eh-frame-dwarf-unwind.test

 # Test handing of dwarf expressions specifying the location of registers, if
 # those expressions refer to the frame's CFA value.
 
 # UNSUPPORTED: system-windows
 # REQUIRES: target-x86_64, native
 
-# RUN: %clang %p/Inputs/call-asm.c %p/Inputs/eh-frame-dwarf-unwind.s -o %t
+# RUN: %clang_host %p/Inputs/call-asm.c %p/Inputs/eh-frame-dwarf-unwind.s -o %t
 # RUN: %lldb %t -s %s -o exit | FileCheck %s
 
 breakpoint set -n bar
 # CHECK: Breakpoint 1: where = {{.*}}`bar
 
 process launch
 # CHECK: stop reason = breakpoint 1.1
 
 thread backtrace
 # CHECK: frame #0: {{.*}}`bar
 # CHECK: frame #1: {{.*}}`foo + 5
 # CHECK: frame #2: {{.*}}`asm_main + 22
 
 target modules show-unwind -n foo
 # CHECK: eh_frame UnwindPlan:
 # CHECK: row[0]: 0: CFA=rsp +8 => rip=DW_OP_lit8 , DW_OP_minus , DW_OP_deref , DW_OP_const1u 0x47, DW_OP_minus

lldb/test/Shell/Unwind/eh-frame-small-fde.test

 # This test that we are able to unwind using eh_frame in case an FDE entry does
 # not cover the entire range of a function we are unwinding through.
 
 # REQUIRES: target-x86_64, system-linux, native
 
-# RUN: %clang %p/Inputs/eh-frame-small-fde.s -o %t
+# RUN: %clang_host %p/Inputs/eh-frame-small-fde.s -o %t
 # RUN: %lldb %t -s %s -o exit | FileCheck %s
 
 breakpoint set -n bar
 # CHECK: Breakpoint 1: where = {{.*}}`bar
 
 process launch
 # CHECK: stop reason = breakpoint 1.1
 
 thread backtrace
 # CHECK: frame #0: {{.*}}`bar
 # CHECK: frame #1: {{.*}}`foo + 6
 # CHECK: frame #2: {{.*}}`main + 20
 
 target modules show-unwind -n foo
 # CHECK: eh_frame UnwindPlan:
 # CHECK: row[0]: 0: CFA=rsp +8 => rip=r13

lldb/test/Shell/Unwind/prefer-debug-over-eh-frame.test

 # Test that we prefer debug_frame over eh_frame unwind plans. They usually
 # contain the same information, and we rarely have both kinds of entries for a
 # single function. However, in theory the debug_frame plan can be more complete,
 # whereas eh_frame is only required to be correct at places where exceptions can
 # be thrown.
 
 # UNSUPPORTED: system-windows
 # XFAIL: system-darwin
 # REQUIRES: target-x86_64, native
 
-# RUN: %clang -g %p/Inputs/call-asm.c %p/Inputs/prefer-debug-over-eh-frame.s -o %t
+# RUN: %clang_host -g %p/Inputs/call-asm.c %p/Inputs/prefer-debug-over-eh-frame.s -o %t
 # RUN: %lldb %t -s %s -o exit | FileCheck %s
 
 breakpoint set -n bar
 # CHECK: Breakpoint 1: where = {{.*}}`bar
 
 process launch
 # CHECK: stop reason = breakpoint 1.1
 
 target modules show-unwind -n foo
 # CHECK: Asynchronous (not restricted to call-sites) UnwindPlan is 'DWARF CFI plus augmentation from assembly parsing'
 # CHECK: Synchronous (restricted to call-sites) UnwindPlan is 'DWARF CFI'
 # CHECK: eh_frame UnwindPlan:
 # CHECK: debug_frame UnwindPlan:

lldb/test/Shell/Unwind/trap_frame_sym_ctx.test

 # Test that symbol contexts for trap handler frames are set correctly even when
 # the pc is at the start of the function.
 
 # UNSUPPORTED: system-windows
 # REQUIRES: target-x86_64, native
 
-# RUN: %clang %p/Inputs/call-asm.c %p/Inputs/trap_frame_sym_ctx.s -o %t
+# RUN: %clang_host %p/Inputs/call-asm.c %p/Inputs/trap_frame_sym_ctx.s -o %t
 # RUN: %lldb %t -s %s -o exit | FileCheck %s
 
 settings append target.trap-handler-names tramp
 
 breakpoint set -n bar
 # CHECK: Breakpoint 1: where = {{.*}}`bar
 
 process launch
 # CHECK: stop reason = breakpoint 1.1
 
 thread backtrace
 # CHECK: frame #0: {{.*}}`bar
 # CHECK: frame #1: {{.*}}`tramp
 # CHECK: frame #2: {{.*}}`main

lldb/test/Shell/Unwind/unwind-plan-dwarf-dump.test

 # REQUIRES: target-x86_64, system-linux, native
 
-# RUN: %clang %p/Inputs/unwind-plan-dwarf-dump.s -o %t
+# RUN: %clang_host %p/Inputs/unwind-plan-dwarf-dump.s -o %t
 # RUN: %lldb %t -s %s -o exit | FileCheck %s
 
 breakpoint set -n main
 # CHECK: Breakpoint 1:
 
 process launch
 # CHECK: stop reason = breakpoint 1.1
 
 target modules show-unwind -n main
 # CHECK: eh_frame UnwindPlan:
 # CHECK: row[0]:    0: CFA=DW_OP_breg7 +0, DW_OP_const1u 0x00, DW_OP_plus  => rip=DW_OP_const1s -8, DW_OP_plus , DW_OP_deref

lldb/test/Shell/Watchpoint/SetErrorCases.test

-# RUN: %clangxx %p/Inputs/main.cpp -g -o %t.out
+# RUN: %clangxx_host %p/Inputs/main.cpp -g -o %t.out
 # RUN: %lldb -b -o 'settings set interpreter.stop-command-source-on-error false' -s %s %t.out 2>&1 | FileCheck %s
 
 settings show interpreter.stop-command-source-on-error
 # CHECK: interpreter.stop-command-source-on-error (boolean) = false
 
 b main.cpp:11
 run
 # CHECK: stopped

lldb/test/Shell/helper/toolchain.py

tools = [
         ToolSubst('%msvc_link', command=link, extra_args=linker_flags)]
     llvm_config.add_tool_substitutions(tools)
     return
 
 def use_support_substitutions(config):
     # Set up substitutions for support tools.  These tools can be overridden at the CMake
     # level (by specifying -DLLDB_LIT_TOOLS_DIR), installed, or as a last resort, we can use
     # the just-built version.
-    flags = []
+    host_flags = ['--target=' + config.host_triple]
     if platform.system() in ['Darwin']:
         try:
             out = subprocess.check_output(['xcrun', '--show-sdk-path']).strip()
             res = 0
         except OSError:
             res = -1
         if res == 0 and out:
             sdk_path = lit.util.to_string(out)
             llvm_config.lit_config.note('using SDKROOT: %r' % sdk_path)
-            flags = ['-isysroot', sdk_path]
+            host_flags += ['-isysroot', sdk_path]
     elif platform.system() in ['NetBSD', 'OpenBSD', 'Linux']:
-        flags = ['-pthread']
+        host_flags += ['-pthread']
 
     if sys.platform.startswith('netbsd'):
         # needed e.g. to use freshly built libc++
-        flags += ['-L' + config.llvm_libs_dir,
+        host_flags += ['-L' + config.llvm_libs_dir,
                   '-Wl,-rpath,' + config.llvm_libs_dir]
 
     # The clang module cache is used for building inferiors.
-    flags += ['-fmodules-cache-path={}'.format(config.clang_module_cache)]
+    host_flags += ['-fmodules-cache-path={}'.format(config.clang_module_cache)]
+
+    host_flags = ' '.join(host_flags)
+    config.substitutions.append(('%clang_host', '%clang ' + host_flags))
+    config.substitutions.append(('%clangxx_host', '%clangxx ' + host_flags))
+    config.substitutions.append(('%clang_cl_host', '%clang_cl --target='+config.host_triple))
 
     additional_tool_dirs=[]
     if config.lldb_lit_tools_dir:
         additional_tool_dirs.append(config.lldb_lit_tools_dir)
 
-    llvm_config.use_clang(additional_flags=flags,
+    llvm_config.use_clang(additional_flags=['--target=specify-a-target-or-use-a-_host-substitution'],
                           additional_tool_dirs=additional_tool_dirs,
                           required=True)
 
+
     if sys.platform == 'win32':
         _use_msvc_substitutions(config)
 
     have_lld = llvm_config.use_lld(additional_tool_dirs=additional_tool_dirs,
                                    required=False)
     if have_lld:
         config.available_features.add('lld')
 
 
     support_tools = ['yaml2obj', 'obj2yaml', 'llvm-pdbutil',
                      'llvm-mc', 'llvm-readobj', 'llvm-objdump',
                      'llvm-objcopy', 'lli']
     additional_tool_dirs += [config.lldb_tools_dir, config.llvm_tools_dir]
     llvm_config.add_tool_substitutions(support_tools, additional_tool_dirs)