gdb: defer commit resume until all available events are consumed

[deliverable/binutils-gdb.git] / elfcpp / elfcpp_swap.h

diff --git a/elfcpp/elfcpp_swap.h b/elfcpp/elfcpp_swap.h
index 24ffccd0879fb6b6d3c19aeb3da1d5b2fe8a3337..61b3ba5752012ef59c8d90ce6566cc0fe72a0e91 100644 (file)
--- a/elfcpp/elfcpp_swap.h
+++ b/elfcpp/elfcpp_swap.h
@@ -1,6 +1,6 @@
 // elfcpp_swap.h -- Handle swapping for elfcpp   -*- C++ -*-
 
-// Copyright 2006, 2007, Free Software Foundation, Inc.
+// Copyright (C) 2006-2020 Free Software Foundation, Inc.
 // Written by Ian Lance Taylor <iant@google.com>.
 
 // This file is part of elfcpp.
@@ -37,8 +37,60 @@
 #define ELFCPP_SWAP_H
 
 #include <stdint.h>
-#include <endian.h>
+
+// We need an autoconf-generated config.h file for endianness and
+// swapping.  We check two macros: WORDS_BIGENDIAN and
+// HAVE_BYTESWAP_H.
+
+#include "config.h"
+
+#ifdef HAVE_BYTESWAP_H
 #include <byteswap.h>
+#endif // defined(HAVE_BYTESWAP_H)
+
+// Provide our own versions of the byteswap functions.
+#if !HAVE_DECL_BSWAP_16
+static inline uint16_t
+bswap_16(uint16_t v)
+{
+  return ((v >> 8) & 0xff) | ((v & 0xff) << 8);
+}
+#endif // !HAVE_DECL_BSWAP16
+
+#if !HAVE_DECL_BSWAP_32
+static inline uint32_t
+bswap_32(uint32_t v)
+{
+  return (  ((v & 0xff000000) >> 24)
+         | ((v & 0x00ff0000) >>  8)
+         | ((v & 0x0000ff00) <<  8)
+         | ((v & 0x000000ff) << 24));
+}
+#endif // !HAVE_DECL_BSWAP32
+
+#if !HAVE_DECL_BSWAP_64
+static inline uint64_t
+bswap_64(uint64_t v)
+{
+  return (  ((v & 0xff00000000000000ULL) >> 56)
+         | ((v & 0x00ff000000000000ULL) >> 40)
+         | ((v & 0x0000ff0000000000ULL) >> 24)
+         | ((v & 0x000000ff00000000ULL) >>  8)
+         | ((v & 0x00000000ff000000ULL) <<  8)
+         | ((v & 0x0000000000ff0000ULL) << 24)
+         | ((v & 0x000000000000ff00ULL) << 40)
+         | ((v & 0x00000000000000ffULL) << 56));
+}
+#endif // !HAVE_DECL_BSWAP64
+
+// gcc 4.3 and later provides __builtin_bswap32 and __builtin_bswap64.
+
+#if defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 3))
+#undef bswap_32
+#define bswap_32 __builtin_bswap32
+#undef bswap_64
+#define bswap_64 __builtin_bswap64
+#endif
 
 namespace elfcpp
 {
@@ -49,12 +101,18 @@ struct Endian
 {
  public:
   // Used for template specializations.
-  static const bool host_big_endian = __BYTE_ORDER == __BIG_ENDIAN;
+  static const bool host_big_endian = 
+#ifdef WORDS_BIGENDIAN
+    true
+#else
+    false
+#endif
+    ;
 };
 
 // Valtype_base is a template based on size (8, 16, 32, 64) which
-// defines the type Valtype as the unsigned integer of the specified
-// size.
+// defines the type Valtype as the unsigned integer, and
+// Signed_valtype as the signed integer, of the specified size.
 
 template<int size>
 struct Valtype_base;
@@ -62,25 +120,29 @@ struct Valtype_base;
 template<>
 struct Valtype_base<8>
 {
-  typedef unsigned char Valtype;
+  typedef uint8_t Valtype;
+  typedef int8_t Signed_valtype;
 };
 
 template<>
 struct Valtype_base<16>
 {
   typedef uint16_t Valtype;
+  typedef int16_t Signed_valtype;
 };
 
 template<>
 struct Valtype_base<32>
 {
   typedef uint32_t Valtype;
+  typedef int32_t Signed_valtype;
 };
 
 template<>
 struct Valtype_base<64>
 {
   typedef uint64_t Valtype;
+  typedef int64_t Signed_valtype;
 };
 
 // Convert_endian is a template based on size and on whether the host
@@ -363,14 +425,79 @@ struct Swap_unaligned<64, true>
   static inline void
   writeval(unsigned char* wv, Valtype v)
   {
-    wv[7] = v >> 56;
-    wv[6] = v >> 48;
-    wv[5] = v >> 40;
-    wv[4] = v >> 32;
-    wv[3] = v >> 24;
-    wv[2] = v >> 16;
-    wv[1] = v >> 8;
-    wv[0] = v;
+    wv[0] = v >> 56;
+    wv[1] = v >> 48;
+    wv[2] = v >> 40;
+    wv[3] = v >> 32;
+    wv[4] = v >> 24;
+    wv[5] = v >> 16;
+    wv[6] = v >> 8;
+    wv[7] = v;
+  }
+};
+
+// Swap_aligned32 is a template based on size and on whether the
+// target is big endian.  It defines the type Valtype and the
+// functions readval and writeval.  The functions read and write
+// values of the appropriate size out of buffers which may not be
+// 64-bit aligned, but are 32-bit aligned.
+
+template<int size, bool big_endian>
+struct Swap_aligned32
+{
+  typedef typename Valtype_base<size>::Valtype Valtype;
+
+  static inline Valtype
+  readval(const unsigned char* wv)
+  { return Swap<size, big_endian>::readval(
+       reinterpret_cast<const Valtype*>(wv)); }
+
+  static inline void
+  writeval(unsigned char* wv, Valtype v)
+  { Swap<size, big_endian>::writeval(reinterpret_cast<Valtype*>(wv), v); }
+};
+
+template<>
+struct Swap_aligned32<64, true>
+{
+  typedef Valtype_base<64>::Valtype Valtype;
+
+  static inline Valtype
+  readval(const unsigned char* wv)
+  {
+    return ((static_cast<Valtype>(Swap<32, true>::readval(wv)) << 32)
+           | static_cast<Valtype>(Swap<32, true>::readval(wv + 4)));
+  }
+
+  static inline void
+  writeval(unsigned char* wv, Valtype v)
+  {
+    typedef Valtype_base<32>::Valtype Valtype32;
+
+    Swap<32, true>::writeval(wv, static_cast<Valtype32>(v >> 32));
+    Swap<32, true>::writeval(wv + 4, static_cast<Valtype32>(v));
+  }
+};
+
+template<>
+struct Swap_aligned32<64, false>
+{
+  typedef Valtype_base<64>::Valtype Valtype;
+
+  static inline Valtype
+  readval(const unsigned char* wv)
+  {
+    return ((static_cast<Valtype>(Swap<32, false>::readval(wv + 4)) << 32)
+           | static_cast<Valtype>(Swap<32, false>::readval(wv)));
+  }
+
+  static inline void
+  writeval(unsigned char* wv, Valtype v)
+  {
+    typedef Valtype_base<32>::Valtype Valtype32;
+
+    Swap<32, false>::writeval(wv + 4, static_cast<Valtype32>(v >> 32));
+    Swap<32, false>::writeval(wv, static_cast<Valtype32>(v));
   }
 };