Distinguish "native" from "native-arch" in lit testing

[probinson]

Summary

"REQUIRES: native" means the compiled code needs to be runnable on the
host. Things like JIT and lli may need this.

"REQUIRES: native-arch" (new in this commit) means that the host's
arch needs to be one of the configured targets. Some tools, e.g. llc,
will default to the host triple if none is specified, and will fail if
the host's arch is not included (e.g. building on X86 and only the ARM
target is included).

Adds lit.cfg code to set "native-arch" and modifies all the places
where r243960 added "native" to use "native-arch" instead.

[chapuni]

This change itself seems fine, .. but I don't understand why it is needed.
Should we fix the root cause anyways?

I don't oppose to commit this if there'd be any cases that really require "native" codegen.

AFAIK, It's just JIT that runs as LLVM_HOST_TRIPLE by default target.
(I found llvm-ar depends on host triple by trivial reason)

I suppose most of tools, like llc, are runs with LLVM_DEFAULT_TARGET_TRIPLE, not HOST_TRIPLE.
I guess configure script might miss checking whether targets_to_build covers target_triple.

[mehdi_amini]

The native use-case is still not clearly motivated to me: it seems that it comes from the JIT tools (lli, other?) defaulting to the default LLVM triple, while I would expect them to default to the host triple.

If changing the tools is not desirable (why?), then the tests could be updated by always forcing the JIT to use the host on the command line (exporting the host triple as an env var and passing it on the RUN: line).

llvm/test/lit.cfg

343

"objects compiled for the *default* target triple will run the host".

[probinson]

I was mis-remembering some research from maybe six months ago... in fact llc does *not* default to the host triple, it will pay attention to the default triple. The sequence is:

• take the triple from the IR, if specified
• triple from the command line will override this, if specified
• if still no triple is set, use default target triple specified at build time

So, as an experiment I should have done in the first place, I took an LLVM hosted on X86 with only the ARM backend included, and a default LLVM triple set to an ARM value. I removed llvm/test/DebugInfo/lit.local.cfg (essentially undoing Mehdi's change) and then ran the DebugInfo tests under llvm-lit. They basically worked (2 unexpected failures out of 100 or so). One was a segfault, one is something that has commentary about it being a bit flakey.

@Mehdi, this suggests that your change should not have been necessary in the first place. What configuration were you using that caused so many failures?

[mehdi_amini]

LLVM hosted on X86 with only the ARM backend included, no default LLVM triple specified.

[probinson]

In D12506#237342, @joker.eph wrote:

LLVM hosted on X86 with only the ARM backend included, no default LLVM triple specified.

That seems like a build-configuration mistake. I believe if you don't explicitly configure a triple, the default target triple is set to the host triple. Using a default triple for a target that you have not included doesn't make any sense?

[chapuni]

It's a bug in configuration. But AFAIK it has not been filed.
Also configure doesn't check if --enable-targets didn't cover --target.

I suppose as if this issue were our common sense.
Should we file bugs?

[mehdi_amini]

Using the DEFAULT_TRIPLE to run the validation on test that were not designed for this triple does not make any sense either. I'm validating GPU backends, and it won't be able to handle all the test cases that were not written specifically for it. There is absolutely no guarantee in general that a backend will properly handle the IR generated and processed for another target.
For instance, I just tried to configure the default target triple to "amdgcn--amdhsa" and configure in the X86 and AMDGPU backends. Running ninja check yields 202 failures.

[chapuni]

I see. So then, we should clarify

• DEFAULT_TARGET_TRIPLE is just default, and it wouldn't work if one didn't configure TARGETS_TO_BUILD didn't cover DEFAULT_TARGET_TRIPLE.

And we may work for;

• Make sure tools (including clang) should fail without explicit triple (or explicit arch) in this configuration. Note, environment might be inferred from DEFAULT_TARGET_TRIPLE with -march.
• Introduce the new feature like "DEFAULT_TARGET_UNAVAILABLE" in Lit tests for it.

This may be fed to llvmdev for the discussion.

[probinson]

In D12506#237410, @joker.eph wrote:

For instance, I just tried to configure the default target triple to "amdgcn--amdhsa" and configure in the X86 and AMDGPU backends. Running ninja check yields 202 failures.

Yes, but I just tried an ARM-backend-only configuration (r243957, prior to your changes) running on X86, default triple "armv7a--linux" and running 'ninja check' yielded NO failures. So I think your issues have more to do with GPU backends not being general-purpose, rather than the host-arch not being one of the available targets. You have applied too big a hammer to the problem, and turned off testing configurations that are actually valuable.

I think Takumi is correct, this needs to be discussed on the dev list. I am unlikely to have time to write up a proper description today so if you want to, go ahead; if you don't I will probably get to it tomorrow.

[probinson]

Superseded by D12660/r247775.

llvm/test/CodeGen/Generic/lit.local.cfg

-if 'native' not in config.available_features:
+if 'native-arch' not in config.available_features:
     config.unsupported = True
 

llvm/test/CodeGen/MIR/Generic/lit.local.cfg

-if 'native' not in config.available_features:
+if 'native-arch' not in config.available_features:
     config.unsupported = True
 

llvm/test/DebugInfo/lit.local.cfg

-if 'native' not in config.available_features:
+if 'native-arch' not in config.available_features:
     config.unsupported = True
 

llvm/test/Feature/optnone-llc.ll

 ; RUN: llc -O0 -debug %s -o /dev/null 2>&1 | FileCheck %s --check-prefix=LLC-O0
 ; RUN: llc -O1 -debug %s -o /dev/null 2>&1 | FileCheck %s --check-prefix=LLC-Ox
 ; RUN: llc -O2 -debug %s -o /dev/null 2>&1 | FileCheck %s --check-prefix=LLC-Ox
 ; RUN: llc -O3 -debug %s -o /dev/null 2>&1 | FileCheck %s --check-prefix=LLC-Ox
 ; RUN: llc -misched-postra -debug %s -o /dev/null 2>&1 | FileCheck %s --check-prefix=LLC-MORE
 
-; REQUIRES: asserts, native
+; REQUIRES: asserts, native-arch
 
 ; This test verifies that we don't run Machine Function optimizations
 ; on optnone functions.
 
 ; Function Attrs: noinline optnone
 define i32 @_Z3fooi(i32 %x) #0 {
 entry:
   %x.addr = alloca i32, align 4

llvm/test/Feature/optnone.ll

 ; RUN: llvm-as < %s | llvm-dis | FileCheck %s
-; REQUIRE: native
+; REQUIRE: native-arch
 
 ; Check for the presence of attribute optnone in the disassembly.
 
 ; CHECK: @foo() #0
 define void @foo() #0 {
   ret void
 }
 
 ; CHECK: attributes #0 = { noinline optnone }
 attributes #0 = { optnone noinline }
 

llvm/test/Linker/subprogram-linkonce-weak.ll

-; REQUIRES: native
+; REQUIRES: native-arch
 ; RUN: llvm-link %s %S/Inputs/subprogram-linkonce-weak.ll -S -o %t1
 ; RUN: FileCheck %s -check-prefix=LW -check-prefix=CHECK <%t1
 ; RUN: llvm-link %S/Inputs/subprogram-linkonce-weak.ll %s -S -o %t2
 ; RUN: FileCheck %s -check-prefix=WL -check-prefix=CHECK <%t2
 
 ; This testcase tests the following flow:
 ;  - File A defines a linkonce version of @foo which has inlined into @bar.
 ;  - File B defines a weak version of @foo (different definition).

llvm/test/Linker/type-unique-odr-a.ll

-; REQUIRES: object-emission, native
+; REQUIRES: object-emission, native-arch
 ;
 ; RUN: llvm-link %s %p/type-unique-odr-b.ll -S -o - | %llc_dwarf -dwarf-linkage-names=Enable -filetype=obj -O0 | llvm-dwarfdump -debug-dump=info - | FileCheck %s
 ;
 ; Test ODR-based type uniquing for C++ class members.
 ; rdar://problem/15851313.
 ;
 ; $ cat -n type-unique-odr-a.cpp
 ;     1 class A {

llvm/test/Linker/type-unique-simple-a.ll

-; REQUIRES: object-emission, native
+; REQUIRES: object-emission, native-arch
 
 ; RUN: llvm-link %s %p/type-unique-simple-b.ll -S -o %t
 ; RUN: cat %t | FileCheck %s -check-prefix=LINK
 ; RUN: %llc_dwarf -filetype=obj -O0 < %t > %t2
 ; RUN: llvm-dwarfdump -debug-dump=info %t2 | FileCheck %s
 
 ; Make sure the backend generates a single DIE and uses ref_addr.
 ; CHECK: 0x[[BASE:.*]]: DW_TAG_structure_type

llvm/test/Linker/type-unique-simple2-a.ll

-; REQUIRES: object-emission, native
+; REQUIRES: object-emission, native-arch
 ;
 ; RUN: llvm-link %s %p/type-unique-simple2-b.ll -S -o - | %llc_dwarf -filetype=obj -O0 | llvm-dwarfdump -debug-dump=info - | FileCheck %s
 ;
 ; Tests for a merge error where attributes are inserted twice into the same DIE.
 ;
 ; $ cat ab.h
 ; typedef int foo_t;
 ; class A {

llvm/test/Linker/type-unique-simple2.ll

-; REQUIRES: object-emission; native
+; REQUIRES: object-emission, native-arch
 
 ; RUN: llvm-link %S/Inputs/type-unique-simple2-a.ll %S/Inputs/type-unique-simple2-b.ll -S -o %t
 ; RUN: cat %t | FileCheck %S/Inputs/type-unique-simple2-a.ll -check-prefix=LINK
 ; RUN: %llc_dwarf -filetype=obj -O0 < %t > %t2
 ; RUN: llvm-dwarfdump -debug-dump=info %t2 | FileCheck %S/Inputs/type-unique-simple2-a.ll

llvm/test/Linker/type-unique-type-array-a.ll

-; REQUIRES: object-emission, native
+; REQUIRES: object-emission, native-arch
 ;
 ; RUN: llvm-link %s %p/type-unique-type-array-b.ll -S -o - | %llc_dwarf -filetype=obj -O0 | llvm-dwarfdump -debug-dump=info - | FileCheck %s
 ;
 ; rdar://problem/17628609
 ;
 ; cat -n a.cpp
 ;     1 struct SA {
 ;     2   int a;

llvm/test/Other/2010-05-06-Printer.ll

-; REQUIRES: native
+; REQUIRES: native-arch
 ; RUN: llc -O2 -print-after-all < %s 2>/dev/null
 
 define void @tester(){
   ret void
 }
 

llvm/test/lit.cfg

 if not 'hexagon' in config.target_triple and not re.match(r'^x86_64.*-(mingw32|windows-gnu|win32)', config.target_triple):
     config.available_features.add("object-emission")
 
 if config.have_zlib == "1":
     config.available_features.add("zlib")
 else:
     config.available_features.add("nozlib")
 
-# Native compilation: host arch == target arch and native backend built-in
-# FIXME: Consider cases that target can be executed
+# Native compilation: Objects compiled for target will run on the host.
+# We approximate this with: host triple == target triple.
+# FIXME: Consider cases that target can be executed on the host
 # even if host_triple were different from target_triple.
-if (config.host_triple == config.target_triple and
-    config.native_target in config.targets_to_build):
+# For example host == x86_64-linux and target == i686-linux.
+if config.host_triple == config.target_triple:
     config.available_features.add("native")
 
+# Native architecture: Host arch is one of the included targets.
+# This is for tools like llc where the default target is the host
+# but we don't require the result to be executable on the host.
+if config.native_target in config.targets_to_build:
+    config.available_features.add("native-arch")
+
 import subprocess
 
 def have_ld_plugin_support():
     if not os.path.exists(os.path.join(config.llvm_shlib_dir, 'LLVMgold.so')):
         return False
 
     ld_cmd = subprocess.Popen([config.gold_executable, '--help'], stdout = subprocess.PIPE, env={'LANG': 'C'})
     ld_out = ld_cmd.stdout.read().decode()

llvm/test/tools/llvm-mc/fatal_warnings.test

 # RUN: not llvm-mc --fatal-warnings %s 2>&1 | FileCheck %s
 # XFAIL: hexagon
-# REQUIRES: native
+# REQUIRES: native-arch
 
 # CHECK: error: .warning directive invoked in source file
 .warning

llvm/test/tools/llvm-mc/line_end_with_space.test

 RUN: llvm-mc -disassemble %s
-# REQUIRES: native
+# REQUIRES: native-arch

llvm/test/tools/llvm-mc/no_warnings.test

 # RUN: llvm-mc --no-warn %s 2>&1 | FileCheck %s
 # XFAIL: hexagon
-# REQUIRES: native
+# REQUIRES: native-arch
 
 # CHECK-NOT: warning:
 .warning