[x86][inline-asm][AVX512][llvm][PART-2] Introducing "k" and "Yk" constraints for extended inline assembly, enabling use of AVX512 masked vectorized instructions.

[mharoush]

Summary

Extending inline assembly support, compatible with GCC as folowing:
"k" constraint hints the compiler to select any of AVX512 k0-k7 registers.
"Yk" constraint is a subset of "k" excluding k0 which is not allowd to be used as a mask.

This patch is complimented by the following review:
D25063

[rnk]

Looks good functionally with some surface level nits

lib/Target/X86/X86ISelLowering.cpp

32250

Let's check size 2 after size 1, it seems more logical, and is 1 is probably the common case.

32321

Typo on "Impliment". Also the comment could be reworded.

32608

Seems like a good place to use a switch on VT

32728

"register"

32730

Maybe do a switch?

[mharoush]

fixed Reids comments

[mharoush]

Added default case, minor ws style.

[rnk]

lgtm

lib/Target/X86/X86ISelLowering.cpp

32315

Use LLVM_FALLTHROUGH here to avoid warnings in some compilers.

[mharoush]

Added LLVM_FALLTHROUGH

lib/Target/X86/X86ISelLowering.cpp

if (Constraint.size() == 1) {
     case 't':
     case 'u':
     case 'y':
     case 'x':
     case 'v':
     case 'Y':
     case 'l':
       return C_RegisterClass;
+    case 'k': // AVX512 masking registers.
     case 'a':
     case 'b':
     case 'c':
     case 'd':
     case 'S':
     case 'D':
     case 'A':
       return C_Register;
     case 'I':
     case 'J':
     case 'K':
     case 'L':
     case 'M':
     case 'N':
     case 'G':
     case 'C':
     case 'e':
     case 'Z':
       return C_Other;
     default:
       break;
     }
   }
+  else if (Constraint.size() == 2) {
+    switch (Constraint[0]) {
+    default:
+      break;
+    case 'Y':
+      switch (Constraint[1]) {
+      default:
+        break;
+      case 'k':
+        return C_Register;
+      }
+    }
+  }
   return TargetLowering::getConstraintType(Constraint);
 }
 
 /// Examine constraint type and operand type and determine a weight value.
 /// This object must already have been set up with the operand type
 /// and the current alternative constraint selected.
 TargetLowering::ConstraintWeight
   X86TargetLowering::getSingleConstraintMatchWeight(
TargetLowering::ConstraintWeight
   case 'u':
     if (type->isFloatingPointTy())
       weight = CW_SpecificReg;
     break;
   case 'y':
     if (type->isX86_MMXTy() && Subtarget.hasMMX())
       weight = CW_SpecificReg;
     break;
+  case 'Y':
+    // Other "Y<x>" (e.g. "Yk") constraints should be implemented below.
+    if (constraint[1] == 'k') {
+      // Support for 'Yk' (similarly to the 'k' variant below).
+      weight = CW_SpecificReg;
+      break;
+    }
+  // Else fall through (handle "Y" constraint).
   case 'v':
     if ((type->getPrimitiveSizeInBits() == 512) && Subtarget.hasAVX512())
       weight = CW_Register;
     LLVM_FALLTHROUGH;
   case 'x':
-  case 'Y':
     if (((type->getPrimitiveSizeInBits() == 128) && Subtarget.hasSSE1()) ||
         ((type->getPrimitiveSizeInBits() == 256) && Subtarget.hasFp256()))
       weight = CW_Register;
     break;
+  case 'k':
+    // Enable conditional vector operations using %k<#> registers.
+    weight = CW_SpecificReg;
+    break;
   case 'I':
     if (ConstantInt *C = dyn_cast<ConstantInt>(info.CallOperandVal)) {
       if (C->getZExtValue() <= 31)
         weight = CW_Constant;
     }
     break;
   case 'J':
     if (ConstantInt *C = dyn_cast<ConstantInt>(CallOperandVal)) {
X86TargetLowering::getRegForInlineAsmConstraint(const TargetRegisterInfo *TRI,
   // register class.
   if (Constraint.size() == 1) {
     // GCC Constraint Letters
     switch (Constraint[0]) {
     default: break;
       // TODO: Slight differences here in allocation order and leaving
       // RIP in the class. Do they matter any more here than they do
       // in the normal allocation?
+    case 'k':
+      if (Subtarget.hasAVX512()) {
+        //  Only supported in AVX512 or later.
+          switch (VT.SimpleTy) {
+          case MVT::i32:
+            return std::make_pair(0U, &X86::VK32RegClass);
+          case MVT::i16:
+            return std::make_pair(0U, &X86::VK16RegClass);
+          case MVT::i8:
+            return std::make_pair(0U, &X86::VK8RegClass);
+          case MVT::i1:
+            return std::make_pair(0U, &X86::VK1RegClass);
+          case MVT::i64:
+            return std::make_pair(0U, &X86::VK64RegClass);
+          }
+      }
+      break;
     case 'q':   // GENERAL_REGS in 64-bit mode, Q_REGS in 32-bit mode.
       if (Subtarget.is64Bit()) {
         if (VT == MVT::i32 || VT == MVT::f32)
           return std::make_pair(0U, &X86::GR32RegClass);
         if (VT == MVT::i16)
           return std::make_pair(0U, &X86::GR16RegClass);
         if (VT == MVT::i8 || VT == MVT::i1)
           return std::make_pair(0U, &X86::GR8RegClass);
case 'x':   // SSE_REGS if SSE1 allowed or AVX_REGS if AVX allowed
       case MVT::v8f64:
       case MVT::v16f32:
       case MVT::v16i32:
       case MVT::v8i64:
         return std::make_pair(0U, &X86::VR512RegClass);
       }
       break;
     }
+  } else if (Constraint.size() == 2 && Constraint[0] == 'Y') {
+    switch (Constraint[1]) {
+    default:
+      break;
+    case 'k':
+      // This register class doesn't allocate k0 for masked vector operation.
+      if (Subtarget.hasAVX512()) { // Only supported in AVX512.
+          switch (VT.SimpleTy) {
+          case MVT::i32:
+              return std::make_pair(0U, &X86::VK32WMRegClass);
+          case MVT::i16:
+              return std::make_pair(0U, &X86::VK16WMRegClass);
+          case MVT::i8:
+              return std::make_pair(0U, &X86::VK8WMRegClass);
+          case MVT::i1:
+              return std::make_pair(0U, &X86::VK1WMRegClass);
+          case MVT::i64:
+              return std::make_pair(0U, &X86::VK64WMRegClass);
+          } 
+      }
+      break;
+    }
   }
 
   // Use the default implementation in TargetLowering to convert the register
   // constraint into a member of a register class.
   std::pair<unsigned, const TargetRegisterClass*> Res;
   Res = TargetLowering::getRegForInlineAsmConstraint(TRI, Constraint, VT);
 
   // Not found as a standard register?