if (interrupts_enabled(regs)) {
                if (regs->exit_rcu) {
                        trace_hardirqs_on_prepare();
-                       lockdep_hardirqs_on_prepare(CALLER_ADDR0);
+                       lockdep_hardirqs_on_prepare();
                        rcu_irq_exit();
                        lockdep_hardirqs_on(CALLER_ADDR0);
                        return;
 static __always_inline void __exit_to_user_mode(void)
 {
        trace_hardirqs_on_prepare();
-       lockdep_hardirqs_on_prepare(CALLER_ADDR0);
+       lockdep_hardirqs_on_prepare();
        user_enter_irqoff();
        lockdep_hardirqs_on(CALLER_ADDR0);
 }
        ftrace_nmi_exit();
        if (restore) {
                trace_hardirqs_on_prepare();
-               lockdep_hardirqs_on_prepare(CALLER_ADDR0);
+               lockdep_hardirqs_on_prepare();
        }
 
        rcu_nmi_exit();
 
        if (restore) {
                trace_hardirqs_on_prepare();
-               lockdep_hardirqs_on_prepare(CALLER_ADDR0);
+               lockdep_hardirqs_on_prepare();
        }
 
        rcu_nmi_exit();
 
         */
        instrumentation_begin();
        trace_hardirqs_on_prepare();
-       lockdep_hardirqs_on_prepare(CALLER_ADDR0);
+       lockdep_hardirqs_on_prepare();
        instrumentation_end();
 
        guest_enter_irqoff();
 
 #ifdef CONFIG_PROVE_LOCKING
   extern void lockdep_softirqs_on(unsigned long ip);
   extern void lockdep_softirqs_off(unsigned long ip);
-  extern void lockdep_hardirqs_on_prepare(unsigned long ip);
+  extern void lockdep_hardirqs_on_prepare(void);
   extern void lockdep_hardirqs_on(unsigned long ip);
   extern void lockdep_hardirqs_off(unsigned long ip);
 #else
   static inline void lockdep_softirqs_on(unsigned long ip) { }
   static inline void lockdep_softirqs_off(unsigned long ip) { }
-  static inline void lockdep_hardirqs_on_prepare(unsigned long ip) { }
+  static inline void lockdep_hardirqs_on_prepare(void) { }
   static inline void lockdep_hardirqs_on(unsigned long ip) { }
   static inline void lockdep_hardirqs_off(unsigned long ip) { }
 #endif
 
 {
        instrumentation_begin();
        trace_hardirqs_on_prepare();
-       lockdep_hardirqs_on_prepare(CALLER_ADDR0);
+       lockdep_hardirqs_on_prepare();
        instrumentation_end();
 
        guest_context_enter_irqoff();
 
 {
        instrumentation_begin();
        trace_hardirqs_on_prepare();
-       lockdep_hardirqs_on_prepare(CALLER_ADDR0);
+       lockdep_hardirqs_on_prepare();
        instrumentation_end();
 
        user_enter_irqoff();
                        instrumentation_begin();
                        /* Tell the tracer that IRET will enable interrupts */
                        trace_hardirqs_on_prepare();
-                       lockdep_hardirqs_on_prepare(CALLER_ADDR0);
+                       lockdep_hardirqs_on_prepare();
                        instrumentation_end();
                        rcu_irq_exit();
                        lockdep_hardirqs_on(CALLER_ADDR0);
        ftrace_nmi_exit();
        if (irq_state.lockdep) {
                trace_hardirqs_on_prepare();
-               lockdep_hardirqs_on_prepare(CALLER_ADDR0);
+               lockdep_hardirqs_on_prepare();
        }
        instrumentation_end();
 
 
  */
 static int add_lock_to_list(struct lock_class *this,
                            struct lock_class *links_to, struct list_head *head,
-                           unsigned long ip, u16 distance, u8 dep,
+                           u16 distance, u8 dep,
                            const struct lock_trace *trace)
 {
        struct lock_list *entry;
         * to the previous lock's dependency list:
         */
        ret = add_lock_to_list(hlock_class(next), hlock_class(prev),
-                              &hlock_class(prev)->locks_after,
-                              next->acquire_ip, distance,
-                              calc_dep(prev, next),
-                              *trace);
+                              &hlock_class(prev)->locks_after, distance,
+                              calc_dep(prev, next), *trace);
 
        if (!ret)
                return 0;
 
        ret = add_lock_to_list(hlock_class(prev), hlock_class(next),
-                              &hlock_class(next)->locks_before,
-                              next->acquire_ip, distance,
-                              calc_depb(prev, next),
-                              *trace);
+                              &hlock_class(next)->locks_before, distance,
+                              calc_depb(prev, next), *trace);
        if (!ret)
                return 0;
 
 
 /**
  * lockdep_hardirqs_on_prepare - Prepare for enabling interrupts
- * @ip:                Caller address
  *
  * Invoked before a possible transition to RCU idle from exit to user or
  * guest mode. This ensures that all RCU operations are done before RCU
  * stops watching. After the RCU transition lockdep_hardirqs_on() has to be
  * invoked to set the final state.
  */
-void lockdep_hardirqs_on_prepare(unsigned long ip)
+void lockdep_hardirqs_on_prepare(void)
 {
        if (unlikely(!debug_locks))
                return;
 
 static void
 print_lock_nested_lock_not_held(struct task_struct *curr,
-                               struct held_lock *hlock,
-                               unsigned long ip)
+                               struct held_lock *hlock)
 {
        if (!debug_locks_off())
                return;
        chain_key = iterate_chain_key(chain_key, hlock_id(hlock));
 
        if (nest_lock && !__lock_is_held(nest_lock, -1)) {
-               print_lock_nested_lock_not_held(curr, hlock, ip);
+               print_lock_nested_lock_not_held(curr, hlock);
                return 0;
        }
 
 
                 * last -- this is very similar to the entry code.
                 */
                trace_hardirqs_on_prepare();
-               lockdep_hardirqs_on_prepare(_THIS_IP_);
+               lockdep_hardirqs_on_prepare();
                rcu_idle_enter();
                lockdep_hardirqs_on(_THIS_IP_);
 
 
                this_cpu_write(tracing_irq_cpu, 0);
        }
 
-       lockdep_hardirqs_on_prepare(CALLER_ADDR0);
+       lockdep_hardirqs_on_prepare();
        lockdep_hardirqs_on(CALLER_ADDR0);
 }
 EXPORT_SYMBOL(trace_hardirqs_on);
                this_cpu_write(tracing_irq_cpu, 0);
        }
 
-       lockdep_hardirqs_on_prepare(CALLER_ADDR0);
+       lockdep_hardirqs_on_prepare();
        lockdep_hardirqs_on(CALLER_ADDR0);
 }
 EXPORT_SYMBOL(trace_hardirqs_on_caller);