[LLVM][Convergence] further refactor convergence verifier

[sameerds]

Summary

This is in preparation for using the same convergence verifier for both LLVM IR
and Machine IR.

[yassingh]

LGTM but kindly wait for other reviewers to have a look

llvm/include/llvm/ADT/GenericConvergenceVerifier.h

enum {
     UncontrolledConvergence,
     NoConvergence
   } ConvergenceKind = NoConvergence;
 
   // Cache token uses found so far. Note that we track the unique definitions
   // and not the token values.
   DenseMap<const InstructionT *, const InstructionT *> Tokens;
 
+  static bool isInsideConvergentFunction(const InstructionT &I);
+  static bool isConvergent(const InstructionT &I);
   const InstructionT *findAndCheckConvergenceTokenUsed(const InstructionT &I);
-  bool isControlledConvergent(const InstructionT &I);
-  bool isConvergent(const InstructionT &I) const;
 
   void reportFailure(const Twine &Message, ArrayRef<Printable> Values);
 };
 
 } // end namespace llvm
 
 #endif // LLVM_ADT_GENERICCONVERGENCEVERIFIER_H

llvm/include/llvm/IR/GenericConvergenceVerifierImpl.h

 template <class ContextT> void GenericConvergenceVerifier<ContextT>::clear() {
   Tokens.clear();
   CI.clear();
   ConvergenceKind = NoConvergence;
 }
 
 template <class ContextT>
 void GenericConvergenceVerifier<ContextT>::visit(const InstructionT &I) {
-  if (isControlledConvergent(I)) {
+  auto ID = ContextT::getIntrinsicID(I);
+  auto *TokenDef = findAndCheckConvergenceTokenUsed(I);
+
+  bool IsCtrlIntrinsic = true;
+
+  switch (ID) {
+  case Intrinsic::experimental_convergence_entry:
+    Check(isInsideConvergentFunction(I),
+          "Entry intrinsic can occur only in a convergent function.",
+          {Context.print(&I)});
+    Check(I.getParent()->isEntryBlock(),
+          "Entry intrinsic can occur only in the entry block.",
+          {Context.print(&I)});
+    Check(I.getParent()->getFirstNonPHI() == &I,
+          "Entry intrinsic can occur only at the start of the basic block.",
+          {Context.print(&I)});
+    LLVM_FALLTHROUGH;
+  case Intrinsic::experimental_convergence_anchor:
+    Check(!TokenDef,
+          "Entry or anchor intrinsic cannot have a convergencectrl token "
+          "operand.",
+          {Context.print(&I)});
+    break;
+  case Intrinsic::experimental_convergence_loop:
+    Check(TokenDef, "Loop intrinsic must have a convergencectrl token operand.",
+          {Context.print(&I)});
+    Check(I.getParent()->getFirstNonPHI() == &I,
+          "Loop intrinsic can occur only at the start of the basic block.",
+          {Context.print(&I)});
+    break;
+  default:
+    IsCtrlIntrinsic = false;
+    break;
+  }
+
+  if (TokenDef || IsCtrlIntrinsic) {
     Check(isConvergent(I),
-          "Expected convergent attribute on a controlled convergent call.",
+          "Convergence control token can only be used in a convergent call.",
           {Context.print(&I)});
     Check(ConvergenceKind != UncontrolledConvergence,
           "Cannot mix controlled and uncontrolled convergence in the same "
           "function.",
           {Context.print(&I)});
     ConvergenceKind = ControlledConvergence;
   } else if (isConvergent(I)) {
     Check(ConvergenceKind != ControlledConvergence,

llvm/lib/IR/ConvergenceVerifier.cpp

GenericConvergenceVerifier<SSAContext>::findAndCheckConvergenceTokenUsed(
 
   if (Def)
     Tokens[&I] = Def;
 
   return Def;
 }
 
 template <>
-bool GenericConvergenceVerifier<SSAContext>::isConvergent(
-    const InstructionT &I) const {
-  if (auto *CB = dyn_cast<CallBase>(&I)) {
-    return CB->isConvergent();
-  }
-  return false;
+bool GenericConvergenceVerifier<SSAContext>::isInsideConvergentFunction(
+    const InstructionT &I) {
+  auto *F = I.getFunction();
+  return F->isConvergent();
 }
 
 template <>
-bool GenericConvergenceVerifier<SSAContext>::isControlledConvergent(
+bool GenericConvergenceVerifier<SSAContext>::isConvergent(
     const InstructionT &I) {
-  // First find a token and place it in the map.
-  if (findAndCheckConvergenceTokenUsed(I))
-    return true;
-
-  // The entry and anchor intrinsics do not use a token, so we do a broad check
-  // here. The loop intrinsic will be checked separately for a missing token.
-  if (isConvergenceControlIntrinsic(SSAContext::getIntrinsicID(I)))
-    return true;
-
+  if (auto *CB = dyn_cast<CallBase>(&I)) {
+    return CB->isConvergent();
+  }
   return false;
 }
 
 template class llvm::GenericConvergenceVerifier<SSAContext>;

llvm/lib/IR/Verifier.cpp

case Intrinsic::amdgcn_cs_chain: {
 
     Check(Call.paramHasAttr(2, Attribute::InReg),
           "SGPR arguments must have the `inreg` attribute", &Call);
     Check(!Call.paramHasAttr(3, Attribute::InReg),
           "VGPR arguments must not have the `inreg` attribute", &Call);
     break;
   }
   case Intrinsic::experimental_convergence_entry:
-    Check(Call.getFunction()->isConvergent(),
-          "Entry intrinsic can occur only in a convergent function.", &Call);
-    Check(Call.getParent()->isEntryBlock(),
-          "Entry intrinsic must occur in the entry block.", &Call);
-    Check(Call.getParent()->getFirstNonPHI() == &Call,
-          "Entry intrinsic must occur at the start of the basic block.", &Call);
     LLVM_FALLTHROUGH;
   case Intrinsic::experimental_convergence_anchor:
-    Check(!Call.getOperandBundle(LLVMContext::OB_convergencectrl),
-          "Entry or anchor intrinsic must not have a convergencectrl bundle.",
-          &Call);
     break;
   case Intrinsic::experimental_convergence_loop:
-    Check(Call.getOperandBundle(LLVMContext::OB_convergencectrl),
-          "Loop intrinsic must have a convergencectrl bundle.", &Call);
-    Check(Call.getParent()->getFirstNonPHI() == &Call,
-          "Loop intrinsic must occur at the start of the basic block.", &Call);
     break;
   };
 
   // Verify that there aren't any unmediated control transfers between funclets.
   if (IntrinsicInst::mayLowerToFunctionCall(ID)) {
     Function *F = Call.getParent()->getParent();
     if (F->hasPersonalityFn() &&
         isScopedEHPersonality(classifyEHPersonality(F->getPersonalityFn()))) {

llvm/test/Verifier/convergencectrl-invalid.ll

 ; RUN: not llvm-as < %s -o /dev/null 2>&1 | FileCheck %s
 
-; CHECK: Entry or anchor intrinsic must not have a convergencectrl bundle.
+; CHECK: Entry or anchor intrinsic cannot have a convergencectrl token operand.
 ; CHECK-NEXT: %t04_tok2 = call token
-; CHECK: Loop intrinsic must have a convergencectrl bundle.
+; CHECK: Loop intrinsic must have a convergencectrl token operand.
 ; CHECK-NEXT: %t04_tok3 = call token
 define void @basic_syntax() {
   %t04_tok1 = call token @llvm.experimental.convergence.anchor()
   %t04_tok2 = call token @llvm.experimental.convergence.anchor() [ "convergencectrl"(token %t04_tok1) ]
   %t04_tok3 = call token @llvm.experimental.convergence.loop()
   ret void
 }
 
 ; CHECK: Convergence control tokens can only be produced by calls to the convergence control intrinsics.
 ; CHECK-NEXT:  %t04_tok1 = call token @produce_token()
 ; CHECK-NEXT:  call void @f() [ "convergencectrl"(token %t04_tok1) ]
 define void @wrong_token() {
   %t04_tok1 = call token @produce_token()
   call void @f() [ "convergencectrl"(token %t04_tok1) ]
   ret void
 }
 
-; CHECK: Expected convergent attribute on a controlled convergent call.
+; CHECK: Convergence control token can only be used in a convergent call.
 ; CHECK-NEXT  call void @g(){{.*}}%t05_tok1
 define void @missing.attribute() {
   %t05_tok1 = call token @llvm.experimental.convergence.anchor()
   call void @g() [ "convergencectrl"(token %t05_tok1) ]
   ret void
 }
 
 ; CHECK: The 'convergencectrl' bundle requires exactly one token use.
A:
   %t50_tok1 = call token @llvm.experimental.convergence.anchor()
   br label %B
 
 B:
   call void @f() [ "convergencectrl"(token %t50_tok1) ]
   br label %B
 }
 
-; CHECK: Entry intrinsic must occur at the start of the basic block.
+; CHECK: Entry intrinsic can occur only at the start of the basic block.
 ; CHECK:   %t60_tok1
 define void @entry_at_start(i32 %x, i32 %y) convergent {
   %z = add i32 %x, %y
   %t60_tok1 = call token @llvm.experimental.convergence.entry()
   ret void
 }
 
 ; CHECK: Entry intrinsic can occur only in a convergent function.
 ; CHECK:   %t60_tok2
 define void @entry_in_convergent(i32 %x, i32 %y) {
   %t60_tok2 = call token @llvm.experimental.convergence.entry()
   ret void
 }
 
-; CHECK: Loop intrinsic must occur at the start of the basic block.
+; CHECK: Loop intrinsic can occur only at the start of the basic block.
 ; CHECK:   %t60_tok3
 define void @loop_at_start(i32 %x, i32 %y) convergent {
 A:
   %t60_tok3 = call token @llvm.experimental.convergence.entry()
   br label %B
 B:
   %z = add i32 %x, %y
   %h1 = call token @llvm.experimental.convergence.loop() [ "convergencectrl"(token %t60_tok3) ]
   ret void
 }
 
-; CHECK: Entry intrinsic must occur in the entry block.
+; CHECK: Entry intrinsic can occur only in the entry block.
 ; CHECK:   %t60_tok4
 define void @entry_at_entry(i32 %x, i32 %y) convergent {
 A:
   %z = add i32 %x, %y
   br label %B
 B:
   %t60_tok4 = call token @llvm.experimental.convergence.entry()
   ret void