ScuroNeko
/
VMProtect
mirror of https://github.com/Obfuscator-Collections/VMProtect.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity
VMProtect/core/dwarf.cc

1188 lines
35 KiB
C++
Raw Normal View History

first commit Version 3.x.x
2023-05-14 16:21:09 +03:00
#include "../runtime/crypto.h"
#include "objects.h"
#include "files.h"
#include "dwarf.h"
/**
* EncodedData
*/
EncodedData::EncodedData(uint64_t address, OperandSize pointer_size)
: std::vector<uint8_t>(), address_(address), pointer_size_(pointer_size)
{
}
void EncodedData::Read(void *buf, size_t count, size_t *pos) const
{
if (*pos + count > size())
throw std::runtime_error("buffer index out of bounds");
memcpy(buf, data() + *pos, count);
*pos += count;
}
void EncodedData::ReadFromFile(IArchitecture &file, size_t size)
{
resize(size);
file.Read(data(), size);
}
uint8_t EncodedData::ReadByte(size_t *pos) const
{
uint8_t res;
Read(&res, sizeof(res), pos);
return res;
}
uint16_t EncodedData::ReadWord(size_t *pos) const
{
uint16_t res;
Read(&res, sizeof(res), pos);
return res;
}
uint32_t EncodedData::ReadDWord(size_t *pos) const
{
uint32_t res;
Read(&res, sizeof(res), pos);
return res;
}
uint64_t EncodedData::ReadQWord(size_t *pos) const
{
uint64_t res;
Read(&res, sizeof(res), pos);
return res;
}
uint64_t EncodedData::ReadUleb128(size_t *pos) const
{
uint64_t result = 0, slice;
int bit = 0;
uint8_t byte;
do {
byte = ReadByte(pos);
slice = byte & 0x7f;
if (bit > 63) {
throw std::runtime_error("uleb128 too big for uint64");
} else {
result |= (slice << bit);
bit += 7;
}
} while (byte & 0x80);
return result;
}
int64_t EncodedData::ReadSleb128(size_t *pos) const
{
int64_t result = 0;
int bit = 0;
uint8_t byte;
do {
byte = ReadByte(pos);
result |= (int64_t(byte & 0x7f) << bit);
bit += 7;
} while (byte & 0x80);
/* Sign extend negative numbers. */
if ((byte & 0x40) != 0)
result |= (-1LL) << bit; //-V610
return result;
}
std::string EncodedData::ReadString(size_t *pos) const
{
std::string res;
while (true) {
char c = ReadByte(pos);
if (c == '\0')
break;
res.push_back(c);
}
return res;
}
uint32_t EncodedData::ReadUnsigned(size_t *pos) const
{
static const uint32_t len_tab[0x10] = {
1, 2, 1, 3, 1, 2, 1, 4, 1, 2, 1, 3, 1, 2, 1, 5
};
uint8_t c = at(*pos) & 0xf;
size_t size = len_tab[c];
*pos += size;
uint32_t res = 0;
bool need_shift = true;
if (size > 4) {
size = 4;
need_shift = false;
}
memcpy(&res, data() + *pos - size, size);
if (need_shift)
res >>= len_tab[c];
return res;
}
uint64_t EncodedData::ReadEncoding(uint8_t encoding, size_t *pos) const
{
uint64_t base;
switch (encoding & 0x70) {
case DW_EH_PE_pcrel:
base = address_ + *pos;
break;
case DW_EH_PE_datarel:
base = address_;
break;
default:
base = 0;
break;
}
switch (encoding & 0x0f) {
case DW_EH_PE_absptr:
if (pointer_size_ == osDWord)
return base + static_cast<int32_t>(ReadDWord(pos));
if (pointer_size_ == osQWord)
return base + static_cast<int64_t>(ReadQWord(pos));
break;
case DW_EH_PE_uleb128:
return base + ReadUleb128(pos);
case DW_EH_PE_sleb128:
return base + ReadSleb128(pos);
case DW_EH_PE_udata2:
return base + ReadWord(pos);
case DW_EH_PE_sdata2:
return base + static_cast<int16_t>(ReadWord(pos));
case DW_EH_PE_udata4:
return base + ReadDWord(pos);
case DW_EH_PE_sdata4:
return base + static_cast<int32_t>(ReadDWord(pos));
case DW_EH_PE_udata8:
return base + ReadQWord(pos);
case DW_EH_PE_sdata8:
return base + static_cast<int64_t>(ReadQWord(pos));
}
throw std::runtime_error("Invalid encoding");
}
void EncodedData::WriteUleb128(uint64_t value)
{
uint8_t byte;
do {
byte = value & 0x7F;
value &= ~(uint64_t)0x7F;
if ( value != 0 )
byte |= 0x80;
push_back(byte);
value = value >> 7;
} while( byte >= 0x80 );
}
void EncodedData::WriteSleb128(int64_t value)
{
bool is_neg = ( value < 0 );
uint8_t byte;
bool more;
do {
byte = value & 0x7F;
value = value >> 7;
if (is_neg)
more = ((value != -1) || ((byte & 0x40) == 0));
else
more = ((value != 0) || ((byte & 0x40) != 0));
if (more)
byte |= 0x80;
push_back(byte);
}
while( more );
}
void EncodedData::WriteString(const std::string &str)
{
Write(str.c_str(), str.size() + 1);
}
void EncodedData::WriteByte(uint8_t value)
{
push_back(value);
}
void EncodedData::WriteWord(uint16_t value)
{
Write(&value, sizeof(value));
}
void EncodedData::WriteDWord(uint32_t value)
{
Write(&value, sizeof(value));
}
void EncodedData::WriteQWord(uint64_t value)
{
Write(&value, sizeof(value));
}
void EncodedData::Write(const void *buf, size_t count)
{
insert(end(), static_cast<const uint8_t *>(buf), static_cast<const uint8_t *>(buf) + count);
}
void EncodedData::WriteEncoding(uint8_t encoding, uint64_t value)
{
switch (encoding & 0x70) {
case DW_EH_PE_pcrel:
value -= address_ + size();
break;
case DW_EH_PE_datarel:
value -= address_;
break;
}
switch (encoding & 0x0f) {
case DW_EH_PE_absptr:
if (pointer_size_ == osDWord) {
WriteDWord(static_cast<uint32_t>(value));
return;
}
if (pointer_size_ == osQWord) {
WriteQWord(value);
return;
}
break;
case DW_EH_PE_uleb128:
WriteUleb128(value);
return;
case DW_EH_PE_sleb128:
WriteSleb128(value);
return;
case DW_EH_PE_udata2:
case DW_EH_PE_sdata2:
WriteWord(static_cast<uint16_t>(value));
return;
case DW_EH_PE_udata4:
case DW_EH_PE_sdata4:
WriteDWord(static_cast<uint32_t>(value));
return;
case DW_EH_PE_udata8:
case DW_EH_PE_sdata8:
WriteQWord(value);
return;
}
throw std::runtime_error("Invalid encoding");
}
size_t EncodedData::encoding_size(uint8_t encoding) const
{
switch (encoding & 0x0f) {
case DW_EH_PE_absptr:
return OperandSizeToValue(pointer_size_);
case DW_EH_PE_udata2:
case DW_EH_PE_sdata2:
return sizeof(uint16_t);
case DW_EH_PE_udata4:
case DW_EH_PE_sdata4:
return sizeof(uint32_t);
case DW_EH_PE_udata8:
case DW_EH_PE_sdata8:
return sizeof(uint64_t);
}
throw std::runtime_error("Invalid encoding");
}
/**
* CommonInformationEntry
*/
CommonInformationEntry::CommonInformationEntry(CommonInformationEntryList *owner, 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> &initial_instructions)
: IObject(), owner_(owner), version_(version), augmentation_(augmentation), code_alignment_factor_(code_alignment_factor),
data_alignment_factor_(data_alignment_factor), return_address_register_(return_address_register), fde_encoding_(fde_encoding),
lsda_encoding_(lsda_encoding), personality_encoding_(personality_encoding), personality_routine_(personality_routine), initial_instructions_(initial_instructions)
{
}
CommonInformationEntry::CommonInformationEntry(CommonInformationEntryList *owner, const CommonInformationEntry &src)
: IObject(), owner_(owner)
{
version_ = src.version_;
code_alignment_factor_ = src.code_alignment_factor_;
data_alignment_factor_ = src.data_alignment_factor_;
return_address_register_ = src.return_address_register_;
augmentation_ = src.augmentation_;
fde_encoding_ = src.fde_encoding_;
lsda_encoding_ = src.lsda_encoding_;
personality_encoding_ = src.personality_encoding_;
personality_routine_ = src.personality_routine_;
initial_instructions_ = src.initial_instructions_;
}
CommonInformationEntry *CommonInformationEntry::Clone(CommonInformationEntryList *owner) const
{
CommonInformationEntry *entry = new CommonInformationEntry(owner, *this);
return entry;
}
CommonInformationEntry::~CommonInformationEntry()
{
if (owner_)
owner_->RemoveObject(this);
}
void CommonInformationEntry::Rebase(uint64_t delta_base)
{
if (personality_routine_)
personality_routine_ += delta_base;
}
/**
* CommonInformationEntryList
*/
CommonInformationEntryList::CommonInformationEntryList()
: ObjectList<CommonInformationEntry>()
{
}
CommonInformationEntryList::CommonInformationEntryList(const CommonInformationEntryList &src)
: ObjectList<CommonInformationEntry>()
{
for (size_t i = 0; i < src.count(); i++) {
AddObject(src.item(i)->Clone(this));
}
}
CommonInformationEntry *CommonInformationEntryList::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)
{
CommonInformationEntry *entry = new CommonInformationEntry(this, version, augmentation, code_alignment_factor,
data_alignment_factor, return_address_register, fde_encoding, lsda_encoding, personality_encoding, personality_routine, call_frame_instructions);
AddObject(entry);
return entry;
}
CommonInformationEntryList *CommonInformationEntryList::Clone() const
{
CommonInformationEntryList *list = new CommonInformationEntryList(*this);
return list;
}
void CommonInformationEntryList::Rebase(uint64_t delta_base)
{
for (size_t i = 0; i < count(); i++) {
item(i)->Rebase(delta_base);
}
}
/**
* DwarfParser
*/
uint32_t DwarfParser::CreateCompactEncoding(IArchitecture &file, const std::vector<uint8_t> &fde_instructions, CommonInformationEntry *cie_, uint64_t start)
{
PrologInfo info = PrologInfo();
if (ParseInstructions(cie_->initial_instructions(), cie_, info) && ParseInstructions(fde_instructions, cie_, info))
return (file.cpu_address_size() == osDWord) ? CreateCompactEncodingForX32(file, start, info) : CreateCompactEncodingForX64(file, start, info);
return UNWIND_X86_MODE_DWARF;
}
bool DwarfParser::ParseInstructions(const std::vector<uint8_t> &instructions, CommonInformationEntry *cie_, PrologInfo &info)
{
EncodedData data;
data.Write(instructions.data(), instructions.size());
uint64_t reg, reg2, length;
uint64_t code_offset = 0;
int64_t offset;
PrologInfo initial_state = info;
for (size_t pos = 0; pos < data.size(); ) {
uint8_t opcode = data.ReadByte(&pos);
uint8_t operand;
switch (opcode) {
case DW_CFA_nop:
break;
case DW_CFA_set_loc:
code_offset = data.ReadEncoding(cie_->fde_encoding(), &pos);
break;
case DW_CFA_advance_loc1:
code_offset += data.ReadByte(&pos) * cie_->code_alignment_factor();
break;
case DW_CFA_advance_loc2:
code_offset += data.ReadWord(&pos) * cie_->code_alignment_factor();
break;
case DW_CFA_advance_loc4:
code_offset += data.ReadDWord(&pos) * cie_->code_alignment_factor();
break;
case DW_CFA_offset_extended:
reg = data.ReadUleb128(&pos);
offset = data.ReadUleb128(&pos) * cie_->data_alignment_factor();
if (reg >= kMaxRegisterNumber)
return false;
if (info.savedRegisters[reg].location != kRegisterUnused)
info.registerSavedMoreThanOnce = true;
info.savedRegisters[reg].location = kRegisterInCFA;
info.savedRegisters[reg].value = offset;
break;
case DW_CFA_restore_extended:
reg = data.ReadUleb128(&pos);
if (reg >= kMaxRegisterNumber)
return false;
info.savedRegisters[reg] = initial_state.savedRegisters[reg];
break;
case DW_CFA_undefined:
reg = data.ReadUleb128(&pos);
if (reg >= kMaxRegisterNumber)
return false;
info.savedRegisters[reg].location = kRegisterUnused;
break;
case DW_CFA_same_value:
reg = data.ReadUleb128(&pos);
if (reg >= kMaxRegisterNumber)
return false;
info.savedRegisters[reg].location = kRegisterUnused;
info.sameValueUsed = true;
break;
case DW_CFA_register:
reg = data.ReadUleb128(&pos);
reg2 = data.ReadUleb128(&pos);
if (reg >= kMaxRegisterNumber)
return false;
if (reg2 >= kMaxRegisterNumber)
return false;
info.savedRegisters[reg].location = kRegisterInRegister;
info.savedRegisters[reg].value = reg2;
info.registersInOtherRegisters = true;
break;
case DW_CFA_remember_state:
break;
case DW_CFA_restore_state:
break;
case DW_CFA_def_cfa:
reg = data.ReadUleb128(&pos);
offset = data.ReadUleb128(&pos);
if (reg >= kMaxRegisterNumber)
return false;
info.cfaRegister = static_cast<uint32_t>(reg);
info.cfaRegisterOffset = static_cast<int32_t>(offset);
if (offset > 0x80000000)
info.cfaOffsetWasNegative = true;
break;
case DW_CFA_def_cfa_register:
reg = data.ReadUleb128(&pos);
if (reg >= kMaxRegisterNumber)
return false;
info.cfaRegister = static_cast<uint32_t>(reg);
break;
case DW_CFA_def_cfa_offset:
info.cfaRegisterOffset = static_cast<int32_t>(data.ReadUleb128(&pos));
info.codeOffsetAtStackDecrement = static_cast<uint32_t>(code_offset);
break;
case DW_CFA_def_cfa_expression:
info.cfaRegister = 0;
info.cfaExpression = pos;
length = data.ReadUleb128(&pos);
pos += static_cast<size_t>(length);
break;
case DW_CFA_expression:
reg = data.ReadUleb128(&pos);
if (reg >= kMaxRegisterNumber)
return false;
info.savedRegisters[reg].location = kRegisterAtExpression;
info.savedRegisters[reg].value = pos;
length = data.ReadUleb128(&pos);
pos += static_cast<size_t>(length);
break;
case DW_CFA_offset_extended_sf:
reg = data.ReadUleb128(&pos);
offset = data.ReadSleb128(&pos) * cie_->data_alignment_factor();
if (reg >= kMaxRegisterNumber)
return false;
if (info.savedRegisters[reg].location != kRegisterUnused)
info.registerSavedMoreThanOnce = true;
info.savedRegisters[reg].location = kRegisterInCFA;
info.savedRegisters[reg].value = offset;
break;
case DW_CFA_def_cfa_sf:
reg = data.ReadUleb128(&pos);
offset = data.ReadSleb128(&pos) * cie_->data_alignment_factor();
if (reg >= kMaxRegisterNumber)
return false;
info.cfaRegister = static_cast<uint32_t>(reg);
info.cfaRegisterOffset = static_cast<int32_t>(offset);
break;
case DW_CFA_def_cfa_offset_sf:
info.cfaRegisterOffset = static_cast<int32_t>(data.ReadSleb128(&pos) * cie_->data_alignment_factor());
info.codeOffsetAtStackDecrement = static_cast<uint32_t>(code_offset);
break;
case DW_CFA_val_offset:
reg = data.ReadUleb128(&pos);
offset = data.ReadUleb128(&pos) * cie_->data_alignment_factor();
if (reg >= kMaxRegisterNumber)
return false;
info.savedRegisters[reg].location = kRegisterOffsetFromCFA;
info.savedRegisters[reg].value = offset;
break;
case DW_CFA_val_offset_sf:
reg = data.ReadUleb128(&pos);
offset = data.ReadSleb128(&pos) * cie_->data_alignment_factor();
if (reg >= kMaxRegisterNumber)
return false;
info.savedRegisters[reg].location = kRegisterOffsetFromCFA;
info.savedRegisters[reg].value = offset;
break;
case DW_CFA_val_expression:
reg = data.ReadUleb128(&pos);
if (reg >= kMaxRegisterNumber)
return false;
info.savedRegisters[reg].location = kRegisterIsExpression;
info.savedRegisters[reg].value = pos;
length = data.ReadUleb128(&pos);
pos += static_cast<size_t>(length);
break;
case DW_CFA_GNU_args_size:
offset = data.ReadUleb128(&pos);
info.spExtraArgSize = static_cast<uint32_t>(offset);
break;
case DW_CFA_GNU_negative_offset_extended:
reg = data.ReadUleb128(&pos);
if (reg >= kMaxRegisterNumber)
return false;
offset = data.ReadUleb128(&pos) * cie_->data_alignment_factor();
if (info.savedRegisters[reg].location != kRegisterUnused)
info.registerSavedMoreThanOnce = true;
info.savedRegisters[reg].location = kRegisterInCFA;
info.savedRegisters[reg].value = -offset;
break;
default:
operand = opcode & 0x3F;
switch ( opcode & 0xC0 ) {
case DW_CFA_offset:
reg = operand;
offset = data.ReadUleb128(&pos) * cie_->data_alignment_factor();
if (info.savedRegisters[reg].location != kRegisterUnused) {
/*
if ( (pcoffset == (pint_t)(-1))
&& (results->savedRegisters[reg].location == kRegisterInCFA)
&& (results->savedRegisters[reg].value == offset) )
results->registerSavedTwiceInCIE = reg;
else
results->registerSavedMoreThanOnce = true;
*/
}
info.savedRegisters[reg].location = kRegisterInCFA;
info.savedRegisters[reg].value = offset;
break;
case DW_CFA_advance_loc:
code_offset += operand * cie_->code_alignment_factor();
break;
case DW_CFA_restore:
reg = operand;
info.savedRegisters[reg] = initial_state.savedRegisters[reg];
break;
default:
return false;
}
}
}
return true;
}
uint32_t DwarfParser::GetRBPEncodedRegister(uint32_t reg, int32_t regOffsetFromBaseOffset, bool &failure)
{
if ( (regOffsetFromBaseOffset < 0) || (regOffsetFromBaseOffset > 32) ) {
failure = true;
return 0;
}
unsigned int slotIndex = regOffsetFromBaseOffset/8;
switch ( reg ) {
case UNW_X86_64_RBX:
return UNWIND_X86_64_REG_RBX << (slotIndex*3);
case UNW_X86_64_R12:
return UNWIND_X86_64_REG_R12 << (slotIndex*3);
case UNW_X86_64_R13:
return UNWIND_X86_64_REG_R13 << (slotIndex*3);
case UNW_X86_64_R14:
return UNWIND_X86_64_REG_R14 << (slotIndex*3);
case UNW_X86_64_R15:
return UNWIND_X86_64_REG_R15 << (slotIndex*3);
}
// invalid register
failure = true;
return 0;
}
uint32_t DwarfParser::CreateCompactEncodingForX64(IArchitecture &file, uint64_t start, PrologInfo &prolog)
{
if (prolog.registerSavedTwiceInCIE == DW_X86_64_RET_ADDR)
return UNWIND_X86_64_MODE_DWARF;
// don't create compact unwind info for unsupported dwarf kinds
if (prolog.registerSavedMoreThanOnce)
return UNWIND_X86_64_MODE_DWARF;
if (prolog.cfaOffsetWasNegative)
return UNWIND_X86_64_MODE_DWARF;
if (prolog.spExtraArgSize != 0)
return UNWIND_X86_64_MODE_DWARF;
if (prolog.sameValueUsed)
return UNWIND_X86_64_MODE_DWARF;
// figure out which kind of frame this function uses
bool standardRBPframe = (
(prolog.cfaRegister == UNW_X86_64_RBP)
&& (prolog.cfaRegisterOffset == 16)
&& (prolog.savedRegisters[UNW_X86_64_RBP].location == kRegisterInCFA)
&& (prolog.savedRegisters[UNW_X86_64_RBP].value == -16) );
bool standardRSPframe = (prolog.cfaRegister == UNW_X86_64_RSP);
if (!standardRBPframe && !standardRSPframe)
return UNWIND_X86_64_MODE_DWARF;
// scan which registers are saved
int saveRegisterCount = 0;
bool rbxSaved = false;
bool r12Saved = false;
bool r13Saved = false;
bool r14Saved = false;
bool r15Saved = false;
bool rbpSaved = false;
for (int i=0; i < 64; ++i) {
if ( prolog.savedRegisters[i].location != kRegisterUnused ) {
if ( prolog.savedRegisters[i].location != kRegisterInCFA )
return UNWIND_X86_64_MODE_DWARF;
switch (i) {
case UNW_X86_64_RBX:
rbxSaved = true;
++saveRegisterCount;
break;
case UNW_X86_64_R12:
r12Saved = true;
++saveRegisterCount;
break;
case UNW_X86_64_R13:
r13Saved = true;
++saveRegisterCount;
break;
case UNW_X86_64_R14:
r14Saved = true;
++saveRegisterCount;
break;
case UNW_X86_64_R15:
r15Saved = true;
++saveRegisterCount;
break;
case UNW_X86_64_RBP:
rbpSaved = true;
++saveRegisterCount;
break;
case DW_X86_64_RET_ADDR:
break;
default:
return UNWIND_X86_64_MODE_DWARF;
}
}
}
const int64_t cfaOffsetRBX = prolog.savedRegisters[UNW_X86_64_RBX].value;
const int64_t cfaOffsetR12 = prolog.savedRegisters[UNW_X86_64_R12].value;
const int64_t cfaOffsetR13 = prolog.savedRegisters[UNW_X86_64_R13].value;
const int64_t cfaOffsetR14 = prolog.savedRegisters[UNW_X86_64_R14].value;
const int64_t cfaOffsetR15 = prolog.savedRegisters[UNW_X86_64_R15].value;
const int64_t cfaOffsetRBP = prolog.savedRegisters[UNW_X86_64_RBP].value;
// encode standard RBP frames
uint32_t encoding = 0;
if ( standardRBPframe ) {
// | |
// +--------------+ <- CFA
// | ret addr |
// +--------------+
// | rbp |
// +--------------+ <- rbp
// ~ ~
// +--------------+
// | saved reg3 |
// +--------------+ <- CFA - offset+16
// | saved reg2 |
// +--------------+ <- CFA - offset+8
// | saved reg1 |
// +--------------+ <- CFA - offset
// | |
// +--------------+
// | |
// <- rsp
//
encoding = UNWIND_X86_64_MODE_RBP_FRAME;
// find save location of farthest register from rbp
int64_t furthestCfaOffset = 0;
if ( rbxSaved & (cfaOffsetRBX < furthestCfaOffset) )
furthestCfaOffset = cfaOffsetRBX;
if ( r12Saved & (cfaOffsetR12 < furthestCfaOffset) )
furthestCfaOffset = cfaOffsetR12;
if ( r13Saved & (cfaOffsetR13 < furthestCfaOffset) )
furthestCfaOffset = cfaOffsetR13;
if ( r14Saved & (cfaOffsetR14 < furthestCfaOffset) )
furthestCfaOffset = cfaOffsetR14;
if ( r15Saved & (cfaOffsetR15 < furthestCfaOffset) )
furthestCfaOffset = cfaOffsetR15;
if ( furthestCfaOffset == 0 ) {
// no registers saved, nothing more to encode
return encoding;
}
// add stack offset to encoding
int64_t rbpOffset = furthestCfaOffset + 16;
int64_t encodedOffset = rbpOffset/(-8);
if ( encodedOffset > 255 )
return UNWIND_X86_64_MODE_DWARF;
encoding |= (encodedOffset << __builtin_ctz(UNWIND_X86_64_RBP_FRAME_OFFSET));
// add register saved from each stack location
bool encodingFailure = false;
if ( rbxSaved )
encoding |= GetRBPEncodedRegister(UNW_X86_64_RBX, static_cast<int32_t>(cfaOffsetRBX - furthestCfaOffset), encodingFailure);
if ( r12Saved )
encoding |= GetRBPEncodedRegister(UNW_X86_64_R12, static_cast<int32_t>(cfaOffsetR12 - furthestCfaOffset), encodingFailure);
if ( r13Saved )
encoding |= GetRBPEncodedRegister(UNW_X86_64_R13, static_cast<int32_t>(cfaOffsetR13 - furthestCfaOffset), encodingFailure);
if ( r14Saved )
encoding |= GetRBPEncodedRegister(UNW_X86_64_R14, static_cast<int32_t>(cfaOffsetR14 - furthestCfaOffset), encodingFailure);
if ( r15Saved )
encoding |= GetRBPEncodedRegister(UNW_X86_64_R15, static_cast<int32_t>(cfaOffsetR15 - furthestCfaOffset), encodingFailure);
if ( encodingFailure )
return UNWIND_X86_64_MODE_DWARF;
return encoding;
}
else {
// | |
// +--------------+ <- CFA
// | ret addr |
// +--------------+
// | saved reg1 |
// +--------------+ <- CFA - 16
// | saved reg2 |
// +--------------+ <- CFA - 24
// | saved reg3 |
// +--------------+ <- CFA - 32
// | saved reg4 |
// +--------------+ <- CFA - 40
// | saved reg5 |
// +--------------+ <- CFA - 48
// | saved reg6 |
// +--------------+ <- CFA - 56
// | |
// <- esp
//
// for RSP based frames we need to encode stack size in unwind info
encoding = UNWIND_X86_64_MODE_STACK_IMMD;
uint64_t stackValue = prolog.cfaRegisterOffset / 8;
uint32_t stackAdjust = 0;
bool immedStackSize = true;
if ( stackValue > (UNWIND_X86_64_FRAMELESS_STACK_SIZE >> __builtin_ctz(UNWIND_X86_64_FRAMELESS_STACK_SIZE)) ) {
// stack size is too big to fit as an immediate value, so encode offset of subq instruction in function
if (prolog.codeOffsetAtStackDecrement == 0)
return UNWIND_X86_64_MODE_DWARF;
uint64_t functionContentAdjustStackIns = start + prolog.codeOffsetAtStackDecrement - 4;
uint64_t pos = file.Tell();
if (!file.AddressSeek(functionContentAdjustStackIns))
return UNWIND_X86_64_MODE_DWARF;
uint32_t stackDecrementInCode = file.ReadDWord();
file.Seek(pos);
stackAdjust = (prolog.cfaRegisterOffset - stackDecrementInCode)/8;
stackValue = functionContentAdjustStackIns - start;
immedStackSize = false;
if ( stackAdjust > 7 )
return UNWIND_X86_64_MODE_DWARF;
encoding = UNWIND_X86_64_MODE_STACK_IND;
}
// validate that saved registers are all within 6 slots abutting return address
int registers[6];
for (int i=0; i < 6;++i)
registers[i] = 0;
if ( r15Saved ) {
if ( cfaOffsetR15 < -56 )
return UNWIND_X86_64_MODE_DWARF;
registers[(cfaOffsetR15+56)/8] = UNWIND_X86_64_REG_R15;
}
if ( r14Saved ) {
if ( cfaOffsetR14 < -56 )
return UNWIND_X86_64_MODE_DWARF;
registers[(cfaOffsetR14+56)/8] = UNWIND_X86_64_REG_R14;
}
if ( r13Saved ) {
if ( cfaOffsetR13 < -56 )
return UNWIND_X86_64_MODE_DWARF;
registers[(cfaOffsetR13+56)/8] = UNWIND_X86_64_REG_R13;
}
if ( r12Saved ) {
if ( cfaOffsetR12 < -56 )
return UNWIND_X86_64_MODE_DWARF;
registers[(cfaOffsetR12+56)/8] = UNWIND_X86_64_REG_R12;
}
if ( rbxSaved ) {
if ( cfaOffsetRBX < -56 )
return UNWIND_X86_64_MODE_DWARF;
registers[(cfaOffsetRBX+56)/8] = UNWIND_X86_64_REG_RBX;
}
if ( rbpSaved ) {
if ( cfaOffsetRBP < -56 )
return UNWIND_X86_64_MODE_DWARF;
registers[(cfaOffsetRBP+56)/8] = UNWIND_X86_64_REG_RBP;
}
// validate that saved registers are contiguous and abut return address on stack
for (int i=0; i < saveRegisterCount; ++i) {
if ( registers[5-i] == 0 ) {
return UNWIND_X86_64_MODE_DWARF;
}
}
// encode register permutation
// the 10-bits are encoded differently depending on the number of registers saved
int renumregs[6];
for (int i=6-saveRegisterCount; i < 6; ++i) {
int countless = 0;
for (int j=6-saveRegisterCount; j < i; ++j) {
if ( registers[j] < registers[i] )
++countless;
}
renumregs[i] = registers[i] - countless -1;
}
uint32_t permutationEncoding = 0;
switch ( saveRegisterCount ) {
case 6:
permutationEncoding |= (120*renumregs[0] + 24*renumregs[1] + 6*renumregs[2] + 2*renumregs[3] + renumregs[4]);
break;
case 5:
permutationEncoding |= (120*renumregs[1] + 24*renumregs[2] + 6*renumregs[3] + 2*renumregs[4] + renumregs[5]);
break;
case 4:
permutationEncoding |= (60*renumregs[2] + 12*renumregs[3] + 3*renumregs[4] + renumregs[5]);
break;
case 3:
permutationEncoding |= (20*renumregs[3] + 4*renumregs[4] + renumregs[5]);
break;
case 2:
permutationEncoding |= (5*renumregs[4] + renumregs[5]);
break;
case 1:
permutationEncoding |= (renumregs[5]);
break;
}
encoding |= (stackValue << __builtin_ctz(UNWIND_X86_64_FRAMELESS_STACK_SIZE));
encoding |= (stackAdjust << __builtin_ctz(UNWIND_X86_64_FRAMELESS_STACK_ADJUST));
encoding |= (saveRegisterCount << __builtin_ctz(UNWIND_X86_64_FRAMELESS_STACK_REG_COUNT));
encoding |= (permutationEncoding << __builtin_ctz(UNWIND_X86_64_FRAMELESS_STACK_REG_PERMUTATION));
return encoding;
}
}
uint32_t DwarfParser::GetEBPEncodedRegister(uint32_t reg, int32_t regOffsetFromBaseOffset, bool& failure)
{
if ( (regOffsetFromBaseOffset < 0) || (regOffsetFromBaseOffset > 16) ) {
failure = true;
return 0;
}
unsigned int slotIndex = regOffsetFromBaseOffset/4;
switch ( reg ) {
case UNW_X86_EBX:
return UNWIND_X86_REG_EBX << (slotIndex*3);
case UNW_X86_ECX:
return UNWIND_X86_REG_ECX << (slotIndex*3);
case UNW_X86_EDX:
return UNWIND_X86_REG_EDX << (slotIndex*3);
case UNW_X86_EDI:
return UNWIND_X86_REG_EDI << (slotIndex*3);
case UNW_X86_ESI:
return UNWIND_X86_REG_ESI << (slotIndex*3);
}
// invalid register
failure = true;
return 0;
}
uint32_t DwarfParser::CreateCompactEncodingForX32(IArchitecture &file, uint64_t start, PrologInfo &prolog)
{
if ( prolog.registerSavedTwiceInCIE == DW_X86_RET_ADDR )
return UNWIND_X86_64_MODE_DWARF;
// don't create compact unwind info for unsupported dwarf kinds
if ( prolog.registerSavedMoreThanOnce )
return UNWIND_X86_MODE_DWARF;
if ( prolog.spExtraArgSize != 0 )
return UNWIND_X86_MODE_DWARF;
if ( prolog.sameValueUsed )
return UNWIND_X86_MODE_DWARF;
// figure out which kind of frame this function uses
bool standardEBPframe = (
(prolog.cfaRegister == UNW_X86_EBP)
&& (prolog.cfaRegisterOffset == 8)
&& (prolog.savedRegisters[UNW_X86_EBP].location == kRegisterInCFA)
&& (prolog.savedRegisters[UNW_X86_EBP].value == -8) );
bool standardESPframe = (prolog.cfaRegister == UNW_X86_ESP);
if ( !standardEBPframe && !standardESPframe ) {
// no compact encoding for this
return UNWIND_X86_MODE_DWARF;
}
// scan which registers are saved
int saveRegisterCount = 0;
bool ebxSaved = false;
bool ecxSaved = false;
bool edxSaved = false;
bool esiSaved = false;
bool ediSaved = false;
bool ebpSaved = false;
for (int i=0; i < 64; ++i) {
if ( prolog.savedRegisters[i].location != kRegisterUnused ) {
if ( prolog.savedRegisters[i].location != kRegisterInCFA )
return UNWIND_X86_MODE_DWARF;
switch (i) {
case UNW_X86_EBX:
ebxSaved = true;
++saveRegisterCount;
break;
case UNW_X86_ECX:
ecxSaved = true;
++saveRegisterCount;
break;
case UNW_X86_EDX:
edxSaved = true;
++saveRegisterCount;
break;
case UNW_X86_ESI:
esiSaved = true;
++saveRegisterCount;
break;
case UNW_X86_EDI:
ediSaved = true;
++saveRegisterCount;
break;
case UNW_X86_EBP:
ebpSaved = true;
++saveRegisterCount;
break;
case DW_X86_RET_ADDR:
break;
default:
return UNWIND_X86_MODE_DWARF;
}
}
}
const int32_t cfaOffsetEBX = static_cast<int32_t>(prolog.savedRegisters[UNW_X86_EBX].value);
const int32_t cfaOffsetECX = static_cast<int32_t>(prolog.savedRegisters[UNW_X86_ECX].value);
const int32_t cfaOffsetEDX = static_cast<int32_t>(prolog.savedRegisters[UNW_X86_EDX].value);
const int32_t cfaOffsetEDI = static_cast<int32_t>(prolog.savedRegisters[UNW_X86_EDI].value);
const int32_t cfaOffsetESI = static_cast<int32_t>(prolog.savedRegisters[UNW_X86_ESI].value);
const int32_t cfaOffsetEBP = static_cast<int32_t>(prolog.savedRegisters[UNW_X86_EBP].value);
// encode standard RBP frames
uint32_t encoding = 0;
if ( standardEBPframe ) {
// | |
// +--------------+ <- CFA
// | ret addr |
// +--------------+
// | ebp |
// +--------------+ <- ebp
// ~ ~
// +--------------+
// | saved reg3 |
// +--------------+ <- CFA - offset+8
// | saved reg2 |
// +--------------+ <- CFA - offset+e
// | saved reg1 |
// +--------------+ <- CFA - offset
// | |
// +--------------+
// | |
// <- esp
//
encoding = UNWIND_X86_MODE_EBP_FRAME;
// find save location of farthest register from ebp
int32_t furthestCfaOffset = 0;
if ( ebxSaved & (cfaOffsetEBX < furthestCfaOffset) )
furthestCfaOffset = cfaOffsetEBX;
if ( ecxSaved & (cfaOffsetECX < furthestCfaOffset) )
furthestCfaOffset = cfaOffsetECX;
if ( edxSaved & (cfaOffsetEDX < furthestCfaOffset) )
furthestCfaOffset = cfaOffsetEDX;
if ( ediSaved & (cfaOffsetEDI < furthestCfaOffset) )
furthestCfaOffset = cfaOffsetEDI;
if ( esiSaved & (cfaOffsetESI < furthestCfaOffset) )
furthestCfaOffset = cfaOffsetESI;
if ( furthestCfaOffset == 0 ) {
// no registers saved, nothing more to encode
return encoding;
}
// add stack offset to encoding
int ebpOffset = furthestCfaOffset + 8;
int encodedOffset = ebpOffset/(-4);
if ( encodedOffset > 255 )
return UNWIND_X86_MODE_DWARF;
encoding |= (encodedOffset << __builtin_ctz(UNWIND_X86_EBP_FRAME_OFFSET));
// add register saved from each stack location
bool encodingFailure = false;
if ( ebxSaved )
encoding |= GetEBPEncodedRegister(UNW_X86_EBX, cfaOffsetEBX - furthestCfaOffset, encodingFailure);
if ( ecxSaved )
encoding |= GetEBPEncodedRegister(UNW_X86_ECX, cfaOffsetECX - furthestCfaOffset, encodingFailure);
if ( edxSaved )
encoding |= GetEBPEncodedRegister(UNW_X86_EDX, cfaOffsetEDX - furthestCfaOffset, encodingFailure);
if ( ediSaved )
encoding |= GetEBPEncodedRegister(UNW_X86_EDI, cfaOffsetEDI - furthestCfaOffset, encodingFailure);
if ( esiSaved )
encoding |= GetEBPEncodedRegister(UNW_X86_ESI, cfaOffsetESI - furthestCfaOffset, encodingFailure);
if ( encodingFailure )
return UNWIND_X86_MODE_DWARF;
return encoding;
}
else {
// | |
// +--------------+ <- CFA
// | ret addr |
// +--------------+
// | saved reg1 |
// +--------------+ <- CFA - 8
// | saved reg2 |
// +--------------+ <- CFA - 12
// | saved reg3 |
// +--------------+ <- CFA - 16
// | saved reg4 |
// +--------------+ <- CFA - 20
// | saved reg5 |
// +--------------+ <- CFA - 24
// | saved reg6 |
// +--------------+ <- CFA - 28
// | |
// <- esp
//
// for ESP based frames we need to encode stack size in unwind info
encoding = UNWIND_X86_MODE_STACK_IMMD;
uint64_t stackValue = prolog.cfaRegisterOffset / 4;
uint32_t stackAdjust = 0;
bool immedStackSize = true;
if ( stackValue > (UNWIND_X86_FRAMELESS_STACK_SIZE >> __builtin_ctz(UNWIND_X86_FRAMELESS_STACK_SIZE)) ) {
// stack size is too big to fit as an immediate value, so encode offset of subq instruction in function
uint64_t functionContentAdjustStackIns = start + prolog.codeOffsetAtStackDecrement - 4;
uint64_t pos = file.Tell();
if (!file.AddressSeek(functionContentAdjustStackIns))
return UNWIND_X86_64_MODE_DWARF;
uint32_t stackDecrementInCode = file.ReadDWord();
file.Seek(pos);
stackAdjust = (prolog.cfaRegisterOffset - stackDecrementInCode)/4;
stackValue = functionContentAdjustStackIns - start;
immedStackSize = false;
if ( stackAdjust > 7 )
return UNWIND_X86_MODE_DWARF;
encoding = UNWIND_X86_MODE_STACK_IND;
}
// validate that saved registers are all within 6 slots abutting return address
int registers[6];
for (int i=0; i < 6;++i)
registers[i] = 0;
if ( ebxSaved ) {
if ( cfaOffsetEBX < -28 )
return UNWIND_X86_MODE_DWARF;
registers[(cfaOffsetEBX+28)/4] = UNWIND_X86_REG_EBX;
}
if ( ecxSaved ) {
if ( cfaOffsetECX < -28 )
return UNWIND_X86_MODE_DWARF;
registers[(cfaOffsetECX+28)/4] = UNWIND_X86_REG_ECX;
}
if ( edxSaved ) {
if ( cfaOffsetEDX < -28 )
return UNWIND_X86_MODE_DWARF;
registers[(cfaOffsetEDX+28)/4] = UNWIND_X86_REG_EDX;
}
if ( ediSaved ) {
if ( cfaOffsetEDI < -28 )
return UNWIND_X86_MODE_DWARF;
registers[(cfaOffsetEDI+28)/4] = UNWIND_X86_REG_EDI;
}
if ( esiSaved ) {
if ( cfaOffsetESI < -28 )
return UNWIND_X86_MODE_DWARF;
registers[(cfaOffsetESI+28)/4] = UNWIND_X86_REG_ESI;
}
if ( ebpSaved ) {
if ( cfaOffsetEBP < -28 )
return UNWIND_X86_MODE_DWARF;
registers[(cfaOffsetEBP+28)/4] = UNWIND_X86_REG_EBP;
}
// validate that saved registers are contiguous and abut return address on stack
for (int i=0; i < saveRegisterCount; ++i) {
if ( registers[5-i] == 0 )
return UNWIND_X86_MODE_DWARF;
}
// encode register permutation
// the 10-bits are encoded differently depending on the number of registers saved
int renumregs[6];
for (int i=6-saveRegisterCount; i < 6; ++i) {
int countless = 0;
for (int j=6-saveRegisterCount; j < i; ++j) {
if ( registers[j] < registers[i] )
++countless;
}
renumregs[i] = registers[i] - countless -1;
}
uint32_t permutationEncoding = 0;
switch ( saveRegisterCount ) {
case 6:
permutationEncoding |= (120*renumregs[0] + 24*renumregs[1] + 6*renumregs[2] + 2*renumregs[3] + renumregs[4]);
break;
case 5:
permutationEncoding |= (120*renumregs[1] + 24*renumregs[2] + 6*renumregs[3] + 2*renumregs[4] + renumregs[5]);
break;
case 4:
permutationEncoding |= (60*renumregs[2] + 12*renumregs[3] + 3*renumregs[4] + renumregs[5]);
break;
case 3:
permutationEncoding |= (20*renumregs[3] + 4*renumregs[4] + renumregs[5]);
break;
case 2:
permutationEncoding |= (5*renumregs[4] + renumregs[5]);
break;
case 1:
permutationEncoding |= (renumregs[5]);
break;
}
encoding |= (stackValue << __builtin_ctz(UNWIND_X86_FRAMELESS_STACK_SIZE));
encoding |= (stackAdjust << __builtin_ctz(UNWIND_X86_FRAMELESS_STACK_ADJUST));
encoding |= (saveRegisterCount << __builtin_ctz(UNWIND_X86_FRAMELESS_STACK_REG_COUNT));
encoding |= (permutationEncoding << __builtin_ctz(UNWIND_X86_FRAMELESS_STACK_REG_PERMUTATION));
return encoding;
}
}