haiku.git

/*
 * Copyright 2009, Ingo Weinhold, ingo_weinhold@gmx.de.
 * Distributed under the terms of the MIT License.
 */
#ifndef DWARF_EXPRESSION_EVALUATOR_H
#define DWARF_EXPRESSION_EVALUATOR_H


#include "DataReader.h"
#include "Types.h"


class DwarfTargetInterface;
class ValueLocation;
struct ValuePieceLocation;


class DwarfExpressionEvaluationContext {
public:
								DwarfExpressionEvaluationContext(
									const DwarfTargetInterface* targetInterface,
									uint8 addressSize,
									bool isBigEndian,
									target_addr_t relocationDelta);
	virtual						~DwarfExpressionEvaluationContext();

			const DwarfTargetInterface* TargetInterface() const
									{ return fTargetInterface; }
			uint8				AddressSize() const	{ return fAddressSize; }
			bool				IsBigEndian() const { return fIsBigEndian; }

			target_addr_t			RelocationDelta() const
									{ return fRelocationDelta; }

	virtual	bool				GetObjectAddress(target_addr_t& _address) = 0;
	virtual	bool				GetFrameAddress(target_addr_t& _address) = 0;
	virtual	bool				GetFrameBaseAddress(target_addr_t& _address)
									= 0;
	virtual	bool				GetTLSAddress(target_addr_t localAddress,
									target_addr_t& _address) = 0;

	virtual	status_t			GetCallTarget(uint64 offset,
									uint8 refType, const void*& _block,
									off_t& _size) = 0;
									// returns error, when an error resolving
									// the entry occurs; returns B_OK and a NULL
									// block, when the entry doesn't have a
									// location attribute

protected:
			const DwarfTargetInterface* fTargetInterface;
			uint8				fAddressSize;
			bool				fIsBigEndian;
			target_addr_t		fRelocationDelta;
};


class DwarfExpressionEvaluator {
public:
								DwarfExpressionEvaluator(
									DwarfExpressionEvaluationContext* context);
								~DwarfExpressionEvaluator();

			status_t			Push(target_addr_t value);

			status_t			Evaluate(const void* expression, size_t size,
									target_addr_t& _result);
			status_t			EvaluateLocation(const void* expression,
									size_t size, ValueLocation& _location);
									// The returned location will have DWARF
									// semantics regarding register numbers and
									// bit offsets/sizes (cf. bit pieces).

private:
			struct EvaluationException;

private:
	inline	void				_AssertMinStackSize(size_t size) const;

	inline	void				_Push(target_addr_t value);
	inline	target_addr_t		_Pop();

			status_t			_Evaluate(ValuePieceLocation* _piece);
			void				_DereferenceAddress(uint8 addressSize);
			void				_DereferenceAddressSpaceAddress(
									uint8 addressSize);
			void				_PushRegister(uint32 reg, target_addr_t offset);
			void				_Call(uint64 offset, uint8 refType);

private:
			DwarfExpressionEvaluationContext* fContext;
			target_addr_t*		fStack;
			size_t				fStackSize;
			size_t				fStackCapacity;
			DataReader			fDataReader;
			target_addr_t		fObjectAddress;
			target_addr_t		fFrameAddress;
			bool				fObjectAddressValid;
			bool				fFrameAddressValid;
};


#endif	// DWARF_EXPRESSION_EVALUATOR_H