Make sect_offset and cu_offset strong typedefs instead of structs

A while ago, back when GDB was a C program, the sect_offset and
cu_offset types were made structs in order to prevent incorrect mixing
of those offsets.  Now that we require C++11, we can make them
integers again, while keeping the safety, by exploiting "enum class".
We can add a bit more safety, even, by defining operators that the
types _should_ support, helping making the suspicious uses stand out
more.

Getting at the underlying type is done with the new to_underlying
function added by the previous patch, which also helps better spot
where do we need to step out of the safety net.  Mostly, that's around
parsing the DWARF, and when we print the offset for complaint/debug
purposes.  But there are other occasional uses.

Since we have to define the sect_offset/cu_offset types in a header
anyway, I went ahead and generalized/library-fied the idea of "offset"
types, making it trivial to add more such types if we find a use.  See
common/offset-type.h and the DEFINE_OFFSET_TYPE macro.

I needed a couple generaly-useful preprocessor bits (e.g., yet another
CONCAT implementation), so I started a new common/preprocessor.h file.

I included units tests covering the "offset" types API.  These are
mostly compile-time tests, using SFINAE to check that expressions that
shouldn't compile (e.g., comparing unrelated offset types) really are
invalid and would fail to compile.  This same idea appeared in my
pending enum-flags revamp from a few months ago (though this version
is a bit further modernized compared to what I had posted), and I plan
on reusing the "check valid expression" bits added here in that
series, so I went ahead and defined the CHECK_VALID_EXPR macro in its
own header -- common/valid-expr.h.  I think that's nicer regardless.

I was borderline between calling the new types "offset" types, or
"index" types, BTW.  I stuck with "offset" simply because that's what
we're already calling them, mostly.

gdb/ChangeLog:
2017-04-04  Pedro Alves  <palves@redhat.com>

	* Makefile.in (SUBDIR_UNITTESTS_SRCS): Add
	unittests/offset-type-selftests.c.
	(SUBDIR_UNITTESTS_OBS): Add offset-type-selftests.o.
	* common/offset-type.h: New file.
	* common/preprocessor.h: New file.
	* common/traits.h: New file.
	* common/valid-expr.h: New file.
	* dwarf2expr.c: Include "common/underlying.h".  Adjust to use
	sect_offset and cu_offset strong typedefs throughout.
	* dwarf2expr.h: Adjust to use sect_offset and cu_offset strong
	typedefs throughout.
	* dwarf2loc.c: Include "common/underlying.h".  Adjust to use
	sect_offset and cu_offset strong typedefs throughout.
	* dwarf2read.c: Adjust to use sect_offset and cu_offset strong
	typedefs throughout.
	* gdbtypes.h: Include "common/offset-type.h".
	(cu_offset): Now an offset type (strong typedef) instead of a
	struct.
	(sect_offset): Likewise.
	(union call_site_parameter_u): Rename "param_offset" field to
	"param_cu_off".
	* unittests/offset-type-selftests.c: New file.

4 files changed, 322 insertions, 0 deletions

diff --git a/gdb/common/offset-type.h b/gdb/common/offset-type.h
new file mode 100644
index 0000000..9be65e9
--- /dev/null
+++ b/gdb/common/offset-type.h
@@ -0,0 +1,149 @@
+/* Offset types for GDB.
+
+   Copyright (C) 2017 Free Software Foundation, Inc.
+
+   This file is part of GDB.
+
+   This program is free software; you can redistribute it and/or modify
+   it under the terms of the GNU General Public License as published by
+   the Free Software Foundation; either version 3 of the License, or
+   (at your option) any later version.
+
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU General Public License for more details.
+
+   You should have received a copy of the GNU General Public License
+   along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
+
+/* Define an "offset" type.  Offset types are distinct integer types
+   that are used to represent an offset into anything that is
+   addressable.  For example, an offset into a DWARF debug section.
+   The idea is catch mixing unrelated offset types at compile time, in
+   code that needs to manipulate multiple different kinds of offsets
+   that are easily confused.  They're safer to use than native
+   integers, because they have no implicit conversion to anything.
+   And also, since they're implemented as "enum class" strong
+   typedefs, they're still integers ABI-wise, making them a bit more
+   efficient than wrapper structs on some ABIs.
+
+   Some properties of offset types, loosely modeled on pointers:
+
+   - You can compare offsets of the same type for equality and order.
+     You can't compare an offset with an unrelated type.
+
+   - You can add/substract an integer to/from an offset, which gives
+     you back a shifted offset.
+
+   - You can subtract two offsets of the same type, which gives you
+     back the delta as an integer (of the enum class's underlying
+     type), not as an offset type.
+
+   - You can't add two offsets of the same type, as that would not
+     make sense.
+
+   However, unlike pointers, you can't deference offset types.  */
+
+#ifndef COMMON_OFFSET_TYPE_H
+#define COMMON_OFFSET_TYPE_H
+
+/* Declare TYPE as being an offset type.  This declares the type and
+   enables the operators defined below.  */
+#define DEFINE_OFFSET_TYPE(TYPE, UNDERLYING)	\
+  enum class TYPE : UNDERLYING {};		\
+  void is_offset_type (TYPE)
+
+/* The macro macro is all you need to know use offset types.  The rest
+   below is all implementation detail.  */
+
+/* For each enum class type that you want to support relational
+   operators, declare an "is_offset_type" overload that has exactly
+   one parameter, of type that enum class.  E.g.,:
+
+     void is_offset_type (sect_offset);
+
+   The function does not need to be defined, only declared.
+   DEFINE_OFFSET_TYPE declares this.
+
+   A function declaration is preferred over a traits type, because the
+   former allows calling the DEFINE_OFFSET_TYPE macro inside a
+   namespace to define the corresponding offset type in that
+   namespace.  The compiler finds the corresponding is_offset_type
+   function via ADL.
+*/
+
+#define DEFINE_OFFSET_REL_OP(OP)					\
+  template<typename E,							\
+	   typename = decltype (is_offset_type (std::declval<E> ()))>	\
+  constexpr bool							\
+  operator OP (E lhs, E rhs)						\
+  {									\
+    using underlying = typename std::underlying_type<E>::type;		\
+    return (static_cast<underlying> (lhs)				\
+	    OP static_cast<underlying> (lhs));				\
+  }
+
+DEFINE_OFFSET_REL_OP(>)
+DEFINE_OFFSET_REL_OP(>=)
+DEFINE_OFFSET_REL_OP(<)
+DEFINE_OFFSET_REL_OP(<=)
+
+/* Adding or subtracting an integer to an offset type shifts the
+   offset.  This is like "PTR = PTR + INT" and "PTR += INT".  */
+
+#define DEFINE_OFFSET_ARITHM_OP(OP)					\
+  template<typename E,							\
+	   typename = decltype (is_offset_type (std::declval<E> ()))>	\
+  constexpr E								\
+  operator OP (E lhs, typename std::underlying_type<E>::type rhs)	\
+  {									\
+    using underlying = typename std::underlying_type<E>::type;		\
+    return (E) (static_cast<underlying> (lhs) OP rhs);			\
+  }									\
+									\
+  template<typename E,							\
+	   typename = decltype (is_offset_type (std::declval<E> ()))>	\
+  constexpr E								\
+  operator OP (typename std::underlying_type<E>::type lhs, E rhs)	\
+  {									\
+    using underlying = typename std::underlying_type<E>::type;		\
+    return (E) (lhs OP static_cast<underlying> (rhs));			\
+  }									\
+									\
+  template<typename E,							\
+	   typename = decltype (is_offset_type (std::declval<E> ()))>	\
+  E &									\
+  operator OP ## = (E &lhs, typename std::underlying_type<E>::type rhs)	\
+  {									\
+    using underlying = typename std::underlying_type<E>::type;		\
+    lhs = (E) (static_cast<underlying> (lhs) OP rhs);			\
+    return lhs;								\
+  }
+
+DEFINE_OFFSET_ARITHM_OP(+)
+DEFINE_OFFSET_ARITHM_OP(-)
+
+/* Adding two offset types doesn't make sense, just like "PTR + PTR"
+   doesn't make sense.  This is defined as a deleted function so that
+   a compile error easily brings you to this comment.  */
+
+template<typename E,
+	 typename = decltype (is_offset_type (std::declval<E> ()))>
+constexpr typename std::underlying_type<E>::type
+operator+ (E lhs, E rhs) = delete;
+
+/* Subtracting two offset types, however, gives you back the
+   difference between the offsets, as an underlying type.  Similar to
+   how "PTR2 - PTR1" returns a ptrdiff_t.  */
+
+template<typename E,
+	 typename = decltype (is_offset_type (std::declval<E> ()))>
+constexpr typename std::underlying_type<E>::type
+operator- (E lhs, E rhs)
+{
+  using underlying = typename std::underlying_type<E>::type;
+  return static_cast<underlying> (lhs) - static_cast<underlying> (rhs);
+}
+
+#endif /* COMMON_OFFSET_TYPE_H */
diff --git a/gdb/common/preprocessor.h b/gdb/common/preprocessor.h
new file mode 100644
index 0000000..6877344
--- /dev/null
+++ b/gdb/common/preprocessor.h
@@ -0,0 +1,31 @@
+/* Copyright (C) 2017 Free Software Foundation, Inc.
+
+   This file is part of GDB.
+
+   This program is free software; you can redistribute it and/or modify
+   it under the terms of the GNU General Public License as published by
+   the Free Software Foundation; either version 3 of the License, or
+   (at your option) any later version.
+
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU General Public License for more details.
+
+   You should have received a copy of the GNU General Public License
+   along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
+
+#ifndef COMMON_PREPROC_H
+#define COMMON_PREPROC_H
+
+/* Generally useful preprocessor bits.  */
+
+/* Concatenate two tokens.  */
+#define CONCAT_1(a, b) a ## b
+#define CONCAT(a, b) CONCAT_1 (a, b)
+
+/* Escape parens out.  Useful if you need to pass an argument that
+   includes commas to another macro.  */
+#define ESC(...) __VA_ARGS__
+
+#endif /* COMMON_PREPROC */
diff --git a/gdb/common/traits.h b/gdb/common/traits.h
new file mode 100644
index 0000000..4b7bac3
--- /dev/null
+++ b/gdb/common/traits.h
@@ -0,0 +1,34 @@
+/* Copyright (C) 2017 Free Software Foundation, Inc.
+
+   This file is part of GDB.
+
+   This program is free software; you can redistribute it and/or modify
+   it under the terms of the GNU General Public License as published by
+   the Free Software Foundation; either version 3 of the License, or
+   (at your option) any later version.
+
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU General Public License for more details.
+
+   You should have received a copy of the GNU General Public License
+   along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
+
+#ifndef COMMON_TRAITS_H
+#define COMMON_TRAITS_H
+
+namespace gdb {
+
+/* Pre C++14-safe (CWG 1558) version of C++17's std::void_t.  See
+   <http://en.cppreference.com/w/cpp/types/void_t>.  */
+
+template<typename... Ts>
+struct make_void { typedef void type; };
+
+template<typename... Ts>
+using void_t = typename make_void<Ts...>::type;
+
+}
+
+#endif /* COMMON_TRAITS_H */
diff --git a/gdb/common/valid-expr.h b/gdb/common/valid-expr.h
new file mode 100644
index 0000000..80998917
--- /dev/null
+++ b/gdb/common/valid-expr.h
@@ -0,0 +1,108 @@
+/* Compile-time valid expression checker for GDB, the GNU debugger.
+
+   Copyright (C) 2017 Free Software Foundation, Inc.
+
+   This file is part of GDB.
+
+   This program is free software; you can redistribute it and/or modify
+   it under the terms of the GNU General Public License as published by
+   the Free Software Foundation; either version 3 of the License, or
+   (at your option) any later version.
+
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU General Public License for more details.
+
+   You should have received a copy of the GNU General Public License
+   along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
+
+/* Helper macros used to build compile-time unit tests that make sure
+   that invalid expressions that should not compile would not compile,
+   and that expressions that should compile do compile, and have the
+   right type.  This is mainly used to verify that some utility's API
+   is really as safe as intended.  */
+
+#ifndef COMMON_VALID_EXPR_H
+#define COMMON_VALID_EXPR_H
+
+#include "common/preprocessor.h"
+#include "common/traits.h"
+
+/* Macro that uses SFINAE magic to detect whether the EXPR expression
+   is either valid or ill-formed, at compile time, without actually
+   producing compile-time errors.  I.e., check that bad uses of the
+   types (e.g., involving mismatching types) would be caught at
+   compile time.  If the expression is valid, also check whether the
+   expression has the right type.
+
+   EXPR must be defined in terms of some of the template parameters,
+   so that template substitution failure discards the overload instead
+   of causing a real compile error.  TYPES is thus the list of types
+   involved in the expression, and TYPENAMES is the same list, but
+   with each element prefixed by "typename".  These are passed as
+   template parameter types to the templates within the macro.
+
+   VALID is a boolean that indicates whether the expression is
+   supposed to be valid or invalid.
+
+   EXPR_TYPE is the expected type of EXPR.  Only meaningful iff VALID
+   is true.  If VALID is false, then you must pass "void" as expected
+   type.
+
+   Each invocation of the macro is wrapped in its own namespace to
+   avoid ODR violations.  The generated namespace only includes the
+   line number, so client code should wrap sets of calls in a
+   test-specific namespace too, to fully guarantee uniqueness between
+   the multiple clients in the codebase.  */
+#define CHECK_VALID_EXPR_INT(TYPENAMES, TYPES, VALID, EXPR_TYPE, EXPR)	\
+  namespace CONCAT (check_valid_expr, __LINE__) {			\
+									\
+  template<typename, typename, typename = void>				\
+  struct is_valid_expression						\
+    : std::false_type {};						\
+									\
+  template <TYPENAMES>							\
+    struct is_valid_expression<TYPES, gdb::void_t<decltype (EXPR)>>	\
+    : std::true_type {};						\
+									\
+  static_assert (is_valid_expression<TYPES>::value == VALID,		\
+		 "");							\
+									\
+  template<TYPENAMES, typename = void>					\
+  struct is_same_type							\
+    : std::is_same<EXPR_TYPE, void> {};					\
+									\
+  template <TYPENAMES>							\
+    struct is_same_type<TYPES, gdb::void_t<decltype (EXPR)>>		\
+    : std::is_same<EXPR_TYPE, decltype (EXPR)> {};			\
+									\
+  static_assert (is_same_type<TYPES>::value, "");			\
+  } /* namespace */
+
+/* A few convenience macros that support expressions involving a
+   varying numbers of types.  If you need more types, feel free to add
+   another variant.  */
+
+#define CHECK_VALID_EXPR_1(T1, VALID, EXPR_TYPE, EXPR)			\
+  CHECK_VALID_EXPR_INT (ESC (typename T1),				\
+			ESC (T1),					\
+			VALID, EXPR_TYPE, EXPR)
+
+#define CHECK_VALID_EXPR_2(T1, T2, VALID, EXPR_TYPE, EXPR)		\
+  CHECK_VALID_EXPR_INT (ESC (typename T1, typename T2),			\
+			ESC (T1, T2),					\
+			VALID, EXPR_TYPE, EXPR)
+
+#define CHECK_VALID_EXPR_3(T1, T2, T3, VALID, EXPR_TYPE, EXPR)		\
+  CHECK_VALID_EXPR_INT (ESC (typename T1, typename T2, typename T3),	\
+			ESC (T1, T2, T3),				\
+			VALID, EXPR_TYPE, EXPR)
+
+#define CHECK_VALID_EXPR_4(T1, T2, T3, T4, VALID, EXPR_TYPE, EXPR)	\
+  CHECK_VALID_EXPR_INT (ESC (typename T1, typename T2,			\
+			     typename T3, typename T4),			\
+			ESC (T1, T2, T3, T4),				\
+			VALID, EXPR_TYPE, EXPR)
+
+#endif /* COMMON_VALID_EXPR_H */