/*
* [The "BSD licence"]
* Copyright (c) 2010 Ben Gruver (JesusFreke)
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
* 3. The name of the author may not be used to endorse or promote products
* derived from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
* IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
* OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
* IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
* NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
* THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
package org.jf.dexlib.Debug;
import org.jf.dexlib.DebugInfoItem;
import org.jf.dexlib.DexFile;
import org.jf.dexlib.StringIdItem;
import org.jf.dexlib.TypeIdItem;
import org.jf.dexlib.Util.ByteArrayInput;
import org.jf.dexlib.Util.Input;
public class DebugInstructionIterator {
/**
* This method decodes the debug instructions in the given byte array and iterates over them, calling
* the ProcessDebugInstructionDelegate.ProcessDebugInstruction method for each instruction
* @param in an Input object that the debug instructions can be read from
* @param processDebugInstruction a <code>ProcessDebugInstructionDelegate</code> object that gets called
* for each instruction that is encountered
*/
public static void IterateInstructions(Input in, ProcessRawDebugInstructionDelegate processDebugInstruction) {
int startDebugOffset;
while(true)
{
startDebugOffset = in.getCursor();
byte debugOpcode = in.readByte();
switch (debugOpcode) {
case 0x00:
{
processDebugInstruction.ProcessEndSequence(startDebugOffset);
return;
}
case 0x01:
{
int codeAddressDiff = in.readUnsignedLeb128();
processDebugInstruction.ProcessAdvancePC(startDebugOffset, in.getCursor() - startDebugOffset,
codeAddressDiff);
break;
}
case 0x02:
{
int lineDiff = in.readSignedLeb128();
processDebugInstruction.ProcessAdvanceLine(startDebugOffset, in.getCursor() - startDebugOffset,
lineDiff);
break;
}
case 0x03:
{
int registerNum = in.readUnsignedOrSignedLeb128();
boolean isSignedRegister = false;
if (registerNum < 0) {
isSignedRegister = true;
registerNum = ~registerNum;
}
int nameIndex = in.readUnsignedLeb128() - 1;
int typeIndex = in.readUnsignedLeb128() - 1;
processDebugInstruction.ProcessStartLocal(startDebugOffset, in.getCursor() - startDebugOffset,
registerNum, nameIndex, typeIndex, isSignedRegister);
break;
}
case 0x04:
{
int registerNum = in.readUnsignedOrSignedLeb128();
boolean isSignedRegister = false;
if (registerNum < 0) {
isSignedRegister = true;
registerNum = ~registerNum;
}
int nameIndex = in.readUnsignedLeb128() - 1;
int typeIndex = in.readUnsignedLeb128() - 1;
int signatureIndex = in.readUnsignedLeb128() - 1;
processDebugInstruction.ProcessStartLocalExtended(startDebugOffset,
in.getCursor() - startDebugOffset, registerNum, nameIndex, typeIndex, signatureIndex,
isSignedRegister);
break;
}
case 0x05:
{
int registerNum = in.readUnsignedOrSignedLeb128();
boolean isSignedRegister = false;
if (registerNum < 0) {
isSignedRegister = true;
registerNum = ~registerNum;
}
processDebugInstruction.ProcessEndLocal(startDebugOffset, in.getCursor() - startDebugOffset,
registerNum, isSignedRegister);
break;
}
case 0x06:
{
int registerNum = in.readUnsignedOrSignedLeb128();
boolean isSignedRegister = false;
if (registerNum < 0) {
isSignedRegister = true;
registerNum = ~registerNum;
}
processDebugInstruction.ProcessRestartLocal(startDebugOffset, in.getCursor() - startDebugOffset,
registerNum, isSignedRegister);
break;
}
case 0x07:
{
processDebugInstruction.ProcessSetPrologueEnd(startDebugOffset);
break;
}
case 0x08:
{
processDebugInstruction.ProcessSetEpilogueBegin(startDebugOffset);
break;
}
case 0x09:
{
int nameIndex = in.readUnsignedLeb128();
processDebugInstruction.ProcessSetFile(startDebugOffset, in.getCursor() - startDebugOffset,
nameIndex);
break;
}
default:
{
int base = ((debugOpcode & 0xFF) - 0x0A);
processDebugInstruction.ProcessSpecialOpcode(startDebugOffset, debugOpcode, (base % 15) - 4, base / 15);
}
}
}
}
/**
* This method decodes the debug instructions in the given byte array and iterates over them, calling
* the ProcessDebugInstructionDelegate.ProcessDebugInstruction method for each instruction
* @param debugInfoItem the <code>DebugInfoItem</code> to iterate over
* @param registerCount the number of registers in the method that the given debug info is for
* @param processDecodedDebugInstruction a <code>ProcessDebugInstructionDelegate</code> object that gets called
* for each instruction that is encountered
*/
public static void DecodeInstructions(DebugInfoItem debugInfoItem, int registerCount,
ProcessDecodedDebugInstructionDelegate processDecodedDebugInstruction) {
int startDebugOffset;
int currentCodeAddress = 0;
int line = debugInfoItem.getLineStart();
Input in = new ByteArrayInput(debugInfoItem.getEncodedDebugInfo());
DexFile dexFile = debugInfoItem.getDexFile();
Local[] locals = new Local[registerCount];
while(true)
{
startDebugOffset = in.getCursor();
byte debugOpcode = in.readByte();
switch (DebugOpcode.getDebugOpcodeByValue(debugOpcode)) {
case DBG_END_SEQUENCE:
{
return;
}
case DBG_ADVANCE_PC:
{
int codeAddressDiff = in.readUnsignedLeb128();
currentCodeAddress += codeAddressDiff;
break;
}
case DBG_ADVANCE_LINE:
{
int lineDiff = in.readSignedLeb128();
line += lineDiff;
break;
}
case DBG_START_LOCAL:
{
int registerNum = in.readUnsignedLeb128();
StringIdItem name = dexFile.StringIdsSection.getOptionalItemByIndex(in.readUnsignedLeb128() - 1);
TypeIdItem type = dexFile.TypeIdsSection.getOptionalItemByIndex(in.readUnsignedLeb128() - 1);
locals[registerNum] = new Local(registerNum, name, type, null);
processDecodedDebugInstruction.ProcessStartLocal(currentCodeAddress,
in.getCursor() - startDebugOffset, registerNum, name, type);
break;
}
case DBG_START_LOCAL_EXTENDED:
{
int registerNum = in.readUnsignedLeb128();
StringIdItem name = dexFile.StringIdsSection.getOptionalItemByIndex(in.readUnsignedLeb128() - 1);
TypeIdItem type = dexFile.TypeIdsSection.getOptionalItemByIndex(in.readUnsignedLeb128() - 1);
StringIdItem signature =
dexFile.StringIdsSection.getOptionalItemByIndex(in.readUnsignedLeb128() - 1);
locals[registerNum] = new Local(registerNum, name, type, signature);
processDecodedDebugInstruction.ProcessStartLocalExtended(currentCodeAddress,
in.getCursor() - startDebugOffset, registerNum, name, type, signature);
break;
}
case DBG_END_LOCAL:
{
int registerNum = in.readUnsignedLeb128();
Local local = locals[registerNum];
if (local == null) {
processDecodedDebugInstruction.ProcessEndLocal(currentCodeAddress, in.getCursor() - startDebugOffset, registerNum,
null, null, null);
} else {
processDecodedDebugInstruction.ProcessEndLocal(currentCodeAddress, in.getCursor() - startDebugOffset, registerNum,
local.name, local.type, local.signature);
}
break;
}
case DBG_RESTART_LOCAL:
{
int registerNum = in.readUnsignedLeb128();
Local local = locals[registerNum];
if (local == null) {
processDecodedDebugInstruction.ProcessRestartLocal(currentCodeAddress, in.getCursor() - startDebugOffset,
registerNum, null, null, null);
} else {
processDecodedDebugInstruction.ProcessRestartLocal(currentCodeAddress, in.getCursor() - startDebugOffset,
registerNum, local.name, local.type, local.signature);
}
break;
}
case DBG_SET_PROLOGUE_END:
{
processDecodedDebugInstruction.ProcessSetPrologueEnd(currentCodeAddress);
break;
}
case DBG_SET_EPILOGUE_BEGIN:
{
processDecodedDebugInstruction.ProcessSetEpilogueBegin(currentCodeAddress);
break;
}
case DBG_SET_FILE:
{
StringIdItem name = dexFile.StringIdsSection.getOptionalItemByIndex(in.readUnsignedLeb128() - 1);
processDecodedDebugInstruction.ProcessSetFile(currentCodeAddress, in.getCursor() - startDebugOffset, name);
break;
}
case DBG_SPECIAL_OPCODE:
{
int base = ((debugOpcode & 0xFF) - 0x0A);
currentCodeAddress += base / 15;
line += (base % 15) - 4;
processDecodedDebugInstruction.ProcessLineEmit(currentCodeAddress, line);
}
}
}
}
public static class ProcessRawDebugInstructionDelegate
{
//TODO: add javadocs
public void ProcessEndSequence(int startDebugOffset) {
ProcessStaticOpcode(DebugOpcode.DBG_END_SEQUENCE, startDebugOffset, 1);
}
public void ProcessAdvancePC(int startDebugOffset, int length, int codeAddressDiff) {
ProcessStaticOpcode(DebugOpcode.DBG_ADVANCE_PC, startDebugOffset, length);
}
public void ProcessAdvanceLine(int startDebugOffset, int length, int lineDiff) {
ProcessStaticOpcode(DebugOpcode.DBG_ADVANCE_LINE, startDebugOffset, length);
}
public void ProcessStartLocal(int startDebugOffset, int length, int registerNum, int nameIndex, int typeIndex,
boolean registerIsSigned) {
}
public void ProcessStartLocalExtended(int startDebugOffset, int length, int registerNum, int nameIndex,
int typeIndex,int signatureIndex, boolean registerIsSigned) {
}
public void ProcessEndLocal(int startDebugOffset, int length, int registerNum, boolean registerIsSigned) {
ProcessStaticOpcode(DebugOpcode.DBG_END_LOCAL, startDebugOffset, length);
}
public void ProcessRestartLocal(int startDebugOffset, int length, int registerNum, boolean registerIsSigned) {
ProcessStaticOpcode(DebugOpcode.DBG_RESTART_LOCAL, startDebugOffset, length);
}
public void ProcessSetPrologueEnd(int startDebugOffset) {
ProcessStaticOpcode(DebugOpcode.DBG_SET_PROLOGUE_END, startDebugOffset, 1);
}
public void ProcessSetEpilogueBegin(int startDebugOffset) {
ProcessStaticOpcode(DebugOpcode.DBG_SET_EPILOGUE_BEGIN, startDebugOffset, 1);
}
public void ProcessSetFile(int startDebugOffset, int length, int nameIndex) {
}
public void ProcessSpecialOpcode(int startDebugOffset, int debugOpcode, int lineDiff, int codeAddressDiff) {
ProcessStaticOpcode(DebugOpcode.DBG_SPECIAL_OPCODE, startDebugOffset, 1);
}
public void ProcessStaticOpcode(DebugOpcode debugOpcode, int startDebugOffset, int length) {
}
}
public static class ProcessDecodedDebugInstructionDelegate
{
public void ProcessStartLocal(int codeAddress, int length, int registerNum, StringIdItem name,
TypeIdItem type) {
}
public void ProcessStartLocalExtended(int codeAddress, int length, int registerNum, StringIdItem name,
TypeIdItem type, StringIdItem signature) {
}
public void ProcessEndLocal(int codeAddress, int length, int registerNum, StringIdItem name, TypeIdItem type,
StringIdItem signature) {
}
public void ProcessRestartLocal(int codeAddress, int length, int registerNum, StringIdItem name,
TypeIdItem type, StringIdItem signature) {
}
public void ProcessSetPrologueEnd(int codeAddress) {
}
public void ProcessSetEpilogueBegin(int codeAddress) {
}
public void ProcessSetFile(int codeAddress, int length, StringIdItem name) {
}
public void ProcessLineEmit(int codeAddress, int line) {
}
}
private static class Local {
public final int register;
public final StringIdItem name;
public final TypeIdItem type;
public final StringIdItem signature;
public Local(int register, StringIdItem name, TypeIdItem type, StringIdItem signature) {
this.register = register;
this.name = name;
this.type = type;
this.signature = signature;
}
}
}