path: root/src/readDwarf.h

#ifndef __READDWARF_H__

#define __READDWARF_H__


#include <string>

#include <vector>

#include "mspdb.h"


inline unsigned int LEB128(unsigned char* &p)
{
	unsigned int x = 0;
	int shift = 0;
	while (*p & 0x80)
	{
		x |= (*p & 0x7f) << shift;
		shift += 7;
		p++;
	}
	x |= *p << shift;
	p++;
	return x;
}

inline int SLEB128(unsigned char* &p)
{
	unsigned int x = 0;
	int shift = 0;
	while (*p & 0x80)
	{
		x |= (*p & 0x7f) << shift;
		shift += 7;
		p++;
	}
	x |= *p << shift;
	if (*p & 0x40)
		x |= -(1 << (shift + 7)); // sign extend

	p++;
	return x;
}

inline unsigned int RD2(unsigned char* p)
{
	unsigned int x = *p++;
	x |= *p++ << 8;
	return x;
}

inline unsigned int RD4(unsigned char* p)
{
	unsigned int x = *p++;
	x |= *p++ << 8;
	x |= *p++ << 16;
	x |= *p++ << 24;
	return x;
}

inline unsigned long long RD8(unsigned char* p)
{
	unsigned long long x = *p++;
	for (int shift = 8; shift < 64; shift += 8)
		x |= (unsigned long long) *p++ << shift;
	return x;
}

inline unsigned long long RDsize(unsigned char* p, int size)
{
	if (size > 8)
		size = 8;
	unsigned long long x = *p++;
	for (int shift = 8; shift < size * 8; shift += 8)
		x |= (unsigned long long) *p++ << shift;
	return x;
}


///////////////////////////////////////////////////////////////////////////////


#include "pshpack1.h"


struct DWARF_CompilationUnit
{
	unsigned int unit_length; // 12 byte in DWARF-64

	unsigned short version;
	unsigned int debug_abbrev_offset; // 8 byte in DWARF-64

	unsigned char address_size;

	bool isDWARF64() const { return unit_length == ~0; }
	int refSize() const { return unit_length == ~0 ? 8 : 4; }
};

struct DWARF_FileName
{
	const char* file_name;
	unsigned int  dir_index;
	unsigned long lastModification;
	unsigned long fileLength;

	void read(unsigned char* &p)
	{
		file_name = (const char*)p;
		p += strlen((const char*)p) + 1;
		dir_index = LEB128(p);
		lastModification = LEB128(p);
		fileLength = LEB128(p);
	}
};

struct DWARF_InfoData
{
	int entryOff;
	int code;
	int tag;
	int hasChild;

	const char* name;
	const char* linkage_name;
	const char* dir;
	unsigned long byte_size;
	unsigned long sibling;
	unsigned long encoding;
	unsigned long pclo;
	unsigned long pchi;
	unsigned long ranges;
	unsigned long type;
	unsigned long containing_type;
	unsigned long specification;
	unsigned long inlined;
	unsigned long external;
	unsigned char*location_ptr;
	unsigned long location_len;
	unsigned char*member_location_ptr;
	unsigned long member_location_len;
	unsigned long member_location_data;
	unsigned long locationlist; // offset into debug_loc

	long frame_base;
	long upper_bound;
	long lower_bound;
	unsigned char* abbrev;

	void clear()
	{
		entryOff = 0;
		code = 0;
		tag = 0;
		hasChild = 0;

		name = 0;
		linkage_name = 0;
		dir = 0;
		byte_size = 0;
		sibling = 0;
		encoding = 0;
		pclo = 0;
		pchi = 0;
		ranges = 0;
		type = 0;
		containing_type = 0;
		specification = 0;
		inlined = 0;
		external = 0;
		member_location_ptr = 0;
		member_location_len = 0;
		member_location_data = 0;
		location_ptr = 0;
		location_len = 0;
		locationlist = 0;
		frame_base = -1;
		upper_bound = 0;
		lower_bound = 0;
		abbrev = 0;
	}
};

static const int maximum_operations_per_instruction = 1;

struct DWARF_LineNumberProgramHeader
{
	unsigned int unit_length; // 12 byte in DWARF-64

	unsigned short version;
	unsigned int header_length; // 8 byte in DWARF-64

	unsigned char minimum_instruction_length;
	//unsigned char maximum_operations_per_instruction; (// not in DWARF 2

	unsigned char default_is_stmt;
	signed char line_base;
	unsigned char line_range;
	unsigned char opcode_base;
	//LEB128 standard_opcode_lengths[opcode_base]; 

	// string include_directories[] // zero byte terminated

	// DWARF_FileNames file_names[] // zero byte terminated

};

struct DWARF_LineState
{
	// hdr info

	std::vector<const char*> include_dirs;
	std::vector<DWARF_FileName> files;

	unsigned long address;
	unsigned int  op_index;
	unsigned int  file;
	unsigned int  line;
	unsigned int  column;
	bool          is_stmt;
	bool          basic_block;
	bool          end_sequence;
	bool          prologue_end;
	bool          epilogue_end;
	unsigned int  isa;
	unsigned int  discriminator;

	// not part of the "documented" state

	DWARF_FileName* file_ptr;
	unsigned long seg_offset;
	unsigned long last_addr;
	std::vector<mspdb::LineInfoEntry> lineInfo;

	DWARF_LineState()
	{
		seg_offset = 0x400000;
		init(0);
	}

	void init(DWARF_LineNumberProgramHeader* hdr)
	{
		address = 0;
		op_index = 0;
		file = 1;
		line = 1;
		column = 0;
		is_stmt = hdr && hdr->default_is_stmt != 0;
		basic_block = false;
		end_sequence = false;
		prologue_end = false;
		epilogue_end = false;
		isa = 0;
		discriminator = 0;
	}

	void advance_addr(DWARF_LineNumberProgramHeader* hdr, int operation_advance)
	{
		int address_advance = hdr->minimum_instruction_length * ((op_index + operation_advance) / maximum_operations_per_instruction);
		address += address_advance;
		op_index = (op_index + operation_advance) % maximum_operations_per_instruction;
	}

	void addLineInfo()
	{
#if 0

		const char* fname = (file == 0 ? file_ptr->file_name : files[file - 1].file_name);
		printf("Adr:%08x Line: %5d File: %s\n", address, line, fname);
#endif

		if (address < seg_offset)
			return;
		mspdb::LineInfoEntry entry;
		entry.offset = address - seg_offset;
		entry.line = line;
		lineInfo.push_back(entry);
	}
};

#include "poppack.h"


///////////////////////////////////////////////////////////////////////////////



long decodeLocation(unsigned char* loc, long len, bool push0, int &id, int& size);

inline long decodeLocation(unsigned char*loc, long len, bool push0, int &id)
{
	int size;
	return decodeLocation(loc, len, push0, id, size);
}


class PEImage;

// Debug Information Entry Cursor

class DIECursor
{
public:
	DWARF_CompilationUnit* cu;
	unsigned char* ptr;
	int level;
	bool hasChild; // indicates whether the last read DIE has children

	unsigned int sibling;

	unsigned char* getDWARFAbbrev(unsigned off, unsigned findcode);

public:

	static void setContext(PEImage* img_);

	// Create a new DIECursor from compilation unit with offset relative to the CU.

	DIECursor(DWARF_CompilationUnit* cu_, unsigned long offset);

	// Reads next sibling DIE.  If the last read DIE had any children, they will be skipped over.

	// Returns 'false' upon reaching the last sibling on the current level.

	bool readSibling(DWARF_InfoData& id);

	// Returns cursor that will enumerate children of the last read DIE.

	DIECursor getSubtreeCursor();

	// Reads the next DIE in physical order, returns 'true' if succeeds.

	// If stopAtNull is true, readNext() will stop upon reaching a null DIE (end of the current tree level).

	// Otherwise, it will skip null DIEs and stop only at the end of the subtree for which this DIECursor was created.

	bool readNext(DWARF_InfoData& id, bool stopAtNull = false);
};

#endif