xref: /haiku/src/kits/debugger/dwarf/DwarfFile.cpp

/*
 * Copyright 2009-2012, Ingo Weinhold, ingo_weinhold@gmx.de.
 * Copyright 2012-2014, Rene Gollent, rene@gollent.com.
 * Distributed under the terms of the MIT License.
 */


#include "DwarfFile.h"

#include <algorithm>
#include <new>

#include <AutoDeleter.h>
#include <Entry.h>
#include <FindDirectory.h>
#include <Path.h>
#include <PathFinder.h>

#include "AttributeClasses.h"
#include "AttributeValue.h"
#include "AbbreviationTable.h"
#include "CfaContext.h"
#include "CompilationUnit.h"
#include "DataReader.h"
#include "DwarfExpressionEvaluator.h"
#include "DwarfTargetInterface.h"
#include "ElfFile.h"
#include "TagNames.h"
#include "TargetAddressRangeList.h"
#include "Tracing.h"
#include "Variant.h"


// #pragma mark - AutoSectionPutter


class AutoSectionPutter {
public:
	AutoSectionPutter(ElfFile* elfFile, ElfSection* elfSection)
		:
		fElfFile(elfFile),
		fElfSection(elfSection)
	{
	}

	~AutoSectionPutter()
	{
		if (fElfSection != NULL)
			fElfFile->PutSection(fElfSection);
	}

private:
	ElfFile*			fElfFile;
	ElfSection*			fElfSection;
};


// #pragma mark - ExpressionEvaluationContext


struct DwarfFile::ExpressionEvaluationContext
	: DwarfExpressionEvaluationContext {
public:
	ExpressionEvaluationContext(DwarfFile* file, CompilationUnit* unit,
		uint8 addressSize, bool isBigEndian, DIESubprogram* subprogramEntry,
		const DwarfTargetInterface* targetInterface,
		target_addr_t instructionPointer, target_addr_t objectPointer,
		bool hasObjectPointer, target_addr_t framePointer,
		target_addr_t relocationDelta)
		:
		DwarfExpressionEvaluationContext(targetInterface, addressSize, isBigEndian,
			relocationDelta),
		fFile(file),
		fUnit(unit),
		fSubprogramEntry(subprogramEntry),
		fInstructionPointer(instructionPointer),
		fObjectPointer(objectPointer),
		fHasObjectPointer(hasObjectPointer),
		fFramePointer(framePointer),
		fFrameBasePointer(0),
		fFrameBaseEvaluated(false)
	{
	}

	virtual bool GetObjectAddress(target_addr_t& _address)
	{
		if (!fHasObjectPointer)
			return false;

		_address = fObjectPointer;
		return true;
	}

	virtual bool GetFrameAddress(target_addr_t& _address)
	{
		if (fFramePointer == 0)
			return false;

		_address = fFramePointer;
		return true;
	}

	virtual bool GetFrameBaseAddress(target_addr_t& _address)
	{
		if (fFrameBaseEvaluated) {
			if (fFrameBasePointer == 0)
				return false;

			_address = fFrameBasePointer;
			return true;
		}

		// set flag already to prevent recursion for a buggy expression
		fFrameBaseEvaluated = true;

		// get the subprogram's frame base location
		if (fSubprogramEntry == NULL)
			return false;
		const LocationDescription* location = fSubprogramEntry->FrameBase();
		if (!location->IsValid())
			return false;

		// get the expression
		const void* expression;
		off_t expressionLength;
		status_t error = fFile->_GetLocationExpression(fUnit, location,
			fInstructionPointer, expression, expressionLength);
		if (error != B_OK)
			return false;

		// evaluate the expression
		DwarfExpressionEvaluator evaluator(this);
		error = evaluator.Evaluate(expression, expressionLength,
			fFrameBasePointer);
		if (error != B_OK)
			return false;

		TRACE_EXPR("  -> frame base: %" B_PRIx64 "\n", fFrameBasePointer);

		_address = fFrameBasePointer;
		return true;
	}

	virtual bool GetTLSAddress(target_addr_t localAddress,
		target_addr_t& _address)
	{
		// TODO:...
		return false;
	}

	virtual status_t GetCallTarget(uint64 offset, uint8 refType,
		const void*& _block, off_t& _size)
	{
		// resolve the entry
		DebugInfoEntry* entry = fFile->_ResolveReference(fUnit, offset, refType);
		if (entry == NULL)
			return B_ENTRY_NOT_FOUND;

		// get the location description
		LocationDescription* location = entry->GetLocationDescription();
		if (location == NULL || !location->IsValid()) {
			_block = NULL;
			_size = 0;
			return B_OK;
		}

		// get the expression
		return fFile->_GetLocationExpression(fUnit, location,
			fInstructionPointer, _block, _size);
	}

private:
	DwarfFile*			fFile;
	CompilationUnit*	fUnit;
	DIESubprogram*		fSubprogramEntry;
	target_addr_t		fInstructionPointer;
	target_addr_t		fObjectPointer;
	bool				fHasObjectPointer;
	target_addr_t		fFramePointer;
	target_addr_t		fFrameBasePointer;
	bool				fFrameBaseEvaluated;
};


// #pragma mark - FDEAugmentation


struct DwarfFile::FDEAugmentation {
	// Currently we're ignoring all augmentation data.
};


// #pragma mark - CIEAugmentation


enum {
	CFI_AUGMENTATION_DATA					= 0x01,
	CFI_AUGMENTATION_LANGUAGE_SPECIFIC_DATA	= 0x02,
	CFI_AUGMENTATION_PERSONALITY			= 0x04,
	CFI_AUGMENTATION_ADDRESS_POINTER_FORMAT	= 0x08,
};


// encodings for CFI_AUGMENTATION_ADDRESS_POINTER_FORMAT
enum {
	CFI_ADDRESS_FORMAT_ABSOLUTE			= 0x00,
	CFI_ADDRESS_FORMAT_UNSIGNED_LEB128	= 0x01,
	CFI_ADDRESS_FORMAT_UNSIGNED_16		= 0x02,
	CFI_ADDRESS_FORMAT_UNSIGNED_32		= 0x03,
	CFI_ADDRESS_FORMAT_UNSIGNED_64		= 0x04,
	CFI_ADDRESS_FORMAT_SIGNED			= 0x08,
	CFI_ADDRESS_FORMAT_SIGNED_LEB128	=
		CFI_ADDRESS_FORMAT_UNSIGNED_LEB128 | CFI_ADDRESS_FORMAT_SIGNED,
	CFI_ADDRESS_FORMAT_SIGNED_16		=
		CFI_ADDRESS_FORMAT_UNSIGNED_16 | CFI_ADDRESS_FORMAT_SIGNED,
	CFI_ADDRESS_FORMAT_SIGNED_32		=
		CFI_ADDRESS_FORMAT_UNSIGNED_32 | CFI_ADDRESS_FORMAT_SIGNED,
	CFI_ADDRESS_FORMAT_SIGNED_64		=
		CFI_ADDRESS_FORMAT_UNSIGNED_64 | CFI_ADDRESS_FORMAT_SIGNED
};


enum {
	CFI_ADDRESS_TYPE_PC_RELATIVE		= 0x10,
	CFI_ADDRESS_TYPE_TEXT_RELATIVE		= 0x20,
	CFI_ADDRESS_TYPE_DATA_RELATIVE		= 0x30,
	CFI_ADDRESS_TYPE_FUNCTION_RELATIVE	= 0x40,
	CFI_ADDRESS_TYPE_ALIGNED			= 0x50,
	CFI_ADDRESS_TYPE_INDIRECT			= 0x80
};


struct DwarfFile::CIEAugmentation {
	CIEAugmentation()
		:
		fString(NULL),
		fFlags(0),
		fAddressEncoding(CFI_ADDRESS_FORMAT_ABSOLUTE)
	{
		// we default to absolute address format since that corresponds
		// to the DWARF standard for .debug_frame. In gcc's case, however,
		// .eh_frame will generally override that via augmentation 'R'
	}

	void Init(DataReader& dataReader)
	{
		fFlags = 0;
		fString = dataReader.ReadString();
	}

	status_t Read(DataReader& dataReader)
	{
		if (fString == NULL || *fString == '\0')
			return B_OK;

		if (*fString == 'z') {
			// There are augmentation data.
			fFlags |= CFI_AUGMENTATION_DATA;
			const char* string = fString + 1;

			// read the augmentation data block -- it is preceeded by an
			// LEB128 indicating the length of the data block
			uint64 length = dataReader.ReadUnsignedLEB128(0);
			uint64 remaining = length;
			// let's see what data we have to expect

			TRACE_CFI("    %" B_PRIu64 " bytes of augmentation data\n", length);
			while (*string != '\0') {
				switch (*string) {
					case 'L':
						fFlags |= CFI_AUGMENTATION_LANGUAGE_SPECIFIC_DATA;
						dataReader.Read<char>(0);
						--remaining;
						break;
					case 'P':
					{
						char tempEncoding = fAddressEncoding;
						fAddressEncoding = dataReader.Read<char>(0);
						off_t offset = dataReader.Offset();
						ReadEncodedAddress(dataReader, NULL, NULL, true);
						fAddressEncoding = tempEncoding;
						remaining -= dataReader.Offset() - offset + 1;
 						break;
					}
					case 'R':
						fFlags |= CFI_AUGMENTATION_ADDRESS_POINTER_FORMAT;
						fAddressEncoding = dataReader.Read<char>(0);
						--remaining;
						break;
					default:
						WARNING("Encountered unsupported augmentation '%c' "
							" while parsing CIE augmentation string %s\n",
							*string, fString);
						return B_UNSUPPORTED;
				}
				string++;
			}

			// we should have read through all of the augmentation data
			// at this point, if not, something is wrong.
			if (remaining != 0 || dataReader.HasOverflow()) {
				WARNING("Error while reading CIE Augmentation, expected "
					"%" B_PRIu64 " bytes of augmentation data, but read "
					"%" B_PRIu64 " bytes.\n", length, length - remaining);
				return B_BAD_DATA;
			}

			return B_OK;
		}

		// nothing to do
		if (strcmp(fString, "eh") == 0)
			return B_OK;

		// something we can't handle
		return B_UNSUPPORTED;
	}

	status_t ReadFDEData(DataReader& dataReader,
		FDEAugmentation& fdeAugmentation)
	{
		if (!HasData())
			return B_OK;

		// read the augmentation data block -- it is preceeded by an LEB128
		// indicating the length of the data block
		uint64 length = dataReader.ReadUnsignedLEB128(0);
		dataReader.Skip(length);
			// TODO: Actually read what is interesting for us!

		TRACE_CFI("    %" B_PRIu64 " bytes of augmentation data\n", length);

		if (dataReader.HasOverflow())
			return B_BAD_DATA;

		return B_OK;
	}

	const char* String() const
	{
		return fString;
	}

	bool HasData() const
	{
		return (fFlags & CFI_AUGMENTATION_DATA) != 0;
	}

	bool HasFDEAddressFormat() const
	{
		return (fFlags & CFI_AUGMENTATION_ADDRESS_POINTER_FORMAT) != 0;
	}

	target_addr_t FDEAddressOffset(ElfFile* file,
		ElfSection* debugFrameSection) const
	{
		switch (FDEAddressType()) {
			case CFI_ADDRESS_FORMAT_ABSOLUTE:
				TRACE_CFI("FDE address format: absolute, ");
				return 0;
			case CFI_ADDRESS_TYPE_PC_RELATIVE:
				TRACE_CFI("FDE address format: PC relative, ");
				return debugFrameSection->LoadAddress();
			case CFI_ADDRESS_TYPE_FUNCTION_RELATIVE:
				TRACE_CFI("FDE address format: function relative, ");
				return 0;
			case CFI_ADDRESS_TYPE_TEXT_RELATIVE:
				TRACE_CFI("FDE address format: text relative, ");
				return file->TextSegment()->LoadAddress();
			case CFI_ADDRESS_TYPE_DATA_RELATIVE:
				TRACE_CFI("FDE address format: data relative, ");
				return file->DataSegment()->LoadAddress();
			case CFI_ADDRESS_TYPE_ALIGNED:
			case CFI_ADDRESS_TYPE_INDIRECT:
				TRACE_CFI("FDE address format: UNIMPLEMENTED, ");
				// TODO: implement
				// -- note: type indirect is currently not generated
				return 0;
		}

		return 0;
	}

	uint8 FDEAddressType() const
	{
		return fAddressEncoding & 0x70;
	}

	target_addr_t ReadEncodedAddress(DataReader &reader,
		ElfFile* file, ElfSection* debugFrameSection,
		bool valueOnly = false) const
	{
		target_addr_t address = valueOnly ? 0 : FDEAddressOffset(file,
			debugFrameSection);
		switch (fAddressEncoding & 0x0f) {
			case CFI_ADDRESS_FORMAT_ABSOLUTE:
				address += reader.ReadAddress(0);
				TRACE_CFI(" target address: %" B_PRId64 "\n", address);
				break;
			case CFI_ADDRESS_FORMAT_UNSIGNED_LEB128:
				address += reader.ReadUnsignedLEB128(0);
				TRACE_CFI(" unsigned LEB128: %" B_PRId64 "\n", address);
				break;
			case CFI_ADDRESS_FORMAT_SIGNED_LEB128:
				address += reader.ReadSignedLEB128(0);
				TRACE_CFI(" signed LEB128: %" B_PRId64 "\n", address);
				break;
			case CFI_ADDRESS_FORMAT_UNSIGNED_16:
				address += reader.Read<uint16>(0);
				TRACE_CFI(" unsigned 16-bit: %" B_PRId64 "\n", address);
				break;
			case CFI_ADDRESS_FORMAT_SIGNED_16:
				address += reader.Read<int16>(0);
				TRACE_CFI(" signed 16-bit: %" B_PRId64 "\n", address);
				break;
			case CFI_ADDRESS_FORMAT_UNSIGNED_32:
				address += reader.Read<uint32>(0);
				TRACE_CFI(" unsigned 32-bit: %" B_PRId64 "\n", address);
				break;
			case CFI_ADDRESS_FORMAT_SIGNED_32:
				address += reader.Read<int32>(0);
				TRACE_CFI(" signed 32-bit: %" B_PRId64 "\n", address);
				break;
			case CFI_ADDRESS_FORMAT_UNSIGNED_64:
				address += reader.Read<uint64>(0);
				TRACE_CFI(" unsigned 64-bit: %" B_PRId64 "\n", address);
				break;
			case CFI_ADDRESS_FORMAT_SIGNED_64:
				address += reader.Read<int64>(0);
				TRACE_CFI(" signed 64-bit: %" B_PRId64 "\n", address);
				break;
		}

		return address;
	}


private:
	const char*	fString;
	uint32		fFlags;
	int8		fAddressEncoding;
};


// #pragma mark - FDELookupInfo


struct DwarfFile::FDELookupInfo {
public:
	FDELookupInfo(target_addr_t start, target_addr_t end,
		uint64 fdeOffset, uint64 cieOffset, bool ehFrame)
	:
	start(start),
	end(end),
	fdeOffset(fdeOffset),
	cieOffset(cieOffset),
	ehFrame(ehFrame)
	{
	}

	static int CompareFDEInfos(const FDELookupInfo* a, const FDELookupInfo* b)
	{
		if (a->start < b->start)
			return -1;
		else if (a->start > b->start)
			return 1;

		return 0;
	}

	inline bool ContainsAddress(target_addr_t address) const
	{
		return address >= start && address < end;
	}

	target_addr_t 		start;
	target_addr_t 		end;
	uint64				fdeOffset;
	uint64				cieOffset;
	bool				ehFrame;
};


// #pragma mark - DwarfFile


DwarfFile::DwarfFile()
	:
	fName(NULL),
	fAlternateName(NULL),
	fElfFile(NULL),
	fAlternateElfFile(NULL),
	fDebugInfoSection(NULL),
	fDebugAbbrevSection(NULL),
	fDebugAddressSection(NULL),
	fDebugStringSection(NULL),
	fDebugStrOffsetsSection(NULL),
	fDebugRangesSection(NULL),
	fDebugLineSection(NULL),
	fDebugLineStrSection(NULL),
	fDebugFrameSection(NULL),
	fEHFrameSection(NULL),
	fDebugLocationSection(NULL),
	fDebugPublicTypesSection(NULL),
	fDebugTypesSection(NULL),
	fCompilationUnits(20, true),
	fTypeUnits(),
	fDebugFrameInfos(100, true),
	fEHFrameInfos(100, true),
	fTypesSectionRequired(false),
	fFinished(false),
	fItaniumEHFrameFormat(false),
	fFinishError(B_OK)
{
}


DwarfFile::~DwarfFile()
{
	while (AbbreviationTable* table = fAbbreviationTables.RemoveHead())
		delete table;

	if (fElfFile != NULL) {
		ElfFile* debugInfoFile = fAlternateElfFile != NULL
			? fAlternateElfFile : fElfFile;

		debugInfoFile->PutSection(fDebugInfoSection);
		debugInfoFile->PutSection(fDebugAbbrevSection);
		debugInfoFile->PutSection(fDebugAddressSection);
		debugInfoFile->PutSection(fDebugStringSection);
		debugInfoFile->PutSection(fDebugStrOffsetsSection);
		debugInfoFile->PutSection(fDebugRangesSection);
		debugInfoFile->PutSection(fDebugLineSection);
		debugInfoFile->PutSection(fDebugLineStrSection);
		debugInfoFile->PutSection(fDebugFrameSection);
		fElfFile->PutSection(fEHFrameSection);
		debugInfoFile->PutSection(fDebugLocationSection);
		debugInfoFile->PutSection(fDebugPublicTypesSection);
		delete fElfFile;
		delete fAlternateElfFile;
	}

	TypeUnitTableEntry* entry = fTypeUnits.Clear(true);
	while (entry != NULL) {
		TypeUnitTableEntry* nextEntry = entry->next;
		delete entry;
		entry = nextEntry;
	}

	free(fName);
	free(fAlternateName);
}


status_t
DwarfFile::StartLoading(const char* fileName, BString& _requiredExternalFile)
{
	fName = strdup(fileName);
	if (fName == NULL)
		return B_NO_MEMORY;

	status_t error = fTypeUnits.Init();
	if (error != B_OK)
		return error;

	// load the ELF file
	fElfFile = new(std::nothrow) ElfFile;
	if (fElfFile == NULL)
		return B_NO_MEMORY;

	error = fElfFile->Init(fileName);
	if (error != B_OK)
		return error;

	return _LocateDebugInfo(_requiredExternalFile);
}


status_t
DwarfFile::Load(uint8 addressSize, bool isBigEndian, const BString& externalInfoFilePath)
{
	status_t error = B_OK;
	if (fDebugInfoSection == NULL) {
		BString path;
		error = _LocateDebugInfo(path, externalInfoFilePath.IsEmpty()
				? NULL : externalInfoFilePath.String());
		if (error != B_OK)
			return error;
	}

	ElfFile* debugInfoFile = fAlternateElfFile != NULL
		? fAlternateElfFile : fElfFile;

	// non mandatory sections
	fDebugAddressSection = debugInfoFile->GetSection(".debug_addr");
	fDebugStringSection = debugInfoFile->GetSection(".debug_str");
	fDebugStrOffsetsSection = debugInfoFile->GetSection(".debug_str_offsets");
	fDebugRangesSection = debugInfoFile->GetSection(".debug_ranges");
	fDebugLineSection = debugInfoFile->GetSection(".debug_line");
	fDebugLineStrSection = debugInfoFile->GetSection(".debug_line_str");
	fDebugFrameSection = debugInfoFile->GetSection(".debug_frame");

	if (fDebugFrameSection != NULL) {
		error = _ParseFrameSection(fDebugFrameSection,
			addressSize, isBigEndian,
			false, fDebugFrameInfos);
		if (error != B_OK)
			return error;
	}

	// .eh_frame doesn't appear to get copied into separate debug
	// info files properly, therefore always use it off the main
	// executable image
	if (fEHFrameSection == NULL)
		fEHFrameSection = fElfFile->GetSection(".eh_frame");

	if (fEHFrameSection != NULL) {
		error = _ParseFrameSection(fEHFrameSection,
			addressSize, isBigEndian,
			true, fEHFrameInfos);
		if (error != B_OK)
			return error;
	}

	fDebugLocationSection = debugInfoFile->GetSection(".debug_loc");
	fDebugPublicTypesSection = debugInfoFile->GetSection(".debug_pubtypes");

	if (fDebugInfoSection == NULL) {
		fFinished = true;
		return B_OK;
	}

	error = _ParseDebugInfoSection(addressSize, isBigEndian);
	if (error != B_OK)
		return error;

	if (fTypesSectionRequired) {
		fDebugTypesSection = debugInfoFile->GetSection(".debug_types");
		if (fDebugTypesSection == NULL) {
			WARNING(".debug_types section required but missing.\n");
			return B_BAD_DATA;
		}
		error = _ParseTypesSection(addressSize, isBigEndian);
		if (error != B_OK)
			return error;
	}

	return B_OK;
}


status_t
DwarfFile::FinishLoading(uint8 addressSize, bool isBigEndian)
{
	if (fFinished)
		return B_OK;
	if (fFinishError != B_OK)
		return fFinishError;

	status_t error;
	for (TypeUnitTable::Iterator it = fTypeUnits.GetIterator();
		TypeUnitTableEntry* entry = it.Next();) {
		error = _FinishUnit(entry->unit);
		if (error != B_OK)
			return fFinishError = error;
	}

	for (int32 i = 0; CompilationUnit* unit = fCompilationUnits.ItemAt(i);
			i++) {
		error = _FinishUnit(unit);
		if (error != B_OK)
			return fFinishError = error;
	}

	_ParsePublicTypesInfo(addressSize, isBigEndian);

	fFinished = true;
	return B_OK;
}


int32
DwarfFile::CountCompilationUnits() const
{
	return fCompilationUnits.CountItems();
}


CompilationUnit*
DwarfFile::CompilationUnitAt(int32 index) const
{
	return fCompilationUnits.ItemAt(index);
}


CompilationUnit*
DwarfFile::CompilationUnitForDIE(const DebugInfoEntry* entry) const
{
	// find the root of the tree the entry lives in
	while (entry != NULL && entry->Parent() != NULL)
		entry = entry->Parent();

	// that should be the compilation unit entry
	const DIECompileUnitBase* unitEntry
		= dynamic_cast<const DIECompileUnitBase*>(entry);
	if (unitEntry == NULL)
		return NULL;

	// find the compilation unit
	for (int32 i = 0; CompilationUnit* unit = fCompilationUnits.ItemAt(i);
			i++) {
		if (unit->UnitEntry() == unitEntry)
			return unit;
	}

	return NULL;
}


TargetAddressRangeList*
DwarfFile::ResolveRangeList(CompilationUnit* unit, uint64 offset) const
{
	if (unit == NULL || fDebugRangesSection == NULL)
		return NULL;

	if (offset >= (uint64)fDebugRangesSection->Size())
		return NULL;

	TargetAddressRangeList* ranges = new(std::nothrow) TargetAddressRangeList;
	if (ranges == NULL) {
		ERROR("Out of memory.\n");
		return NULL;
	}
	BReference<TargetAddressRangeList> rangesReference(ranges, true);

	target_addr_t baseAddress = unit->AddressRangeBase();
	target_addr_t maxAddress = unit->MaxAddress();

	DataReader dataReader((uint8*)fDebugRangesSection->Data() + offset,
		fDebugRangesSection->Size() - offset, unit->AddressSize(), unit->IsBigEndian());
	while (true) {
		target_addr_t start = dataReader.ReadAddress(0);
		target_addr_t end = dataReader.ReadAddress(0);
		if (dataReader.HasOverflow())
			return NULL;

		if (start == 0 && end == 0)
			break;
		if (start == maxAddress) {
			baseAddress = end;
			continue;
		}
		if (start == end)
			continue;

		if (!ranges->AddRange(baseAddress + start, end - start)) {
			ERROR("Out of memory.\n");
			return NULL;
		}
	}

	return rangesReference.Detach();
}


status_t
DwarfFile::UnwindCallFrame(CompilationUnit* unit, uint8 addressSize, bool isBigEndian,
	DIESubprogram* subprogramEntry, target_addr_t location,
	const DwarfTargetInterface* inputInterface,
	DwarfTargetInterface* outputInterface, target_addr_t& _framePointer)
{
	FDELookupInfo* info = _GetContainingFDEInfo(location);
	if (info == NULL)
		return B_ENTRY_NOT_FOUND;

	return _UnwindCallFrame(unit, addressSize, isBigEndian,
		subprogramEntry, location, info,
		inputInterface, outputInterface, _framePointer);
}


status_t
DwarfFile::EvaluateExpression(CompilationUnit* unit, uint8 addressSize, bool isBigEndian,
	DIESubprogram* subprogramEntry, const void* expression,
	off_t expressionLength, const DwarfTargetInterface* targetInterface,
	target_addr_t instructionPointer, target_addr_t framePointer,
	target_addr_t valueToPush, bool pushValue, target_addr_t& _result)
{
	ExpressionEvaluationContext context(this, unit, addressSize, isBigEndian,
		subprogramEntry, targetInterface, instructionPointer, 0, false,
		framePointer, 0);
	DwarfExpressionEvaluator evaluator(&context);

	if (pushValue && evaluator.Push(valueToPush) != B_OK)
		return B_NO_MEMORY;

	return evaluator.Evaluate(expression, expressionLength, _result);
}


status_t
DwarfFile::ResolveLocation(CompilationUnit* unit, uint8 addressSize, bool isBigEndian,
	DIESubprogram* subprogramEntry, const LocationDescription* location,
	const DwarfTargetInterface* targetInterface,
	target_addr_t instructionPointer, target_addr_t objectPointer,
	bool hasObjectPointer, target_addr_t framePointer,
	target_addr_t relocationDelta, ValueLocation& _result)
{
	// get the expression
	const void* expression;
	off_t expressionLength;
	status_t error = _GetLocationExpression(unit, location, instructionPointer,
		expression, expressionLength);
	if (error != B_OK)
		return error;

	// evaluate it
	ExpressionEvaluationContext context(this, unit, addressSize, isBigEndian,
		subprogramEntry, targetInterface, instructionPointer, objectPointer,
		hasObjectPointer, framePointer, relocationDelta);
	DwarfExpressionEvaluator evaluator(&context);
	return evaluator.EvaluateLocation(expression, expressionLength,
		_result);
}


status_t
DwarfFile::EvaluateConstantValue(CompilationUnit* unit, uint8 addressSize, bool isBigEndian,
	DIESubprogram* subprogramEntry, const ConstantAttributeValue* value,
	const DwarfTargetInterface* targetInterface,
	target_addr_t instructionPointer, target_addr_t framePointer,
	BVariant& _result)
{
	if (!value->IsValid())
		return B_BAD_VALUE;

	switch (value->attributeClass) {
		case ATTRIBUTE_CLASS_CONSTANT:
			_result.SetTo(value->constant);
			return B_OK;
		case ATTRIBUTE_CLASS_STRING:
			_result.SetTo(value->string);
			return B_OK;
		case ATTRIBUTE_CLASS_BLOCK:
		{
			target_addr_t result;
			status_t error = EvaluateExpression(unit, addressSize, isBigEndian,
				subprogramEntry, value->block.data, value->block.length,
				targetInterface, instructionPointer, framePointer, 0, false,
				result);
			if (error != B_OK)
				return error;

			_result.SetTo(result);
			return B_OK;
		}
		default:
			return B_BAD_VALUE;
	}
}


status_t
DwarfFile::EvaluateDynamicValue(CompilationUnit* unit, uint8 addressSize, bool isBigEndian,
	DIESubprogram* subprogramEntry, const DynamicAttributeValue* value,
	const DwarfTargetInterface* targetInterface,
	target_addr_t instructionPointer, target_addr_t framePointer,
	BVariant& _result, DIEType** _type)
{
	if (!value->IsValid())
		return B_BAD_VALUE;

	DIEType* dummyType;
	if (_type == NULL)
		_type = &dummyType;

	switch (value->attributeClass) {
		case ATTRIBUTE_CLASS_CONSTANT:
			_result.SetTo(value->constant);
			*_type = NULL;
			return B_OK;

		case ATTRIBUTE_CLASS_REFERENCE:
		{
			// TODO: The specs are a bit fuzzy on this one: "the value is a
			// reference to another entity whose value is the value of the
			// attribute". Supposedly that also means e.g. if the referenced
			// entity is a variable, we should read the value of that variable.
			// ATM we only check for the types that can have a DW_AT_const_value
			// attribute and evaluate it, if present.
			DebugInfoEntry* entry = value->reference;
			if (entry == NULL)
				return B_BAD_VALUE;

			const ConstantAttributeValue* constantValue = NULL;
			DIEType* type = NULL;

			switch (entry->Tag()) {
				case DW_TAG_constant:
				{
					DIEConstant* constantEntry
						= dynamic_cast<DIEConstant*>(entry);
					constantValue = constantEntry->ConstValue();
					type = constantEntry->GetType();
					break;
				}
				case DW_TAG_enumerator:
					constantValue = dynamic_cast<DIEEnumerator*>(entry)
						->ConstValue();
					if (DIEEnumerationType* enumerationType
							= dynamic_cast<DIEEnumerationType*>(
								entry->Parent())) {
						type = enumerationType->GetType();
					}
					break;
				case DW_TAG_formal_parameter:
				{
					DIEFormalParameter* parameterEntry
						= dynamic_cast<DIEFormalParameter*>(entry);
					constantValue = parameterEntry->ConstValue();
					type = parameterEntry->GetType();
					break;
				}
				case DW_TAG_template_value_parameter:
				{
					DIETemplateValueParameter* parameterEntry
						= dynamic_cast<DIETemplateValueParameter*>(entry);
					constantValue = parameterEntry->ConstValue();
					type = parameterEntry->GetType();
					break;
				}
				case DW_TAG_variable:
				{
					DIEVariable* variableEntry
						= dynamic_cast<DIEVariable*>(entry);
					constantValue = variableEntry->ConstValue();
					type = variableEntry->GetType();
					break;
				}
				default:
					return B_BAD_VALUE;
			}

			if (constantValue == NULL || !constantValue->IsValid())
				return B_BAD_VALUE;

			status_t error = EvaluateConstantValue(unit, addressSize, isBigEndian,
				subprogramEntry, constantValue, targetInterface,
				instructionPointer, framePointer, _result);
			if (error != B_OK)
				return error;

			*_type = type;
			return B_OK;
		}

		case ATTRIBUTE_CLASS_BLOCK:
		{
			target_addr_t result;
			status_t error = EvaluateExpression(unit, addressSize, isBigEndian,
				subprogramEntry, value->block.data, value->block.length,
				targetInterface, instructionPointer, framePointer, 0, false,
				result);
			if (error != B_OK)
				return error;

			_result.SetTo(result);
			*_type = NULL;
			return B_OK;
		}

		default:
			return B_BAD_VALUE;
	}
}


status_t
DwarfFile::_ParseDebugInfoSection(uint8 _addressSize, bool isBigEndian)
{
	// iterate through the debug info section
	DataReader dataReader(fDebugInfoSection->Data(),
		fDebugInfoSection->Size(), _addressSize, isBigEndian);

	while (dataReader.HasData()) {
		off_t unitHeaderOffset = dataReader.Offset();
		bool dwarf64;
		uint64 unitLength = dataReader.ReadInitialLength(dwarf64);

		off_t unitLengthOffset = dataReader.Offset();
			// the unitLength starts here

		if (unitLengthOffset + unitLength
				> (uint64)fDebugInfoSection->Size()) {
			WARNING("\"%s\": Invalid compilation unit length.\n", fName);
			break;
		}

		int version = dataReader.Read<uint16>(0);
		if (version >= 5) {
			uint8 unitType = dataReader.Read<uint8>(0);
			if (unitType != DW_UT_compile) {
				WARNING("\"%s\": Unsupported unit type %d\n",
					fName, unitType);
				return B_UNSUPPORTED;
			}
		}

		off_t abbrevOffset;
		uint8 addressSize;

		if (version >= 5) {
			addressSize = dataReader.Read<uint8>(0);
			abbrevOffset = dwarf64
				? dataReader.Read<uint64>(0)
				: dataReader.Read<uint32>(0);
		} else {
			abbrevOffset = dwarf64
				? dataReader.Read<uint64>(0)
				: dataReader.Read<uint32>(0);
			addressSize = dataReader.Read<uint8>(0);
		}

		if (dataReader.HasOverflow()) {
			WARNING("\"%s\": Unexpected end of data in compilation unit "
				"header.\n", fName);
			break;
		}

		TRACE_DIE("DWARF%d compilation unit: version %d, length: %" B_PRIu64
			", abbrevOffset: %" B_PRIdOFF ", address size: %d\n",
			dwarf64 ? 64 : 32, version, unitLength, abbrevOffset, addressSize);

		if (version < 2 || version > 4) {
			WARNING("\"%s\": Unsupported compilation unit version: %d\n",
				fName, version);
			break;
		}

		if (addressSize != 4 && addressSize != 8) {
			WARNING("\"%s\": Unsupported address size: %d\n", fName,
				addressSize);
			break;
		}
		dataReader.SetAddressSize(addressSize);

		off_t unitContentOffset = dataReader.Offset();

		// create a compilation unit object
		CompilationUnit* unit = new(std::nothrow) CompilationUnit(
			unitHeaderOffset, unitContentOffset,
			unitLength + (unitLengthOffset - unitHeaderOffset),
			abbrevOffset, addressSize, isBigEndian, dwarf64);
		if (unit == NULL || !fCompilationUnits.AddItem(unit)) {
			delete unit;
			return B_NO_MEMORY;
		}

		// parse the debug info for the unit
		status_t error = _ParseCompilationUnit(unit);
		if (error != B_OK)
			return error;

		dataReader.SeekAbsolute(unitLengthOffset + unitLength);
	}

	return B_OK;
}


status_t
DwarfFile::_ParseTypesSection(uint8 _addressSize, bool isBigEndian)
{
	DataReader dataReader(fDebugTypesSection->Data(),
		fDebugTypesSection->Size(), _addressSize, isBigEndian);
	while (dataReader.HasData()) {
		off_t unitHeaderOffset = dataReader.Offset();
		bool dwarf64;
		uint64 unitLength = dataReader.ReadInitialLength(dwarf64);

		off_t unitLengthOffset = dataReader.Offset();
			// the unitLength starts here

		if (unitLengthOffset + unitLength
				> (uint64)fDebugTypesSection->Size()) {
			WARNING("Invalid type unit length, offset %#" B_PRIx64 ".\n",
				unitHeaderOffset);
			break;
		}

		int version = dataReader.Read<uint16>(0);
		off_t abbrevOffset = dwarf64
			? dataReader.Read<uint64>(0)
			: dataReader.Read<uint32>(0);
		uint8 addressSize = dataReader.Read<uint8>(0);

		if (dataReader.HasOverflow()) {
			WARNING("Unexpected end of data in type unit header at %#"
				B_PRIx64 ".\n", unitHeaderOffset);
			break;
		}

		dataReader.SetAddressSize(addressSize);

		uint64 signature = dataReader.Read<uint64>(0);

		off_t typeOffset = dwarf64
			? dataReader.Read<uint64>(0)
			: dataReader.Read<uint32>(0);

		off_t unitContentOffset = dataReader.Offset();

		TRACE_DIE("DWARF%d type unit: version %d, length: %" B_PRIu64
			", abbrevOffset: %" B_PRIdOFF ", address size: %d, "
			"signature: %#" B_PRIx64 ", type offset: %" B_PRIu64 "\n",
			dwarf64 ? 64 : 32, version, unitLength, abbrevOffset, addressSize,
			signature, typeOffset);

		if (version > 4) {
			WARNING("\"%s\": Unsupported type unit version: %d\n",
				fName, version);
			break;
		}

		if (addressSize != 4 && addressSize != 8) {
			WARNING("\"%s\": Unsupported address size: %d\n", fName,
				addressSize);
			break;
		}

		// create a type unit object
		TypeUnit* unit = new(std::nothrow) TypeUnit(
			unitHeaderOffset, unitContentOffset,
			unitLength + (unitLengthOffset - unitHeaderOffset),
			abbrevOffset, typeOffset, addressSize, isBigEndian,
			signature, dwarf64);
		if (unit == NULL)
			return B_NO_MEMORY;

		// parse the debug info for the unit
		status_t error = _ParseTypeUnit(unit);
		if (error != B_OK)
			return error;

		// TODO: it should theoretically never happen that we get a duplicate,
		// but it wouldn't hurt to check since that situation would potentially
		// be problematic.
		if (fTypeUnits.Lookup(signature) == NULL) {
			TypeUnitTableEntry* entry = new(std::nothrow)
				TypeUnitTableEntry(signature, unit);
			if (entry == NULL)
				return B_NO_MEMORY;

			fTypeUnits.Insert(entry);
		}

		dataReader.SeekAbsolute(unitLengthOffset + unitLength);
	}

	return B_OK;
}


status_t
DwarfFile::_ParseFrameSection(ElfSection* section, uint8 addressSize, bool isBigEndian,
	bool ehFrame, FDEInfoList& infos)
{
	if (ehFrame) {
		fItaniumEHFrameFormat = section->IsWritable();
			// Crude heuristic for recognizing GCC 4 (Itanium ABI) style
			// .eh_frame sections. The ones generated by GCC 2 are writable,
			// the ones generated by GCC 4 aren't.
	}

	DataReader dataReader((uint8*)section->Data(),
		section->Size(), addressSize, isBigEndian);

	while (dataReader.BytesRemaining() > 0) {
		// length
		bool dwarf64;
		off_t entryOffset = dataReader.Offset();
		uint64 length = dataReader.ReadInitialLength(dwarf64);

		TRACE_CFI("DwarfFile::_ParseFrameSection(): offset: %" B_PRIdOFF
			", length: %" B_PRId64 "\n", entryOffset, length);

		if (length > (uint64)dataReader.BytesRemaining())
			return B_BAD_DATA;
		off_t lengthOffset = dataReader.Offset();

		// If the length is 0, it means a terminator of the CIE.
		// Then just skip this .debug_frame/.eh_frame section.
		if (length == 0)
			return B_OK;

		// CIE ID/CIE pointer
		uint64 cieID = dwarf64
			? dataReader.Read<uint64>(0) : dataReader.Read<uint32>(0);

		// In .debug_frame ~0 indicates a CIE, in .eh_frame 0 does.
		if (ehFrame
			? cieID == 0
			: (dwarf64
				? cieID == 0xffffffffffffffffULL
				: cieID == 0xffffffff)) {
			// this is a CIE -- skip it
		} else {
			// this is a FDE
			uint64 initialLocationOffset = dataReader.Offset();
			// In .eh_frame the CIE offset is a relative back offset.
			if (ehFrame) {
				if (cieID > (uint64)lengthOffset) {
					TRACE_CFI("Invalid CIE offset: %" B_PRIu64 ", max "
						"possible: %" B_PRIu64 "\n", cieID, lengthOffset);
					break;
				}
				// convert to a section relative offset
				cieID = lengthOffset - cieID;
			}


			CfaContext context;
			CIEAugmentation cieAugmentation;
			// when using .eh_frame format, we need to parse the CIE's
			// augmentation up front in order to know how the FDE's addresses
			//  will be represented
			DataReader cieReader;
			off_t cieRemaining;
			status_t error = _ParseCIEHeader(section, ehFrame, NULL,
				addressSize, isBigEndian, context,
				cieID, cieAugmentation, cieReader, cieRemaining);
			if (error != B_OK)
				return error;
			if (cieReader.HasOverflow())
				return B_BAD_DATA;
			if (cieRemaining < 0)
				return B_BAD_DATA;

			target_addr_t initialLocation = cieAugmentation.ReadEncodedAddress(
				dataReader, fElfFile, section);
			target_addr_t addressRange = cieAugmentation.ReadEncodedAddress(
				dataReader, fElfFile, section, true);

			if (dataReader.HasOverflow())
				return B_BAD_DATA;

			if ((cieAugmentation.FDEAddressType()
					& CFI_ADDRESS_TYPE_PC_RELATIVE) != 0) {
				initialLocation += initialLocationOffset;
			}

			// for unknown reasons, the debug frame sections generated by gcc
			// sometimes contain duplicates at different offsets within the
			// section. In such a case, simply skip the duplicates.
			FDELookupInfo* temp = _GetContainingFDEInfo(initialLocation,
				infos);
			if (temp == NULL) {
				FDELookupInfo* info = new(std::nothrow)FDELookupInfo(
					initialLocation, initialLocation + addressRange - 1,
					entryOffset, cieID, ehFrame);
				if (info == NULL)
					return B_NO_MEMORY;

				ObjectDeleter<FDELookupInfo> infoDeleter(info);
				if (!infos.BinaryInsert(info, FDELookupInfo::CompareFDEInfos))
					return B_NO_MEMORY;

				infoDeleter.Detach();
			}
		}

		dataReader.SeekAbsolute(lengthOffset + length);
	}

	return B_OK;
}


status_t
DwarfFile::_ParseCompilationUnit(CompilationUnit* unit)
{
	AbbreviationTable* abbreviationTable;
	status_t error = _GetAbbreviationTable(unit->AbbreviationOffset(),
		abbreviationTable);
	if (error != B_OK)
		return error;

	unit->SetAbbreviationTable(abbreviationTable);

	DataReader dataReader(
		(const uint8*)fDebugInfoSection->Data() + unit->ContentOffset(),
		unit->ContentSize(), unit->AddressSize(), unit->IsBigEndian());

	DebugInfoEntry* entry;
	bool endOfEntryList;
	error = _ParseDebugInfoEntry(dataReader, unit, abbreviationTable, entry,
		endOfEntryList);
	if (error != B_OK)
		return error;

	DIECompileUnitBase* unitEntry = dynamic_cast<DIECompileUnitBase*>(entry);
	if (unitEntry == NULL) {
		WARNING("No compilation unit entry in .debug_info section.\n");
		return B_BAD_DATA;
	}

	unit->SetUnitEntry(unitEntry);

	TRACE_DIE_ONLY(
		TRACE_DIE("remaining bytes in unit: %" B_PRIdOFF "\n",
			dataReader.BytesRemaining());
		if (dataReader.HasData()) {
			TRACE_DIE("  ");
			while (dataReader.HasData())
				TRACE_DIE("%02x", dataReader.Read<uint8>(0));
			TRACE_DIE("\n");
		}
	)
	return B_OK;
}


status_t
DwarfFile::_ParseTypeUnit(TypeUnit* unit)
{
	AbbreviationTable* abbreviationTable;
	status_t error = _GetAbbreviationTable(unit->AbbreviationOffset(),
		abbreviationTable);
	if (error != B_OK)
		return error;

	unit->SetAbbreviationTable(abbreviationTable);

	DataReader dataReader(
		(const uint8*)fDebugTypesSection->Data() + unit->ContentOffset(),
		unit->ContentSize(), unit->AddressSize(), unit->IsBigEndian());

	DebugInfoEntry* entry;
	bool endOfEntryList;
	error = _ParseDebugInfoEntry(dataReader, unit, abbreviationTable, entry,
		endOfEntryList);
	if (error != B_OK)
		return error;

	DIETypeUnit* unitEntry = dynamic_cast<DIETypeUnit*>(entry);
	if (unitEntry == NULL) {
		WARNING("No type unit entry in .debug_types section.\n");
		return B_BAD_DATA;
	}

	unit->SetUnitEntry(unitEntry);
	DebugInfoEntry* typeEntry = unit->EntryForOffset(unit->TypeOffset());
	if (typeEntry == NULL) {
		WARNING("No type found for type unit %p at specified offset %"
			B_PRId64 ".\n", unit, unit->TypeOffset());
		return B_BAD_DATA;
	}
	unit->SetTypeEntry(typeEntry);

	TRACE_DIE_ONLY(
		TRACE_DIE("remaining bytes in unit: %" B_PRIdOFF "\n",
			dataReader.BytesRemaining());
		if (dataReader.HasData()) {
			TRACE_DIE("  ");
			while (dataReader.HasData())
				TRACE_DIE("%02x", dataReader.Read<uint8>(0));
			TRACE_DIE("\n");
		}
	)
	return B_OK;
}


status_t
DwarfFile::_ParseDebugInfoEntry(DataReader& dataReader,
	BaseUnit* unit, AbbreviationTable* abbreviationTable,
	DebugInfoEntry*& _entry, bool& _endOfEntryList, int level)
{
	off_t entryOffset = dataReader.Offset()
		+ unit->RelativeContentOffset();

	uint32 code = dataReader.ReadUnsignedLEB128(0);
	if (code == 0) {
		if (dataReader.HasOverflow()) {
			WARNING("Unexpected end of .debug_info section.\n");
			return B_BAD_DATA;
		}
		_entry = NULL;
		_endOfEntryList = true;
		return B_OK;
	}

	// get the corresponding abbreviation entry
	AbbreviationEntry abbreviationEntry;
	if (!abbreviationTable->GetAbbreviationEntry(code, abbreviationEntry)) {
		WARNING("No abbreviation entry for code %" B_PRIx32 "\n", code);
		return B_BAD_DATA;
	}

	DebugInfoEntry* entry;
	status_t error = fDebugInfoFactory.CreateDebugInfoEntry(
		abbreviationEntry.Tag(), entry);
	if (error != B_OK) {
		WARNING("Failed to generate entry for tag %" B_PRIu32 ", code %"
			B_PRIu32 "\n", abbreviationEntry.Tag(), code);
		return error;
	}

	ObjectDeleter<DebugInfoEntry> entryDeleter(entry);

	TRACE_DIE("%*sentry %p at %" B_PRIdOFF ": %" B_PRIu32 ", tag: %s (%"
		B_PRIu32 "), children: %d\n", level * 2, "", entry, entryOffset,
		abbreviationEntry.Code(), get_entry_tag_name(abbreviationEntry.Tag()),
		abbreviationEntry.Tag(), abbreviationEntry.HasChildren());

	error = unit->AddDebugInfoEntry(entry, entryOffset);

	if (error != B_OK)
		return error;

	// parse the attributes (supply NULL entry to avoid adding them yet)
	error = _ParseEntryAttributes(dataReader, unit, NULL, abbreviationEntry);
	if (error != B_OK)
		return error;

	// parse children, if the entry has any
	if (abbreviationEntry.HasChildren()) {
		while (true) {
			DebugInfoEntry* childEntry;
			bool endOfEntryList;
			status_t error = _ParseDebugInfoEntry(dataReader,
				unit, abbreviationTable, childEntry, endOfEntryList, level + 1);
			if (error != B_OK)
				return error;

			// add the child to our entry
			if (childEntry != NULL) {
				if (entry != NULL) {
					error = entry->AddChild(childEntry);
					if (error == B_OK) {
						childEntry->SetParent(entry);
					} else if (error == ENTRY_NOT_HANDLED) {
						error = B_OK;
						TRACE_DIE("%*s  -> child unhandled\n", level * 2, "");
					}

					if (error != B_OK) {
						delete childEntry;
						return error;
					}
				} else
					delete childEntry;
			}

			if (endOfEntryList)
				break;
		}
	}

	entryDeleter.Detach();
	_entry = entry;
	_endOfEntryList = false;
	return B_OK;
}


status_t
DwarfFile::_FinishUnit(BaseUnit* unit)
{
	CompilationUnit* compilationUnit = dynamic_cast<CompilationUnit*>(unit);
	bool isTypeUnit = compilationUnit == NULL;
	TRACE_DIE("\nfinishing %s unit %p\n",
		isTypeUnit ? "type" : "compilation", unit);


	AbbreviationTable* abbreviationTable = unit->GetAbbreviationTable();

	ElfSection* section = isTypeUnit
			? fDebugTypesSection : fDebugInfoSection;
	DataReader dataReader(
		(const uint8*)section->Data() + unit->HeaderOffset(),
		unit->TotalSize(), unit->AddressSize(), unit->IsBigEndian());

	DebugInfoEntryInitInfo entryInitInfo;

	int entryCount = unit->CountEntries();
	for (int i = 0; i < entryCount; i++) {
		// get the entry
		DebugInfoEntry* entry;
		off_t offset;
		unit->GetEntryAt(i, entry, offset);

		TRACE_DIE("entry %p at %" B_PRIdOFF "\n", entry, offset);

		// seek the reader to the entry
		dataReader.SeekAbsolute(offset);

		// read the entry code
		uint32 code = dataReader.ReadUnsignedLEB128(0);

		// get the respective abbreviation entry
		AbbreviationEntry abbreviationEntry;
		abbreviationTable->GetAbbreviationEntry(code, abbreviationEntry);

		// initialization before setting the attributes
		status_t error = entry->InitAfterHierarchy(entryInitInfo);
		if (error != B_OK) {
			WARNING("Init after hierarchy failed!\n");
			return error;
		}

		// parse the attributes -- this time pass the entry, so that the
		// attribute get set on it
		error = _ParseEntryAttributes(dataReader, unit, entry,
			abbreviationEntry);
		if (error != B_OK)
			return error;

		// initialization after setting the attributes
		error = entry->InitAfterAttributes(entryInitInfo);
		if (error != B_OK) {
			WARNING("Init after attributes failed!\n");
			return error;
		}
	}

	// set the compilation unit's source language
	unit->SetSourceLanguage(entryInitInfo.languageInfo);

	if (isTypeUnit)
		return B_OK;

	// resolve the compilation unit's address range list
	if (TargetAddressRangeList* ranges = ResolveRangeList(compilationUnit,
			compilationUnit->UnitEntry()->AddressRangesOffset())) {
		compilationUnit->SetAddressRanges(ranges);
		ranges->ReleaseReference();
	}

	// add compilation dir to directory list
	const char* compilationDir = compilationUnit->UnitEntry()
		->CompilationDir();
	if (!compilationUnit->AddDirectory(compilationDir != NULL
				? compilationDir : ".")) {
		return B_NO_MEMORY;
	}

	// parse line info header
	if (fDebugLineSection != NULL)
		_ParseLineInfo(compilationUnit);

	return B_OK;
}


status_t
DwarfFile::_ReadStringIndirect(BaseUnit* unit, uint64 index, const char*& value) const
{
	if (fDebugStrOffsetsSection == NULL) {
		WARNING("Invalid DW_FORM_strx*: no debug_str_offsets section!\n");
		return B_BAD_DATA;
	}

	uint64 strOffsetsBase = unit->IsDwarf64() ? 16 : 8;
	uint64 offsetSize = unit->IsDwarf64() ? 8 : 4;

	if (strOffsetsBase + index * offsetSize >= fDebugStrOffsetsSection->Size()) {
		WARNING("Invalid DW_FORM_strx* index: %" B_PRIu64 "\n", index);
		return B_BAD_DATA;
	}

	const char *strOffsets = (const char*)fDebugStrOffsetsSection->Data() + strOffsetsBase;
	uint64 offset = unit->IsDwarf64()
		? ((uint64*)strOffsets)[index]
		: ((uint32*)strOffsets)[index];

	if (offset >= fDebugStringSection->Size()) {
		WARNING("Invalid DW_FORM_strx* offset: %" B_PRIu64 "\n", offset);
		return B_BAD_DATA;
	}

	value = (const char*)fDebugStringSection->Data() + offset;
	return B_OK;
}


status_t
DwarfFile::_ReadAddressIndirect(BaseUnit* unit, uint64 index, uint64& value) const
{
	if (fDebugAddressSection == NULL) {
		WARNING("Invalid DW_FORM_addrx*: no debug_addr section!\n");
		return B_BAD_DATA;
	}

	uint64 addrBase = unit->IsDwarf64() ? 16 : 8;

	if (addrBase + index * unit->AddressSize() >= fDebugAddressSection->Size()) {
		WARNING("Invalid DW_FORM_addrx* index: %" B_PRIu64 "\n", index);
		return B_BAD_DATA;
	}

	const char *addrPtr = (const char*)fDebugAddressSection->Data()
		+ addrBase + index * unit->AddressSize();

	if (unit->AddressSize() == 8)
		value = *(uint64*)addrPtr;
	else
		value = *(uint32*)addrPtr;

	return B_OK;
}


status_t
DwarfFile::_ParseEntryAttributes(DataReader& dataReader,
	BaseUnit* unit, DebugInfoEntry* entry, AbbreviationEntry& abbreviationEntry)
{
	uint32 attributeName;
	uint32 attributeForm;
	int32 attributeImplicitConst = 0;
	while (abbreviationEntry.GetNextAttribute(attributeName,
			attributeForm, attributeImplicitConst)) {
		// resolve attribute form indirection
		if (attributeForm == DW_FORM_indirect)
			attributeForm = dataReader.ReadUnsignedLEB128(0);

		// prepare an AttributeValue
		AttributeValue attributeValue;
		attributeValue.attributeForm = attributeForm;
		bool isSigned = false;

		// Read the attribute value according to the attribute's form. For
		// the forms that don't map to a single attribute class only or
		// those that need additional processing, we read a temporary value
		// first.
		uint64 value = 0;
		off_t blockLength = 0;
		off_t valueOffset = dataReader.Offset() + unit->ContentOffset();
		uint8 refType = dwarf_reference_type_local;

		switch (attributeForm) {
			case DW_FORM_addr:
				value = dataReader.ReadAddress(0);
				break;
			case DW_FORM_block2:
				blockLength = dataReader.Read<uint16>(0);
				break;
			case DW_FORM_block4:
				blockLength = dataReader.Read<uint32>(0);
				break;
			case DW_FORM_data2:
				value = dataReader.Read<uint16>(0);
				break;
			case DW_FORM_data4:
				value = dataReader.Read<uint32>(0);
				break;
			case DW_FORM_data8:
				value = dataReader.Read<uint64>(0);
				break;
			case DW_FORM_string:
				attributeValue.SetToString(dataReader.ReadString());
				break;
			case DW_FORM_block:
			case DW_FORM_exprloc:
				blockLength = dataReader.ReadUnsignedLEB128(0);
				break;
			case DW_FORM_block1:
				blockLength = dataReader.Read<uint8>(0);
				break;
			case DW_FORM_data1:
				value = dataReader.Read<uint8>(0);
				break;
			case DW_FORM_flag:
				attributeValue.SetToFlag(dataReader.Read<uint8>(0) != 0);
				break;
			case DW_FORM_sdata:
				value = dataReader.ReadSignedLEB128(0);
				isSigned = true;
				break;
			case DW_FORM_strp:
			{
				if (fDebugStringSection != NULL) {
					uint64 offset = unit->IsDwarf64()
						? dataReader.Read<uint64>(0)
						: dataReader.Read<uint32>(0);
					if (offset >= fDebugStringSection->Size()) {
						WARNING("Invalid DW_FORM_strp offset: %" B_PRIu64 "\n",
							offset);
						return B_BAD_DATA;
					}
					attributeValue.SetToString(
						(const char*)fDebugStringSection->Data() + offset);
				} else {
					WARNING("Invalid DW_FORM_strp: no string section!\n");
					return B_BAD_DATA;
				}
				break;
			}
			case DW_FORM_udata:
				value = dataReader.ReadUnsignedLEB128(0);
				break;
			case DW_FORM_ref_addr:
				value = unit->IsDwarf64()
					? dataReader.Read<uint64>(0)
					: (uint64)dataReader.Read<uint32>(0);
				refType = dwarf_reference_type_global;
				break;
			case DW_FORM_ref1:
				value = dataReader.Read<uint8>(0);
				break;
			case DW_FORM_ref2:
				value = dataReader.Read<uint16>(0);
				break;
			case DW_FORM_ref4:
				value = dataReader.Read<uint32>(0);
				break;
			case DW_FORM_ref8:
				value = dataReader.Read<uint64>(0);
				break;
			case DW_FORM_ref_udata:
				value = dataReader.ReadUnsignedLEB128(0);
				break;
			case DW_FORM_flag_present:
				attributeValue.SetToFlag(true);
				break;
			case DW_FORM_strx:
			{
				uint64 index = dataReader.ReadUnsignedLEB128(0);
				const char* strValue;
				status_t res = _ReadStringIndirect(unit, index, strValue);
				if (res != B_OK)
					return res;
				attributeValue.SetToString(strValue);
				break;
			}
			case DW_FORM_addrx:
			{
				uint64 index = dataReader.ReadUnsignedLEB128(0);
				status_t res = _ReadAddressIndirect(unit, index, value);
				if (res != B_OK)
					return res;
				break;
			}
			case DW_FORM_line_strp:
			{
				if (fDebugLineStrSection != NULL) {
					uint64 offset = unit->IsDwarf64()
						? dataReader.Read<uint64>(0)
						: dataReader.Read<uint32>(0);
					if (offset >= fDebugLineStrSection->Size()) {
						WARNING("Invalid DW_FORM_line_strp offset: %" B_PRIu64 "\n",
							offset);
						return B_BAD_DATA;
					}
					attributeValue.SetToString(
						(const char*)fDebugLineStrSection->Data() + offset);
				} else {
					WARNING("Invalid DW_FORM_line_strp: no debug_line_str section!\n");
					return B_BAD_DATA;
				}
				break;
			}
			case DW_FORM_ref_sig8:
				fTypesSectionRequired = true;
				value = dataReader.Read<uint64>(0);
				refType = dwarf_reference_type_signature;
				break;
			case DW_FORM_implicit_const:
				value = attributeImplicitConst;
				break;
			case DW_FORM_sec_offset:
				value = unit->IsDwarf64()
					? dataReader.Read<uint64>(0)
					: (uint64)dataReader.Read<uint32>(0);
				break;
			case DW_FORM_strx1:
			case DW_FORM_strx2:
			case DW_FORM_strx3:
			case DW_FORM_strx4:
			{
				size_t numBytes = attributeForm - DW_FORM_strx1 + 1;
				uint64 index = dataReader.ReadUInt(numBytes, 0);
				const char* strValue;
				status_t res = _ReadStringIndirect(unit, index, strValue);
				if (res != B_OK)
					return res;
				attributeValue.SetToString(strValue);
				break;
			}
			case DW_FORM_addrx1:
			case DW_FORM_addrx2:
			case DW_FORM_addrx3:
			case DW_FORM_addrx4:
			{
				size_t numBytes = attributeForm - DW_FORM_addrx1 + 1;
				uint64 index = dataReader.ReadUInt(numBytes, 0);
				status_t res = _ReadAddressIndirect(unit, index, value);
				if (res != B_OK)
					return res;
				break;
			}
			case DW_FORM_indirect:
			default:
				WARNING("Unsupported attribute form: %" B_PRIu32 "\n",
					attributeForm);
				return B_BAD_DATA;
		}

		// get the attribute class -- skip the attribute, if we can't handle
		// it
		uint8 attributeClass = get_attribute_class(attributeName,
			attributeForm);

		if (attributeClass == ATTRIBUTE_CLASS_UNKNOWN) {
			TRACE_DIE("skipping attribute with unrecognized class: %s (%#"
				B_PRIx32 ") %s (%#" B_PRIx32 ")\n",
				get_attribute_name_name(attributeName), attributeName,
				get_attribute_form_name(attributeForm), attributeForm);
			continue;
		}

		// set the attribute value according to the attribute's class
		switch (attributeClass) {
			case ATTRIBUTE_CLASS_ADDRESS:
				attributeValue.SetToAddress(value);
				break;
			case ATTRIBUTE_CLASS_ADDRPTR:
				attributeValue.SetToAddrPtr(value);
				break;
			case ATTRIBUTE_CLASS_BLOCK:
				attributeValue.SetToBlock(dataReader.Data(), blockLength);
				dataReader.Skip(blockLength);
				break;
			case ATTRIBUTE_CLASS_CONSTANT:
				attributeValue.SetToConstant(value, isSigned);
				break;
			case ATTRIBUTE_CLASS_LINEPTR:
				attributeValue.SetToLinePointer(value);
				break;
			case ATTRIBUTE_CLASS_LOCLIST:
				attributeValue.SetToLocationList(value);
				break;
			case ATTRIBUTE_CLASS_LOCLISTPTR:
				attributeValue.SetToLocationListPointer(value);
				break;
			case ATTRIBUTE_CLASS_MACPTR:
				attributeValue.SetToMacroPointer(value);
				break;
			case ATTRIBUTE_CLASS_RANGELIST:
				attributeValue.SetToRangeList(value);
				break;
			case ATTRIBUTE_CLASS_RANGELISTPTR:
				attributeValue.SetToRangeListPointer(value);
				break;
			case ATTRIBUTE_CLASS_REFERENCE:
				if (entry != NULL) {
					attributeValue.SetToReference(_ResolveReference(
						unit, value, refType));
					if (attributeValue.reference == NULL) {
						// gcc 2 apparently somtimes produces DW_AT_sibling
						// attributes pointing to the end of the sibling list.
						// Just ignore those.
						if (attributeName == DW_AT_sibling)
							continue;

						WARNING("Failed to resolve reference on entry %p: "
							"(%#" B_PRIx64 ") %s (%#" B_PRIx32 ") %s "
							"(%#" B_PRIx32 "): value: %#" B_PRIx64 "\n",
							entry,
							valueOffset,
							get_attribute_name_name(attributeName),
							attributeName,
							get_attribute_form_name(attributeForm),
							attributeForm, value);
						return B_ENTRY_NOT_FOUND;
					}
				}
				break;
			case ATTRIBUTE_CLASS_FLAG:
			case ATTRIBUTE_CLASS_STRING:
				// already set
				break;
			case ATTRIBUTE_CLASS_STROFFSETSPTR:
				attributeValue.SetToStrOffsetsPtr(value);
				break;
		}

		if (dataReader.HasOverflow()) {
			WARNING("Unexpected end of .debug_info section.\n");
			return B_BAD_DATA;
		}

		TRACE_DIE_ONLY(
			char buffer[1024];
			TRACE_DIE("  attr (%#" B_PRIx64 ") %s %s (%d): %s\n",
				valueOffset,
				get_attribute_name_name(attributeName),
				get_attribute_form_name(attributeForm), attributeClass,
				attributeValue.ToString(buffer, sizeof(buffer)));
		)

		// add the attribute
		if (entry != NULL) {
			DebugInfoEntrySetter attributeSetter
				= get_attribute_name_setter(attributeName);
			if (attributeSetter != 0) {
				status_t error = (entry->*attributeSetter)(attributeName,
					attributeValue);

				if (error == ATTRIBUTE_NOT_HANDLED) {
					error = B_OK;
					TRACE_DIE("    -> unhandled\n");
				}

				if (error != B_OK) {
					WARNING("Failed to set attribute: name: %s, form: %s: %s\n",
						get_attribute_name_name(attributeName),
						get_attribute_form_name(attributeForm),
						strerror(error));
				}
			} else
				TRACE_DIE("    -> no attribute setter!\n");
		}
	}

	return B_OK;
}


status_t
DwarfFile::_ParseLineInfoFormatString(CompilationUnit* unit, DataReader &dataReader,
	uint64 format, const char*& value)
{
	switch (format) {
		case DW_FORM_string:
			value = dataReader.ReadString();
			break;
		case DW_FORM_line_strp:
		{
			if (fDebugLineStrSection == NULL) {
				WARNING("Invalid DW_FORM_line_strp: no line_str section!\n");
				return B_BAD_DATA;
			}

			target_addr_t offset = unit->IsDwarf64()
				? dataReader.Read<uint64>(0)
				: dataReader.Read<uint32>(0);
			if (offset > fDebugLineStrSection->Size()) {
				WARNING("Invalid DW_FORM_line_strp offset: %" B_PRIu64 "\n",
					offset);
				return B_BAD_DATA;
			}

			value = (const char*)fDebugLineStrSection->Data() + offset;
			break;
		}
		case DW_FORM_strp:
		{
			if (fDebugStringSection == NULL) {
				WARNING("Invalid DW_FORM_strp: no string section!\n");
				return B_BAD_DATA;
			}

			target_addr_t offset = unit->IsDwarf64()
				? dataReader.Read<uint64>(0)
				: dataReader.Read<uint32>(0);
			if (offset > fDebugStringSection->Size()) {
				WARNING("Invalid DW_FORM_strp offset: %" B_PRIu64 "\n",
					offset);
				return B_BAD_DATA;
			}

			value = (const char*)fDebugStringSection->Data() + offset;
			break;
		}
		case DW_FORM_strp_sup:
			return B_UNSUPPORTED;
			break;
		default:
			WARNING("DwarfFile::_ParseLineInfoFormatString(\"%s\"): unsupported "
				"field type %" PRIu64 "\n", fName, format);
			return B_BAD_DATA;
	}

	return B_OK;
}


status_t
DwarfFile::_ParseLineInfoFormatUint(CompilationUnit* unit, DataReader &dataReader,
	uint64 format, uint64 &value)
{
	switch (format)
	{
		case DW_FORM_data1:
			value = dataReader.Read<uint8>(0);
			break;
		case DW_FORM_data2:
			value = dataReader.Read<uint16>(0);
			break;
		case DW_FORM_data4:
			value = dataReader.Read<uint32>(0);
			break;
		case DW_FORM_data8:
			value = dataReader.Read<uint64>(0);
			break;
		case DW_FORM_udata:
			value = dataReader.ReadUnsignedLEB128(0);
			break;
		default:
			WARNING("DwarfFile::_ParseLineInfoFormatUint(\"%s\"): unsupported "
				"field type %" PRIu64 "\n", fName, format);
			return B_BAD_DATA;
	}

	return B_OK;
}


status_t
DwarfFile::_ParseLineInfo(CompilationUnit* unit)
{
	off_t offset = unit->UnitEntry()->StatementListOffset();

	TRACE_LINES("DwarfFile::_ParseLineInfo(%p), offset: %" B_PRIdOFF "\n", unit,
		offset);

	DataReader dataReader((uint8*)fDebugLineSection->Data() + offset,
		fDebugLineSection->Size() - offset, unit->AddressSize(), unit->IsBigEndian());

	// unit length
	bool dwarf64;
	uint64 unitLength = dataReader.ReadInitialLength(dwarf64);
	if (unitLength > (uint64)dataReader.BytesRemaining())
		return B_BAD_DATA;
	off_t unitOffset = dataReader.Offset();

	// version (uhalf)
	uint16 version = dataReader.Read<uint16>(0);

	if (version < 2 || version > 5) {
		WARNING("DwarfFile::_ParseLineInfo(\"%s\"): unsupported "
			"version %d\n", fName, version);
		return B_UNSUPPORTED;
	}

	uint8 addressSize = unit->AddressSize();
	uint8 segmentSelectorSize = 0;

	if (version >= 5) {
		addressSize = dataReader.Read<uint8>(0);
		if (addressSize != 4 && addressSize != 8) {
			WARNING("DwarfFile::_ParseLineInfo(\"%s\"): unsupported "
				"addressSize %d\n", fName, addressSize);
			return B_BAD_DATA;
		}

		segmentSelectorSize = dataReader.Read<uint8>(0);
		if (segmentSelectorSize != 0) {
			WARNING("DwarfFile::_ParseLineInfo(\"%s\"): unsupported "
				"segmentSelectorSize %d\n", fName, segmentSelectorSize);
			return B_BAD_DATA;
		}
	}

	// header_length (4/8)
	uint64 headerLength = dwarf64
		? dataReader.Read<uint64>(0) : (uint64)dataReader.Read<uint32>(0);
	off_t headerOffset = dataReader.Offset();

	if ((uint64)dataReader.BytesRemaining() < headerLength)
		return B_BAD_DATA;

	// minimum instruction length
	uint8 minInstructionLength = dataReader.Read<uint8>(0);

	uint8 maxOpsPerInstruction;
	if (version >= 4)
		maxOpsPerInstruction = dataReader.Read<uint8>(0);
	else
		maxOpsPerInstruction = 1;

	if (maxOpsPerInstruction != 1) {
		WARNING("DwarfFile::_ParseLineInfo(\"%s\"): unsupported "
			"maxOpsPerInstruction %u\n", fName, maxOpsPerInstruction);
		return B_UNSUPPORTED;
	}

	// default is statement
	bool defaultIsStatement = dataReader.Read<uint8>(0) != 0;

	// line_base (sbyte)
	int8 lineBase = (int8)dataReader.Read<uint8>(0);

	// line_range (ubyte)
	uint8 lineRange = dataReader.Read<uint8>(0);

	// opcode_base (ubyte)
	uint8 opcodeBase = dataReader.Read<uint8>(0);

	// standard_opcode_lengths (ubyte[])
	const uint8* standardOpcodeLengths = (const uint8*)dataReader.Data();
	dataReader.Skip(opcodeBase - 1);

	if (dataReader.HasOverflow())
		return B_BAD_DATA;

	TRACE_LINES("  unitLength:           %" B_PRIu64 "\n", unitLength);
	TRACE_LINES("  version:              %u\n", version);
	if (version >= 5) {
		TRACE_LINES("  addressSize:          %u\n", addressSize);
		TRACE_LINES("  segmentSelectorSize:  %u\n", segmentSelectorSize);
	}
	TRACE_LINES("  headerLength:         %" B_PRIu64 "\n", headerLength);
	TRACE_LINES("  minInstructionLength: %u\n", minInstructionLength);
	if (version >= 4)
		TRACE_LINES("  maxOpsPerInstruction: %u\n", maxOpsPerInstruction);
	TRACE_LINES("  defaultIsStatement:   %d\n", defaultIsStatement);
	TRACE_LINES("  lineBase:             %d\n", lineBase);
	TRACE_LINES("  lineRange:            %u\n", lineRange);
	TRACE_LINES("  opcodeBase:           %u\n", opcodeBase);

	if (version >= 5) {
		uint8 dirEntryFormatCount = dataReader.Read<uint8>(0);
		TRACE_LINES("  dirEntryFormatCount:  %u\n", dirEntryFormatCount);

		off_t dirEntryFormatOffset = dataReader.Offset();
		for (unsigned int i = 0; i < dirEntryFormatCount; i++) {
			TRACE_LINES_ONLY(uint64 content =)
				dataReader.ReadUnsignedLEB128(0);
			TRACE_LINES_ONLY(uint64 format =)
				dataReader.ReadUnsignedLEB128(0);

			TRACE_LINES("    content:            %" B_PRIu64 "\n", content);
			TRACE_LINES("    format:             %" B_PRIu64 "\n", format);
		}
		off_t dirEntryFormatLength = dataReader.Offset() - dirEntryFormatOffset;
		DataReader dirEntryFormatReader = dataReader.RestrictedReader(-dirEntryFormatLength,
			dirEntryFormatLength);

		uint8 dirCount = dataReader.Read<uint8>(0);
		TRACE_LINES("  dirCount:             %u\n", dirCount);

		for (unsigned int i = 0; i < dirCount; i++) {
			dirEntryFormatReader.SeekAbsolute(0);
			for (unsigned int j = 0; j < dirEntryFormatCount; j++) {
				uint64 content = dirEntryFormatReader.ReadUnsignedLEB128(0);
				uint64 format = dirEntryFormatReader.ReadUnsignedLEB128(0);
				if (content != DW_LNCT_path) {
					WARNING("DwarfFile::_ParseLineInfo(\"%s\"): unsupported "
						"field in dirs %" PRIu64 "\n", fName, content);
					return B_UNSUPPORTED;
				}

				const char* directory;
				status_t res = _ParseLineInfoFormatString(unit, dataReader, format, directory);
				if (res != B_OK)
					return res;
				TRACE_LINES("    \"%s\"\n", directory);

				if (!unit->AddDirectory(directory))
					return B_NO_MEMORY;

			}
		}

		uint8 fileNameEntryFormatCount = dataReader.Read<uint8>(0);
		TRACE_LINES("  fileNameFormatCount:  %u\n", fileNameEntryFormatCount);

		off_t fileNameEntryFormatOffset = dataReader.Offset();
		for (unsigned int i = 0; i < fileNameEntryFormatCount; i++) {
			TRACE_LINES_ONLY(uint64 content =)
				dataReader.ReadUnsignedLEB128(0);
			TRACE_LINES_ONLY(uint64 format =)
				dataReader.ReadUnsignedLEB128(0);

			TRACE_LINES("    content:            %" B_PRIu64 "\n", content);
			TRACE_LINES("    format:             %" B_PRIu64 "\n", format);
		}
		off_t fileNameEntryFormatLength = dataReader.Offset() - fileNameEntryFormatOffset;
		DataReader fileNameEntryFormatReader = dataReader.RestrictedReader(-fileNameEntryFormatLength,
			fileNameEntryFormatLength);

		uint8 fileNameCount = dataReader.Read<uint8>(0);
		TRACE_LINES("  fileNameCount:        %u\n", dirCount);

		for (unsigned int i = 0; i < fileNameCount; i++) {
			const char* fileName = NULL;
			uint64 dirIndex = 0xffffffffffffffffull;
			uint64 modificationTime = 0;
			uint64 fileLength = 0;

			fileNameEntryFormatReader.SeekAbsolute(0);
			for (unsigned int j = 0; j < fileNameEntryFormatCount; j++) {

				uint64 content = fileNameEntryFormatReader.ReadUnsignedLEB128(0);
				uint64 format = fileNameEntryFormatReader.ReadUnsignedLEB128(0);
				status_t res;
				switch (content) {
					case DW_LNCT_path:
						res = _ParseLineInfoFormatString(unit, dataReader,
							format, fileName);
						if (res != B_OK)
							return res;
						break;
					case DW_LNCT_directory_index:
						res = _ParseLineInfoFormatUint(unit, dataReader,
							format, dirIndex);
						if (res != B_OK)
							return res;
						break;
					case DW_LNCT_timestamp:
						res = _ParseLineInfoFormatUint(unit, dataReader,
							format, modificationTime);
						if (res != B_OK)
							return res;
						break;
					case DW_LNCT_size:
						res = _ParseLineInfoFormatUint(unit, dataReader,
							format, fileLength);
						if (res != B_OK)
							return res;
						break;
					case DW_LNCT_MD5:
						if (format != DW_FORM_data16)
							return B_BAD_DATA;

						dataReader.Skip(16);
						break;
					default:
						WARNING("DwarfFile::_ParseLineInfo(\"%s\"): unsupported "
							"field in files %" PRIu64 "\n",
							fName, content);
						return B_UNSUPPORTED;
				}
			}

			if ((fileName != NULL) && (dirIndex != 0xffffffffffffffffull)) {
				TRACE_LINES("    \"%s\", dir index: %" B_PRIu64 "\n",
					fileName, dirIndex);

				if (!unit->AddFile(fileName, dirIndex))
					return B_NO_MEMORY;
			}
		}
	} else {
		// include directories
		TRACE_LINES("  include directories:\n");
		while (const char* directory = dataReader.ReadString()) {
			if (*directory == '\0')
				break;
			TRACE_LINES("    \"%s\"\n", directory);

			if (!unit->AddDirectory(directory))
				return B_NO_MEMORY;
		}

		// file names
		TRACE_LINES("  files:\n");
		while (const char* file = dataReader.ReadString()) {
			if (*file == '\0')
				break;
			uint64 dirIndex = dataReader.ReadUnsignedLEB128(0);
			TRACE_LINES_ONLY(uint64 modificationTime =)
				dataReader.ReadUnsignedLEB128(0);
			TRACE_LINES_ONLY(uint64 fileLength =)
				dataReader.ReadUnsignedLEB128(0);

			if (dataReader.HasOverflow())
				return B_BAD_DATA;

			TRACE_LINES("    \"%s\", dir index: %" B_PRIu64 ", mtime: %" B_PRIu64
				", length: %" B_PRIu64 "\n", file, dirIndex, modificationTime,
				fileLength);

			if (!unit->AddFile(file, dirIndex))
				return B_NO_MEMORY;
		}
	}

	off_t readerOffset = dataReader.Offset();
	if ((uint64)readerOffset > readerOffset + headerLength)
		return B_BAD_DATA;
	off_t offsetToProgram = headerOffset + headerLength - readerOffset;

	const uint8* program = (uint8*)dataReader.Data() + offsetToProgram;
	size_t programSize = unitLength - (readerOffset - unitOffset);

	return unit->GetLineNumberProgram().Init(program, programSize,
		minInstructionLength, defaultIsStatement, lineBase, lineRange,
			opcodeBase, standardOpcodeLengths);
}


status_t
DwarfFile::_UnwindCallFrame(CompilationUnit* unit, uint8 addressSize, bool isBigEndian,
	DIESubprogram* subprogramEntry, target_addr_t location,
	const FDELookupInfo* info, const DwarfTargetInterface* inputInterface,
	DwarfTargetInterface* outputInterface, target_addr_t& _framePointer)
{
	ElfSection* currentFrameSection = (info->ehFrame)
		? fEHFrameSection : fDebugFrameSection;

	TRACE_CFI("DwarfFile::_UnwindCallFrame(%#" B_PRIx64 ")\n", location);

	DataReader dataReader((uint8*)currentFrameSection->Data(),
		currentFrameSection->Size(),
		unit != NULL ? unit->AddressSize() : addressSize,
		unit != NULL ? unit->IsBigEndian() : isBigEndian);
	dataReader.SeekAbsolute(info->fdeOffset);

	bool dwarf64;
	uint64 length = dataReader.ReadInitialLength(dwarf64);
	uint64 lengthOffset = dataReader.Offset();

	CfaContext context;
	CIEAugmentation cieAugmentation;
	// when using .eh_frame format, we need to parse the CIE's
	// augmentation up front in order to know how the FDE's addresses
	//  will be represented
	DataReader cieReader;
	off_t cieRemaining;
	status_t error = _ParseCIEHeader(currentFrameSection,
		info->ehFrame, unit, addressSize, isBigEndian, context, info->cieOffset,
		cieAugmentation, cieReader, cieRemaining);
	if (error != B_OK)
		return error;
	if (cieReader.HasOverflow())
		return B_BAD_DATA;
	if (cieRemaining < 0)
		return B_BAD_DATA;

	// skip CIE ID, initial offset and range, since we already know those
	// from FDELookupInfo.
	dwarf64	? dataReader.Read<uint64>(0) : dataReader.Read<uint32>(0);
	cieAugmentation.ReadEncodedAddress(dataReader, fElfFile,
		currentFrameSection);
	cieAugmentation.ReadEncodedAddress(dataReader, fElfFile,
		currentFrameSection, true);

	TRACE_CFI("  found fde: length: %" B_PRIu64 " (%" B_PRIdOFF
		"), CIE offset: %#" B_PRIx64 ", location: %#" B_PRIx64 ", "
		"range: %#" B_PRIx64 "\n", length, dataReader.BytesRemaining(),
		info->cieOffset, info->start, info->end - info->start);

	context.SetLocation(location, info->start);
	uint32 registerCount = outputInterface->CountRegisters();
	error = context.Init(registerCount);
	if (error != B_OK)
		return error;

	error = outputInterface->InitRegisterRules(context);
	if (error != B_OK)
		return error;

	// process the CIE's frame info instructions
	cieReader = cieReader.RestrictedReader(cieRemaining);
	error = _ParseFrameInfoInstructions(unit, context,
		cieReader, cieAugmentation);
	if (error != B_OK)
		return error;

	// read the FDE augmentation data (if any)
	FDEAugmentation fdeAugmentation;
	error = cieAugmentation.ReadFDEData(dataReader,
		fdeAugmentation);
	if (error != B_OK) {
		TRACE_CFI("  failed to read FDE augmentation data!\n");
		return error;
	}

	error = context.SaveInitialRuleSet();
	if (error != B_OK)
		return error;

	uint64 remaining = lengthOffset + length - dataReader.Offset();
	if (remaining < 0)
		return B_BAD_DATA;

	DataReader restrictedReader =
		dataReader.RestrictedReader(remaining);
	error = _ParseFrameInfoInstructions(unit, context,
		restrictedReader, cieAugmentation);
	if (error != B_OK)
		return error;

	TRACE_CFI("  found row!\n");

	// apply the rules of the final row
	// get the frameAddress first
	target_addr_t frameAddress;
	CfaCfaRule* cfaCfaRule = context.GetCfaCfaRule();
	switch (cfaCfaRule->Type()) {
		case CFA_CFA_RULE_REGISTER_OFFSET:
		{
			BVariant value;
			if (!inputInterface->GetRegisterValue(
					cfaCfaRule->Register(), value)
				|| !value.IsNumber()) {
				return B_UNSUPPORTED;
			}
			frameAddress = value.ToUInt64() + cfaCfaRule->Offset();
			break;
		}
		case CFA_CFA_RULE_EXPRESSION:
		{
			error = EvaluateExpression(unit, addressSize, isBigEndian,
				subprogramEntry,
				cfaCfaRule->Expression().block,
				cfaCfaRule->Expression().size,
				inputInterface, location, 0, 0, false,
				frameAddress);
			if (error != B_OK)
				return error;
			break;
		}
		case CFA_CFA_RULE_UNDEFINED:
		default:
			return B_BAD_VALUE;
	}

	TRACE_CFI("  frame address: %#" B_PRIx64 "\n", frameAddress);

	// apply the register rules
	for (uint32 i = 0; i < registerCount; i++) {
		TRACE_CFI("  reg %" B_PRIu32 "\n", i);

		uint32 valueType = outputInterface->RegisterValueType(i);
		if (valueType == 0)
			continue;

		CfaRule* rule = context.RegisterRule(i);
		if (rule == NULL)
			continue;

		// apply the rule
		switch (rule->Type()) {
			case CFA_RULE_SAME_VALUE:
			{
				TRACE_CFI("  -> CFA_RULE_SAME_VALUE\n");

				BVariant value;
				if (inputInterface->GetRegisterValue(i, value))
					outputInterface->SetRegisterValue(i, value);
				break;
			}
			case CFA_RULE_LOCATION_OFFSET:
			{
				TRACE_CFI("  -> CFA_RULE_LOCATION_OFFSET: %"
					B_PRId64 "\n", rule->Offset());

				BVariant value;
				if (inputInterface->ReadValueFromMemory(
						frameAddress + rule->Offset(), valueType,
						value)) {
					outputInterface->SetRegisterValue(i, value);
				}
				break;
			}
			case CFA_RULE_VALUE_OFFSET:
				TRACE_CFI("  -> CFA_RULE_VALUE_OFFSET\n");

				outputInterface->SetRegisterValue(i,
					frameAddress + rule->Offset());
				break;
			case CFA_RULE_REGISTER:
			{
				TRACE_CFI("  -> CFA_RULE_REGISTER\n");

				BVariant value;
				if (inputInterface->GetRegisterValue(
						rule->Register(), value)) {
					outputInterface->SetRegisterValue(i, value);
				}
				break;
			}
			case CFA_RULE_LOCATION_EXPRESSION:
			{
				TRACE_CFI("  -> CFA_RULE_LOCATION_EXPRESSION\n");

				target_addr_t address;
				error = EvaluateExpression(unit, addressSize, isBigEndian,
					subprogramEntry,
					rule->Expression().block,
					rule->Expression().size,
					inputInterface, location, frameAddress,
					frameAddress, true, address);
				BVariant value;
				if (error == B_OK
					&& inputInterface->ReadValueFromMemory(address,
						valueType, value)) {
					outputInterface->SetRegisterValue(i, value);
				}
				break;
			}
			case CFA_RULE_VALUE_EXPRESSION:
			{
				TRACE_CFI("  -> CFA_RULE_VALUE_EXPRESSION\n");

				target_addr_t value;
				error = EvaluateExpression(unit, addressSize, isBigEndian,
					subprogramEntry,
					rule->Expression().block,
					rule->Expression().size,
					inputInterface, location, frameAddress,
					frameAddress, true, value);
				if (error == B_OK)
					outputInterface->SetRegisterValue(i, value);
				break;
			}
			case CFA_RULE_UNDEFINED:
				TRACE_CFI("  -> CFA_RULE_UNDEFINED\n");
			default:
				break;
		}
	}

	_framePointer = frameAddress;

	return B_OK;
}


status_t
DwarfFile::_ParseCIEHeader(ElfSection* debugFrameSection,
	bool usingEHFrameSection, CompilationUnit* unit, uint8 addressSize, bool isBigEndian,
	CfaContext& context, off_t cieOffset, CIEAugmentation& cieAugmentation,
	DataReader& dataReader, off_t& _cieRemaining)
{
	if (cieOffset < 0 || (uint64)cieOffset >= debugFrameSection->Size())
		return B_BAD_DATA;

	dataReader.SetTo((uint8*)debugFrameSection->Data() + cieOffset,
		debugFrameSection->Size() - cieOffset,
		unit != NULL ? unit->AddressSize() : addressSize,
		unit != NULL ? unit->IsBigEndian() : isBigEndian);

	// length
	bool dwarf64;
	uint64 length = dataReader.ReadInitialLength(dwarf64);
	if (length > (uint64)dataReader.BytesRemaining())
		return B_BAD_DATA;

	off_t lengthOffset = dataReader.Offset();

	// CIE ID/CIE pointer
	uint64 cieID = dwarf64
		? dataReader.Read<uint64>(0) : dataReader.Read<uint32>(0);
	if (usingEHFrameSection) {
		if (cieID != 0)
			return B_BAD_DATA;
	} else {
		if (dwarf64 ? cieID != 0xffffffffffffffffULL : cieID != 0xffffffff)
			return B_BAD_DATA;
	}

	uint8 version = dataReader.Read<uint8>(0);
	if (version != 1) {
		TRACE_CFI("  cie: length: %" B_PRIu64 ", offset: %#" B_PRIx64 ", "
			"version: %u -- unsupported\n",	length, (uint64)cieOffset, version);
		return B_UNSUPPORTED;
	}

	// read the augmentation string
	cieAugmentation.Init(dataReader);

	// in the cause of augmentation string "eh",
	// the exception table pointer is located immediately before the
	// code/data alignment values. We have no use for it so simply skip.
	if (strcmp(cieAugmentation.String(), "eh") == 0)
		dataReader.Skip(dwarf64 ? sizeof(uint64) : sizeof(uint32));

	context.SetCodeAlignment(dataReader.ReadUnsignedLEB128(0));
	context.SetDataAlignment(dataReader.ReadSignedLEB128(0));
	context.SetReturnAddressRegister(dataReader.ReadUnsignedLEB128(0));

	TRACE_CFI("  cie: length: %" B_PRIu64 ", offset: %#" B_PRIx64 ", version: "
		"%u, augmentation: \"%s\", aligment: code: %" B_PRIu32 ", data: %"
		B_PRId32 ", return address reg: %" B_PRIu32 "\n", length,
		(uint64)cieOffset, version, cieAugmentation.String(),
		context.CodeAlignment(), context.DataAlignment(),
		context.ReturnAddressRegister());

	status_t error = cieAugmentation.Read(dataReader);
	if (error != B_OK) {
		TRACE_CFI("  cie: length: %" B_PRIu64 ", version: %u, augmentation: "
			"\"%s\" -- unsupported\n", length, version,
			cieAugmentation.String());
		return error;
	}

	if (dataReader.HasOverflow())
		return B_BAD_DATA;

	_cieRemaining = length -(dataReader.Offset() - lengthOffset);
	if (_cieRemaining < 0)
		return B_BAD_DATA;

	return B_OK;
}


status_t
DwarfFile::_ParseFrameInfoInstructions(CompilationUnit* unit,
	CfaContext& context, DataReader& dataReader, CIEAugmentation& augmentation)
{
	while (dataReader.BytesRemaining() > 0) {
		TRACE_CFI("    [%2" B_PRId64 "]", dataReader.BytesRemaining());

		uint8 opcode = dataReader.Read<uint8>(0);
		if ((opcode >> 6) != 0) {
			uint32 operand = opcode & 0x3f;

			switch (opcode >> 6) {
				case DW_CFA_advance_loc:
				{
					TRACE_CFI("    DW_CFA_advance_loc: %#" B_PRIx32 "\n",
						operand);

					target_addr_t location = context.Location()
						+ operand * context.CodeAlignment();
					if (location > context.TargetLocation())
						return B_OK;
					context.SetLocation(location);
					break;
				}
				case DW_CFA_offset:
				{
					uint64 offset = dataReader.ReadUnsignedLEB128(0);
					TRACE_CFI("    DW_CFA_offset: reg: %" B_PRIu32 ", offset: "
						"%" B_PRIu64 "\n", operand, offset);

					if (CfaRule* rule = context.RegisterRule(operand)) {
						rule->SetToLocationOffset(
							offset * context.DataAlignment());
					}
					break;
				}
				case DW_CFA_restore:
				{
					TRACE_CFI("    DW_CFA_restore: %#" B_PRIx32 "\n", operand);

					context.RestoreRegisterRule(operand);
					break;
				}
			}
		} else {
			switch (opcode) {
				case DW_CFA_nop:
				{
					TRACE_CFI("    DW_CFA_nop\n");
					break;
				}
				case DW_CFA_set_loc:
				{
					target_addr_t location = augmentation.ReadEncodedAddress(
							dataReader, fElfFile, fDebugFrameSection);

					TRACE_CFI("    DW_CFA_set_loc: %#" B_PRIx64 "\n", location);

					if (location < context.Location())
						return B_BAD_VALUE;
					if (location > context.TargetLocation())
						return B_OK;
					context.SetLocation(location);
					break;
				}
				case DW_CFA_advance_loc1:
				{
					uint32 delta = dataReader.Read<uint8>(0);

					TRACE_CFI("    DW_CFA_advance_loc1: %#" B_PRIx32 "\n",
						delta);

					target_addr_t location = context.Location()
						+ delta * context.CodeAlignment();
					if (location > context.TargetLocation())
						return B_OK;
					context.SetLocation(location);
					break;
				}
				case DW_CFA_advance_loc2:
				{
					uint32 delta = dataReader.Read<uint16>(0);

					TRACE_CFI("    DW_CFA_advance_loc2: %#" B_PRIx32 "\n",
						delta);

					target_addr_t location = context.Location()
						+ delta * context.CodeAlignment();
					if (location > context.TargetLocation())
						return B_OK;
					context.SetLocation(location);
					break;
				}
				case DW_CFA_advance_loc4:
				{
					uint32 delta = dataReader.Read<uint32>(0);

					TRACE_CFI("    DW_CFA_advance_loc4: %#" B_PRIx32 "\n",
						delta);

					target_addr_t location = context.Location()
						+ delta * context.CodeAlignment();
					if (location > context.TargetLocation())
						return B_OK;
					context.SetLocation(location);
					break;
				}
				case DW_CFA_offset_extended:
				{
					uint32 reg = dataReader.ReadUnsignedLEB128(0);
					uint64 offset = dataReader.ReadUnsignedLEB128(0);

					TRACE_CFI("    DW_CFA_offset_extended: reg: %" B_PRIu32 ", "
						"offset: %" B_PRIu64 "\n", reg, offset);

					if (CfaRule* rule = context.RegisterRule(reg)) {
						rule->SetToLocationOffset(
							offset * context.DataAlignment());
					}
					break;
				}
				case DW_CFA_restore_extended:
				{
					uint32 reg = dataReader.ReadUnsignedLEB128(0);

					TRACE_CFI("    DW_CFA_restore_extended: %#" B_PRIx32 "\n",
						reg);

					context.RestoreRegisterRule(reg);
					break;
				}
				case DW_CFA_undefined:
				{
					uint32 reg = dataReader.ReadUnsignedLEB128(0);

					TRACE_CFI("    DW_CFA_undefined: %" B_PRIu32 "\n", reg);

					if (CfaRule* rule = context.RegisterRule(reg))
						rule->SetToUndefined();
					break;
				}
				case DW_CFA_same_value:
				{
					uint32 reg = dataReader.ReadUnsignedLEB128(0);

					TRACE_CFI("    DW_CFA_same_value: %" B_PRIu32 "\n", reg);

					if (CfaRule* rule = context.RegisterRule(reg))
						rule->SetToSameValue();
					break;
				}
				case DW_CFA_register:
				{
					uint32 reg1 = dataReader.ReadUnsignedLEB128(0);
					uint32 reg2 = dataReader.ReadUnsignedLEB128(0);

					TRACE_CFI("    DW_CFA_register: reg1: %" B_PRIu32 ", reg2: "
						"%" B_PRIu32 "\n", reg1, reg2);

					if (CfaRule* rule = context.RegisterRule(reg1))
						rule->SetToValueOffset(reg2);
					break;
				}
				case DW_CFA_remember_state:
				{
					TRACE_CFI("    DW_CFA_remember_state\n");

					status_t error = context.PushRuleSet();
					if (error != B_OK)
						return error;
					break;
				}
				case DW_CFA_restore_state:
				{
					TRACE_CFI("    DW_CFA_restore_state\n");

					status_t error = context.PopRuleSet();
					if (error != B_OK)
						return error;
					break;
				}
				case DW_CFA_def_cfa:
				{
					uint32 reg = dataReader.ReadUnsignedLEB128(0);
					uint64 offset = dataReader.ReadUnsignedLEB128(0);

					TRACE_CFI("    DW_CFA_def_cfa: reg: %" B_PRIu32 ", offset: "
						"%" B_PRIu64 "\n", reg, offset);

					context.GetCfaCfaRule()->SetToRegisterOffset(reg, offset);
					break;
				}
				case DW_CFA_def_cfa_register:
				{
					uint32 reg = dataReader.ReadUnsignedLEB128(0);

					TRACE_CFI("    DW_CFA_def_cfa_register: %" B_PRIu32 "\n",
						reg);

					if (context.GetCfaCfaRule()->Type()
							!= CFA_CFA_RULE_REGISTER_OFFSET) {
						return B_BAD_DATA;
					}
					context.GetCfaCfaRule()->SetRegister(reg);
					break;
				}
				case DW_CFA_def_cfa_offset:
				{
					uint64 offset = dataReader.ReadUnsignedLEB128(0);

					TRACE_CFI("    DW_CFA_def_cfa_offset: %" B_PRIu64 "\n",
						offset);

					if (context.GetCfaCfaRule()->Type()
							!= CFA_CFA_RULE_REGISTER_OFFSET) {
						return B_BAD_DATA;
					}
					context.GetCfaCfaRule()->SetOffset(offset);
					break;
				}
				case DW_CFA_def_cfa_expression:
				{
					uint64 blockLength = dataReader.ReadUnsignedLEB128(0);
					uint8* block = (uint8*)dataReader.Data();
					dataReader.Skip(blockLength);

					TRACE_CFI("    DW_CFA_def_cfa_expression: %p, %" B_PRIu64
						"\n", block, blockLength);

					context.GetCfaCfaRule()->SetToExpression(block,
						blockLength);
					break;
				}
				case DW_CFA_expression:
				{
					uint32 reg = dataReader.ReadUnsignedLEB128(0);
					uint64 blockLength = dataReader.ReadUnsignedLEB128(0);
					uint8* block = (uint8*)dataReader.Data();
					dataReader.Skip(blockLength);

					TRACE_CFI("    DW_CFA_expression: reg: %" B_PRIu32 ", "
						"block: %p, %" B_PRIu64 "\n", reg, block, blockLength);

					if (CfaRule* rule = context.RegisterRule(reg))
						rule->SetToLocationExpression(block, blockLength);
					break;
				}
				case DW_CFA_offset_extended_sf:
				{
					uint32 reg = dataReader.ReadUnsignedLEB128(0);
					int64 offset = dataReader.ReadSignedLEB128(0);

					TRACE_CFI("    DW_CFA_offset_extended: reg: %" B_PRIu32 ", "
						"offset: %" B_PRId64 "\n", reg, offset);

					if (CfaRule* rule = context.RegisterRule(reg)) {
						rule->SetToLocationOffset(
							offset * (int32)context.DataAlignment());
					}
					break;
				}
				case DW_CFA_def_cfa_sf:
				{
					uint32 reg = dataReader.ReadUnsignedLEB128(0);
					int64 offset = dataReader.ReadSignedLEB128(0);

					TRACE_CFI("    DW_CFA_def_cfa_sf: reg: %" B_PRIu32 ", "
						"offset: %" B_PRId64 "\n", reg, offset);

					context.GetCfaCfaRule()->SetToRegisterOffset(reg,
						offset * (int32)context.DataAlignment());
					break;
				}
				case DW_CFA_def_cfa_offset_sf:
				{
					int64 offset = dataReader.ReadSignedLEB128(0);

					TRACE_CFI("    DW_CFA_def_cfa_offset: %" B_PRId64 "\n",
						offset);

					if (context.GetCfaCfaRule()->Type()
							!= CFA_CFA_RULE_REGISTER_OFFSET) {
						return B_BAD_DATA;
					}
					context.GetCfaCfaRule()->SetOffset(
						offset * (int32)context.DataAlignment());
					break;
				}
				case DW_CFA_val_offset:
				{
					uint32 reg = dataReader.ReadUnsignedLEB128(0);
					uint64 offset = dataReader.ReadUnsignedLEB128(0);

					TRACE_CFI("    DW_CFA_val_offset: reg: %" B_PRIu32 ", "
						"offset: %" B_PRIu64 "\n", reg, offset);

					if (CfaRule* rule = context.RegisterRule(reg)) {
						rule->SetToValueOffset(
							offset * context.DataAlignment());
					}
					break;
				}
				case DW_CFA_val_offset_sf:
				{
					uint32 reg = dataReader.ReadUnsignedLEB128(0);
					int64 offset = dataReader.ReadSignedLEB128(0);

					TRACE_CFI("    DW_CFA_val_offset_sf: reg: %" B_PRIu32 ", "
						"offset: %" B_PRId64 "\n", reg, offset);

					if (CfaRule* rule = context.RegisterRule(reg)) {
						rule->SetToValueOffset(
							offset * (int32)context.DataAlignment());
					}
					break;
				}
				case DW_CFA_val_expression:
				{
					uint32 reg = dataReader.ReadUnsignedLEB128(0);
					uint64 blockLength = dataReader.ReadUnsignedLEB128(0);
					uint8* block = (uint8*)dataReader.Data();
					dataReader.Skip(blockLength);

					TRACE_CFI("    DW_CFA_val_expression: reg: %" B_PRIu32 ", "
						"block: %p, %" B_PRIu64 "\n", reg, block, blockLength);

					if (CfaRule* rule = context.RegisterRule(reg))
						rule->SetToValueExpression(block, blockLength);
					break;
				}

				// extensions
				case DW_CFA_MIPS_advance_loc8:
				{
					uint64 delta = dataReader.Read<uint64>(0);

					TRACE_CFI("    DW_CFA_MIPS_advance_loc8: %#" B_PRIx64 "\n",
						delta);

					target_addr_t location = context.Location()
						+ delta * context.CodeAlignment();
					if (location > context.TargetLocation())
						return B_OK;
					context.SetLocation(location);
					break;
				}
				case DW_CFA_GNU_window_save:
				{
					// SPARC specific, no args
					TRACE_CFI("    DW_CFA_GNU_window_save\n");

					// TODO: Implement once we have SPARC support!
					break;
				}
				case DW_CFA_GNU_args_size:
				{
					// Updates the total size of arguments on the stack.
					TRACE_CFI_ONLY(uint64 size =)
						dataReader.ReadUnsignedLEB128(0);

					TRACE_CFI("    DW_CFA_GNU_args_size: %" B_PRIu64 "\n",
						size);
// TODO: Implement!
					break;
				}
				case DW_CFA_GNU_negative_offset_extended:
				{
					// obsolete
					uint32 reg = dataReader.ReadUnsignedLEB128(0);
					int64 offset = dataReader.ReadSignedLEB128(0);

					TRACE_CFI("    DW_CFA_GNU_negative_offset_extended: "
						"reg: %" B_PRIu32 ", offset: %" B_PRId64 "\n", reg,
						offset);

					if (CfaRule* rule = context.RegisterRule(reg)) {
						rule->SetToLocationOffset(
							offset * (int32)context.DataAlignment());
					}
					break;
				}

				default:
					TRACE_CFI("    unknown opcode %u!\n", opcode);
					return B_BAD_DATA;
			}
		}
	}

	return B_OK;
}


status_t
DwarfFile::_ParsePublicTypesInfo(uint8 _addressSize, bool isBigEndian)
{
	TRACE_PUBTYPES("DwarfFile::_ParsePublicTypesInfo()\n");
	if (fDebugPublicTypesSection == NULL) {
		TRACE_PUBTYPES("  -> no public types section\n");
		return B_ENTRY_NOT_FOUND;
	}

	DataReader dataReader((uint8*)fDebugPublicTypesSection->Data(),
		fDebugPublicTypesSection->Size(), _addressSize, isBigEndian);

	while (dataReader.BytesRemaining() > 0) {
		bool dwarf64;
		uint64 unitLength = dataReader.ReadInitialLength(dwarf64);

		off_t unitLengthOffset = dataReader.Offset();
			// the unitLength starts here

		if (dataReader.HasOverflow())
			return B_BAD_DATA;

		if (unitLengthOffset + unitLength
				> (uint64)fDebugPublicTypesSection->Size()) {
			WARNING("Invalid public types set unit length.\n");
			break;
		}

		DataReader unitDataReader(dataReader.Data(), unitLength, _addressSize, isBigEndian);
		_ParsePublicTypesInfo(unitDataReader, dwarf64);

		dataReader.SeekAbsolute(unitLengthOffset + unitLength);
	}

	return B_OK;
}


status_t
DwarfFile::_ParsePublicTypesInfo(DataReader& dataReader, bool dwarf64)
{
	int version = dataReader.Read<uint16>(0);
	if (version != 2) {
		TRACE_PUBTYPES("  pubtypes version %d unsupported\n", version);
		return B_UNSUPPORTED;
	}

	TRACE_PUBTYPES_ONLY(off_t debugInfoOffset =) dwarf64
		? dataReader.Read<uint64>(0)
		: (uint64)dataReader.Read<uint32>(0);
	TRACE_PUBTYPES_ONLY(off_t debugInfoSize =) dwarf64
		? dataReader.Read<uint64>(0)
		: (uint64)dataReader.Read<uint32>(0);

	if (dataReader.HasOverflow())
		return B_BAD_DATA;

	TRACE_PUBTYPES("DwarfFile::_ParsePublicTypesInfo(): compilation unit debug "
		"info: (%" B_PRIdOFF ", %" B_PRIdOFF ")\n", debugInfoOffset,
		debugInfoSize);

	while (dataReader.BytesRemaining() > 0) {
		off_t entryOffset = dwarf64
			? dataReader.Read<uint64>(0)
			: (uint64)dataReader.Read<uint32>(0);
		if (entryOffset == 0)
			return B_OK;

		TRACE_PUBTYPES_ONLY(const char* name =) dataReader.ReadString();

		TRACE_PUBTYPES("  \"%s\" -> %" B_PRIdOFF "\n", name, entryOffset);
	}

	return B_OK;
}


status_t
DwarfFile::_GetAbbreviationTable(off_t offset, AbbreviationTable*& _table)
{
	// check, whether we've already loaded it
	for (AbbreviationTableList::Iterator it
				= fAbbreviationTables.GetIterator();
			AbbreviationTable* table = it.Next();) {
		if (offset == table->Offset()) {
			_table = table;
			return B_OK;
		}
	}

	// create a new table
	AbbreviationTable* table = new(std::nothrow) AbbreviationTable(offset);
	if (table == NULL)
		return B_NO_MEMORY;

	status_t error = table->Init(fDebugAbbrevSection->Data(),
		fDebugAbbrevSection->Size());
	if (error != B_OK) {
		delete table;
		return error;
	}

	fAbbreviationTables.Add(table);
	_table = table;
	return B_OK;
}


DebugInfoEntry*
DwarfFile::_ResolveReference(BaseUnit* unit, uint64 offset,
	uint8 refType) const
{
	switch (refType) {
		case dwarf_reference_type_local:
			return unit->EntryForOffset(offset);
			break;
		case dwarf_reference_type_global:
		{
			CompilationUnit* unit = _GetContainingCompilationUnit(offset);
			if (unit == NULL)
				break;

			offset -= unit->HeaderOffset();
			DebugInfoEntry* entry = unit->EntryForOffset(offset);
			if (entry != NULL)
				return entry;
			break;
		}
		case dwarf_reference_type_signature:
		{
			TRACE_DIE("Resolving signature %#" B_PRIx64 "\n", offset);
			TypeUnitTableEntry* entry = fTypeUnits.Lookup(offset);
			if (entry != NULL && entry->unit != NULL)
				return entry->unit->TypeEntry();
			break;
		}
	}

	return NULL;
}


status_t
DwarfFile::_GetLocationExpression(CompilationUnit* unit,
	const LocationDescription* location, target_addr_t instructionPointer,
	const void*& _expression, off_t& _length) const
{
	if (!location->IsValid())
		return B_BAD_VALUE;

	if (location->IsExpression()) {
		_expression = location->expression.data;
		_length = location->expression.length;
		return B_OK;
	}

	if (location->IsLocationList() && instructionPointer != 0) {
		return _FindLocationExpression(unit, location->listOffset,
			instructionPointer, _expression, _length);
	}

	return B_BAD_VALUE;
}


status_t
DwarfFile::_FindLocationExpression(CompilationUnit* unit, uint64 offset,
	target_addr_t address, const void*& _expression, off_t& _length) const
{
	if (unit == NULL)
		return B_BAD_VALUE;

	if (fDebugLocationSection == NULL)
		return B_ENTRY_NOT_FOUND;

	if (offset < 0 || offset >= (uint64)fDebugLocationSection->Size())
		return B_BAD_DATA;

	target_addr_t baseAddress = unit->AddressRangeBase();
	target_addr_t maxAddress = unit->MaxAddress();

	DataReader dataReader((uint8*)fDebugLocationSection->Data() + offset,
		fDebugLocationSection->Size() - offset, unit->AddressSize(), unit->IsBigEndian());
	while (true) {
		target_addr_t start = dataReader.ReadAddress(0);
		target_addr_t end = dataReader.ReadAddress(0);
		if (dataReader.HasOverflow())
			return B_BAD_DATA;

		if (start == 0 && end == 0)
			return B_ENTRY_NOT_FOUND;

		if (start == maxAddress) {
			baseAddress = end;
			continue;
		}

		uint16 expressionLength = dataReader.Read<uint16>(0);
		const void* expression = dataReader.Data();
		if (!dataReader.Skip(expressionLength))
			return B_BAD_DATA;

		if (start == end)
			continue;

		start += baseAddress;
		end += baseAddress;

		if (address >= start && address < end) {
			_expression = expression;
			_length = expressionLength;
			return B_OK;
		}
	}
}


status_t
DwarfFile::_LocateDebugInfo(BString& _requiredExternalFileName,
	const char* locatedFilePath)
{
	ElfFile* debugInfoFile = fElfFile;
	ElfSection* debugLinkSection = fElfFile->GetSection(".gnu_debuglink");
	if (debugLinkSection != NULL) {
		AutoSectionPutter putter(fElfFile, debugLinkSection);

		// the file specifies a debug link, look at its target instead
		// for debug information.
		// Format: null-terminated filename, as many 0 padding bytes as
		// needed to reach the next 32-bit address boundary, followed
		// by a 32-bit CRC

		BString debugPath;
		if (locatedFilePath)
			debugPath = locatedFilePath;
		else {
			status_t result = _GetDebugInfoPath(
				(const char*)debugLinkSection->Data(),
				_requiredExternalFileName);
			if (result != B_OK)
				return result;
			debugPath = _requiredExternalFileName;
		}

		if (fAlternateName != NULL)
			free(fAlternateName);

		fAlternateName = strdup(debugPath.String());

		if (fAlternateName == NULL)
			return B_NO_MEMORY;

/*
		// TODO: validate CRC
		int32 debugCRC = *(int32*)((char*)debugLinkSection->Data()
			+ debugLinkSection->Size() - sizeof(int32));
*/
		if (fAlternateElfFile == NULL) {
			fAlternateElfFile = new(std::nothrow) ElfFile;
			if (fAlternateElfFile == NULL)
				return B_NO_MEMORY;
		}

		status_t result = fAlternateElfFile->Init(fAlternateName);
		if (result != B_OK)
			return result;

		debugInfoFile = fAlternateElfFile;
	}

	// get the interesting sections
	fDebugInfoSection = debugInfoFile->GetSection(".debug_info");
	fDebugAbbrevSection = debugInfoFile->GetSection(".debug_abbrev");
	if (fDebugInfoSection == NULL || fDebugAbbrevSection == NULL) {
		TRACE_DIE("DwarfManager::File::Load(\"%s\"): no "
			".debug_info or .debug_abbrev.\n", fName);

		// if we at least have an EH frame, use that for stack unwinding
		// if nothing else.
		fEHFrameSection = fElfFile->GetSection(".eh_frame");
		if (fEHFrameSection == NULL)
			return B_ERROR;
	}

	return B_OK;
}


status_t
DwarfFile::_GetDebugInfoPath(const char* debugFileName,
	BString& _infoPath) const
{
	// first, see if we have a relative match to our local directory
	BPath basePath;
	status_t result = basePath.SetTo(fName);
	if (result != B_OK)
		return result;
	basePath.GetParent(&basePath);
	if (strcmp(basePath.Leaf(), "lib") == 0 || strcmp(basePath.Leaf(),
			"add-ons") == 0) {
		_infoPath.SetToFormat("%s/../debug/%s", basePath.Path(),
			debugFileName);
	} else
		_infoPath.SetToFormat("%s/debug/%s", basePath.Path(), debugFileName);

	BEntry entry(_infoPath.String());
	result = entry.InitCheck();
	if (result != B_OK && result != B_ENTRY_NOT_FOUND)
		return result;
	if (entry.Exists())
		return B_OK;

	// If the above search failed, check if our image is located in any
	// of the system installation paths, and attempt to locate the debug info
	// file in the corresponding well-known location
	BString pathSuffix;
	pathSuffix.SetToFormat("debug/%s", debugFileName);

	BPathFinder finder(fName);
	result = finder.FindPath(B_FIND_PATH_DEVELOP_DIRECTORY,
		pathSuffix.String(), B_FIND_PATH_EXISTING_ONLY, basePath);
	if (result == B_OK) {
		_infoPath = basePath.Path();
		return B_OK;
	} else {
		// if we failed to find a match, then it's up to the user to
		// locate it. As such, return the external info file name
		// for user interface purposes.
		_infoPath.SetTo(debugFileName);
	}

	return B_ENTRY_NOT_FOUND;
}


TypeUnitTableEntry*
DwarfFile::_GetTypeUnit(uint64 signature) const
{
	return fTypeUnits.Lookup(signature);
}


CompilationUnit*
DwarfFile::_GetContainingCompilationUnit(off_t refAddr) const
{
	if (fCompilationUnits.IsEmpty())
		return NULL;

	// binary search
	int lower = 0;
	int upper = fCompilationUnits.CountItems() - 1;
	while (lower < upper) {
		int mid = (lower + upper + 1) / 2;
		if (fCompilationUnits.ItemAt(mid)->HeaderOffset() > refAddr)
			upper = mid - 1;
		else
			lower = mid;
	}

	CompilationUnit* unit = fCompilationUnits.ItemAt(lower);
	return unit->ContainsAbsoluteOffset(refAddr) ? unit : NULL;
}


DwarfFile::FDELookupInfo*
DwarfFile::_GetContainingFDEInfo(target_addr_t offset) const
{
	FDELookupInfo* info = NULL;
	if (fDebugFrameSection != NULL) {
		info = _GetContainingFDEInfo(offset, fDebugFrameInfos);
		if (info != NULL)
			return info;
	}

	return _GetContainingFDEInfo(offset, fEHFrameInfos);
}


DwarfFile::FDELookupInfo*
DwarfFile::_GetContainingFDEInfo(target_addr_t offset,
	const FDEInfoList& infoList) const
{
	// binary search
	int lower = 0;
	int upper = infoList.CountItems() - 1;
	if (upper < 0)
		return NULL;

	while (lower < upper) {
		int mid = (lower + upper + 1) / 2;
		if (offset < infoList.ItemAt(mid)->start)
			upper = mid - 1;
		else
			lower = mid;
	}

	FDELookupInfo* info = infoList.ItemAt(lower);
	return info->ContainsAddress(offset) ? info : NULL;
}