SYM_CODE_END(native_iret)
 #endif
 
-SYM_CODE_START(bounds)
-       ASM_CLAC
-       pushl   $0
-       pushl   $do_bounds
-       jmp     common_exception
-SYM_CODE_END(bounds)
-
 SYM_CODE_START(invalid_op)
        ASM_CLAC
        pushl   $0
 
  */
 
 idtentry       X86_TRAP_BP             int3                    do_int3                         has_error_code=0
-idtentry       X86_TRAP_BR             bounds                  do_bounds                       has_error_code=0
 idtentry       X86_TRAP_UD             invalid_op              do_invalid_op                   has_error_code=0
 idtentry       X86_TRAP_NM             device_not_available    do_device_not_available         has_error_code=0
 idtentry       X86_TRAP_OLD_MF         coprocessor_segment_overrun     do_coprocessor_segment_overrun  has_error_code=0
 
 /* Simple exception entry points. No hardware error code */
 DECLARE_IDTENTRY(X86_TRAP_DE,          exc_divide_error);
 DECLARE_IDTENTRY(X86_TRAP_OF,          exc_overflow);
+DECLARE_IDTENTRY(X86_TRAP_BR,          exc_bounds);
 
 #endif
 
 asmlinkage void debug(void);
 asmlinkage void nmi(void);
 asmlinkage void int3(void);
-asmlinkage void bounds(void);
 asmlinkage void invalid_op(void);
 asmlinkage void device_not_available(void);
 #ifdef CONFIG_X86_64
 asmlinkage void xen_xennmi(void);
 asmlinkage void xen_xendebug(void);
 asmlinkage void xen_int3(void);
-asmlinkage void xen_bounds(void);
 asmlinkage void xen_invalid_op(void);
 asmlinkage void xen_device_not_available(void);
 asmlinkage void xen_double_fault(void);
 dotraplinkage void do_debug(struct pt_regs *regs, long error_code);
 dotraplinkage void do_nmi(struct pt_regs *regs, long error_code);
 dotraplinkage void do_int3(struct pt_regs *regs, long error_code);
-dotraplinkage void do_bounds(struct pt_regs *regs, long error_code);
 dotraplinkage void do_invalid_op(struct pt_regs *regs, long error_code);
 dotraplinkage void do_device_not_available(struct pt_regs *regs, long error_code);
 dotraplinkage void do_double_fault(struct pt_regs *regs, long error_code, unsigned long cr2);
 
 static const __initconst struct idt_data def_idts[] = {
        INTG(X86_TRAP_DE,               asm_exc_divide_error),
        INTG(X86_TRAP_NMI,              nmi),
-       INTG(X86_TRAP_BR,               bounds),
+       INTG(X86_TRAP_BR,               asm_exc_bounds),
        INTG(X86_TRAP_UD,               invalid_op),
        INTG(X86_TRAP_NM,               device_not_available),
        INTG(X86_TRAP_OLD_MF,           coprocessor_segment_overrun),
 
        panic("Machine halted.");
 }
 
-dotraplinkage void do_bounds(struct pt_regs *regs, long error_code)
+DEFINE_IDTENTRY(exc_bounds)
 {
-       RCU_LOCKDEP_WARN(!rcu_is_watching(), "entry code didn't wake RCU");
-       if (notify_die(DIE_TRAP, "bounds", regs, error_code,
+       if (notify_die(DIE_TRAP, "bounds", regs, 0,
                        X86_TRAP_BR, SIGSEGV) == NOTIFY_STOP)
                return;
        cond_local_irq_enable(regs);
 
        if (!user_mode(regs))
-               die("bounds", regs, error_code);
+               die("bounds", regs, 0);
 
-       do_trap(X86_TRAP_BR, SIGSEGV, "bounds", regs, error_code, 0, NULL);
+       do_trap(X86_TRAP_BR, SIGSEGV, "bounds", regs, 0, 0, NULL);
 
        cond_local_irq_disable(regs);
 }
 
 #endif
        { page_fault,                  xen_page_fault,                  false },
        TRAP_ENTRY(exc_divide_error,                    false ),
-       { bounds,                      xen_bounds,                      false },
+       TRAP_ENTRY(exc_bounds,                          false ),
        { invalid_op,                  xen_invalid_op,                  false },
        { device_not_available,        xen_device_not_available,        false },
        { coprocessor_segment_overrun, xen_coprocessor_segment_overrun, false },
 
 xen_pv_trap int3
 xen_pv_trap xennmi
 xen_pv_trap asm_exc_overflow
-xen_pv_trap bounds
+xen_pv_trap asm_exc_bounds
 xen_pv_trap invalid_op
 xen_pv_trap device_not_available
 xen_pv_trap double_fault