endianize

Author: labath

llvm/include/llvm/BinaryFormat/SFrame.h

@@ -16,14 +16,14 @@
 #define LLVM_BINARYFORMAT_SFRAME_H
 
 #include "llvm/ADT/BitmaskEnum.h"
-#include "llvm/Support/Compiler.h"
 #include "llvm/Support/DataTypes.h"
+#include "llvm/Support/Endian.h"
 
 namespace llvm::sframe {
 
 LLVM_ENABLE_BITMASK_ENUMS_IN_NAMESPACE();
 
-constexpr uint16_t MagicSignature = 0xdee2;
+constexpr uint16_t Magic = 0xdee2;
 
 enum class Version : uint8_t {
   V1 = 1,
@@ -75,35 +75,39 @@ enum class BaseReg : uint8_t {
   SP = 1,
 };
 
-LLVM_PACKED_START
+namespace detail {
+template <typename T, endianness E>
+using packed =
+    support::detail::packed_endian_specific_integral<T, E, support::unaligned>;
+}
 
-struct Preamble {
-  uint16_t Magic;
-  enum Version Version;
-  enum Flags Flags;
+template <endianness E> struct Preamble {
+  detail::packed<uint16_t, E> Magic;
+  detail::packed<enum Version, E> Version;
+  detail::packed<enum Flags, E> Flags;
 };
 
-struct Header {
-  struct Preamble Preamble;
-  ABI ABIArch;
-  int8_t CFAFixedFPOffset;
-  int8_t CFAFixedRAOffset;
-  uint8_t AuxHdrLen;
-  uint32_t NumFDEs;
-  uint32_t NumFREs;
-  uint32_t FRELen;
-  uint32_t FDEOff;
-  uint32_t FREOff;
+template <endianness E> struct Header {
+  struct Preamble<E> Preamble;
+  detail::packed<ABI, E> ABIArch;
+  detail::packed<int8_t, E> CFAFixedFPOffset;
+  detail::packed<int8_t, E> CFAFixedRAOffset;
+  detail::packed<uint8_t, E> AuxHdrLen;
+  detail::packed<uint32_t, E> NumFDEs;
+  detail::packed<uint32_t, E> NumFREs;
+  detail::packed<uint32_t, E> FRELen;
+  detail::packed<uint32_t, E> FDEOff;
+  detail::packed<uint32_t, E> FREOff;
 };
 
-struct FuncDescEntry {
-  int32_t StartAddress;
-  uint32_t Size;
-  uint32_t StartFREOff;
-  uint32_t NumFREs;
-  uint8_t Info;
-  uint8_t RepSize;
-  uint16_t Padding2;
+template <endianness E> struct FuncDescEntry {
+  detail::packed<int32_t, E> StartAddress;
+  detail::packed<uint32_t, E> Size;
+  detail::packed<uint32_t, E> StartFREOff;
+  detail::packed<uint32_t, E> NumFREs;
+  detail::packed<uint8_t, E> Info;
+  detail::packed<uint8_t, E> RepSize;
+  detail::packed<uint16_t, E> Padding2;
 
   uint8_t getPAuthKey() const { return (Info >> 5) & 1; }
   FDEType getFDEType() const { return static_cast<FDEType>((Info >> 4) & 1); }
@@ -117,8 +121,8 @@ struct FuncDescEntry {
   }
 };
 
-struct FREInfo {
-  uint8_t Info;
+template <endianness E> struct FREInfo {
+  detail::packed<uint8_t, E> Info;
 
   bool isReturnAddressSigned() const { return Info >> 7; }
   FREOffset getOffsetSize() const {
@@ -145,22 +149,14 @@ struct FREInfo {
   }
 };
 
-struct FrameRowEntryAddr1 {
-  uint8_t StartAddress;
-  FREInfo Info;
+template <typename T, endianness E> struct FrameRowEntry {
+  detail::packed<T, E> StartAddress;
+  FREInfo<E> Info;
 };
 
-struct FrameRowEntryAddr2 {
-  uint16_t StartAddress;
-  FREInfo Info;
-};
-
-struct FrameRowEntryAddr4 {
-  uint32_t StartAddress;
-  FREInfo Info;
-};
-
-LLVM_PACKED_END
+template <endianness E> using FrameRowEntryAddr1 = FrameRowEntry<uint8_t, E>;
+template <endianness E> using FrameRowEntryAddr2 = FrameRowEntry<uint16_t, E>;
+template <endianness E> using FrameRowEntryAddr4 = FrameRowEntry<uint32_t, E>;
 
 } // namespace llvm::sframe
 

llvm/unittests/BinaryFormat/SFrameTest.cpp

@@ -8,32 +8,54 @@
 
 #include "llvm/BinaryFormat/SFrame.h"
 #include "gtest/gtest.h"
+#include <type_traits>
 
 using namespace llvm;
 using namespace llvm::sframe;
 
 namespace {
-// Test structure sizes and triviality.
-static_assert(std::is_trivial_v<Preamble>);
-static_assert(sizeof(Preamble) == 4);
 
-static_assert(std::is_trivial_v<Header>);
-static_assert(sizeof(Header) == 28);
+template<typename EndianT>
+class SFrameTest : public testing::Test {
+protected:
+  static constexpr endianness Endian = EndianT::value;
 
-static_assert(std::is_trivial_v<FuncDescEntry>);
-static_assert(sizeof(FuncDescEntry) == 20);
+  // Test structure sizes and triviality.
+  static_assert(std::is_trivial_v<Preamble<Endian>>);
+  static_assert(sizeof(Preamble<Endian>) == 4);
 
-static_assert(std::is_trivial_v<FrameRowEntryAddr1>);
-static_assert(sizeof(FrameRowEntryAddr1) == 2);
+  static_assert(std::is_trivial_v<Header<Endian>>);
+  static_assert(sizeof(Header<Endian>) == 28);
 
-static_assert(std::is_trivial_v<FrameRowEntryAddr2>);
-static_assert(sizeof(FrameRowEntryAddr2) == 3);
+  static_assert(std::is_trivial_v<FuncDescEntry<Endian>>);
+  static_assert(sizeof(FuncDescEntry<Endian>) == 20);
 
-static_assert(std::is_trivial_v<FrameRowEntryAddr4>);
-static_assert(sizeof(FrameRowEntryAddr4) == 5);
+  static_assert(std::is_trivial_v<FrameRowEntryAddr1<Endian>>);
+  static_assert(sizeof(FrameRowEntryAddr1<Endian>) == 2);
 
-TEST(SFrameTest, FDEFlags) {
-  FuncDescEntry FDE = {};
+  static_assert(std::is_trivial_v<FrameRowEntryAddr2<Endian>>);
+  static_assert(sizeof(FrameRowEntryAddr2<Endian>) == 3);
+
+  static_assert(std::is_trivial_v<FrameRowEntryAddr4<Endian>>);
+  static_assert(sizeof(FrameRowEntryAddr4<Endian>) == 5);
+
+};
+
+struct NameGenerator {
+  template <typename T> static constexpr const char *GetName(int) {
+    if constexpr (T::value == endianness::little)
+      return "little";
+    if constexpr (T::value == endianness::big)
+      return "big";
+  }
+};
+using Types =
+    testing::Types<std::integral_constant<endianness, endianness::little>,
+                   std::integral_constant<endianness, endianness::big>>;
+TYPED_TEST_SUITE(SFrameTest, Types, NameGenerator);
+
+TYPED_TEST(SFrameTest, FDEFlags) {
+  FuncDescEntry<TestFixture::Endian> FDE = {};
   EXPECT_EQ(FDE.Info, 0u);
   EXPECT_EQ(FDE.getPAuthKey(), 0);
   EXPECT_EQ(FDE.getFDEType(), FDEType::PCInc);
@@ -58,8 +80,8 @@ TEST(SFrameTest, FDEFlags) {
   EXPECT_EQ(FDE.getFREType(), FREType::Addr4);
 }
 
-TEST(SFrameTest, FREFlags) {
-  FREInfo Info = {};
+TYPED_TEST(SFrameTest, FREFlags) {
+  FREInfo<TestFixture::Endian> Info = {};
   EXPECT_EQ(Info.Info, 0u);
   EXPECT_FALSE(Info.isReturnAddressSigned());
   EXPECT_EQ(Info.getOffsetSize(), FREOffset::B1);