haiku.git

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

#include "LineNumberProgram.h"

#include <algorithm>

#include <stdio.h>
#include <string.h>

#include "Dwarf.h"
#include "Tracing.h"


static const uint8 kLineNumberStandardOpcodeOperands[]
	= { 0, 1, 1, 1, 1, 0, 0, 0, 1, 0, 0, 1 };
static const uint32 kLineNumberStandardOpcodeCount = 12;


LineNumberProgram::LineNumberProgram(uint8 addressSize, bool isBigEndian)
	:
	fProgram(NULL),
	fProgramSize(0),
	fMinInstructionLength(0),
	fDefaultIsStatement(0),
	fLineBase(0),
	fLineRange(0),
	fOpcodeBase(0),
	fAddressSize(addressSize),
	fIsBigEndian(isBigEndian),
	fStandardOpcodeLengths(NULL)
{
}


LineNumberProgram::~LineNumberProgram()
{
}


status_t
LineNumberProgram::Init(const void* program, size_t programSize,
	uint8 minInstructionLength, bool defaultIsStatement, int8 lineBase,
	uint8 lineRange, uint8 opcodeBase, const uint8* standardOpcodeLengths)
{
	// first check the operand counts for the standard opcodes
	uint8 standardOpcodeCount = std::min((uint32)opcodeBase - 1,
		kLineNumberStandardOpcodeCount);
	for (uint8 i = 0; i < standardOpcodeCount; i++) {
		if (standardOpcodeLengths[i] != kLineNumberStandardOpcodeOperands[i]) {
			WARNING("operand count for standard opcode %u does not what we "
				"expect\n", i + 1);
			return B_BAD_DATA;
		}
	}

	fProgram = program;
	fProgramSize = programSize;
	fMinInstructionLength = minInstructionLength;
	fDefaultIsStatement = defaultIsStatement;
	fLineBase = lineBase;
	fLineRange = lineRange;
	fOpcodeBase = opcodeBase;
	fStandardOpcodeLengths = standardOpcodeLengths;

	return B_OK;
}


void
LineNumberProgram::GetInitialState(State& state) const
{
	if (!IsValid())
		return;

	_SetToInitial(state);
	state.dataReader.SetTo(fProgram, fProgramSize, fAddressSize, fIsBigEndian);
}


bool
LineNumberProgram::GetNextRow(State& state) const
{
	if (state.isSequenceEnd)
		_SetToInitial(state);

	DataReader& dataReader = state.dataReader;

	while (dataReader.BytesRemaining() > 0) {
		bool appendRow = false;
		uint8 opcode = dataReader.Read<uint8>(0);
		if (opcode >= fOpcodeBase) {
			// special opcode
			uint adjustedOpcode = opcode - fOpcodeBase;
			state.address += (adjustedOpcode / fLineRange)
				* fMinInstructionLength;
			state.line += adjustedOpcode % fLineRange + fLineBase;
			state.isBasicBlock = false;
			state.isPrologueEnd = false;
			state.isEpilogueBegin = false;
			state.discriminator = 0;
			appendRow = true;
		} else if (opcode > 0) {
			// standard opcode
			switch (opcode) {
				case DW_LNS_copy:
					state.isBasicBlock = false;
					state.isPrologueEnd = false;
					state.isEpilogueBegin = false;
					appendRow = true;
					state.discriminator = 0;
					break;
				case DW_LNS_advance_pc:
					state.address += dataReader.ReadUnsignedLEB128(0)
						* fMinInstructionLength;
					break;
				case DW_LNS_advance_line:
					state.line += dataReader.ReadSignedLEB128(0);
					break;
				case DW_LNS_set_file:
					state.file = dataReader.ReadUnsignedLEB128(0);
					break;
				case DW_LNS_set_column:
					state.column = dataReader.ReadUnsignedLEB128(0);
					break;
				case DW_LNS_negate_stmt:
					state.isStatement = !state.isStatement;
					break;
				case DW_LNS_set_basic_block:
					state.isBasicBlock = true;
					break;
				case DW_LNS_const_add_pc:
					state.address += ((255 - fOpcodeBase) / fLineRange)
						* fMinInstructionLength;
					break;
				case DW_LNS_fixed_advance_pc:
					state.address += dataReader.Read<uint16>(0);
					break;
				case DW_LNS_set_prologue_end:
					state.isPrologueEnd = true;
					break;
				case DW_LNS_set_epilogue_begin:
					state.isEpilogueBegin = true;
					break;
				case DW_LNS_set_isa:
					state.instructionSet = dataReader.ReadUnsignedLEB128(0);
					break;
				default:
					WARNING("unsupported standard opcode %u\n", opcode);
					for (int32 i = 0; i < fStandardOpcodeLengths[opcode - 1];
							i++) {
						dataReader.ReadUnsignedLEB128(0);
					}
			}
		} else {
			// extended opcode
			uint32 instructionLength = dataReader.ReadUnsignedLEB128(0);
			off_t instructionOffset = dataReader.Offset();
			uint8 extendedOpcode = dataReader.Read<uint8>(0);

			switch (extendedOpcode) {
				case DW_LNE_end_sequence:
					state.isSequenceEnd = true;
					appendRow = true;
					break;
				case DW_LNE_set_address:
					state.address = dataReader.ReadAddress(0);
					break;
				case DW_LNE_define_file:
				{
					state.explicitFile = dataReader.ReadString();
					state.explicitFileDirIndex
						= dataReader.ReadUnsignedLEB128(0);
					dataReader.ReadUnsignedLEB128(0);	// modification time
					dataReader.ReadUnsignedLEB128(0);	// file length
					state.file = -1;
					break;
				}
				case DW_LNE_set_discriminator:
				{
					state.discriminator = dataReader.ReadUnsignedLEB128(0);
					break;
				}
				default:
					WARNING("unsupported extended opcode: %u\n",
						extendedOpcode);
					break;
			}

			dataReader.Skip(instructionLength
				- (dataReader.Offset() - instructionOffset));
		}

		if (dataReader.HasOverflow())
			return false;

		if (appendRow)
			return true;
	}

	return false;
}


void
LineNumberProgram::_SetToInitial(State& state) const
{
	state.address = 0;
	state.file = 1;
	state.line = 1;
	state.column = 0;
	state.isStatement = fDefaultIsStatement;
	state.isBasicBlock = false;
	state.isSequenceEnd = false;
	state.isPrologueEnd = false;
	state.isEpilogueBegin = false;
	state.instructionSet = 0;
	state.discriminator = 0;
}