WIP: Unwindabort: Add "unwindabort" syntax for the "call" 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 the call stack is unwound
due to an exception, the personality function should abort the process
instead of continuing to unwind to the caller.

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

[lebedev.ri]

llvm/test/Verifier/unwindabort-personality.ll

8

Need similar check for the cannot use musttail with unwindabort

[barannikov88]

I guess this should exposed via LLVM C API.

[jroelofs]

llvm/docs/ExceptionHandling.rst

307

suggest: s/This flag/The presence of this flag/

309

llvm/docs/LangRef.rst

11861

Maybe I missed it in the Discourse thread, but can you elaborate on why musttail and unwindabort are mutually exclusive?

llvm/include/llvm/Bitcode/LLVMBitCodes.h

529

Trailing comma makes this nicer for the next addition to the list.

llvm/lib/IR/Verifier.cpp

3640–3644

[jroelofs]

I think this deserves an entry in llvm/utils/vim/syntax/llvm.vim under keywords.

[jroelofs]

llvm/docs/LangRef.rst

11861

Oh, I see this is answered in a comment in a later patch:

// A call marked unwindabort cannot be tail called, because the unwinder must
// examine the call frame.

Probably worth sticking some or all of that note here.

[jroelofs]

llvm/docs/LangRef.rst

11892

[jyknight]

Rebase patch.

[jyknight]

In D141913#4059739, @barannikov88 wrote:

I guess this should exposed via LLVM C API.

Adding a new patch to the series for this.

In D141913#4537106, @jroelofs wrote:

I think this deserves an entry in llvm/utils/vim/syntax/llvm.vim under keywords.

Done. Also emacs/llvm-mode.el.

llvm/test/Verifier/unwindabort-personality.ll

8

That test (musttail-invalid.ll) had been previously added to the wrong commit in this series. Corrected.

llvm/docs/ExceptionHandling.rst

 a call to ``__cxa_call_unexpected`` should be made, otherwise
 ``_Unwind_Resume``.  Each of these functions requires a reference to the
 exception structure.  Note that the most general form of a ``landingpad``
 instruction can have any number of catch, cleanup, and filter clauses (though
 having more than one cleanup is pointless). The LLVM C++ front-end can generate
 such ``landingpad`` instructions due to inlining creating nested exception
 handling scopes.
 
+Noexcept
+--------
+
+C++11 added the `noexcept` qualifier on functions, which specifies that if any
+exceptions are thrown out of the function, the program should abort. Unlike
+dynamic exception specifiers (e.g. `throw(ExcType...)`), `noexcept` does not
+require the stack to be fully unwound (and all destructors called) along the way
+to program termination. This allowance is specified in order to allow for more
+efficient code generation, and more optimization opportunities.
+
+In order to efficiently support these semantics, LLVM's :ref:`i_call` has an
+`unwindabort` flag. This flag causes construction of the unwind tables to mark
+the callsite in such a way that the personality function knows to call
+std::terminate if an unwind is attempted through this stack frame -- without
+requiring the generation of a landingpad containing an explicit terminate call,
+and a corresponding usage of ``invoke`` for all calls within the function.
+
+Furthermore, this flag allows the inliner to delete a ``cleanuppad`` or a
+``landingpad`` with only a *cleanup* clause which is inlined through an
+``unwindabort``. (It's "as if" the unwinder only partially unwound before
+terminating the program, which is permitted.)
+
 Restrictions
 ------------
 
 The unwinder delegates the decision of whether to stop in a call frame to that
 call frame's language-specific personality function. Not all unwinders guarantee
 that they will stop to perform cleanups. For example, the GNU C++ unwinder
 doesn't do so unless the exception is actually caught somewhere further up the
 stack.

llvm/docs/LangRef.rst

 '``call``' Instruction
 ^^^^^^^^^^^^^^^^^^^^^^
 
 Syntax:
 """""""
 
 ::
 
-      <result> = [tail | musttail | notail ] call [fast-math flags] [cconv] [ret attrs] [addrspace(<num>)]
+      <result> = [tail | musttail | notail ] call [unwindabort] [fast-math flags] [cconv] [ret attrs] [addrspace(<num>)]
                  <ty>|<fnty> <fnptrval>(<function args>) [fn attrs] [ operand bundles ]
 
 Overview:
 """""""""
 
 The '``call``' instruction represents a simple function call.
 
 Arguments:
- The call must immediately precede a :ref:`ret <i_ret>` instruction,
      or a pointer bitcast followed by a ret instruction.
    - The ret instruction must return the (possibly bitcasted) value
      produced by the call, undef, or void.
    - The calling conventions of the caller and callee must match.
    - The callee must be varargs iff the caller is varargs. Bitcasting a
      non-varargs function to the appropriate varargs type is legal so
      long as the non-varargs prefixes obey the other rules.
    - The return type must not undergo automatic conversion to an `sret` pointer.
+   - The call cannot be 'unwindabort'.
 
   In addition, if the calling convention is not `swifttailcc` or `tailcc`:
 
    - All ABI-impacting function attributes, such as sret, byval, inreg,
      returned, and inalloca, must match.
    - The caller and callee prototypes must match. Pointer types of parameters
      or return types may differ in pointee type, but not in address space.
 
-  Option ``-tailcallopt`` is enabled,
       is ``tailcc``
    -  `Platform-specific constraints are
       met. <CodeGenerator.html#tailcallopt>`_
 
 #. The optional ``notail`` marker indicates that the optimizers should not add
    ``tail`` or ``musttail`` markers to the call. It is used to prevent tail
    call optimization from being performed on the call.
 
+#. The optional '``unwindabort``' marker is used by `LLVM's exception
+   handling system <ExceptionHandling.html#overview>`_ to specify that
+   if the call stack is being unwound due to an exception, the
+   :ref:`personality function <personalityfn>` should abort the
+   process instead of continuing to unwind to the caller.
+
+   It is unspecified whether any intermediate *cleanup*
+   :ref:`landingpad <i_landingpad>` or :ref:`cleanuppad
+   <i_cleanuppad>` handlers are called during the unwind process, when
+   unwinding into an ``unwindabort``. (The compiler may omit any
+   cleanup which would resume execution only through ``unwindabort``,
+   or the personality function may simply not call cleanups once it
+   discovers it needs to abort.)
+
 #. The optional ``fast-math flags`` marker indicates that the call has one or more
    :ref:`fast-math flags <fastmath>`, which are optimization hints to enable
    otherwise unsafe floating-point optimizations. Fast-math flags are only valid
    for calls that return a floating-point scalar or vector type, or an array
    (nested to any depth) of floating-point scalar or vector types.
 
 #. The optional "cconv" marker indicates which :ref:`calling
    convention <callingconv>` the call should use. If none is

llvm/include/llvm/AsmParser/LLToken.h

enum Kind {
   kw_none,
   kw_to,
   kw_caller,
   kw_within,
   kw_from,
   kw_tail,
   kw_musttail,
   kw_notail,
+  kw_unwindabort,
   kw_target,
   kw_triple,
   kw_source_filename,
   kw_unwind,
   kw_datalayout,
   kw_volatile,
   kw_atomic,
   kw_unordered,

llvm/include/llvm/Bitcode/LLVMBitCodes.h

 
 /// Markers and flags for call instruction.
 enum CallMarkersFlags {
   CALL_TAIL = 0,
   CALL_CCONV = 1,
   CALL_MUSTTAIL = 14,
   CALL_EXPLICIT_TYPE = 15,
   CALL_NOTAIL = 16,
-  CALL_FMF = 17 // Call has optional fast-math-flags.
+  CALL_FMF = 17, // Call has optional fast-math-flags.
+  CALL_UNWINDABORT = 18
 };
 
 // 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]

llvm/include/llvm/IR/InstrTypes.h

public:
 
   /// Tests if this call site must be tail call optimized. Only a CallInst can
   /// be tail call optimized.
   bool isMustTailCall() const;
 
   /// Tests if this call site is marked as a tail call.
   bool isTailCall() const;
 
+  /// Tests if this call site is marked 'unwindabort'.
+  bool isUnwindAbort() const;
+
   /// Returns the intrinsic ID of the intrinsic called or
   /// Intrinsic::not_intrinsic if the called function is not an intrinsic, or if
   /// this is an indirect call.
   Intrinsic::ID getIntrinsicID() const;
 
   void setCalledOperand(Value *V) { Op<CalledOperandOpEndIdx>() = V; }
 
   /// Sets the function called, including updating the function type.

llvm/include/llvm/IR/Instructions.h

enum TailCallKind : unsigned {
     TCK_LAST = TCK_NoTail
   };
 
   using TailCallKindField = Bitfield::Element<TailCallKind, 0, 2, TCK_LAST>;
   static_assert(
       Bitfield::areContiguous<TailCallKindField, CallBase::CallingConvField>(),
       "Bitfields must be contiguous");
 
+  using UnwindAbortField = BoolBitfieldElementT<CallingConvField::NextBit>;
+  static_assert(
+      Bitfield::areContiguous<CallBase::CallingConvField, UnwindAbortField>(),
+      "Bitfields must be contiguous");
+
   TailCallKind getTailCallKind() const {
     return getSubclassData<TailCallKindField>();
   }
 
   bool isTailCall() const {
     TailCallKind Kind = getTailCallKind();
     return Kind == TCK_Tail || Kind == TCK_MustTail;
   }
 
   bool isMustTailCall() const { return getTailCallKind() == TCK_MustTail; }
 
   bool isNoTailCall() const { return getTailCallKind() == TCK_NoTail; }
 
   void setTailCallKind(TailCallKind TCK) {
     setSubclassData<TailCallKindField>(TCK);
   }
 
   void setTailCall(bool IsTc = true) {
     setTailCallKind(IsTc ? TCK_Tail : TCK_None);
   }
 
+  bool isUnwindAbort() const { return getSubclassData<UnwindAbortField>(); }
+  void setUnwindAbort(bool IsUA = true) {
+    setSubclassData<UnwindAbortField>(IsUA);
+  }
+
   /// Return true if the call can return twice
   bool canReturnTwice() const { return hasFnAttr(Attribute::ReturnsTwice); }
   void setCanReturnTwice() { addFnAttr(Attribute::ReturnsTwice); }
 
   // Methods for support type inquiry through isa, cast, and dyn_cast:
   static bool classof(const Instruction *I) {
     return I->getOpcode() == Instruction::Call;
   }

llvm/lib/AsmParser/LLLexer.cpp

#define KEYWORD(STR)                                                           \
   KEYWORD(poison);
   KEYWORD(to);
   KEYWORD(caller);
   KEYWORD(within);
   KEYWORD(from);
   KEYWORD(tail);
   KEYWORD(musttail);
   KEYWORD(notail);
+  KEYWORD(unwindabort);
   KEYWORD(target);
   KEYWORD(triple);
   KEYWORD(source_filename);
   KEYWORD(unwind);
   KEYWORD(datalayout);
   KEYWORD(volatile);
   KEYWORD(atomic);
   KEYWORD(unordered);

llvm/lib/AsmParser/LLParser.cpp

bool LLParser::parseCall(Instruction *&Inst, PerFunctionState &PFS,
   unsigned CallAddrSpace;
   unsigned CC;
   Type *RetType = nullptr;
   LocTy RetTypeLoc;
   ValID CalleeID;
   SmallVector<ParamInfo, 16> ArgList;
   SmallVector<OperandBundleDef, 2> BundleList;
   LocTy CallLoc = Lex.getLoc();
+  bool UnwindAbort = false;
 
   if (TCK != CallInst::TCK_None &&
       parseToken(lltok::kw_call,
                  "expected 'tail call', 'musttail call', or 'notail call'"))
     return true;
 
+  if (Lex.getKind() == lltok::kw_unwindabort) {
+    Lex.Lex();
+    UnwindAbort = true;
+  }
+
   FastMathFlags FMF = EatFastMathFlagsIfPresent();
 
   if (parseOptionalCallingConv(CC) || parseOptionalReturnAttrs(RetAttrs) ||
       parseOptionalProgramAddrSpace(CallAddrSpace) ||
       parseType(RetType, RetTypeLoc, true /*void allowed*/) ||
       parseValID(CalleeID, &PFS) ||
       parseParameterList(ArgList, PFS, TCK == CallInst::TCK_MustTail,
                          PFS.getFunction().isVarArg()) ||
bool LLParser::parseCall(Instruction *&Inst, PerFunctionState &PFS,
 
   // Finish off the Attribute and check them
   AttributeList PAL =
       AttributeList::get(Context, AttributeSet::get(Context, FnAttrs),
                          AttributeSet::get(Context, RetAttrs), Attrs);
 
   CallInst *CI = CallInst::Create(Ty, Callee, Args, BundleList);
   CI->setTailCallKind(TCK);
+  CI->setUnwindAbort(UnwindAbort);
   CI->setCallingConv(CC);
   if (FMF.any()) {
     if (!isa<FPMathOperator>(CI)) {
       CI->deleteValue();
       return error(CallLoc, "fast-math-flags specified for call without "
                             "floating-point scalar or vector return type");
     }
     CI->setFastMathFlags(FMF);

llvm/lib/Bitcode/Reader/BitcodeReader.cpp

case bitc::FUNC_CODE_INST_CALL: {
       // Upgrade the bundles if needed.
       if (!OperandBundles.empty())
         UpgradeOperandBundles(OperandBundles);
 
       I = CallInst::Create(FTy, Callee, Args, OperandBundles);
       ResTypeID = getContainedTypeID(FTyID);
       OperandBundles.clear();
       InstructionList.push_back(I);
+      if (CCInfo & (1 << bitc::CALL_UNWINDABORT))
+        cast<CallInst>(I)->setUnwindAbort(true);
       cast<CallInst>(I)->setCallingConv(
           static_cast<CallingConv::ID>((0x7ff & CCInfo) >> bitc::CALL_CCONV));
       CallInst::TailCallKind TCK = CallInst::TCK_None;
       if (CCInfo & 1 << bitc::CALL_TAIL)
         TCK = CallInst::TCK_Tail;
       if (CCInfo & (1 << bitc::CALL_MUSTTAIL))
         TCK = CallInst::TCK_MustTail;
       if (CCInfo & (1 << bitc::CALL_NOTAIL))

llvm/lib/Bitcode/Writer/BitcodeWriter.cpp

case Instruction::Call: {
     Vals.push_back(VE.getAttributeListID(CI.getAttributes()));
 
     unsigned Flags = getOptimizationFlags(&I);
     Vals.push_back(CI.getCallingConv() << bitc::CALL_CCONV |
                    unsigned(CI.isTailCall()) << bitc::CALL_TAIL |
                    unsigned(CI.isMustTailCall()) << bitc::CALL_MUSTTAIL |
                    1 << bitc::CALL_EXPLICIT_TYPE |
                    unsigned(CI.isNoTailCall()) << bitc::CALL_NOTAIL |
-                   unsigned(Flags != 0) << bitc::CALL_FMF);
+                   unsigned(Flags != 0) << bitc::CALL_FMF |
+                   unsigned(CI.isUnwindAbort()) << bitc::CALL_UNWINDABORT);
     if (Flags != 0)
       Vals.push_back(Flags);
 
     Vals.push_back(VE.getTypeID(FTy));
     pushValueAndType(CI.getCalledOperand(), InstID, Vals); // Callee
 
     // Emit value #'s for the fixed parameters.
     for (unsigned i = 0, e = FTy->getNumParams(); i != e; ++i) {

llvm/lib/IR/AsmWriter.cpp

if (isa<BranchInst>(I) && cast<BranchInst>(I).isConditional()) {
     writeOperand(CRI->getOperand(0), /*PrintType=*/false);
 
     Out << " unwind ";
     if (CRI->hasUnwindDest())
       writeOperand(CRI->getOperand(1), /*PrintType=*/true);
     else
       Out << "to caller";
   } else if (const CallInst *CI = dyn_cast<CallInst>(&I)) {
+    if (CI->isUnwindAbort())
+      Out << " unwindabort";
+
     // Print the calling convention being used.
     if (CI->getCallingConv() != CallingConv::C) {
       Out << " ";
       PrintCallingConv(CI->getCallingConv(), Out);
     }
 
     Operand = CI->getCalledOperand();
     FunctionType *FTy = CI->getFunctionType();

llvm/lib/IR/Instructions.cpp

 
 /// Tests if this call site is marked as a tail call.
 bool CallBase::isTailCall() const {
   if (auto *CI = dyn_cast<CallInst>(this))
     return CI->isTailCall();
   return false;
 }
 
+bool CallBase::isUnwindAbort() const {
+  if (auto *CI = dyn_cast<CallInst>(this))
+    return CI->isUnwindAbort();
+  return false;
+}
+
 Intrinsic::ID CallBase::getIntrinsicID() const {
   if (auto *F = getCalledFunction())
     return F->getIntrinsicID();
   return Intrinsic::not_intrinsic;
 }
 
 bool CallBase::isReturnNonNull() const {
   if (hasRetAttr(Attribute::NonNull))
: CallBase(Ty->getReturnType(), Instruction::Call,
                OperandTraits<CallBase>::op_end(this) - 1, 1, InsertAtEnd) {
   init(Ty, Func, Name);
 }
 
 CallInst::CallInst(const CallInst &CI)
     : CallBase(CI.Attrs, CI.FTy, CI.getType(), Instruction::Call,
                OperandTraits<CallBase>::op_end(this) - CI.getNumOperands(),
                CI.getNumOperands()) {
+  setUnwindAbort(CI.isUnwindAbort());
   setTailCallKind(CI.getTailCallKind());
   setCallingConv(CI.getCallingConv());
 
   std::copy(CI.op_begin(), CI.op_end(), op_begin());
   std::copy(CI.bundle_op_info_begin(), CI.bundle_op_info_end(),
             bundle_op_info_begin());
   SubclassOptionalData = CI.SubclassOptionalData;
 }
 
 CallInst *CallInst::Create(CallInst *CI, ArrayRef<OperandBundleDef> OpB,
                            Instruction *InsertPt) {
   std::vector<Value *> Args(CI->arg_begin(), CI->arg_end());
 
   auto *NewCI = CallInst::Create(CI->getFunctionType(), CI->getCalledOperand(),
                                  Args, OpB, CI->getName(), InsertPt);
+  NewCI->setUnwindAbort(CI->isUnwindAbort());
   NewCI->setTailCallKind(CI->getTailCallKind());
   NewCI->setCallingConv(CI->getCallingConv());
   NewCI->SubclassOptionalData = CI->SubclassOptionalData;
   NewCI->setAttributes(CI->getAttributes());
   NewCI->setDebugLoc(CI->getDebugLoc());
   return NewCI;
 }
 

llvm/lib/IR/Verifier.cpp

if (Attrs.hasParamAttr(I, Attribute::Alignment) &&
       (Attrs.hasParamAttr(I, Attribute::ByVal) ||
        Attrs.hasParamAttr(I, Attribute::ByRef)))
     Copy.addAlignmentAttr(Attrs.getParamAlignment(I));
   return Copy;
 }
 
 void Verifier::verifyMustTailCall(CallInst &CI) {
   Check(!CI.isInlineAsm(), "cannot use musttail call with inline asm", &CI);
+  Check(!CI.isUnwindAbort(), "cannot use musttail with unwindabort", &CI);
 
   Function *F = CI.getParent()->getParent();
   FunctionType *CallerTy = F->getFunctionType();
   FunctionType *CalleeTy = CI.getFunctionType();
+
   Check(CallerTy->isVarArg() == CalleeTy->isVarArg(),
         "cannot guarantee tail call due to mismatched varargs", &CI);
   Check(isTypeCongruent(CallerTy->getReturnType(), CalleeTy->getReturnType()),
         "cannot guarantee tail call due to mismatched return types", &CI);
 
   // - The calling conventions of the caller and callee must match.
   Check(F->getCallingConv() == CI.getCallingConv(),
         "cannot guarantee tail call due to mismatched calling conv", &CI);
Check(CallerABIAttrs == CalleeABIAttrs,
           "function attributes",
           &CI, CI.getOperand(I));
   }
 }
 
 void Verifier::visitCallInst(CallInst &CI) {
   visitCallBase(CI);
 
+  if (CI.isUnwindAbort()) {
+    Check(CI.getFunction()->hasPersonalityFn(),
+          "Call with unwindabort needs to be in a function with a personality.",
+          &CI);
+  }
+
   if (CI.isMustTailCall())
     verifyMustTailCall(CI);
 }
 
 void Verifier::visitInvokeInst(InvokeInst &II) {
   visitCallBase(II);
 
   // Verify that the first non-PHI instruction of the unwind destination is an

llvm/test/Bitcode/compatibility.ll

 
 define void @instructions.call_notail() {
   notail call void @f1()
   ; CHECK: notail call void @f1()
 
   ret void
 }
 
+define void @instructions.call_unwindabort() personality i32 -2 {
+  call unwindabort void @f1()
+  ; CHECK: call unwindabort void @f1()
+  ret void
+}
+
 define void @instructions.landingpad() personality i32 -2 {
   invoke void @llvm.donothing() to label %proceed unwind label %catch1
   invoke void @llvm.donothing() to label %proceed unwind label %catch2
   invoke void @llvm.donothing() to label %proceed unwind label %catch3
   invoke void @llvm.donothing() to label %proceed unwind label %catch4
 
 catch1:
   landingpad i32

llvm/test/Verifier/unwindabort-personality.ll

+; RUN: not llvm-as < %s -o /dev/null 2>&1 | FileCheck %s
+
+declare void @fn()
+define void @test1() {
+entry:
+  call unwindabort void @fn()
+  ret void
+; CHECK: Call with unwindabort needs to be in a function with a personality.
+}