Annotate `llvm.eh.sjlj.setjmp` as `returns_twice`

[xtkoba]

Summary

In LLVM, some optimizations are disabled for functions that return twice. For instance, register coalescing in those functions is disabled by D77767. Currently, this does not apply to __builtin_setjmp, because the intrinsic function llvm.eh.sjlj.setjmp is not annotated as returns_twice.

In the proposed change, we annotate llvm.eh.sjlj.setjmp as returns_twice. This fixes PR50234.

[xtkoba]

• Tests revised.
• Reformatted.

[xtkoba]

It has been revealed that this also fixes PR51729.

[xtkoba]

Diff context extended

[dim]

I'm not a reviewer, but this looks good to me. (At first I thought that the required tablegen additions were missing, but they were at the end of the list of files so I missed them :) )

[jdoerfert]

LG, but I'd prefer an explicit IR test. There should be some, if not add a new one to verify we add returns twice properly.

llvm/include/llvm/IR/Intrinsics.td

 // ReadNone - The specified argument pointer is not dereferenced by the
 // intrinsic.
 class ReadNone<AttrIndex idx> : IntrinsicProperty {
   int ArgNo = idx.Value;
 }
 
 def IntrNoReturn : IntrinsicProperty;
 
+def IntrReturnsTwice : IntrinsicProperty;
+
 // IntrNoSync - Threads executing the intrinsic will not synchronize using
 // memory or other means. Applied by default.
 def IntrNoSync : IntrinsicProperty<1>;
 
 // Applied by default.
 def IntrNoFree : IntrinsicProperty<1>;
 
 // Applied by default.
def int_eh_unwind_init: Intrinsic<[]>,
                         GCCBuiltin<"__builtin_unwind_init">;
 
 def int_eh_dwarf_cfa  : Intrinsic<[llvm_ptr_ty], [llvm_i32_ty]>;
 
 def int_eh_sjlj_lsda             : Intrinsic<[llvm_ptr_ty], [], [IntrNoMem]>;
 def int_eh_sjlj_callsite         : Intrinsic<[], [llvm_i32_ty], [IntrNoMem]>;
 
 def int_eh_sjlj_functioncontext : Intrinsic<[], [llvm_ptr_ty]>;
-def int_eh_sjlj_setjmp          : Intrinsic<[llvm_i32_ty], [llvm_ptr_ty]>;
+def int_eh_sjlj_setjmp          : Intrinsic<[llvm_i32_ty], [llvm_ptr_ty],
+                                            [IntrReturnsTwice]>;
 def int_eh_sjlj_longjmp         : Intrinsic<[], [llvm_ptr_ty], [IntrNoReturn]>;
 def int_eh_sjlj_setup_dispatch  : Intrinsic<[], []>;
 
 //===---------------- Generic Variable Attribute Intrinsics----------------===//
 //
 def int_var_annotation : DefaultAttrsIntrinsic<
     [], [llvm_ptr_ty, llvm_ptr_ty, llvm_ptr_ty, llvm_i32_ty, llvm_ptr_ty],
     [IntrInaccessibleMemOnly], "llvm.var.annotation">;

llvm/test/CodeGen/PowerPC/sjlj.ll

 
 ; CHECK-DAG: stfd
 ; CHECK-DAG: stxvd2x
 
 ; CHECK-DAG: addis [[REG:[0-9]+]], 2, env_sigill@toc@ha
 ; CHECK-DAG: std 31, env_sigill@toc@l([[REG]])
 ; CHECK-DAG: addi [[REGA:[0-9]+]], [[REG]], env_sigill@toc@l
 ; CHECK-DAG: std [[REGA]], [[OFF:[0-9]+]](31)                  # 8-byte Folded Spill
-; CHECK-DAG: std 1, 16([[REGA]])
+; CHECK-DAG: std 4, 16([[REGA]])
 ; CHECK-DAG: std 2, 24([[REGA]])
 ; CHECK: bcl 20, 31, .LBB1_3
 ; CHECK: li 3, 1
 ; CHECK: #EH_SjLj_Setup .LBB1_3
 ; CHECK: # %bb.1:
 
 ; CHECK: .LBB1_3:
 ; CHECK: ld [[REG2:[0-9]+]], [[OFF]](31)                   # 8-byte Folded Reload
return:                                           ; preds = %if.end, %if.then
   ret i32 %3
 
 ; CHECK-LABEL: main2:
 
 ; CHECK: addis [[REG:[0-9]+]], 2, env_sigill@toc@ha
 ; CHECK-DAG: std 31, env_sigill@toc@l([[REG]])
 ; CHECK-DAG: addi [[REGB:[0-9]+]], [[REG]], env_sigill@toc@l
 ; CHECK-DAG: std [[REGB]], [[OFF:[0-9]+]](31)                  # 8-byte Folded Spill
-; CHECK-DAG: std 1, 16([[REGB]])
+; CHECK-DAG: std 4, 16([[REGB]])
 ; CHECK-DAG: std 2, 24([[REGB]])
 ; CHECK-DAG: std 30, 32([[REGB]])
 ; CHECK: bcl 20, 31,
 
 ; CHECK: blr
 }
 
 define void @test_sjlj_setjmp() #0 {

llvm/test/CodeGen/Thumb2/setjmp_longjmp.ll

 ; NOTE: Assertions have been autogenerated by utils/update_llc_test_checks.py
 ; RUN: llc %s -o - | FileCheck %s
 target triple = "thumbv7-apple-ios"
 
 declare i32 @llvm.eh.sjlj.setjmp(i8*)
 declare void @llvm.eh.sjlj.longjmp(i8*)
 declare i8* @llvm.frameaddress(i32)
 declare i8* @llvm.stacksave()
 @g = external global i32
 
 define void @double_foobar() {
 ; CHECK-LABEL: double_foobar:
 ; CHECK:       @ %bb.0: @ %entry
 ; CHECK-NEXT:    push.w {r4, r5, r6, r7, r8, r10, r11, lr}
 ; CHECK-NEXT:    add r7, sp, #24
 ; CHECK-NEXT:    sub sp, #24
+; CHECK-NEXT:    mov r0, r7
 ; CHECK-NEXT:    movs r1, #0
+; CHECK-NEXT:    str r0, [sp, #4]
+; CHECK-NEXT:    mov r0, sp
+; CHECK-NEXT:    str r0, [sp, #12]
 ; CHECK-NEXT:    add r0, sp, #4
-; CHECK-NEXT:    str r7, [sp, #4]
-; CHECK-NEXT:    str.w sp, [sp, #12]
 ; CHECK-NEXT:    mov r1, pc @ eh_setjmp begin
 ; CHECK-NEXT:    adds r1, r1, #7
 ; CHECK-NEXT:    str r1, [r0, #4]
 ; CHECK-NEXT:    movs r0, #0
 ; CHECK-NEXT:    b LSJLJEH0
 ; CHECK-NEXT:    movs r0, #1 @ eh_setjmp end
 ; CHECK-NEXT:  LSJLJEH0:
 ; CHECK-NEXT:    cbz r0, LBB0_3
 ; CHECK-NEXT:  @ %bb.1: @ %if.then
 ; CHECK-NEXT:    movw r0, :lower16:(L_g$non_lazy_ptr-(LPC0_0+4))
 ; CHECK-NEXT:    movt r0, :upper16:(L_g$non_lazy_ptr-(LPC0_0+4))
 ; CHECK-NEXT:  LPC0_0:
 ; CHECK-NEXT:    add r0, pc
 ; CHECK-NEXT:    ldr r1, [r0]
 ; CHECK-NEXT:    movs r0, #1
 ; CHECK-NEXT:    str r1, [sp] @ 4-byte Spill
 ; CHECK-NEXT:    str r0, [r1]
+; CHECK-NEXT:    mov r0, r7
+; CHECK-NEXT:    str r0, [sp, #4]
+; CHECK-NEXT:    mov r0, sp
+; CHECK-NEXT:    str r0, [sp, #12]
 ; CHECK-NEXT:    add r0, sp, #4
 ; CHECK-NEXT:    movs r1, #0
-; CHECK-NEXT:    str r7, [sp, #4]
-; CHECK-NEXT:    str.w sp, [sp, #12]
 ; CHECK-NEXT:    mov r1, pc @ eh_setjmp begin
 ; CHECK-NEXT:    adds r1, r1, #7
 ; CHECK-NEXT:    str r1, [r0, #4]
 ; CHECK-NEXT:    movs r0, #0
 ; CHECK-NEXT:    b LSJLJEH1
 ; CHECK-NEXT:    movs r0, #1 @ eh_setjmp end
 ; CHECK-NEXT:  LSJLJEH1:
 ; CHECK-NEXT:    cmp r0, #0

llvm/test/CodeGen/X86/shadow-stack.ll

 ; X86_64-NEXT:    pushq %r12
 ; X86_64-NEXT:    pushq %rbx
 ; X86_64-NEXT:    pushq %rax
 ; X86_64-NEXT:    .cfi_offset %rbx, -56
 ; X86_64-NEXT:    .cfi_offset %r12, -48
 ; X86_64-NEXT:    .cfi_offset %r13, -40
 ; X86_64-NEXT:    .cfi_offset %r14, -32
 ; X86_64-NEXT:    .cfi_offset %r15, -24
-; X86_64-NEXT:    ## kill: def $edi killed $edi def $rdi
-; X86_64-NEXT:    movq %rdi, {{[-0-9]+}}(%r{{[sb]}}p) ## 8-byte Spill
-; X86_64-NEXT:    movq _buf@GOTPCREL(%rip), %rax
-; X86_64-NEXT:    movq (%rax), %rax
-; X86_64-NEXT:    movq %rbp, (%rax)
-; X86_64-NEXT:    movq %rsp, 16(%rax)
-; X86_64-NEXT:    leaq LBB1_4(%rip), %rcx
-; X86_64-NEXT:    movq %rcx, 8(%rax)
-; X86_64-NEXT:    xorq %rcx, %rcx
-; X86_64-NEXT:    rdsspq %rcx
-; X86_64-NEXT:    movq %rcx, 24(%rax)
+; X86_64-NEXT:    movl %edi, {{[-0-9]+}}(%r{{[sb]}}p) ## 4-byte Spill
+; X86_64-NEXT:    movq %rsp, %rcx
+; X86_64-NEXT:    movq _buf@GOTPCREL(%rip), %rdx
+; X86_64-NEXT:    movq (%rdx), %rdx
+; X86_64-NEXT:    movq %rbp, (%rdx)
+; X86_64-NEXT:    movq %rcx, 16(%rdx)
+; X86_64-NEXT:    leaq LBB1_4(%rip), %rax
+; X86_64-NEXT:    movq %rax, 8(%rdx)
+; X86_64-NEXT:    xorq %rax, %rax
+; X86_64-NEXT:    rdsspq %rax
+; X86_64-NEXT:    movq %rax, 24(%rdx)
 ; X86_64-NEXT:    #EH_SjLj_Setup LBB1_4
 ; X86_64-NEXT:  ## %bb.1: ## %entry
 ; X86_64-NEXT:    xorl %eax, %eax
 ; X86_64-NEXT:    jmp LBB1_2
 ; X86_64-NEXT:  LBB1_4: ## Block address taken
 ; X86_64-NEXT:    ## %entry
 ; X86_64-NEXT:    movl $1, %eax
 ; X86_64-NEXT:  LBB1_2: ## %entry
 ; X86_64-NEXT:    testl %eax, %eax
 ; X86_64-NEXT:    je LBB1_5
 ; X86_64-NEXT:  ## %bb.3: ## %if.end
-; X86_64-NEXT:    movq {{[-0-9]+}}(%r{{[sb]}}p), %rax ## 8-byte Reload
+; X86_64-NEXT:    movl {{[-0-9]+}}(%r{{[sb]}}p), %eax ## 4-byte Reload
 ; X86_64-NEXT:    shll $2, %eax
+; X86_64-NEXT:    ## kill: def $eax killed $eax def $rax
 ; X86_64-NEXT:    leal (%rax,%rax,2), %eax
 ; X86_64-NEXT:    addq $8, %rsp
 ; X86_64-NEXT:    popq %rbx
 ; X86_64-NEXT:    popq %r12
 ; X86_64-NEXT:    popq %r13
 ; X86_64-NEXT:    popq %r14
 ; X86_64-NEXT:    popq %r15
 ; X86_64-NEXT:    popq %rbp

 ; X86-NEXT:    .cfi_def_cfa_register %ebp
 ; X86-NEXT:    pushl %ebx
 ; X86-NEXT:    pushl %edi
 ; X86-NEXT:    pushl %esi
 ; X86-NEXT:    subl $12, %esp
 ; X86-NEXT:    .cfi_offset %esi, -20
 ; X86-NEXT:    .cfi_offset %edi, -16
 ; X86-NEXT:    .cfi_offset %ebx, -12
-; X86-NEXT:    movl L_buf$non_lazy_ptr, %eax
-; X86-NEXT:    movl (%eax), %eax
-; X86-NEXT:    movl %ebp, (%eax)
-; X86-NEXT:    movl %esp, 16(%eax)
-; X86-NEXT:    movl $LBB1_4, 4(%eax)
-; X86-NEXT:    xorl %ecx, %ecx
-; X86-NEXT:    rdsspd %ecx
-; X86-NEXT:    movl %ecx, 12(%eax)
+; X86-NEXT:    movl %esp, %ecx
+; X86-NEXT:    movl L_buf$non_lazy_ptr, %edx
+; X86-NEXT:    movl (%edx), %edx
+; X86-NEXT:    movl %ebp, (%edx)
+; X86-NEXT:    movl %ecx, 16(%edx)
+; X86-NEXT:    movl $LBB1_4, 4(%edx)
+; X86-NEXT:    xorl %eax, %eax
+; X86-NEXT:    rdsspd %eax
+; X86-NEXT:    movl %eax, 12(%edx)
 ; X86-NEXT:    #EH_SjLj_Setup LBB1_4
 ; X86-NEXT:  ## %bb.1: ## %entry
 ; X86-NEXT:    xorl %eax, %eax
 ; X86-NEXT:    jmp LBB1_2
 ; X86-NEXT:  LBB1_4: ## Block address taken
 ; X86-NEXT:    ## %entry
 ; X86-NEXT:    movl $1, %eax
 ; X86-NEXT:  LBB1_2: ## %entry

llvm/utils/TableGen/CodeGenIntrinsics.h

struct CodeGenIntrinsic {
   bool isNoDuplicate;
 
   /// True if the intrinsic is marked as nomerge.
   bool isNoMerge;
 
   /// True if the intrinsic is no-return.
   bool isNoReturn;
 
+  /// True if the intrinsic is returns-twice.
+  bool isReturnsTwice;
+
   /// True if the intrinsic is no-sync.
   bool isNoSync;
 
   /// True if the intrinsic is no-free.
   bool isNoFree;
 
   /// True if the intrinsic is will-return.
   bool isWillReturn;

llvm/utils/TableGen/CodeGenTarget.cpp

CodeGenIntrinsic::CodeGenIntrinsic(Record *R,
   std::string DefName = std::string(R->getName());
   ArrayRef<SMLoc> DefLoc = R->getLoc();
   ModRef = ReadWriteMem;
   Properties = 0;
   isOverloaded = false;
   isCommutative = false;
   canThrow = false;
   isNoReturn = false;
+  isReturnsTwice = false;
   isNoSync = false;
   isNoFree = false;
   isWillReturn = false;
   isCold = false;
   isNoDuplicate = false;
   isNoMerge = false;
   isConvergent = false;
   isSpeculatable = false;
void CodeGenIntrinsic::setProperty(Record *R) {
   else if (R->getName() == "IntrNoDuplicate")
     isNoDuplicate = true;
   else if (R->getName() == "IntrNoMerge")
     isNoMerge = true;
   else if (R->getName() == "IntrConvergent")
     isConvergent = true;
   else if (R->getName() == "IntrNoReturn")
     isNoReturn = true;
+  else if (R->getName() == "IntrReturnsTwice")
+    isReturnsTwice = true;
   else if (R->getName() == "IntrNoSync")
     isNoSync = true;
   else if (R->getName() == "IntrNoFree")
     isNoFree = true;
   else if (R->getName() == "IntrWillReturn")
     isWillReturn = !isNoReturn;
   else if (R->getName() == "IntrCold")
     isCold = true;

llvm/utils/TableGen/IntrinsicEmitter.cpp

if (L->isNoDuplicate != R->isNoDuplicate)
       return R->isNoDuplicate;
 
     if (L->isNoMerge != R->isNoMerge)
       return R->isNoMerge;
 
     if (L->isNoReturn != R->isNoReturn)
       return R->isNoReturn;
 
+    if (L->isReturnsTwice != R->isReturnsTwice)
+      return R->isReturnsTwice;
+
     if (L->isNoSync != R->isNoSync)
       return R->isNoSync;
 
     if (L->isNoFree != R->isNoFree)
       return R->isNoFree;
 
     if (L->isWillReturn != R->isWillReturn)
       return R->isWillReturn;
if (Ae) {
           OS << ", AttrValParam" << AttrIdx;
         OS << ");\n";
       }
     }
 
     if (!Intrinsic.canThrow ||
         (Intrinsic.ModRef != CodeGenIntrinsic::ReadWriteMem &&
          !Intrinsic.hasSideEffects) ||
-        Intrinsic.isNoReturn || Intrinsic.isNoSync || Intrinsic.isNoFree ||
-        Intrinsic.isWillReturn || Intrinsic.isCold || Intrinsic.isNoDuplicate ||
-        Intrinsic.isNoMerge || Intrinsic.isConvergent ||
-        Intrinsic.isSpeculatable) {
+        Intrinsic.isNoReturn || Intrinsic.isReturnsTwice ||
+        Intrinsic.isNoSync || Intrinsic.isNoFree || Intrinsic.isWillReturn ||
+        Intrinsic.isCold || Intrinsic.isNoDuplicate || Intrinsic.isNoMerge ||
+        Intrinsic.isConvergent || Intrinsic.isSpeculatable) {
       OS << "      const Attribute::AttrKind Atts[] = {";
       ListSeparator LS(",");
       if (!Intrinsic.canThrow)
         OS << LS << "Attribute::NoUnwind";
       if (Intrinsic.isNoReturn)
         OS << LS << "Attribute::NoReturn";
+      if (Intrinsic.isReturnsTwice)
+        OS << LS << "Attribute::ReturnsTwice";
       if (Intrinsic.isNoSync)
         OS << LS << "Attribute::NoSync";
       if (Intrinsic.isNoFree)
         OS << LS << "Attribute::NoFree";
       if (Intrinsic.isWillReturn)
         OS << LS << "Attribute::WillReturn";
       if (Intrinsic.isCold)
         OS << LS << "Attribute::Cold";