WIP: Unwindabort: Add "unwindabort" syntax for the "catchswitch" instruction.

[jyknight]

Summary

This is part of a series of changes to enable generating more
efficient code for C++ "noexcept" functions. See also the RFC,
https://discourse.llvm.org/t/rfc-add-call-unwindabort-to-llvm-ir/62543

The 'unwindabort' modifier specifies that if none of the handlers
match, execution should abort the program (instead of unwinding to a
specified block, or to the parent function).

This commit adds only the core textual and bitcode IR parsing/writing
for the 'unwindabort' instruction.

Depends on D141914

[arsenm]

Would you mind adding this to the llvm-reduce instruction flag reduction?

[arsenm]

In D141915#4059267, @arsenm wrote:

Would you mind adding this to the llvm-reduce instruction flag reduction?

Maybe not the right place, but I think llvm-reduce should be kept in sync or at least tested with any new ir changes

[jyknight]

Rebase patch.

llvm/docs/LangRef.rst

 
 Syntax:
 """""""
 
 ::
 
       <resultval> = catchswitch within <parent> [ label <handler1>, label <handler2>, ... ] unwind to caller
       <resultval> = catchswitch within <parent> [ label <handler1>, label <handler2>, ... ] unwind label <default>
+      <resultval> = catchswitch within <parent> [ label <handler1>, label <handler2>, ... ] unwindabort
 
 Overview:
 """""""""
 
 The '``catchswitch``' instruction is used by `LLVM's exception handling system
 <ExceptionHandling.html#overview>`_ to describe the set of possible catch handlers
 that may be executed by the :ref:`EH personality routine <personalityfn>`.
 

 the `exception handling documentation\ <ExceptionHandling.html#wineh-constraints>`_.
 
 The ``handlers`` are a nonempty list of successor blocks that each begin with a
 :ref:`catchpad <i_catchpad>` instruction.
 
 Semantics:
 """"""""""
 
-Executing this instruction transfers control to one of the successors in
-``handlers``, if appropriate, or continues to unwind via the unwind label if
-present.
+Executing this instruction transfers control to one of the successors
+in ``handlers``, if appropriate. If no handler matches, continues to
+unwind to the parent function (``unwind to caller``), to the
+specified unwind label (``unwind label <default>``), or, aborts the
+program (``unwindabort``). See also the description of ``unwindabort`` for the
+:ref:`call <i_call>` instruction.
 
 The ``catchswitch`` is both a terminator and a "pad" instruction, meaning that
 it must be both the first non-phi instruction and last instruction in the basic
 block. Therefore, it must be the only non-phi instruction in the block.
 
 Example:
 """"""""
 

llvm/include/llvm/IR/Instructions.h

 
 DEFINE_TRANSPARENT_OPERAND_ACCESSORS(ResumeInst, Value)
 
 //===----------------------------------------------------------------------===//
 //                         CatchSwitchInst Class
 //===----------------------------------------------------------------------===//
 class CatchSwitchInst : public Instruction {
   using UnwindDestField = BoolBitfieldElementT<0>;
+  using UnwindAbortField = BoolBitfieldElementT<1>;
 
   /// The number of operands actually allocated.  NumOperands is
   /// the number actually in use.
   unsigned ReservedSpace;
 
   // Operand[0] = Outer scope
   // Operand[1] = Unwind block destination
   // Operand[n] = BasicBlock to go to on match
public:
   /// Provide fast operand accessors
   DECLARE_TRANSPARENT_OPERAND_ACCESSORS(Value);
 
   // Accessor Methods for CatchSwitch stmt
   Value *getParentPad() const { return getOperand(0); }
   void setParentPad(Value *ParentPad) { setOperand(0, ParentPad); }
 
   // Accessor Methods for CatchSwitch stmt
+  bool isUnwindAbort() const { return getSubclassData<UnwindAbortField>(); }
+  void setUnwindAbort(bool IsUA = true) {
+    setSubclassData<UnwindAbortField>(IsUA);
+  }
+
   bool hasUnwindDest() const { return getSubclassData<UnwindDestField>(); }
   bool unwindsToCaller() const { return !hasUnwindDest(); }
   BasicBlock *getUnwindDest() const {
     if (hasUnwindDest())
       return cast<BasicBlock>(getOperand(1));
     return nullptr;
   }
   void setUnwindDest(BasicBlock *UnwindDest) {

llvm/lib/AsmParser/LLParser.cpp

do {
     if (parseTypeAndBasicBlock(DestBB, PFS))
       return true;
     Table.push_back(DestBB);
   } while (EatIfPresent(lltok::comma));
 
   if (parseToken(lltok::rsquare, "expected ']' after catchswitch labels"))
     return true;
 
-  if (parseToken(lltok::kw_unwind, "expected 'unwind' after catchswitch scope"))
+  bool UnwindAbort = false;
+  BasicBlock *UnwindBB = nullptr;
+  if (Lex.getKind() == lltok::kw_unwindabort) {
+    Lex.Lex();
+    UnwindAbort = true;
+  } else {
+    if (parseToken(lltok::kw_unwind,
+                   "expected 'unwind' after catchswitch scope"))
       return true;
 
-  BasicBlock *UnwindBB = nullptr;
     if (EatIfPresent(lltok::kw_to)) {
       if (parseToken(lltok::kw_caller, "expected 'caller' in catchswitch"))
         return true;
     } else {
       if (parseTypeAndBasicBlock(UnwindBB, PFS))
         return true;
     }
-
+  }
   auto *CatchSwitch =
       CatchSwitchInst::Create(ParentPad, UnwindBB, Table.size());
+  CatchSwitch->setUnwindAbort(UnwindAbort);
   for (BasicBlock *DestBB : Table)
     CatchSwitch->addHandler(DestBB);
   Inst = CatchSwitch;
   return false;
 }
 
 /// parseCatchPad
 ///   ::= 'catchpad' ParamList 'to' TypeAndValue 'unwind' TypeAndValue

llvm/lib/Bitcode/Reader/BitcodeReader.cpp

case bitc::FUNC_CODE_INST_CATCHSWITCH: { // CATCHSWITCH: [tok,num,(bb)*,bb?]
       for (unsigned Op = 0; Op != NumHandlers; ++Op) {
         BasicBlock *BB = getBasicBlock(Record[Idx++]);
         if (!BB)
           return error("Invalid record");
         Handlers.push_back(BB);
       }
 
       BasicBlock *UnwindDest = nullptr;
+      bool UnwindAbort = false;
       if (Idx + 1 == Record.size()) {
-        UnwindDest = getBasicBlock(Record[Idx++]);
+        if (Record[Idx] == FunctionBBs.size()) {
+          // Uses numBBs+1 as flag for unwindabort.
+          UnwindAbort = true;
+        } else {
+          UnwindDest = getBasicBlock(Record[Idx]);
           if (!UnwindDest)
             return error("Invalid record");
         }
+        Idx++;
+      }
 
       if (Record.size() != Idx)
         return error("Invalid record");
 
       auto *CatchSwitch =
           CatchSwitchInst::Create(ParentPad, UnwindDest, NumHandlers);
+      CatchSwitch->setUnwindAbort(UnwindAbort);
       for (BasicBlock *Handler : Handlers)
         CatchSwitch->addHandler(Handler);
       I = CatchSwitch;
       ResTypeID = getVirtualTypeID(I->getType());
       InstructionList.push_back(I);
       break;
     }
     case bitc::FUNC_CODE_INST_CATCHPAD:

llvm/lib/Bitcode/Writer/BitcodeWriter.cpp

case Instruction::CatchSwitch: {
 
     unsigned NumHandlers = CatchSwitch.getNumHandlers();
     Vals.push_back(NumHandlers);
     for (const BasicBlock *CatchPadBB : CatchSwitch.handlers())
       Vals.push_back(VE.getValueID(CatchPadBB));
 
     if (CatchSwitch.hasUnwindDest())
       Vals.push_back(VE.getValueID(CatchSwitch.getUnwindDest()));
+    else if (CatchSwitch.isUnwindAbort()) {
+      // The unwindabort destination is represented by an invalid (one-past-end)
+      // basic-block-id.
+      Vals.push_back(VE.getBasicBlocks().size());
+    }
     break;
   }
   case Instruction::CallBr: {
     const CallBrInst *CBI = cast<CallBrInst>(&I);
     const Value *Callee = CBI->getCalledOperand();
     FunctionType *FTy = CBI->getFunctionType();
 
     if (CBI->hasOperandBundles())

llvm/lib/IR/AsmWriter.cpp

if (isa<BranchInst>(I) && cast<BranchInst>(I).isConditional()) {
     Out << " [";
     unsigned Op = 0;
     for (const BasicBlock *PadBB : CatchSwitch->handlers()) {
       if (Op > 0)
         Out << ", ";
       writeOperand(PadBB, /*PrintType=*/true);
       ++Op;
     }
-    Out << "] unwind ";
-    if (const BasicBlock *UnwindDest = CatchSwitch->getUnwindDest())
+    Out << "]";
+    if (CatchSwitch->isUnwindAbort()) {
+      Out << " unwindabort";
+    } else if (const BasicBlock *UnwindDest = CatchSwitch->getUnwindDest()) {
+      Out << " unwind ";
       writeOperand(UnwindDest, /*PrintType=*/true);
-    else
-      Out << "to caller";
+    } else {
+      Out << " unwind to caller";
+    }
   } else if (const auto *FPI = dyn_cast<FuncletPadInst>(&I)) {
     Out << " within ";
     writeOperand(FPI->getParentPad(), /*PrintType=*/false);
     Out << " [";
     for (unsigned Op = 0, NumOps = FPI->arg_size(); Op < NumOps; ++Op) {
       if (Op > 0)
         Out << ", ";
       writeOperand(FPI->getArgOperand(Op), /*PrintType=*/true);

llvm/lib/IR/Instructions.cpp

CatchSwitchInst::CatchSwitchInst(Value *ParentPad, BasicBlock *UnwindDest,
   init(ParentPad, UnwindDest, NumReservedValues + 1);
   setName(NameStr);
 }
 
 CatchSwitchInst::CatchSwitchInst(const CatchSwitchInst &CSI)
     : Instruction(CSI.getType(), Instruction::CatchSwitch, nullptr,
                   CSI.getNumOperands()) {
   init(CSI.getParentPad(), CSI.getUnwindDest(), CSI.getNumOperands());
+  setUnwindAbort(CSI.isUnwindAbort());
   setNumHungOffUseOperands(ReservedSpace);
   Use *OL = getOperandList();
   const Use *InOL = CSI.getOperandList();
   for (unsigned I = 1, E = ReservedSpace; I != E; ++I)
     OL[I] = InOL[I];
 }
 
 void CatchSwitchInst::init(Value *ParentPad, BasicBlock *UnwindDest,

llvm/test/Bitcode/compatibility.ll

 
 define i32 @instructions.win_eh.1() personality i32 -3 {
 entry:
   %arg1 = alloca i32
   %arg2 = alloca i32
   invoke void @f.ccc() to label %normal unwind label %catchswitch1
   invoke void @f.ccc() to label %normal unwind label %catchswitch2
   invoke void @f.ccc() to label %normal unwind label %catchswitch3
+  invoke void @f.ccc() to label %normal unwind label %catchswitch4
 
 catchswitch1:
   %cs1 = catchswitch within none [label %catchpad1] unwind to caller
+  ; CHECK: %cs1 = catchswitch within none [label %catchpad1] unwind to caller
 
 catchpad1:
   catchpad within %cs1 []
   br label %normal
   ; CHECK: catchpad within %cs1 []
   ; CHECK-NEXT: br label %normal
 
 catchswitch2:
   %cs2 = catchswitch within none [label %catchpad2] unwind to caller
+  ; CHECK: %cs2 = catchswitch within none [label %catchpad2] unwind to caller
 
 catchpad2:
   catchpad within %cs2 [ptr %arg1]
   br label %normal
   ; CHECK: catchpad within %cs2 [ptr %arg1]
   ; CHECK-NEXT: br label %normal
 
 catchswitch3:
   %cs3 = catchswitch within none [label %catchpad3] unwind label %cleanuppad1
+  ; CHECK: %cs3 = catchswitch within none [label %catchpad3] unwind label %cleanuppad1
 
 catchpad3:
   catchpad within %cs3 [ptr %arg1, ptr %arg2]
   br label %normal
   ; CHECK: catchpad within %cs3 [ptr %arg1, ptr %arg2]
   ; CHECK-NEXT: br label %normal
 
 cleanuppad1:
   %clean.1 = cleanuppad within none []
   unreachable
   ; CHECK: %clean.1 = cleanuppad within none []
   ; CHECK-NEXT: unreachable
 
+catchswitch4:
+  %cs4 = catchswitch within none [label %catchpad4] unwindabort
+  ; CHECK:  %cs4 = catchswitch within none [label %catchpad4] unwindabort
+
+catchpad4:
+  catchpad within %cs4 [ptr %arg1, ptr %arg2]
+  br label %normal
+  ; CHECK: catchpad within %cs4 [ptr %arg1, ptr %arg2]
+  ; CHECK-NEXT: br label %normal
+
 normal:
   ret i32 0
 }
 ;
 define i32 @instructions.win_eh.2() personality i32 -4 {
 entry:
   invoke void @f.ccc() to label %invoke.cont unwind label %catchswitch