Skip to content

Commit 50df1f8

Browse files
labathlabath
committed
llvm-ify
1 parent 92d1dba commit 50df1f8

File tree

2 files changed

+147
-145
lines changed

2 files changed

+147
-145
lines changed

‎llvm/include/llvm/BinaryFormat/SFrame.h‎

Lines changed: 94 additions & 92 deletions
Original file line numberDiff line numberDiff line change
@@ -1,4 +1,4 @@
1-
//===-- llvm/BinaryFormat/SFrame.h ---SFrame Data Structures ----*- C++ -*-===//
1+
//===----------------------------------------------------------------------===//
22
//
33
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
44
// See https://llvm.org/LICENSE.txt for license information.
@@ -10,156 +10,158 @@
1010
/// This file contains data-structure definitions and constants to support
1111
/// unwinding based on .sframe sections. This only supports SFRAME_VERSION_2
1212
/// as described at https://sourceware.org/binutils/docs/sframe-spec.html
13-
///
14-
/// Naming conventions follow the spec document. #defines converted to constants
15-
/// and enums for better C++ compatibility.
1613
//===----------------------------------------------------------------------===//
1714

1815
#ifndef LLVM_BINARYFORMAT_SFRAME_H
1916
#define LLVM_BINARYFORMAT_SFRAME_H
2017

18+
#include "llvm/ADT/BitmaskEnum.h"
2119
#include "llvm/Support/Compiler.h"
2220
#include "llvm/Support/DataTypes.h"
2321

24-
namespace llvm {
22+
namespace llvm::sframe {
2523

26-
namespace sframe {
24+
LLVM_ENABLE_BITMASK_ENUMS_IN_NAMESPACE();
2725

28-
constexpr uint16_t SFRAME_MAGIC = 0xDEE2;
26+
constexpr uint16_t MagicSignature = 0xdee2;
2927

30-
enum : uint8_t {
31-
SFRAME_VERSION_1 = 1,
32-
SFRAME_VERSION_2 = 2,
28+
enum class Version : uint8_t {
29+
V1 = 1,
30+
V2 = 2,
3331
};
3432

35-
/// sframe_preable.sfp_flags flags.
36-
enum : uint8_t {
37-
SFRAME_F_FDE_SORTED = 0x1,
38-
SFRAME_F_FRAME_POINTER = 0x2,
33+
enum class Flags : uint8_t {
34+
FDESorted = 0x01,
35+
FramePointer = 0x02,
36+
LLVM_MARK_AS_BITMASK_ENUM(/*LargestValue=*/0xff),
3937
};
4038

41-
/// Possible values for sframe_header.sfh_abi_arch.
42-
enum : uint8_t {
43-
SFRAME_ABI_AARCH64_ENDIAN_BIG = 1,
44-
SFRAME_ABI_AARCH64_ENDIAN_LITTLE = 2,
45-
SFRAME_ABI_AMD64_ENDIAN_LITTLE = 3
39+
enum class ABI : uint8_t {
40+
AArch64EndianBig = 1,
41+
AArch64EndianLittle = 2,
42+
AMD64EndianLittle = 3,
4643
};
4744

48-
/// SFrame FRE Types. Bits 0-3 of sframe_func_desc_entry.sfde_func_info.
49-
enum : uint8_t {
50-
SFRAME_FRE_TYPE_ADDR1 = 0,
51-
SFRAME_FRE_TYPE_ADDR2 = 1,
52-
SFRAME_FRE_TYPE_ADDR4 = 2,
45+
/// SFrame FRE Types. Bits 0-3 of FuncDescEntry.Info.
46+
enum class FREType : uint8_t {
47+
Addr1 = 0,
48+
Addr2 = 1,
49+
Addr4 = 2,
5350
};
5451

55-
/// SFrame FDE Types. Bit 4 of sframe_func_desc_entry.sfde_func_info.
56-
enum : uint8_t {
57-
SFRAME_FDE_TYPE_PCINC = 0,
58-
SFRAME_FDE_TYPE_PCMASK = 1,
52+
/// SFrame FDE Types. Bit 4 of FuncDescEntry.Info.
53+
enum class FDEType : uint8_t {
54+
PCInc = 0,
55+
PCMask = 1,
5956
};
6057

6158
/// Speficies key used for signing return addresses. Bit 5 of
62-
/// sframe_func_desc_entry.sfde_func_info.
63-
enum : uint8_t {
64-
SFRAME_AARCH64_PAUTH_KEY_A = 0,
65-
SFRAME_AARCH64_PAUTH_KEY_B = 1,
59+
/// FuncDescEntry.Info.
60+
enum class AArch64PAuthKey : uint8_t {
61+
A = 0,
62+
B = 1,
6663
};
6764

68-
/// Size of stack offsets. Bits 5-6 of sframe_fre_info.fre_info.
69-
enum : uint8_t {
70-
SFRAME_FRE_OFFSET_1B = 0,
71-
SFRAME_FRE_OFFSET_2B = 1,
72-
SFRAME_FRE_OFFSET_4B = 2,
65+
/// Size of stack offsets. Bits 5-6 of FREInfo.Info.
66+
enum class FREOffset : uint8_t {
67+
B1 = 0,
68+
B2 = 1,
69+
B4 = 2,
7370
};
7471

75-
/// Stack frame base register. Bit 0 of sframe_fre_info.fre_info.
76-
enum : uint8_t { SFRAME_BASE_REG_FP = 0, SFRAME_BASE_REG_SP = 1 };
72+
/// Stack frame base register. Bit 0 of FREInfo.Info.
73+
enum class BaseReg : uint8_t {
74+
FP = 0,
75+
SP = 1,
76+
};
7777

7878
LLVM_PACKED_START
7979

80-
struct sframe_preamble {
81-
uint16_t sfp_magic;
82-
uint8_t sfp_version;
83-
uint8_t sfp_flags;
80+
struct Preamble {
81+
uint16_t Magic;
82+
enum Version Version;
83+
enum Flags Flags;
8484
};
8585

86-
struct sframe_header {
87-
sframe_preamble sfh_preamble;
88-
uint8_t sfh_abi_arch;
89-
int8_t sfh_cfa_fixed_fp_offset;
90-
int8_t sfh_cfa_fixed_ra_offset;
91-
uint8_t sfh_auxhdr_len;
92-
uint32_t sfh_num_fdes;
93-
uint32_t sfh_num_fres;
94-
uint32_t sfh_fre_len;
95-
uint32_t sfh_fdeoff;
96-
uint32_t sfh_freoff;
86+
struct Header {
87+
struct Preamble Preamble;
88+
ABI ABIArch;
89+
int8_t CFAFixedFPOffset;
90+
int8_t CFAFixedRAOffset;
91+
uint8_t AuxHdrLen;
92+
uint32_t NumFDEs;
93+
uint32_t NumFREs;
94+
uint32_t FRELen;
95+
uint32_t FDEOff;
96+
uint32_t FREOff;
9797
};
9898

99-
struct sframe_func_desc_entry {
100-
int32_t sfde_func_start_address;
101-
uint32_t sfde_func_size;
102-
uint32_t sfde_func_start_fre_off;
103-
uint32_t sfde_func_num_fres;
104-
uint8_t sfde_func_info;
105-
uint8_t sfde_func_rep_size;
106-
uint16_t sfde_func_padding2;
107-
108-
uint8_t getPAuthKey() const { return (sfde_func_info >> 5) & 1; }
109-
uint8_t getFDEType() const { return (sfde_func_info >> 4) & 1; }
110-
uint8_t getFREType() const { return sfde_func_info & 0xf; }
99+
struct FuncDescEntry {
100+
int32_t StartAddress;
101+
uint32_t Size;
102+
uint32_t StartFREOff;
103+
uint32_t NumFREs;
104+
uint8_t Info;
105+
uint8_t RepSize;
106+
uint16_t Padding2;
107+
108+
uint8_t getPAuthKey() const { return (Info >> 5) & 1; }
109+
FDEType getFDEType() const { return static_cast<FDEType>((Info >> 4) & 1); }
110+
FREType getFREType() const { return static_cast<FREType>(Info & 0xf); }
111111
void setPAuthKey(uint8_t P) { setFuncInfo(P, getFDEType(), getFREType()); }
112-
void setFDEType(uint8_t D) { setFuncInfo(getPAuthKey(), D, getFREType()); }
113-
void setFREType(uint8_t R) { setFuncInfo(getPAuthKey(), getFDEType(), R); }
114-
void setFuncInfo(uint8_t PAuthKey, uint8_t FDEType, uint8_t FREType) {
115-
sfde_func_info =
116-
((PAuthKey & 1) << 5) | ((FDEType & 1) << 4) | (FREType & 0xf);
112+
void setFDEType(FDEType D) { setFuncInfo(getPAuthKey(), D, getFREType()); }
113+
void setFREType(FREType R) { setFuncInfo(getPAuthKey(), getFDEType(), R); }
114+
void setFuncInfo(uint8_t PAuthKey, FDEType FDE, FREType FRE) {
115+
Info = ((PAuthKey & 1) << 5) | ((static_cast<uint8_t>(FDE) & 1) << 4) |
116+
(static_cast<uint8_t>(FRE) & 0xf);
117117
}
118118
};
119119

120-
struct sframe_fre_info {
121-
uint8_t fre_info;
120+
struct FREInfo {
121+
uint8_t Info;
122122

123-
bool isReturnAddressSigned() const { return fre_info >> 7; }
124-
uint8_t getOffsetSize() const { return (fre_info >> 5) & 3; }
125-
uint8_t getOffsetCount() const { return (fre_info >> 1) & 0xf; }
126-
uint8_t getBaseRegister() const { return fre_info & 1; }
123+
bool isReturnAddressSigned() const { return Info >> 7; }
124+
FREOffset getOffsetSize() const {
125+
return static_cast<FREOffset>((Info >> 5) & 3);
126+
}
127+
uint8_t getOffsetCount() const { return (Info >> 1) & 0xf; }
128+
BaseReg getBaseRegister() const { return static_cast<BaseReg>(Info & 1); }
127129
void setReturnAddressSigned(bool RA) {
128130
setFREInfo(RA, getOffsetSize(), getOffsetCount(), getBaseRegister());
129131
}
130-
void setOffsetSize(uint8_t Sz) {
132+
void setOffsetSize(FREOffset Sz) {
131133
setFREInfo(isReturnAddressSigned(), Sz, getOffsetCount(),
132134
getBaseRegister());
133135
}
134136
void setOffsetCount(uint8_t N) {
135137
setFREInfo(isReturnAddressSigned(), getOffsetSize(), N, getBaseRegister());
136138
}
137-
void setBaseRegister(uint8_t Reg) {
139+
void setBaseRegister(BaseReg Reg) {
138140
setFREInfo(isReturnAddressSigned(), getOffsetSize(), getOffsetCount(), Reg);
139141
}
140-
void setFREInfo(bool RA, uint8_t Sz, uint8_t N, uint8_t Reg) {
141-
fre_info = ((RA & 1) << 7) | ((Sz & 3) << 5) | ((N & 0xf) << 1) | (Reg & 1);
142+
void setFREInfo(bool RA, FREOffset Sz, uint8_t N, BaseReg Reg) {
143+
Info = ((RA & 1) << 7) | ((static_cast<uint8_t>(Sz) & 3) << 5) |
144+
((N & 0xf) << 1) | (static_cast<uint8_t>(Reg) & 1);
142145
}
143146
};
144147

145-
struct sframe_frame_row_entry_addr1 {
146-
uint8_t sfre_start_address;
147-
sframe_fre_info sfre_info;
148+
struct FrameRowEntryAddr1 {
149+
uint8_t StartAddress;
150+
FREInfo Info;
148151
};
149152

150-
struct sframe_frame_row_entry_addr2 {
151-
uint16_t sfre_start_address;
152-
sframe_fre_info sfre_info;
153+
struct FrameRowEntryAddr2 {
154+
uint16_t StartAddress;
155+
FREInfo Info;
153156
};
154157

155-
struct sframe_frame_row_entry_addr4 {
156-
uint32_t sfre_start_address;
157-
sframe_fre_info sfre_info;
158+
struct FrameRowEntryAddr4 {
159+
uint32_t StartAddress;
160+
FREInfo Info;
158161
};
159162

160163
LLVM_PACKED_END
161164

162-
} // namespace sframe
163-
} // namespace llvm
165+
} // namespace llvm::sframe
164166

165167
#endif // LLVM_BINARYFORMAT_SFRAME_H

‎llvm/unittests/BinaryFormat/SFrameTest.cpp‎

Lines changed: 53 additions & 53 deletions
Original file line numberDiff line numberDiff line change
@@ -14,85 +14,85 @@ using namespace llvm::sframe;
1414

1515
namespace {
1616
// Test structure sizes and triviality.
17-
static_assert(std::is_trivial_v<sframe_preamble>);
18-
static_assert(sizeof(sframe_preamble) == 4);
17+
static_assert(std::is_trivial_v<Preamble>);
18+
static_assert(sizeof(Preamble) == 4);
1919

20-
static_assert(std::is_trivial_v<sframe_header>);
21-
static_assert(sizeof(sframe_header) == 28);
20+
static_assert(std::is_trivial_v<Header>);
21+
static_assert(sizeof(Header) == 28);
2222

23-
static_assert(std::is_trivial_v<sframe_func_desc_entry>);
24-
static_assert(sizeof(sframe_func_desc_entry) == 20);
23+
static_assert(std::is_trivial_v<FuncDescEntry>);
24+
static_assert(sizeof(FuncDescEntry) == 20);
2525

26-
static_assert(std::is_trivial_v<sframe_frame_row_entry_addr1>);
27-
static_assert(sizeof(sframe_frame_row_entry_addr1) == 2);
26+
static_assert(std::is_trivial_v<FrameRowEntryAddr1>);
27+
static_assert(sizeof(FrameRowEntryAddr1) == 2);
2828

29-
static_assert(std::is_trivial_v<sframe_frame_row_entry_addr2>);
30-
static_assert(sizeof(sframe_frame_row_entry_addr2) == 3);
29+
static_assert(std::is_trivial_v<FrameRowEntryAddr2>);
30+
static_assert(sizeof(FrameRowEntryAddr2) == 3);
3131

32-
static_assert(std::is_trivial_v<sframe_frame_row_entry_addr4>);
33-
static_assert(sizeof(sframe_frame_row_entry_addr4) == 5);
32+
static_assert(std::is_trivial_v<FrameRowEntryAddr4>);
33+
static_assert(sizeof(FrameRowEntryAddr4) == 5);
3434

3535
TEST(SFrameTest, FDEFlags) {
36-
sframe_func_desc_entry FDE = {};
37-
EXPECT_EQ(FDE.sfde_func_info, 0u);
38-
EXPECT_EQ(FDE.getPAuthKey(), SFRAME_AARCH64_PAUTH_KEY_A);
39-
EXPECT_EQ(FDE.getFDEType(), SFRAME_FDE_TYPE_PCINC);
40-
EXPECT_EQ(FDE.getFREType(), SFRAME_FRE_TYPE_ADDR1);
41-
42-
FDE.setPAuthKey(SFRAME_AARCH64_PAUTH_KEY_B);
43-
EXPECT_EQ(FDE.sfde_func_info, 0x20u);
44-
EXPECT_EQ(FDE.getPAuthKey(), SFRAME_AARCH64_PAUTH_KEY_B);
45-
EXPECT_EQ(FDE.getFDEType(), SFRAME_FDE_TYPE_PCINC);
46-
EXPECT_EQ(FDE.getFREType(), SFRAME_FRE_TYPE_ADDR1);
47-
48-
FDE.setFDEType(SFRAME_FDE_TYPE_PCMASK);
49-
EXPECT_EQ(FDE.sfde_func_info, 0x30u);
50-
EXPECT_EQ(FDE.getPAuthKey(), SFRAME_AARCH64_PAUTH_KEY_B);
51-
EXPECT_EQ(FDE.getFDEType(), SFRAME_FDE_TYPE_PCMASK);
52-
EXPECT_EQ(FDE.getFREType(), SFRAME_FRE_TYPE_ADDR1);
53-
54-
FDE.setFREType(SFRAME_FRE_TYPE_ADDR4);
55-
EXPECT_EQ(FDE.sfde_func_info, 0x32u);
56-
EXPECT_EQ(FDE.getPAuthKey(), SFRAME_AARCH64_PAUTH_KEY_B);
57-
EXPECT_EQ(FDE.getFDEType(), SFRAME_FDE_TYPE_PCMASK);
58-
EXPECT_EQ(FDE.getFREType(), SFRAME_FRE_TYPE_ADDR4);
36+
FuncDescEntry FDE = {};
37+
EXPECT_EQ(FDE.Info, 0u);
38+
EXPECT_EQ(FDE.getPAuthKey(), 0);
39+
EXPECT_EQ(FDE.getFDEType(), FDEType::PCInc);
40+
EXPECT_EQ(FDE.getFREType(), FREType::Addr1);
41+
42+
FDE.setPAuthKey(1);
43+
EXPECT_EQ(FDE.Info, 0x20u);
44+
EXPECT_EQ(FDE.getPAuthKey(), 1);
45+
EXPECT_EQ(FDE.getFDEType(), FDEType::PCInc);
46+
EXPECT_EQ(FDE.getFREType(), FREType::Addr1);
47+
48+
FDE.setFDEType(FDEType::PCMask);
49+
EXPECT_EQ(FDE.Info, 0x30u);
50+
EXPECT_EQ(FDE.getPAuthKey(), 1);
51+
EXPECT_EQ(FDE.getFDEType(), FDEType::PCMask);
52+
EXPECT_EQ(FDE.getFREType(), FREType::Addr1);
53+
54+
FDE.setFREType(FREType::Addr4);
55+
EXPECT_EQ(FDE.Info, 0x32u);
56+
EXPECT_EQ(FDE.getPAuthKey(), 1);
57+
EXPECT_EQ(FDE.getFDEType(), FDEType::PCMask);
58+
EXPECT_EQ(FDE.getFREType(), FREType::Addr4);
5959
}
6060

6161
TEST(SFrameTest, FREFlags) {
62-
sframe_fre_info Info = {};
63-
EXPECT_EQ(Info.fre_info, 0u);
62+
FREInfo Info = {};
63+
EXPECT_EQ(Info.Info, 0u);
6464
EXPECT_FALSE(Info.isReturnAddressSigned());
65-
EXPECT_EQ(Info.getOffsetSize(), SFRAME_FRE_OFFSET_1B);
65+
EXPECT_EQ(Info.getOffsetSize(), FREOffset::B1);
6666
EXPECT_EQ(Info.getOffsetCount(), 0u);
67-
EXPECT_EQ(Info.getBaseRegister(), SFRAME_BASE_REG_FP);
67+
EXPECT_EQ(Info.getBaseRegister(), BaseReg::FP);
6868

6969
Info.setReturnAddressSigned(true);
70-
EXPECT_EQ(Info.fre_info, 0x80u);
70+
EXPECT_EQ(Info.Info, 0x80u);
7171
EXPECT_TRUE(Info.isReturnAddressSigned());
72-
EXPECT_EQ(Info.getOffsetSize(), SFRAME_FRE_OFFSET_1B);
72+
EXPECT_EQ(Info.getOffsetSize(), FREOffset::B1);
7373
EXPECT_EQ(Info.getOffsetCount(), 0u);
74-
EXPECT_EQ(Info.getBaseRegister(), SFRAME_BASE_REG_FP);
74+
EXPECT_EQ(Info.getBaseRegister(), BaseReg::FP);
7575

76-
Info.setOffsetSize(SFRAME_FRE_OFFSET_4B);
77-
EXPECT_EQ(Info.fre_info, 0xc0u);
76+
Info.setOffsetSize(FREOffset::B4);
77+
EXPECT_EQ(Info.Info, 0xc0u);
7878
EXPECT_TRUE(Info.isReturnAddressSigned());
79-
EXPECT_EQ(Info.getOffsetSize(), SFRAME_FRE_OFFSET_4B);
79+
EXPECT_EQ(Info.getOffsetSize(), FREOffset::B4);
8080
EXPECT_EQ(Info.getOffsetCount(), 0u);
81-
EXPECT_EQ(Info.getBaseRegister(), SFRAME_BASE_REG_FP);
81+
EXPECT_EQ(Info.getBaseRegister(), BaseReg::FP);
8282

8383
Info.setOffsetCount(3);
84-
EXPECT_EQ(Info.fre_info, 0xc6u);
84+
EXPECT_EQ(Info.Info, 0xc6u);
8585
EXPECT_TRUE(Info.isReturnAddressSigned());
86-
EXPECT_EQ(Info.getOffsetSize(), SFRAME_FRE_OFFSET_4B);
86+
EXPECT_EQ(Info.getOffsetSize(), FREOffset::B4);
8787
EXPECT_EQ(Info.getOffsetCount(), 3u);
88-
EXPECT_EQ(Info.getBaseRegister(), SFRAME_BASE_REG_FP);
88+
EXPECT_EQ(Info.getBaseRegister(), BaseReg::FP);
8989

90-
Info.setBaseRegister(SFRAME_BASE_REG_SP);
91-
EXPECT_EQ(Info.fre_info, 0xc7u);
90+
Info.setBaseRegister(BaseReg::SP);
91+
EXPECT_EQ(Info.Info, 0xc7u);
9292
EXPECT_TRUE(Info.isReturnAddressSigned());
93-
EXPECT_EQ(Info.getOffsetSize(), SFRAME_FRE_OFFSET_4B);
93+
EXPECT_EQ(Info.getOffsetSize(), FREOffset::B4);
9494
EXPECT_EQ(Info.getOffsetCount(), 3u);
95-
EXPECT_EQ(Info.getBaseRegister(), SFRAME_BASE_REG_SP);
95+
EXPECT_EQ(Info.getBaseRegister(), BaseReg::SP);
9696
}
9797

9898
} // namespace

0 commit comments

Comments
 (0)