1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
|
#ifndef DWARF_H
#define DWARF_H
class CommonInformationEntryList;
class IArchitecture;
class EncodedData : public std::vector<uint8_t>
{
public:
EncodedData(uint64_t address = 0, OperandSize pointer_size = osByte);
void ReadFromFile(IArchitecture &file, size_t size);
uint8_t ReadByte(size_t *pos) const;
uint16_t ReadWord(size_t *pos) const;
uint32_t ReadDWord(size_t *pos) const;
uint64_t ReadQWord(size_t *pos) const;
uint64_t ReadUleb128(size_t *pos) const;
int64_t ReadSleb128(size_t *pos) const;
std::string ReadString(size_t *pos) const;
uint32_t ReadUnsigned(size_t *pos) const;
uint64_t ReadEncoding(uint8_t encoding, size_t *pos) const;
void WriteString(const std::string &str);
void WriteUleb128(uint64_t value);
void WriteSleb128(int64_t value);
void WriteByte(uint8_t value);
void WriteWord(uint16_t value);
void WriteDWord(uint32_t value);
void WriteQWord(uint64_t value);
void WriteEncoding(uint8_t encoding, uint64_t value);
uint64_t address() const { return address_; }
OperandSize pointer_size() const { return pointer_size_; }
void Read(void *buf, size_t count, size_t *pos) const;
void Write(const void *buf, size_t count);
size_t encoding_size(uint8_t encoding) const;
private:
uint64_t address_;
OperandSize pointer_size_;
};
class CommonInformationEntry : public IObject
{
public:
explicit CommonInformationEntry(CommonInformationEntryList *owner, uint8_t version, const std::string &augmentation,
uint64_t code_alignment_factor, uint64_t data_alignment_factor, uint8_t return_adddress_register, uint8_t fde_encoding,
uint8_t lsda_encoding, uint8_t personality_encoding, uint64_t personality_routine, const std::vector<uint8_t> &initial_instructions);
explicit CommonInformationEntry(CommonInformationEntryList *owner, const CommonInformationEntry &src);
~CommonInformationEntry();
CommonInformationEntry *Clone(CommonInformationEntryList *owner) const;
uint8_t version() const { return version_; }
std::string augmentation() const { return augmentation_; }
uint64_t code_alignment_factor() const { return code_alignment_factor_; }
uint64_t data_alignment_factor() const { return data_alignment_factor_; }
uint8_t return_address_register() const { return return_address_register_; }
uint8_t fde_encoding() const { return fde_encoding_; }
uint8_t lsda_encoding() const { return lsda_encoding_; }
uint8_t personality_encoding() const { return personality_encoding_; }
uint64_t personality_routine() const { return personality_routine_; }
std::vector<uint8_t> initial_instructions() const { return initial_instructions_; }
void Rebase(uint64_t delta_base);
private:
CommonInformationEntryList *owner_;
uint8_t version_;
std::string augmentation_;
uint64_t code_alignment_factor_;
uint64_t data_alignment_factor_;
uint8_t return_address_register_;
uint8_t fde_encoding_;
uint8_t lsda_encoding_;
uint8_t personality_encoding_;
uint64_t personality_routine_;
std::vector<uint8_t> initial_instructions_;
};
class CommonInformationEntryList : public ObjectList<CommonInformationEntry>
{
public:
explicit CommonInformationEntryList();
explicit CommonInformationEntryList(const CommonInformationEntryList &src);
CommonInformationEntry *Add(uint8_t version, const std::string &augmentation, uint64_t code_alignment_factor,
uint64_t data_alignment_factor, uint8_t return_address_register, uint8_t fde_encoding,
uint8_t lsda_encoding, uint8_t personality_encoding, uint64_t personality_routine, const std::vector<uint8_t> &call_frame_instructions);
CommonInformationEntryList *Clone() const;
void Rebase(uint64_t delta_base);
private:
// no assignment op
CommonInformationEntryList &operator =(const CommonInformationEntryList &);
};
class DwarfParser
{
public:
static uint32_t CreateCompactEncoding(IArchitecture &file, const std::vector<uint8_t> &fde_instructions, CommonInformationEntry *cie_, uint64_t start);
private:
enum { kMaxRegisterNumber = 120 };
enum RegisterSavedWhere { kRegisterUnused, kRegisterInCFA, kRegisterOffsetFromCFA,
kRegisterInRegister, kRegisterAtExpression, kRegisterIsExpression } ;
struct RegisterLocation {
RegisterSavedWhere location;
int64_t value;
};
struct PrologInfo {
uint32_t cfaRegister;
int32_t cfaRegisterOffset; // CFA = (cfaRegister)+cfaRegisterOffset
int64_t cfaExpression; // CFA = expression
uint32_t spExtraArgSize;
uint32_t codeOffsetAtStackDecrement;
uint8_t registerSavedTwiceInCIE;
bool registersInOtherRegisters;
bool registerSavedMoreThanOnce;
bool cfaOffsetWasNegative;
bool sameValueUsed;
RegisterLocation savedRegisters[kMaxRegisterNumber]; // from where to restore registers
};
static bool ParseInstructions(const std::vector<uint8_t> &instructions, CommonInformationEntry *cie_, PrologInfo &info);
static uint32_t CreateCompactEncodingForX32(IArchitecture &file, uint64_t start, PrologInfo &info);
static uint32_t CreateCompactEncodingForX64(IArchitecture &file, uint64_t start, PrologInfo &info);
static uint32_t GetRBPEncodedRegister(uint32_t reg, int32_t regOffsetFromBaseOffset, bool &failure);
static uint32_t GetEBPEncodedRegister(uint32_t reg, int32_t regOffsetFromBaseOffset, bool &failure);
};
#endif
|
