Remove frame_id_eq

This replaces frame_id_eq with operator== and operator!=.  I wrote
this for a version of this series that I later abandoned; but since it
simplifies the code, I left this patch in.

Approved-by: Tom Tomey <tom@tromey.com>

diff --git a/gdb/breakpoint.c b/gdb/breakpoint.c
index a3a154c19a92326f3ef936e9caeaf5b0ee7514e6..2eabdd63c2ea230fa235d63e382b3135b522b259 100644 (file)
--- a/gdb/breakpoint.c
+++ b/gdb/breakpoint.c
@@ -5325,7 +5325,7 @@ bpstat_check_breakpoint_conditions (bpstat *bs, thread_info *thread)
      breakpoint or a single step breakpoint.  */
 
   if (frame_id_p (b->frame_id)
-      && !frame_id_eq (b->frame_id, get_stack_frame_id (get_current_frame ())))
+      && b->frame_id != get_stack_frame_id (get_current_frame ()))
     {
       infrun_debug_printf ("incorrect frame %s not %s, not stopping",
                           get_stack_frame_id (get_current_frame ()).to_string ().c_str (),

diff --git a/gdb/dummy-frame.c b/gdb/dummy-frame.c
index 40b455c7e4a49338c982de1a3fb62bbbc5a21eff..2fef6eae562fe9c23f3e3e8fe2b3a82343e2703c 100644 (file)
--- a/gdb/dummy-frame.c
+++ b/gdb/dummy-frame.c
@@ -47,7 +47,7 @@ static int
 dummy_frame_id_eq (struct dummy_frame_id *id1,
                   struct dummy_frame_id *id2)
 {
-  return frame_id_eq (id1->id, id2->id) && id1->thread == id2->thread;
+  return id1->id == id2->id && id1->thread == id2->thread;
 }
 
 /* List of dummy_frame destructors.  */
@@ -130,7 +130,7 @@ static bool
 pop_dummy_frame_bpt (struct breakpoint *b, struct dummy_frame *dummy)
 {
   if (b->thread == dummy->id.thread->global_num
-      && b->disposition == disp_del && frame_id_eq (b->frame_id, dummy->id.id))
+      && b->disposition == disp_del && b->frame_id == dummy->id.id)
     {
       while (b->related_breakpoint != b)
        delete_breakpoint (b->related_breakpoint);

diff --git a/gdb/elfread.c b/gdb/elfread.c
index 8aee634b44b5596cb974ac64569427a630ed7850..8b0e3c3046845d624820569f69fb6c229692138f 100644 (file)
--- a/gdb/elfread.c
+++ b/gdb/elfread.c
@@ -946,7 +946,7 @@ elf_gnu_ifunc_resolver_stop (code_breakpoint *b)
 
       if (b_return->thread == thread_id
          && b_return->loc->requested_address == prev_pc
-         && frame_id_eq (b_return->frame_id, prev_frame_id))
+         && b_return->frame_id == prev_frame_id)
        break;
     }
 

diff --git a/gdb/frame-unwind.c b/gdb/frame-unwind.c
index 78fc8dd4bcf8d8ccad8d9830eddecdf050de00d9..78e3f1d8bad45cb1a7177fc1f500f507cb902810 100644 (file)
--- a/gdb/frame-unwind.c
+++ b/gdb/frame-unwind.c
@@ -229,7 +229,7 @@ default_frame_unwind_stop_reason (struct frame_info *this_frame,
 {
   struct frame_id this_id = get_frame_id (this_frame);
 
-  if (frame_id_eq (this_id, outer_frame_id))
+  if (this_id == outer_frame_id)
     return UNWIND_OUTERMOST;
   else
     return UNWIND_NO_REASON;

diff --git a/gdb/frame.c b/gdb/frame.c
index fc883b3239e5b5ec6d09ae3c5b67e40bfc018593..8df5feb48257f996b9f7084adaa8e1fcd0ea4c12 100644 (file)
--- a/gdb/frame.c
+++ b/gdb/frame.c
@@ -244,7 +244,7 @@ frame_addr_hash (const void *ap)
 }
 
 /* Internal equality function for the hash table.  This function
-   defers equality operations to frame_id_eq.  */
+   defers equality operations to frame_id::operator==.  */
 
 static int
 frame_addr_hash_eq (const void *a, const void *b)
@@ -252,8 +252,7 @@ frame_addr_hash_eq (const void *a, const void *b)
   const struct frame_info *f_entry = (const struct frame_info *) a;
   const struct frame_info *f_element = (const struct frame_info *) b;
 
-  return frame_id_eq (f_entry->this_id.value,
-                     f_element->this_id.value);
+  return f_entry->this_id.value == f_element->this_id.value;
 }
 
 /* Internal function to create the frame_stash hash table.  100 seems
@@ -752,28 +751,28 @@ frame_id_artificial_p (frame_id l)
 }
 
 bool
-frame_id_eq (frame_id l, frame_id r)
+frame_id::operator== (const frame_id &r) const
 {
   bool eq;
 
-  if (l.stack_status == FID_STACK_INVALID
+  if (stack_status == FID_STACK_INVALID
       || r.stack_status == FID_STACK_INVALID)
     /* Like a NaN, if either ID is invalid, the result is false.
        Note that a frame ID is invalid iff it is the null frame ID.  */
     eq = false;
-  else if (l.stack_status != r.stack_status || l.stack_addr != r.stack_addr)
+  else if (stack_status != r.stack_status || stack_addr != r.stack_addr)
     /* If .stack addresses are different, the frames are different.  */
     eq = false;
-  else if (l.code_addr_p && r.code_addr_p && l.code_addr != r.code_addr)
+  else if (code_addr_p && r.code_addr_p && code_addr != r.code_addr)
     /* An invalid code addr is a wild card.  If .code addresses are
        different, the frames are different.  */
     eq = false;
-  else if (l.special_addr_p && r.special_addr_p
-          && l.special_addr != r.special_addr)
+  else if (special_addr_p && r.special_addr_p
+          && special_addr != r.special_addr)
     /* An invalid special addr is a wild card (or unused).  Otherwise
        if special addresses are different, the frames are different.  */
     eq = false;
-  else if (l.artificial_depth != r.artificial_depth)
+  else if (artificial_depth != r.artificial_depth)
     /* If artificial depths are different, the frames must be different.  */
     eq = false;
   else
@@ -781,7 +780,7 @@ frame_id_eq (frame_id l, frame_id r)
     eq = true;
 
   frame_debug_printf ("l=%s, r=%s -> %d",
-                     l.to_string ().c_str (), r.to_string ().c_str (), eq);
+                     to_string ().c_str (), r.to_string ().c_str (), eq);
 
   return eq;
 }
@@ -875,7 +874,7 @@ frame_find_by_id (struct frame_id id)
     return NULL;
 
   /* Check for the sentinel frame.  */
-  if (frame_id_eq (id, sentinel_frame_id))
+  if (id == sentinel_frame_id)
     return sentinel_frame;
 
   /* Try using the frame stash first.  Finding it there removes the need
@@ -894,7 +893,7 @@ frame_find_by_id (struct frame_id id)
     {
       struct frame_id self = get_frame_id (frame);
 
-      if (frame_id_eq (id, self))
+      if (id == self)
        /* An exact match.  */
        return frame;
 
@@ -1738,7 +1737,7 @@ lookup_selected_frame (struct frame_id a_frame_id, int frame_level)
         it's highly unlikely the search by level finds the wrong
         frame, it's 99.9(9)% of the time (for all practical purposes)
         safe.  */
-      && frame_id_eq (get_frame_id (frame), a_frame_id))
+      && get_frame_id (frame) == a_frame_id)
     {
       /* Cool, all is fine.  */
       select_frame (frame);

diff --git a/gdb/frame.h b/gdb/frame.h
index b9a3793cc2330cad9c00cdfa936e3f7bd5644ede..75bb3bd2aa0958ed696893742c8ea8cfac9aa771 100644 (file)
--- a/gdb/frame.h
+++ b/gdb/frame.h
@@ -173,6 +173,16 @@ struct frame_id
 
   /* Return a string representation of this frame id.  */
   std::string to_string () const;
+
+  /* Returns true when this frame_id and R identify the same
+     frame.  */
+  bool operator== (const frame_id &r) const;
+
+  /* Inverse of ==.  */
+  bool operator!= (const frame_id &r) const
+  {
+    return !(*this == r);
+  }
 };
 
 /* Save and restore the currently selected frame.  */
@@ -269,9 +279,6 @@ extern bool frame_id_p (frame_id l);
    TAILCALL_FRAME.  */
 extern bool frame_id_artificial_p (frame_id l);
 
-/* Returns true when L and R identify the same frame.  */
-extern bool frame_id_eq (frame_id l, frame_id r);
-
 /* Frame types.  Some are real, some are signal trampolines, and some
    are completely artificial (dummy).  */
 
@@ -498,22 +505,7 @@ extern CORE_ADDR get_frame_base (struct frame_info *);
 
 /* Return the per-frame unique identifer.  Can be used to relocate a
    frame after a frame cache flush (and other similar operations).  If
-   FI is NULL, return the null_frame_id.
-
-   NOTE: kettenis/20040508: These functions return a structure.  On
-   platforms where structures are returned in static storage (vax,
-   m68k), this may trigger compiler bugs in code like:
-
-   if (frame_id_eq (get_frame_id (l), get_frame_id (r)))
-
-   where the return value from the first get_frame_id (l) gets
-   overwritten by the second get_frame_id (r).  Please avoid writing
-   code like this.  Use code like:
-
-   struct frame_id id = get_frame_id (l);
-   if (frame_id_eq (id, get_frame_id (r)))
-
-   instead, since that avoids the bug.  */
+   FI is NULL, return the null_frame_id.  */
 extern struct frame_id get_frame_id (struct frame_info *fi);
 extern struct frame_id get_stack_frame_id (struct frame_info *fi);
 extern struct frame_id frame_unwind_caller_id (struct frame_info *next_frame);

diff --git a/gdb/guile/scm-frame.c b/gdb/guile/scm-frame.c
index 159603b80088236047d18a2476ee0c9dea8f5306..77764944208ca6cf82deef2c56dc037f44b18de5 100644 (file)
--- a/gdb/guile/scm-frame.c
+++ b/gdb/guile/scm-frame.c
@@ -134,7 +134,7 @@ frscm_eq_frame_smob (const void *ap, const void *bp)
   const frame_smob *a = (const frame_smob *) ap;
   const frame_smob *b = (const frame_smob *) bp;
 
-  return (frame_id_eq (a->frame_id, b->frame_id)
+  return (a->frame_id == b->frame_id
          && a->inferior == b->inferior
          && a->inferior != NULL);
 }

diff --git a/gdb/ia64-tdep.c b/gdb/ia64-tdep.c
index 0b448e9a231cf5d0fc6c74e6278069d9e79b405c..2bac2a64e9dc12009587bebc918e9040545e06f5 100644 (file)
--- a/gdb/ia64-tdep.c
+++ b/gdb/ia64-tdep.c
@@ -2901,7 +2901,7 @@ ia64_libunwind_frame_this_id (struct frame_info *this_frame, void **this_cache,
   CORE_ADDR bsp;
 
   libunwind_frame_this_id (this_frame, this_cache, &id);
-  if (frame_id_eq (id, outer_frame_id))
+  if (id == outer_frame_id)
     {
       (*this_id) = outer_frame_id;
       return;
@@ -3032,7 +3032,7 @@ ia64_libunwind_sigtramp_frame_this_id (struct frame_info *this_frame,
   struct frame_id id = outer_frame_id;
 
   libunwind_frame_this_id (this_frame, this_cache, &id);
-  if (frame_id_eq (id, outer_frame_id))
+  if (id == outer_frame_id)
     {
       (*this_id) = outer_frame_id;
       return;

diff --git a/gdb/infrun.c b/gdb/infrun.c
index 1957e8020dd0a42b9fb9174dd4fbae59d22ed0f7..db82e2a9bbbac030dcb5a807e18c46817bdac6cb 100644 (file)
--- a/gdb/infrun.c
+++ b/gdb/infrun.c
@@ -4565,7 +4565,7 @@ stepped_in_from (struct frame_info *frame, struct frame_id step_frame_id)
        frame != NULL;
        frame = get_prev_frame (frame))
     {
-      if (frame_id_eq (get_frame_id (frame), step_frame_id))
+      if (get_frame_id (frame) == step_frame_id)
        return true;
 
       if (get_frame_type (frame) != INLINE_FRAME)
@@ -4595,7 +4595,7 @@ inline_frame_is_marked_for_skip (bool prev_frame, struct thread_info *tp)
       symtab_and_line sal;
       struct symbol *sym;
 
-      if (frame_id_eq (get_frame_id (frame), tp->control.step_frame_id))
+      if (get_frame_id (frame) == tp->control.step_frame_id)
        break;
       if (get_frame_type (frame) != INLINE_FRAME)
        break;
@@ -6576,8 +6576,8 @@ handle_signal_stop (struct execution_control_state *ecs)
          && (pc_in_thread_step_range (ecs->event_thread->stop_pc (),
                                       ecs->event_thread)
              || ecs->event_thread->control.step_range_end == 1)
-         && frame_id_eq (get_stack_frame_id (frame),
-                         ecs->event_thread->control.step_stack_frame_id)
+         && (get_stack_frame_id (frame)
+             == ecs->event_thread->control.step_stack_frame_id)
          && ecs->event_thread->control.step_resume_breakpoint == NULL)
        {
          /* The inferior is about to take a signal that will take it
@@ -6744,8 +6744,7 @@ process_event_stop_test (struct execution_control_state *ecs)
          {
            struct frame_id current_id
              = get_frame_id (get_current_frame ());
-           if (frame_id_eq (current_id,
-                            ecs->event_thread->initiating_frame))
+           if (current_id == ecs->event_thread->initiating_frame)
              {
                /* Case 2.  Fall through.  */
              }
@@ -6918,8 +6917,7 @@ process_event_stop_test (struct execution_control_state *ecs)
   if (pc_in_thread_step_range (ecs->event_thread->stop_pc (),
                               ecs->event_thread)
       && (execution_direction != EXEC_REVERSE
-         || frame_id_eq (get_frame_id (frame),
-                         ecs->event_thread->control.step_frame_id)))
+         || get_frame_id (frame) == ecs->event_thread->control.step_frame_id))
     {
       infrun_debug_printf
        ("stepping inside range [%s-%s]",
@@ -7053,7 +7051,7 @@ process_event_stop_test (struct execution_control_state *ecs)
      previous frame's ID is sufficient - but it is a common case and
      cheaper than checking the previous frame's ID.
 
-     NOTE: frame_id_eq will never report two invalid frame IDs as
+     NOTE: frame_id::operator== will never report two invalid frame IDs as
      being equal, so to get into this block, both the current and
      previous frame must have valid frame IDs.  */
   /* The outer_frame_id check is a heuristic to detect stepping
@@ -7063,14 +7061,14 @@ process_event_stop_test (struct execution_control_state *ecs)
      "outermost" function.  This could be fixed by marking
      outermost frames as !stack_p,code_p,special_p.  Then the
      initial outermost frame, before sp was valid, would
-     have code_addr == &_start.  See the comment in frame_id_eq
+     have code_addr == &_start.  See the comment in frame_id::operator==
      for more.  */
-  if (!frame_id_eq (get_stack_frame_id (frame),
-                   ecs->event_thread->control.step_stack_frame_id)
-      && (frame_id_eq (frame_unwind_caller_id (get_current_frame ()),
-                      ecs->event_thread->control.step_stack_frame_id)
-         && (!frame_id_eq (ecs->event_thread->control.step_stack_frame_id,
-                           outer_frame_id)
+  if ((get_stack_frame_id (frame)
+       != ecs->event_thread->control.step_stack_frame_id)
+      && ((frame_unwind_caller_id (get_current_frame ())
+          == ecs->event_thread->control.step_stack_frame_id)
+         && ((ecs->event_thread->control.step_stack_frame_id
+              != outer_frame_id)
              || (ecs->event_thread->control.step_start_function
                  != find_pc_function (ecs->event_thread->stop_pc ())))))
     {
@@ -7327,8 +7325,8 @@ process_event_stop_test (struct execution_control_state *ecs)
      frame machinery detected some skipped call sites, we have entered
      a new inline function.  */
 
-  if (frame_id_eq (get_frame_id (get_current_frame ()),
-                  ecs->event_thread->control.step_frame_id)
+  if ((get_frame_id (get_current_frame ())
+       == ecs->event_thread->control.step_frame_id)
       && inline_skipped_frames (ecs->event_thread))
     {
       infrun_debug_printf ("stepped into inlined function");
@@ -7376,8 +7374,8 @@ process_event_stop_test (struct execution_control_state *ecs)
      through a more inlined call beyond its call site.  */
 
   if (get_frame_type (get_current_frame ()) == INLINE_FRAME
-      && !frame_id_eq (get_frame_id (get_current_frame ()),
-                      ecs->event_thread->control.step_frame_id)
+      && (get_frame_id (get_current_frame ())
+         != ecs->event_thread->control.step_frame_id)
       && stepped_in_from (get_current_frame (),
                          ecs->event_thread->control.step_frame_id))
     {
@@ -7409,8 +7407,8 @@ process_event_stop_test (struct execution_control_state *ecs)
          end_stepping_range (ecs);
          return;
        }
-      else if (frame_id_eq (get_frame_id (get_current_frame ()),
-                           ecs->event_thread->control.step_frame_id))
+      else if (get_frame_id (get_current_frame ())
+               == ecs->event_thread->control.step_frame_id)
        {
          /* We are not at the start of a statement, and we have not changed
             frame.
@@ -8467,8 +8465,8 @@ print_stop_location (const target_waitstatus &ws)
         should) carry around the function and does (or should) use
         that when doing a frame comparison.  */
       if (tp->control.stop_step
-         && frame_id_eq (tp->control.step_frame_id,
-                         get_frame_id (get_current_frame ()))
+         && (tp->control.step_frame_id
+             == get_frame_id (get_current_frame ()))
          && (tp->control.step_start_function
              == find_pc_function (tp->stop_pc ())))
        {

diff --git a/gdb/mi/mi-cmd-stack.c b/gdb/mi/mi-cmd-stack.c
index 70c51e6186e1ce7fe381634edbaab9046c23dfb9..8acb9cd6fd9de1371d0f20f07c05ff610c0559b1 100644 (file)
--- a/gdb/mi/mi-cmd-stack.c
+++ b/gdb/mi/mi-cmd-stack.c
@@ -729,7 +729,7 @@ parse_frame_specification (const char *frame_exp)
        fid != NULL;
        fid = get_prev_frame (fid))
     {
-      if (frame_id_eq (id, get_frame_id (fid)))
+      if (id == get_frame_id (fid))
        {
          struct frame_info *prev_frame;
 
@@ -737,7 +737,7 @@ parse_frame_specification (const char *frame_exp)
            {
              prev_frame = get_prev_frame (fid);
              if (!prev_frame
-                 || !frame_id_eq (id, get_frame_id (prev_frame)))
+                 || id != get_frame_id (prev_frame))
                break;
              fid = prev_frame;
            }

diff --git a/gdb/mi/mi-main.c b/gdb/mi/mi-main.c
index 80b5cd9bf90104ae12f6721cf9d68080cd918db4..6d8e510619e8774ae75b967992fba766063ce5f5 100644 (file)
--- a/gdb/mi/mi-main.c
+++ b/gdb/mi/mi-main.c
@@ -1997,7 +1997,7 @@ struct user_selected_context
        reports not-equal, we only do the equality test if we have something
        other than the innermost frame selected.  */
     if (current_frame_level != -1
-       && !frame_id_eq (current_frame_id, m_previous_frame_id))
+       && current_frame_id != m_previous_frame_id)
       return true;
 
     /* Nothing changed!  */

diff --git a/gdb/python/py-finishbreakpoint.c b/gdb/python/py-finishbreakpoint.c
index c4b043f5bfe2589c33e94a6429ec14deb63c64ef..317e2d708d97ac9a6a2fe165eeda74a26e4dd4f8 100644 (file)
--- a/gdb/python/py-finishbreakpoint.c
+++ b/gdb/python/py-finishbreakpoint.c
@@ -207,7 +207,7 @@ bpfinishpy_init (PyObject *self, PyObject *args, PyObject *kwargs)
          else
            {
              frame_id = get_frame_id (prev_frame);
-             if (frame_id_eq (frame_id, null_frame_id))
+             if (frame_id == null_frame_id)
                PyErr_SetString (PyExc_ValueError,
                                 _("Invalid ID for the `frame' object."));
            }

diff --git a/gdb/python/py-frame.c b/gdb/python/py-frame.c
index 8bd2e0bc6daa6b808d72042549fff8e92f0edb41..0240da966ffa711cb8bade2538a1d6f157ff9545 100644 (file)
--- a/gdb/python/py-frame.c
+++ b/gdb/python/py-frame.c
@@ -701,7 +701,7 @@ frapy_richcompare (PyObject *self, PyObject *other, int op)
   frame_object *other_frame = (frame_object *) other;
 
   if (self_frame->frame_id_is_next == other_frame->frame_id_is_next
-      && frame_id_eq (self_frame->frame_id, other_frame->frame_id))
+      && self_frame->frame_id == other_frame->frame_id)
     result = Py_EQ;
   else
     result = Py_NE;

diff --git a/gdb/record-btrace.c b/gdb/record-btrace.c
index 3a56925f63e48fda1ba3c4eb66876a0c98fc00ec..bc1411ecb3f584f308a23852431a051b2b70cd10 100644 (file)
--- a/gdb/record-btrace.c
+++ b/gdb/record-btrace.c
@@ -2033,10 +2033,8 @@ record_btrace_start_replaying (struct thread_info *tp)
       frame_id = get_thread_current_frame_id (tp);
 
       /* Check if we need to update any stepping-related frame id's.  */
-      upd_step_frame_id = frame_id_eq (frame_id,
-                                      tp->control.step_frame_id);
-      upd_step_stack_frame_id = frame_id_eq (frame_id,
-                                            tp->control.step_stack_frame_id);
+      upd_step_frame_id = (frame_id == tp->control.step_frame_id);
+      upd_step_stack_frame_id = (frame_id == tp->control.step_stack_frame_id);
 
       /* We start replaying at the end of the branch trace.  This corresponds
         to the current instruction.  */

diff --git a/gdb/stack.c b/gdb/stack.c
index 379635e409e78ff38d51a87a2b64d872a61cf5b8..012aa5d57d545f9434a0c80551772639f772175c 100644 (file)
--- a/gdb/stack.c
+++ b/gdb/stack.c
@@ -3252,7 +3252,7 @@ find_frame_for_address (CORE_ADDR address)
        fid != NULL;
        fid = get_prev_frame (fid))
     {
-      if (frame_id_eq (id, get_frame_id (fid)))
+      if (id == get_frame_id (fid))
        {
          struct frame_info *prev_frame;
 
@@ -3260,7 +3260,7 @@ find_frame_for_address (CORE_ADDR address)
            {
              prev_frame = get_prev_frame (fid);
              if (!prev_frame
-                 || !frame_id_eq (id, get_frame_id (prev_frame)))
+                 || id != get_frame_id (prev_frame))
                break;
              fid = prev_frame;
            }

diff --git a/gdb/tracepoint.c b/gdb/tracepoint.c
index 6f01f52a874b900a5c4e176859096e417556372b..2f867a0606d2b2837eb88b65cc09f3c8b7cff87c 100644 (file)
--- a/gdb/tracepoint.c
+++ b/gdb/tracepoint.c
@@ -2190,8 +2190,7 @@ tfind_1 (enum trace_find_type type, int num,
         function and it's arguments) -- otherwise we'll just show the
         new source line.  */
 
-      if (frame_id_eq (old_frame_id,
-                      get_frame_id (get_current_frame ())))
+      if (old_frame_id == get_frame_id (get_current_frame ()))
        print_what = SRC_LINE;
       else
        print_what = SRC_AND_LOC;

diff --git a/gdb/value.c b/gdb/value.c
index 8ed941f3749b5ab7235a61125827bb7abbc93357..43023bf7ee48c8f237ff1cec904e541073a8e837 100644 (file)
--- a/gdb/value.c
+++ b/gdb/value.c
@@ -4004,7 +4004,7 @@ value_fetch_lazy_register (struct value *val)
         in this situation.  */
       if (VALUE_LVAL (new_val) == lval_register
          && value_lazy (new_val)
-         && frame_id_eq (VALUE_NEXT_FRAME_ID (new_val), next_frame_id))
+         && VALUE_NEXT_FRAME_ID (new_val) == next_frame_id)
        internal_error (__FILE__, __LINE__,
                        _("infinite loop while fetching a register"));
     }