Fix assertion when using a V constraint in inline asm.

[jacobly]

Summary

Uses of Constraint_v are commented with not offsetable, but that describes the V constraint, not v which is related to vector registers on x86. Because TargetLowering::getConstraintType gets the case correct, a V constraint triggers an assertion when TargetLowering::getInlineAsmMemConstraint returns Constraint_unknown.

include/llvm/IR/InlineAsm.h

enum : uint32_t {
     // These could be tablegenerated but there's little need to do that since
     // there's plenty of space in the encoding to support the union of all
     // constraint codes for all targets.
     Constraint_Unknown = 0,
     Constraint_es,
     Constraint_i,
     Constraint_m,
     Constraint_o,
-    Constraint_v,
+    Constraint_V,
     Constraint_Q,
     Constraint_R,
     Constraint_S,
     Constraint_T,
     Constraint_Um,
     Constraint_Un,
     Constraint_Uq,
     Constraint_Us,

lib/CodeGen/MachineInstr.cpp

if (isDebugValue() && MO.isMetadata()) {
 
       if (InlineAsm::isMemKind(Flag)) {
         unsigned MCID = InlineAsm::getMemoryConstraintID(Flag);
         switch (MCID) {
         case InlineAsm::Constraint_es: OS << ":es"; break;
         case InlineAsm::Constraint_i:  OS << ":i"; break;
         case InlineAsm::Constraint_m:  OS << ":m"; break;
         case InlineAsm::Constraint_o:  OS << ":o"; break;
-        case InlineAsm::Constraint_v:  OS << ":v"; break;
+        case InlineAsm::Constraint_V:  OS << ":V"; break;
         case InlineAsm::Constraint_Q:  OS << ":Q"; break;
         case InlineAsm::Constraint_R:  OS << ":R"; break;
         case InlineAsm::Constraint_S:  OS << ":S"; break;
         case InlineAsm::Constraint_T:  OS << ":T"; break;
         case InlineAsm::Constraint_Um: OS << ":Um"; break;
         case InlineAsm::Constraint_Un: OS << ":Un"; break;
         case InlineAsm::Constraint_Uq: OS << ":Uq"; break;
         case InlineAsm::Constraint_Us: OS << ":Us"; break;

lib/Target/Hexagon/HexagonISelDAGToDAG.cpp

SelectInlineAsmMemoryOperand(const SDValue &Op, unsigned ConstraintID,
                              std::vector<SDValue> &OutOps) {
   SDValue Inp = Op, Res;
 
   switch (ConstraintID) {
   default:
     return true;
   case InlineAsm::Constraint_i:
   case InlineAsm::Constraint_o: // Offsetable.
-  case InlineAsm::Constraint_v: // Not offsetable.
+  case InlineAsm::Constraint_V: // Not offsetable.
   case InlineAsm::Constraint_m: // Memory.
     if (SelectAddrFI(Inp, Res))
       OutOps.push_back(Res);
     else
       OutOps.push_back(Inp);
     break;
   }
 

lib/Target/X86/X86ISelDAGToDAG.cpp

SelectInlineAsmMemoryOperand(const SDValue &Op, unsigned ConstraintID,
   switch (ConstraintID) {
   default:
     llvm_unreachable("Unexpected asm memory constraint");
   case InlineAsm::Constraint_i:
     // FIXME: It seems strange that 'i' is needed here since it's supposed to
     //        be an immediate and not a memory constraint.
     LLVM_FALLTHROUGH;
   case InlineAsm::Constraint_o: // offsetable        ??
-  case InlineAsm::Constraint_v: // not offsetable    ??
+  case InlineAsm::Constraint_V: // not offsetable    ??
   case InlineAsm::Constraint_m: // memory
   case InlineAsm::Constraint_X:
     if (!selectAddr(nullptr, Op, Op0, Op1, Op2, Op3, Op4))
       return true;
     break;
   }
 
   OutOps.push_back(Op0);

lib/Target/X86/X86ISelLowering.h

void LowerAsmOperandForConstraint(SDValue Op,
                                       SelectionDAG &DAG) const override;
 
     unsigned
     getInlineAsmMemConstraint(StringRef ConstraintCode) const override {
       if (ConstraintCode == "i")
         return InlineAsm::Constraint_i;
       else if (ConstraintCode == "o")
         return InlineAsm::Constraint_o;
-      else if (ConstraintCode == "v")
-        return InlineAsm::Constraint_v;
+      else if (ConstraintCode == "V")
+        return InlineAsm::Constraint_V;
       else if (ConstraintCode == "X")
         return InlineAsm::Constraint_X;
       return TargetLowering::getInlineAsmMemConstraint(ConstraintCode);
     }
 
     /// Given a physical register constraint
     /// (e.g. {edx}), return the register number and the register class for the
     /// register.  This should only be used for C_Register constraints.  On

test/CodeGen/X86/inline-asm-V-constraint.ll

+; RUN: llc -mtriple=x86_64-pc-linux-gnu < %s | FileCheck %s
+
+@foobar = common global i32 0, align 4
+
+define void @zed() nounwind {
+entry:
+  call void asm "nop", "=*V,~{dirflag},~{fpsr},~{flags}"(i32* @foobar) nounwind
+  ret void
+}
+
+; CHECK: zed
+; CHECK: nop