[binutils-gdb] gdb: Fix std::{min, max}-related build breakage on 32-bit hosts

[Pedro Alves <palves at sourceware dot org>]

https://sourceware.org/git/gitweb.cgi?p=binutils-gdb.git;h=768adc05c44c7e8b5c0f9ca5ad3ca96657715293

commit 768adc05c44c7e8b5c0f9ca5ad3ca96657715293
Author: Pedro Alves <palves@redhat.com>
Date:   Sun Sep 18 23:56:01 2016 +0100

    gdb: Fix std::{min, max}-related build breakage on 32-bit hosts
    
    Building on a 32-bit host fails currently with errors like:
    
      .../src/gdb/exec.c: In function â??target_xfer_status section_table_read_available_memory(gdb_byte*, ULONGEST, ULONGEST, ULONGEST*)â??:
      .../src/gdb/exec.c:801:54: error: no matching function for call to â??min(ULONGEST, long unsigned int)â??
          end = std::min (offset + len, r->start + r->length);
    							^
      In file included from /usr/include/c++/5.3.1/algorithm:61:0,
    		   from .../src/gdb/exec.c:46:
      /usr/include/c++/5.3.1/bits/stl_algobase.h:195:5: note: candidate: template<class _Tp> const _Tp& std::min(const _Tp&, const _Tp&)
           min(const _Tp& __a, const _Tp& __b)
           ^
      /usr/include/c++/5.3.1/bits/stl_algobase.h:195:5: note:   template argument deduction/substitution failed:
      .../src/gdb/exec.c:801:54: note:   deduced conflicting types for parameter â??const _Tpâ?? (â??long long unsigned intâ?? and â??long unsigned intâ??)
          end = std::min (offset + len, r->start + r->length);
    							^
      In file included from /usr/include/c++/5.3.1/algorithm:61:0,
    		   from .../src/gdb/exec.c:46:
      /usr/include/c++/5.3.1/bits/stl_algobase.h:243:5: note: candidate: template<class _Tp, class _Compare> const _Tp& std::min(const _Tp&, const _Tp&, _Compare)
           min(const _Tp& __a, const _Tp& __b, _Compare __comp)
           ^
    
    The problem is that the std::min/std::max function templates use the
    same type for both parameters.  When the argument types are different,
    the compiler can't automatically deduce which template specialization
    to pick from the arguments' types.
    
    Fix that by specifying the specialization we want explicitly.
    
    gdb/ChangeLog:
    2016-09-18  Pedro Alves  <palves@redhat.com>
    
    	* breakpoint.c (hardware_watchpoint_inserted_in_range): Explicitly
    	specify the std:min/std::max specialization.
    	* exec.c (section_table_read_available_memory): Likewise.
    	* remote.c (remote_read_qxfer): Likewise.
    	* target.c (simple_verify_memory): Likewise.

Diff:
---
 gdb/ChangeLog    | 8 ++++++++
 gdb/breakpoint.c | 4 ++--
 gdb/exec.c       | 2 +-
 gdb/remote.c     | 2 +-
 gdb/target.c     | 2 +-
 5 files changed, 13 insertions(+), 5 deletions(-)

diff --git a/gdb/ChangeLog b/gdb/ChangeLog
index 2c980b7..f86e0a4 100644
--- a/gdb/ChangeLog
+++ b/gdb/ChangeLog
@@ -1,3 +1,11 @@
+2016-09-18  Pedro Alves  <palves@redhat.com>
+
+	* breakpoint.c (hardware_watchpoint_inserted_in_range): Explicitly
+	specify the std:min/std::max specialization.
+	* exec.c (section_table_read_available_memory): Likewise.
+	* remote.c (remote_read_qxfer): Likewise.
+	* target.c (simple_verify_memory): Likewise.
+
 2016-09-16  Simon Marchi  <simark@simark.ca>
 
 	* infrun.c (restore_current_uiout_cleanup): Move to ui-out.c.
diff --git a/gdb/breakpoint.c b/gdb/breakpoint.c
index 28331f1..1e05932 100644
--- a/gdb/breakpoint.c
+++ b/gdb/breakpoint.c
@@ -4436,8 +4436,8 @@ hardware_watchpoint_inserted_in_range (struct address_space *aspace,
 	    CORE_ADDR l, h;
 
 	    /* Check for intersection.  */
-	    l = std::max (loc->address, addr);
-	    h = std::min (loc->address + loc->length, addr + len);
+	    l = std::max<CORE_ADDR> (loc->address, addr);
+	    h = std::min<CORE_ADDR> (loc->address + loc->length, addr + len);
 	    if (l < h)
 	      return 1;
 	  }
diff --git a/gdb/exec.c b/gdb/exec.c
index b18ca8b..7435971 100644
--- a/gdb/exec.c
+++ b/gdb/exec.c
@@ -798,7 +798,7 @@ section_table_read_available_memory (gdb_byte *readbuf, ULONGEST offset,
 	  enum target_xfer_status status;
 
 	  /* Get the intersection window.  */
-	  end = std::min (offset + len, r->start + r->length);
+	  end = std::min<CORE_ADDR> (offset + len, r->start + r->length);
 
 	  gdb_assert (end - offset <= len);
 
diff --git a/gdb/remote.c b/gdb/remote.c
index 2309205..e80db79 100644
--- a/gdb/remote.c
+++ b/gdb/remote.c
@@ -9907,7 +9907,7 @@ remote_read_qxfer (struct target_ops *ops, const char *object_name,
      may not, since we don't know how much of it will need to be escaped;
      the target is free to respond with slightly less data.  We subtract
      five to account for the response type and the protocol frame.  */
-  n = std::min (get_remote_packet_size () - 5, len);
+  n = std::min<LONGEST> (get_remote_packet_size () - 5, len);
   snprintf (rs->buf, get_remote_packet_size () - 4, "qXfer:%s:read:%s:%s,%s",
 	    object_name, annex ? annex : "",
 	    phex_nz (offset, sizeof offset),
diff --git a/gdb/target.c b/gdb/target.c
index 628bceb..b93244d 100644
--- a/gdb/target.c
+++ b/gdb/target.c
@@ -3585,7 +3585,7 @@ simple_verify_memory (struct target_ops *ops,
       ULONGEST xfered_len;
       enum target_xfer_status status;
       gdb_byte buf[1024];
-      ULONGEST howmuch = std::min (sizeof (buf), size - total_xfered);
+      ULONGEST howmuch = std::min<ULONGEST> (sizeof (buf), size - total_xfered);
 
       status = target_xfer_partial (ops, TARGET_OBJECT_MEMORY, NULL,
 				    buf, NULL, lma + total_xfered, howmuch,