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 --git a/gdb/ChangeLog b/gdb/ChangeLog
index 2c980b78dc8cc561aae651fb46571e975cbecc3c..f86e0a43b98ec7d331760852ba6effca991df605 100644 (file)
--- 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 28331f10881fc36f41053eecef3146759353cb75..1e059325aa2f7f8065ce7f01164ac18e288d1543 100644 (file)
--- 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 b18ca8b662e4eb43ec67ca7efacfe1f009da351b..74359711736eedcf07030c2218cff85f41961980 100644 (file)
--- 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 2309205ed7513366a136324b943b061e475cec21..e80db79b1029c98a2fa59da16a5f37c7d0dccc84 100644 (file)
--- 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 628bceb6642ce06724836ca24d14000906cedc38..b93244da2a2b98661c6e5b021b54a83b3c3c1e1f 100644 (file)
--- 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,