[X86] Remove AVX/AVX512 check from validateOperandSize, just always accept 512

[craig.topper]

Summary

The AVX/AVX512 check were based on the command line features. But the function may have a target attribute that gives more features than the command line. We shouldn't fail for 512 operand if the command line doesn't support it, but the target attribute does. gcc supports this.

I don't know how to get to the target attribute here, or if we even can without creating a layering issue. So I've just removed the check entirely and always allow 512 bits. In some simple testing, the backend seems to produce an error like "couldn't allocate output register for constraint 'x'" when the type is larger than supported by the subtarget features. So I think we can handle this gracefully without crashing.

[rnk]

I notice that x86 is the only target for which validateInput/OutputSize are implemented. If you are going to disable these checks, perhaps we should get rid of these methods and leave all these errors to the backend? You could add -S to the x86_32-inline-asm.c test and turn it into an integration test that shows that we no longer crash. It would need REQUIRES: x86-registered-target if you do that.

Adding @void and @ahatanak, who added these long ago.

clang/lib/Basic/Targets/X86.cpp

1768

I think the same issues apply to this SSELevel check. I suspect no one complains about these checks because everyone enables SSE2 in one way or another.

[echristo]

The idea was that we'd have a much more graceful error message as well as a way for the front end to do the diagnosis. The code is being called out of SemaStmtAsm.cpp and I'm pretty sure we can probably accumulate the target attributes there?

-eric

[craig.topper]

New patch to factor in the target attribute D68627

clang/lib/Basic/Targets/X86.cpp

default:
       return false;
     case 'm':
       // 'Ym' is synonymous with 'y'.
     case 'k':
       return Size <= 64;
     case 'z':
     case '0':
       // XMM0
       if (SSELevel >= SSE1)
         return Size <= 128U;
       return false;
     case 'i':
     case 't':
     case '2':
       // 'Yi','Yt','Y2' are synonymous with 'x' when SSE2 is enabled.
       if (SSELevel < SSE2)
         return false;
       break;
     }
     LLVM_FALLTHROUGH;
   case 'v':
   case 'x':
-    if (SSELevel >= AVX512F)
-      // 512-bit zmm registers can be used if target supports AVX512F.
-      return Size <= 512U;
-    else if (SSELevel >= AVX)
-      // 256-bit ymm registers can be used if target supports AVX.
-      return Size <= 256U;
-    return Size <= 128U;
-
+// FIXME: We should check the size based on the SSE level, but that requires
+// supporting the target attribute. The X86 backend seems to tolerate large
+// sizes and will produce an error message.
+//    if (SSELevel >= AVX512F)
+//      // 512-bit zmm registers can be used if target supports AVX512F.
+//      return Size <= 512U;
+//    else if (SSELevel >= AVX)
+//      // 256-bit ymm registers can be used if target supports AVX.
+//      return Size <= 256U;
+//    return Size <= 128U;
   }
 
   return true;
 }
 
 std::string X86TargetInfo::convertConstraint(const char *&Constraint) const {
   switch (*Constraint) {
   case '@':

clang/test/CodeGen/x86_32-inline-asm.c

int func1() {
   __asm__ volatile("outb %0, %w1" : : "c" (val), "Nd" (port)); // expected-error {{invalid input size for constraint 'c'}}
   __asm__ volatile("outb %0, %w1" : : "d" (val), "Nd" (port)); // expected-error {{invalid input size for constraint 'd'}}
   __asm__ volatile("outb %0, %w1" : : "S" (val), "Nd" (port)); // expected-error {{invalid input size for constraint 'S'}}
   __asm__ volatile("outb %0, %w1" : : "D" (val), "Nd" (port)); // expected-error {{invalid input size for constraint 'D'}}
   __asm__ volatile("foo1 %0" : : "A" (val128)); // expected-error {{invalid input size for constraint 'A'}}
   __asm__ volatile("foo1 %0" : : "f" (val256)); // expected-error {{invalid input size for constraint 'f'}}
   __asm__ volatile("foo1 %0" : : "t" (val256)); // expected-error {{invalid input size for constraint 't'}}
   __asm__ volatile("foo1 %0" : : "u" (val256)); // expected-error {{invalid input size for constraint 'u'}}
-  __asm__ volatile("foo1 %0" : : "x" (val512)); // expected-error {{invalid input size for constraint 'x'}}
+  __asm__ volatile("foo1 %0" : : "x" (val512)); // No error.
 
   __asm__ volatile("foo1 %0" : "=R" (val)); // expected-error {{invalid output size for constraint '=R'}}
   __asm__ volatile("foo1 %0" : "=q" (val)); // expected-error {{invalid output size for constraint '=q'}}
   __asm__ volatile("foo1 %0" : "=Q" (val)); // expected-error {{invalid output size for constraint '=Q'}}
   __asm__ volatile("foo1 %0" : "=a" (val)); // expected-error {{invalid output size for constraint '=a'}}
   __asm__ volatile("foo1 %0" : "=b" (val)); // expected-error {{invalid output size for constraint '=b'}}
   __asm__ volatile("foo1 %0" : "=c" (val)); // expected-error {{invalid output size for constraint '=c'}}
   __asm__ volatile("foo1 %0" : "=d" (val)); // expected-error {{invalid output size for constraint '=d'}}
   __asm__ volatile("foo1 %0" : "=S" (val)); // expected-error {{invalid output size for constraint '=S'}}
   __asm__ volatile("foo1 %0" : "=D" (val)); // expected-error {{invalid output size for constraint '=D'}}
   __asm__ volatile("foo1 %0" : "=A" (val128)); // expected-error {{invalid output size for constraint '=A'}}
   __asm__ volatile("foo1 %0" : "=t" (val256)); // expected-error {{invalid output size for constraint '=t'}}
   __asm__ volatile("foo1 %0" : "=u" (val256)); // expected-error {{invalid output size for constraint '=u'}}
-  __asm__ volatile("foo1 %0" : "=x" (val512)); // expected-error {{invalid output size for constraint '=x'}}
+  __asm__ volatile("foo1 %0" : "=x" (val512)); // No error.
 
-#ifdef __AVX__
   __asm__ volatile("foo1 %0" : : "x" (val256)); // No error.
   __asm__ volatile("foo1 %0" : "=x" (val256));  // No error.
-#else
-  __asm__ volatile("foo1 %0" : : "x" (val256)); // expected-error {{invalid input size for constraint 'x'}}
-  __asm__ volatile("foo1 %0" : "=x" (val256)); // expected-error {{invalid output size for constraint '=x'}}
-#endif
 }

clang/test/CodeGen/x86_64-PR42672.c

#ifdef IMPOSSIBLE_X
   struct S {
     unsigned x[8];
   } z;
   asm volatile("nop"
                : "=x"(z));
 #endif
 }
 
-// CHECK-IMPOSSIBLE_X: invalid output size for constraint
+// CHECK-IMPOSSIBLE_X: impossible constraint in asm: can't store value into a register
 
 // http://crbug.com/999160
 // Clang used to report the following message:
 //   "impossible constraint in asm: can't store struct into a register"
 // for the assembly directive below, although there's no struct.
 void crbug_999160_regtest() {
 #ifdef IMPOSSIBLE_9BYTES
   char buf[9];
   asm(""
       : "=r"(buf));
 #endif
 }
 
 // CHECK-IMPOSSIBLE_9BYTES: impossible constraint in asm: can't store value into a register