[X86] Implement TargetRegisterInfo::getCustomEHPadPreservedMask

This method needs to be implemented so that the register allocator can
correctly split live ranges of loop invariant virtual registers.
This default return value is correct for DWARF unwinder, which preserves
all registers (except exception pointer/selector), but not for SjLj,
which only preserves sp/fp and possibly bp (they should be reserved).

In the added test `rcx` on the entry to the loop contains the argument
to `foo`. It survives the call due to `preserve_allcc`, but not the
unwind edge entering LBB0_3, and so must be recomputed before going to
the next iteration.
Similarly, `rdx` holds the address of a jump table and is recomputed on
every iteration rather than once before the loop.

Author: s-barannikov

llvm/lib/Target/X86/X86RegisterInfo.cpp

@@ -525,6 +525,13 @@ X86RegisterInfo::getNoPreservedMask() const {
   return CSR_NoRegs_RegMask;
 }
 
+const uint32_t *
+X86RegisterInfo::getCustomEHPadPreservedMask(const MachineFunction &MF) const {
+  if (MF.getTarget().Options.ExceptionModel == ExceptionHandling::SjLj)
+    return getNoPreservedMask();
+  return TargetRegisterInfo::getCustomEHPadPreservedMask(MF);
+}
+
 const uint32_t *X86RegisterInfo::getDarwinTLSCallPreservedMask() const {
   return CSR_64_TLS_Darwin_RegMask;
 }

llvm/lib/Target/X86/X86RegisterInfo.h

@@ -102,6 +102,8 @@ class X86RegisterInfo final : public X86GenRegisterInfo {
   const uint32_t *getCallPreservedMask(const MachineFunction &MF,
                                        CallingConv::ID) const override;
   const uint32_t *getNoPreservedMask() const override;
+  const uint32_t *
+  getCustomEHPadPreservedMask(const MachineFunction &MF) const override;
 
   // Calls involved in thread-local variable lookup save more registers than
   // normal calls, so they need a different mask to represent this.

llvm/test/CodeGen/X86/sjlj-unwind-clobber.ll

@@ -22,26 +22,28 @@ define void @test() personality ptr @__gxx_personality_sj0 {
 ; CHECK-NEXT:    movq $.LBB0_3, -80(%rbp)
 ; CHECK-NEXT:    leaq -136(%rbp), %rdi
 ; CHECK-NEXT:    callq _Unwind_SjLj_Register@PLT
-; CHECK-NEXT:    leaq -44(%rbp), %rdi
-; CHECK-NEXT:    leaq .LJTI0_0(%rip), %rax
+; CHECK-NEXT:    leaq -44(%rbp), %rcx
 ; CHECK-NEXT:  .LBB0_1: # %while.cond
 ; CHECK-NEXT:    # =>This Inner Loop Header: Depth=1
 ; CHECK-NEXT:    movl $1, -128(%rbp)
 ; CHECK-NEXT:  .Ltmp0:
+; CHECK-NEXT:    movq %rcx, %rdi
 ; CHECK-NEXT:    callq foo
 ; CHECK-NEXT:  .Ltmp1:
 ; CHECK-NEXT:    jmp .LBB0_2
 ; CHECK-NEXT:  .LBB0_3: # in Loop: Header=BB0_1 Depth=1
-; CHECK-NEXT:    movl -128(%rbp), %ecx
-; CHECK-NEXT:    cmpl $1, %ecx
+; CHECK-NEXT:    leaq -44(%rbp), %rcx
+; CHECK-NEXT:    movl -128(%rbp), %eax
+; CHECK-NEXT:    cmpl $1, %eax
 ; CHECK-NEXT:    jae .LBB0_5
 ; CHECK-NEXT:  # %bb.4: # in Loop: Header=BB0_1 Depth=1
-; CHECK-NEXT:    jmpq *(%rax,%rcx,8)
+; CHECK-NEXT:    leaq .LJTI0_0(%rip), %rdx
+; CHECK-NEXT:    jmpq *(%rdx,%rax,8)
 ; CHECK-NEXT:  .LBB0_6: # %lpad
 ; CHECK-NEXT:    # in Loop: Header=BB0_1 Depth=1
 ; CHECK-NEXT:  .Ltmp2:
-; CHECK-NEXT:    movl -124(%rbp), %ecx
-; CHECK-NEXT:    movl -120(%rbp), %ecx
+; CHECK-NEXT:    movl -124(%rbp), %eax
+; CHECK-NEXT:    movl -120(%rbp), %eax
 ; CHECK-NEXT:    jmp .LBB0_1
 ; CHECK-NEXT:  .LBB0_2: # %while.end
 ; CHECK-NEXT:    leaq -136(%rbp), %rdi