haiku.git

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

#include "Architecture.h"

#include <new>

#include <AutoDeleter.h>
#include <AutoLocker.h>

#include "CfaContext.h"
#include "CpuState.h"
#include "FunctionInstance.h"
#include "Image.h"
#include "ImageDebugInfo.h"
#include "ImageDebugInfoProvider.h"
#include "Register.h"
#include "RegisterMap.h"
#include "SpecificImageDebugInfo.h"
#include "StackTrace.h"
#include "Team.h"


Architecture::Architecture(TeamMemory* teamMemory, uint8 addressSize,
	size_t debugCpuStateSize, bool bigEndian)
	:
	fTeamMemory(teamMemory),
	fAddressSize(addressSize),
	fDebugCpuStateSize(debugCpuStateSize),
	fBigEndian(bigEndian)
{
}


Architecture::~Architecture()
{
}


status_t
Architecture::Init()
{
	return B_OK;
}


status_t
Architecture::InitRegisterRules(CfaContext& context) const
{
	// Init the initial register rules. The DWARF 3 specs on the
	// matter: "The default rule for all columns before
	// interpretation of the initial instructions is the undefined
	// rule. However, an ABI authoring body or a compilation system
	// authoring body may specify an alternate default value for any
	// or all columns."
	// GCC's assumes the "same value" rule for all callee preserved
	// registers. We set them respectively.
	// the stack pointer is initialized to
	// CFA offset 0 by default.
	const Register* registers = Registers();
	RegisterMap* toDwarf = NULL;
	status_t result = GetDwarfRegisterMaps(&toDwarf, NULL);
	if (result != B_OK)
		return result;

	BReference<RegisterMap> toDwarfMapReference(toDwarf, true);
	for (int32 i = 0; i < CountRegisters(); i++) {
		int32 dwarfReg = toDwarf->MapRegisterIndex(i);
		if (dwarfReg < 0 || dwarfReg > CountRegisters() - 1)
			continue;

		// TODO: on CPUs that have a return address register
		// a default rule should be set up to use that to
		// extract the instruction pointer
		switch (registers[i].Type()) {
			case REGISTER_TYPE_STACK_POINTER:
			{
				context.RegisterRule(dwarfReg)->SetToValueOffset(0);
				break;
			}
			default:
			{
				context.RegisterRule(dwarfReg)->SetToSameValue();
				break;
			}
		}
	}

	return result;
}


status_t
Architecture::CreateStackTrace(Team* team,
	ImageDebugInfoProvider* imageInfoProvider, CpuState* cpuState,
	StackTrace*& _stackTrace, ReturnValueInfoList* returnValueInfos,
	int32 maxStackDepth, bool useExistingTrace, bool getFullFrameInfo)
{
	BReference<CpuState> cpuStateReference(cpuState);

	StackTrace* stackTrace = NULL;
	ObjectDeleter<StackTrace> stackTraceDeleter;
	StackFrame* nextFrame = NULL;

	if (useExistingTrace)
		stackTrace = _stackTrace;
	else {
		// create the object
		stackTrace = new(std::nothrow) StackTrace;
		if (stackTrace == NULL)
			return B_NO_MEMORY;
		stackTraceDeleter.SetTo(stackTrace);
	}

	// if we're passed an already existing partial stack trace,
	// attempt to continue building it from where it left off.
	if (stackTrace->CountFrames() > 0) {
		nextFrame = stackTrace->FrameAt(stackTrace->CountFrames() - 1);
		cpuState = nextFrame->PreviousCpuState();
	}

	while (cpuState != NULL) {
		// get the instruction pointer
		target_addr_t instructionPointer = cpuState->InstructionPointer();

		// get the image for the instruction pointer
		AutoLocker<Team> teamLocker(team);
		Image* image = team->ImageByAddress(instructionPointer);
		BReference<Image> imageReference(image);
		teamLocker.Unlock();

		// get the image debug info
		ImageDebugInfo* imageDebugInfo = NULL;
		if (image != NULL)
			imageInfoProvider->GetImageDebugInfo(image, imageDebugInfo);
		BReference<ImageDebugInfo> imageDebugInfoReference(imageDebugInfo,
			true);

		// get the function
		teamLocker.Lock();
		FunctionInstance* function = NULL;
		FunctionDebugInfo* functionDebugInfo = NULL;
		if (imageDebugInfo != NULL) {
			function = imageDebugInfo->FunctionAtAddress(instructionPointer);
			if (function != NULL)
				functionDebugInfo = function->GetFunctionDebugInfo();
		}
		BReference<FunctionInstance> functionReference(function);
		teamLocker.Unlock();

		// If the CPU state's instruction pointer is actually the return address
		// of the next frame, we let the architecture fix that.
		if (nextFrame != NULL
			&& nextFrame->ReturnAddress() == cpuState->InstructionPointer()) {
			UpdateStackFrameCpuState(nextFrame, image,
				functionDebugInfo, cpuState);
		}

		// create the frame using the debug info
		StackFrame* frame = NULL;
		CpuState* previousCpuState = NULL;
		if (function != NULL) {
			status_t error = functionDebugInfo->GetSpecificImageDebugInfo()
				->CreateFrame(image, function, cpuState, getFullFrameInfo,
					nextFrame == NULL
						? returnValueInfos : NULL, frame,
					previousCpuState);
			if (error != B_OK && error != B_UNSUPPORTED)
				break;
		}

		// If we have no frame yet, let the architecture create it.
		if (frame == NULL) {
			status_t error = CreateStackFrame(image, functionDebugInfo,
				cpuState, nextFrame == NULL, frame, previousCpuState);
			if (error != B_OK)
				break;
		}

		cpuStateReference.SetTo(previousCpuState, true);

		frame->SetImage(image);
		frame->SetFunction(function);

		if (!stackTrace->AddFrame(frame)) {
			delete frame;
			return B_NO_MEMORY;
		}

		nextFrame = frame;
		cpuState = previousCpuState;
		if (--maxStackDepth == 0)
			break;
	}

	if (stackTrace->CountFrames() == 0)
		return B_ERROR;

	stackTraceDeleter.Detach();
	_stackTrace = stackTrace;
	return B_OK;
}