[binutils-gdb] gdb: mark disassembler function callback types as noexcept

[binutils-gdb] gdb: mark disassembler function callback types as noexcept

[Andrew Burgess]

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

commit 5975a5caceb238be7eddb3b279d51145a1628af8
Author: Andrew Burgess <aburgess@redhat.com>
Date:   Thu Oct 27 15:20:10 2022 +0100

    gdb: mark disassembler function callback types as noexcept
    
    In disasm.h we define a set of types that are used by the various
    disassembler classes to hold callback functions before passing the
    callbacks into libopcodes.
    
    Because libopcodes is C code, and on some (many?) targets, C code is
    compiled without exception support, it is important that GDB not try
    to throw an exception over libopcode code.
    
    In the previous commit all the existing callbacks were marked as
    noexcept, however, this doesn't protect us from a future change to GDB
    either adding a new callback that is not noexcept, or removing the
    noexcept keyword from an existing callback.
    
    In this commit I mark all the callback types as noexcept.  This means
    that GDB's disassembler classes will no longer compile if we try to
    pass a callback that is not marked as noexcept.
    
    At least, that's the idea.  Unfortunately, it's not that easy.
    
    Before C++17, the noexcept keyword on a function typedef would be
    ignored, thus:
    
      using func_type = void (*) (void) noexcept;
    
      void
      a_func ()
      {
        throw 123;
      }
    
      void
      some_func (func_type f)
      {
        f ();
      }
    
      int
      main ()
      {
        some_func (a_func);
        return 0;
      }
    
    Will compile just fine for C++11 and C++14 with GCC.  Clang on the
    other hand complains that 'noexcept' should not appear on function
    types, but then does appear to correctly complain that passing a_func
    is a mismatch in the set of exceptions that could be thrown.
    
    Switching to C++17 and both GCC and Clang correctly point out that
    passing a_func is an invalid conversion relating to the noexcept
    keyword.  Changing a_func to:
    
      void
      a_func () noexcept
      { /* Nothing.  */ }
    
    And for C++17 both GCC and Clang compile this just fine.
    
    My conclusion then is that adding the noexcept keyword to the function
    types is pointless while GDB is not compiled as C++17, and silencing
    the warnings would require us to jump through a bunch of hoops.
    
    And so, in this commit, I define a macro LIBOPCODE_CALLBACK_NOEXCEPT,
    this macro expands to noexcept when compiling for C++17, but otherwise
    expands to nothing.  I then add this macro to the function types.
    
    I've compiled GDB as the default C++11 and also forced the compile to
    C++17.  When compiling as C++17 I spotted a few additional places
    where callbacks needed to be marked noexcept (these fixes were merged
    into the previous commit, but this confirmed to be that the macro is
    working as expected).

Diff:
---
 gdb/disasm.h | 40 ++++++++++++++++++++++++++++------------
 1 file changed, 28 insertions(+), 12 deletions(-)

diff --git a/gdb/disasm.h b/gdb/disasm.h
index 58c6c623098..d6aec9a4705 100644
--- a/gdb/disasm.h
+++ b/gdb/disasm.h
@@ -26,6 +26,12 @@ struct gdbarch;
 struct ui_out;
 struct ui_file;
 
+#if __cplusplus >= 201703L
+#define LIBOPCODE_CALLBACK_NOEXCEPT noexcept
+#else
+#define LIBOPCODE_CALLBACK_NOEXCEPT
+#endif
+
 /* A wrapper around a disassemble_info and a gdbarch.  This is the core
    set of data that all disassembler sub-classes will need.  This class
    doesn't actually implement the disassembling process, that is something
@@ -51,18 +57,28 @@ struct gdb_disassemble_info
 
 protected:
 
-  /* Types for the function callbacks within m_di.  It would be nice if
-     these function types were all defined to include the noexcept
-     keyword, as every implementation of these must be noexcept.  However,
-     using noexcept within a function typedef like this is a C++17
-     feature, trying to do this for earlier C++ versions results in a
-     warning from GCC/Clang, and the noexcept isn't checked.  After we
-     move to C++17 these should be updated to add noexcept.  */
-  using read_memory_ftype = decltype (disassemble_info::read_memory_func);
-  using memory_error_ftype = decltype (disassemble_info::memory_error_func);
-  using print_address_ftype = decltype (disassemble_info::print_address_func);
-  using fprintf_ftype = decltype (disassemble_info::fprintf_func);
-  using fprintf_styled_ftype = decltype (disassemble_info::fprintf_styled_func);
+  /* Types for the function callbacks within m_di.  The actual function
+     signatures here are taken from include/dis-asm.h.  The noexcept macro
+     expands to 'noexcept' for C++17 and later, otherwise, it expands to
+     nothing.  This is because including noexcept was ignored for function
+     types before C++17, but both GCC and Clang warn that the noexcept
+     will become relevant when you switch to C++17, and this warning
+     causes the build to fail.  */
+  using read_memory_ftype
+    = int (*) (bfd_vma, bfd_byte *, unsigned int, struct disassemble_info *)
+	LIBOPCODE_CALLBACK_NOEXCEPT;
+  using memory_error_ftype
+    = void (*) (int, bfd_vma, struct disassemble_info *)
+	LIBOPCODE_CALLBACK_NOEXCEPT;
+  using print_address_ftype
+    = void (*) (bfd_vma, struct disassemble_info *)
+	LIBOPCODE_CALLBACK_NOEXCEPT;
+  using fprintf_ftype
+    = int (*) (void *, const char *, ...)
+	LIBOPCODE_CALLBACK_NOEXCEPT;
+  using fprintf_styled_ftype
+    = int (*) (void *, enum disassembler_style, const char *, ...)
+	LIBOPCODE_CALLBACK_NOEXCEPT;
 
   /* Constructor, many fields in m_di are initialized from GDBARCH.  The
      remaining arguments are function callbacks that are written into m_di.