WIP: Unwindabort: Add "unwindabort" syntax for the "resume" 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 on "resume" specifies that execution should
abort in a personality-function-defined manner, instead of continuing
execution in the caller.

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

Depends on D141913

[lebedev.ri]

llvm/lib/AsmParser/LLParser.cpp

7431–7442

This should be in the previous patch

[jroelofs]

llvm/lib/IR/AsmWriter.cpp

4079–4082

[jyknight]

Rebase patch.

llvm/docs/LangRef.rst

 '``resume``' Instruction
 ^^^^^^^^^^^^^^^^^^^^^^^^
 
 Syntax:
 """""""
 
 ::
 
-      resume <type> <value>
+      resume [unwindabort] <type> <value>
 
 Overview:
 """""""""
 
 The '``resume``' instruction is a terminator instruction that has no
 successors.
 
 Arguments:
 """"""""""
 
 The '``resume``' instruction requires one argument, which must have the
 same type as the result of any '``landingpad``' instruction in the same
 function.
 
 Semantics:
 """"""""""
 
 The '``resume``' instruction resumes propagation of an existing
 (in-flight) exception whose unwinding was interrupted with a
 :ref:`landingpad <i_landingpad>` instruction.
 
+If the ``unwindabort`` flag is set, the personality function will be
+instructed to abort instead of proceeding to unwind to the
+caller. See also the description of ``unwindabort`` for the
+:ref:`call <i_call>` instruction.
+
 Example:
 """"""""
 
 .. code-block:: llvm
 
       resume { ptr, i32 } %exn
 
 .. _i_catchswitch:

llvm/include/llvm/Bitcode/LLVMBitCodes.h

enum CallMarkersFlags {
   CALL_CCONV = 1,
   CALL_MUSTTAIL = 14,
   CALL_EXPLICIT_TYPE = 15,
   CALL_NOTAIL = 16,
   CALL_FMF = 17, // Call has optional fast-math-flags.
   CALL_UNWINDABORT = 18
 };
 
+enum ResumeFlags {
+  RESUME_UNWINDABORT = 0,
+};
+
 // The function body block (FUNCTION_BLOCK_ID) describes function bodies.  It
 // can contain a constant block (CONSTANTS_BLOCK_ID).
 enum FunctionCodes {
   FUNC_CODE_DECLAREBLOCKS = 1, // DECLAREBLOCKS: [n]
 
   FUNC_CODE_INST_BINOP = 2,      // BINOP:      [opcode, ty, opval, opval]
   FUNC_CODE_INST_CAST = 3,       // CAST:       [opcode, ty, opty, opval]
   FUNC_CODE_INST_GEP_OLD = 4,    // GEP:        [n x operands]

llvm/include/llvm/IR/Instructions.h

 /// Resume the propagation of an exception.
 ///
 class ResumeInst : public Instruction {
   ResumeInst(const ResumeInst &RI);
 
   explicit ResumeInst(Value *Exn, Instruction *InsertBefore=nullptr);
   ResumeInst(Value *Exn, BasicBlock *InsertAtEnd);
 
+  using UnwindAbortField = BoolBitfieldElementT<0>;
+
 protected:
   // Note: Instruction needs to be a friend here to call cloneImpl.
   friend class Instruction;
 
   ResumeInst *cloneImpl() const;
 
 public:
   static ResumeInst *Create(Value *Exn, Instruction *InsertBefore = nullptr) {
     return new(1) ResumeInst(Exn, InsertBefore);
   }
 
   static ResumeInst *Create(Value *Exn, BasicBlock *InsertAtEnd) {
     return new(1) ResumeInst(Exn, InsertAtEnd);
   }
 
   /// Provide fast operand accessors
   DECLARE_TRANSPARENT_OPERAND_ACCESSORS(Value);
 
   /// Convenience accessor.
   Value *getValue() const { return Op<0>(); }
 
   unsigned getNumSuccessors() const { return 0; }
 
+  bool isUnwindAbort() const { return getSubclassData<UnwindAbortField>(); }
+  void setUnwindAbort(bool IsUA = true) {
+    setSubclassData<UnwindAbortField>(IsUA);
+  }
+
   // Methods for support type inquiry through isa, cast, and dyn_cast:
   static bool classof(const Instruction *I) {
     return I->getOpcode() == Instruction::Resume;
   }
   static bool classof(const Value *V) {
     return isa<Instruction>(V) && classof(cast<Instruction>(V));
   }
 

llvm/lib/AsmParser/LLParser.cpp

bool LLParser::parseInvoke(Instruction *&Inst, PerFunctionState &PFS) {
   II->setCallingConv(CC);
   II->setAttributes(PAL);
   ForwardRefAttrGroups[II] = FwdRefAttrGrps;
   Inst = II;
   return false;
 }
 
 /// parseResume
-///   ::= 'resume' TypeAndValue
+///   ::= 'resume' 'unwindabort'? TypeAndValue
 bool LLParser::parseResume(Instruction *&Inst, PerFunctionState &PFS) {
   Value *Exn; LocTy ExnLoc;
+  bool UnwindAbort = false;
+
+  if (Lex.getKind() == lltok::kw_unwindabort) {
+    Lex.Lex();
+    UnwindAbort = true;
+  }
+
   if (parseTypeAndValue(Exn, ExnLoc, PFS))
     return true;
 
   ResumeInst *RI = ResumeInst::Create(Exn);
+  if (UnwindAbort)
+    RI->setUnwindAbort();
+
   Inst = RI;
   return false;
 }
 
 bool LLParser::parseExceptionArgs(SmallVectorImpl<Value *> &Args,
                                   PerFunctionState &PFS) {
   if (parseToken(lltok::lsquare, "expected '[' in catchpad/cleanuppad"))
     return true;
bool LLParser::parseFreeze(Instruction *&Inst, PerFunctionState &PFS) {
   Value *Op;
   if (parseTypeAndValue(Op, Loc, PFS))
     return true;
 
   Inst = new FreezeInst(Op);
   return false;
 }
 
 /// parseCall
 ///   ::= 'call' 'unwindabort'? OptionalFastMathFlags OptionalCallingConv
 ///           OptionalAttrs Type Value ParameterList OptionalAttrs
 ///   ::= 'tail' 'call' 'unwindabort'? OptionalFastMathFlags OptionalCallingConv
 ///           OptionalAttrs Type Value ParameterList OptionalAttrs
 ///   ::= 'musttail' 'call' 'unwindabort'? OptionalFastMathFlags
 ///           OptionalCallingConv OptionalAttrs Type Value ParameterList
 ///           OptionalAttrs
 ///   ::= 'notail' 'call'  'unwindabort'? OptionalFastMathFlags
 ///           OptionalCallingConv OptionalAttrs Type Value ParameterList
 ///           OptionalAttrs
 bool LLParser::parseCall(Instruction *&Inst, PerFunctionState &PFS,
                          CallInst::TailCallKind TCK) {
   AttrBuilder RetAttrs(M->getContext()), FnAttrs(M->getContext());
   std::vector<unsigned> FwdRefAttrGrps;
   LocTy BuiltinLoc;
   unsigned CallAddrSpace;
   unsigned CC;
   Type *RetType = nullptr;
   LocTy RetTypeLoc;

llvm/lib/Bitcode/Reader/BitcodeReader.cpp

case bitc::FUNC_CODE_INST_INVOKE: {
       if (Error Err = propagateAttributeTypes(cast<CallBase>(I), ArgTyIDs)) {
         I->deleteValue();
         return Err;
       }
 
       break;
     }
     case bitc::FUNC_CODE_INST_RESUME: { // RESUME: [opval]
-      unsigned Idx = 0;
+      unsigned OpNum = 0;
       Value *Val = nullptr;
       unsigned ValTypeID;
-      if (getValueTypePair(Record, Idx, NextValueNo, Val, ValTypeID, CurBB))
+      if (getValueTypePair(Record, OpNum, NextValueNo, Val, ValTypeID, CurBB))
         return error("Invalid record");
       I = ResumeInst::Create(Val);
+      unsigned Flags = 0;
+      if (OpNum < Record.size())
+        Flags = Record[OpNum++];
+      if (Flags & (1 << bitc::RESUME_UNWINDABORT))
+        cast<ResumeInst>(I)->setUnwindAbort();
+
       InstructionList.push_back(I);
       break;
     }
     case bitc::FUNC_CODE_INST_CALLBR: {
       // CALLBR: [attr, cc, norm, transfs, fty, fnid, args]
       unsigned OpNum = 0;
       AttributeList PAL = getAttributes(Record[OpNum++]);
       unsigned CCInfo = Record[OpNum++];

llvm/lib/Bitcode/Writer/BitcodeWriter.cpp

case Instruction::Invoke: {
 
     // Emit type/value pairs for varargs params.
     if (FTy->isVarArg()) {
       for (unsigned i = FTy->getNumParams(), e = II->arg_size(); i != e; ++i)
         pushValueAndType(I.getOperand(i), InstID, Vals); // vararg
     }
     break;
   }
-  case Instruction::Resume:
+  case Instruction::Resume: {
     Code = bitc::FUNC_CODE_INST_RESUME;
+    unsigned Flags = 0;
+    if (cast<ResumeInst>(I).isUnwindAbort())
+      Flags |= 1 << bitc::RESUME_UNWINDABORT;
     pushValueAndType(I.getOperand(0), InstID, Vals);
+    Vals.push_back(Flags);
     break;
+  }
   case Instruction::CleanupRet: {
     Code = bitc::FUNC_CODE_INST_CLEANUPRET;
     const auto &CRI = cast<CleanupReturnInst>(I);
     pushValue(CRI.getCleanupPad(), InstID, Vals);
     if (CRI.hasUnwindDest())
       Vals.push_back(VE.getValueID(CRI.getUnwindDest()));
     break;
   }

llvm/lib/IR/AsmWriter.cpp

void AssemblyWriter::printInstruction(const Instruction &I) {
 
   // If this is a volatile operation, print out the volatile marker.
   if ((isa<LoadInst>(I)  && cast<LoadInst>(I).isVolatile()) ||
       (isa<StoreInst>(I) && cast<StoreInst>(I).isVolatile()) ||
       (isa<AtomicCmpXchgInst>(I) && cast<AtomicCmpXchgInst>(I).isVolatile()) ||
       (isa<AtomicRMWInst>(I) && cast<AtomicRMWInst>(I).isVolatile()))
     Out << " volatile";
 
+  if (const ResumeInst *RI = dyn_cast<ResumeInst>(&I)) {
+    if (RI->isUnwindAbort())
+      Out << " unwindabort";
+  }
+
   // Print out optimization information.
   WriteOptimizationInfo(Out, &I);
 
   // Print out the compare instruction predicates
   if (const CmpInst *CI = dyn_cast<CmpInst>(&I))
     Out << ' ' << CI->getPredicate();
 
   // Print out the atomicrmw operation

llvm/lib/IR/Instructions.cpp

 //===----------------------------------------------------------------------===//
 //                        ResumeInst Implementation
 //===----------------------------------------------------------------------===//
 
 ResumeInst::ResumeInst(const ResumeInst &RI)
     : Instruction(Type::getVoidTy(RI.getContext()), Instruction::Resume,
                   OperandTraits<ResumeInst>::op_begin(this), 1) {
   Op<0>() = RI.Op<0>();
+  setUnwindAbort(RI.isUnwindAbort());
 }
 
 ResumeInst::ResumeInst(Value *Exn, Instruction *InsertBefore)
     : Instruction(Type::getVoidTy(Exn->getContext()), Instruction::Resume,
                   OperandTraits<ResumeInst>::op_begin(this), 1, InsertBefore) {
   Op<0>() = Exn;
 }
 

llvm/test/Bitcode/compatibility.ll

; CHECK: landingpad i32
              filter [2 x i32] zeroinitializer
              ; CHECK: filter [2 x i32] zeroinitializer
   br label %proceed
 
 proceed:
   ret void
 }
 
+define void @instructions.resume() personality i32 -1 {
+  invoke void @llvm.donothing() to label %proceed unwind label %catch1
+  invoke void @llvm.donothing() to label %proceed unwind label %catch2
+
+catch1:
+landingpad i32 cleanup
+; CHECK: resume i32 0
+resume i32 0
+
+catch2:
+landingpad i32 cleanup
+; CHECK: resume unwindabort i32 0
+resume unwindabort i32 0
+
+proceed:
+  ret void
+}
+
+
 ;; Intrinsic Functions
 
 ; Intrinsic Functions -- Variable Argument Handling
 declare void @llvm.va_start(ptr)
 declare void @llvm.va_copy(ptr, ptr)
 declare void @llvm.va_end(ptr)
 define void @instructions.va_arg(ptr %v, ...) {
   %ap = alloca ptr