ReVanced/smali
1
0
Fork 0
mirror of https://github.com/revanced/smali.git synced 2025-05-28 03:40:12 +02:00
Code Issues Packages Projects Releases Wiki Activity

Add DexBacked implementation of MethodImplementation

Browse Source
This commit is contained in:
Ben Gruver 2012-10-19 21:07:37 -07:00
parent 337dc0ea26
commit 5ec83fb0f0
5 changed files with 183 additions and 24 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
dexlib2/src/main/java/org/jf/dexlib2/dexbacked/DexBackedCatchAllExceptionHandler.java
View File

@ -32,13 +32,15 @@
package org.jf.dexlib2.dexbacked;
import org.jf.dexlib2.DexFileReader;
import org.jf.dexlib2.dexbacked.util.InstructionOffsetMap;
import org.jf.dexlib2.immutable.ImmutableExceptionHandler;
import javax.annotation.Nonnull;
public class DexBackedCatchAllExceptionHandler extends ImmutableExceptionHandler {
public DexBackedCatchAllExceptionHandler(@Nonnull DexFileReader dexFileReader) {
public DexBackedCatchAllExceptionHandler(@Nonnull DexFileReader dexFileReader,
@Nonnull InstructionOffsetMap instructionOffsetMap) {
super(null,
dexFileReader.readSmallUleb128());
instructionOffsetMap.getInstructionIndexAtOffsetExact(dexFileReader.readSmallUleb128()));
}
}

7
dexlib2/src/main/java/org/jf/dexlib2/dexbacked/DexBackedExceptionHandler.java
View File

@ -32,13 +32,16 @@
package org.jf.dexlib2.dexbacked;
import org.jf.dexlib2.DexFileReader;
import org.jf.dexlib2.dexbacked.util.InstructionOffsetMap;
import org.jf.dexlib2.immutable.ImmutableExceptionHandler;
import javax.annotation.Nonnull;
public class DexBackedExceptionHandler extends ImmutableExceptionHandler {
public DexBackedExceptionHandler(@Nonnull DexFileReader dexFileReader) {
public DexBackedExceptionHandler(@Nonnull DexFileReader dexFileReader,
@Nonnull InstructionOffsetMap instructionOffsetMap) {
// TODO: verify dalvik doesn't accept an exception handler that points in the middle of an instruction
super(dexFileReader.getType(dexFileReader.readSmallUleb128()),
dexFileReader.readSmallUleb128());
instructionOffsetMap.getInstructionIndexAtOffsetExact(dexFileReader.readSmallUleb128()));
}
}

96
dexlib2/src/main/java/org/jf/dexlib2/dexbacked/DexBackedMethodImplementation.java
View File

@ -31,37 +31,109 @@
package org.jf.dexlib2.dexbacked;
import com.google.common.collect.ImmutableList;
import org.jf.dexlib2.DexFile;
import org.jf.dexlib2.DexFileReader;
import org.jf.dexlib2.dexbacked.instruction.DexBackedInstruction;
import org.jf.dexlib2.dexbacked.util.FixedSizeList;
import org.jf.dexlib2.dexbacked.util.InstructionOffsetMap;
import org.jf.dexlib2.iface.MethodImplementation;
import org.jf.dexlib2.iface.TryBlock;
import org.jf.dexlib2.iface.instruction.Instruction;
import org.jf.util.AlignmentUtils;
import javax.annotation.Nonnull;
import java.util.ArrayList;
import java.util.List;
public class DexBackedMethodImplementation implements MethodImplementation {
@Nonnull public final DexFile dexFile;
private final int codeOffset;
public final int registerCount;
@Nonnull public final ImmutableList<? extends Instruction> instructions;
@Nonnull private final InstructionOffsetMap instructionOffsetMap;
// code_item offsets
private static final int TRIES_SIZE_OFFSET = 6;
private static final int INSTRUCTIONS_SIZE_OFFSET = 12;
private static final int INSTRUCTIONS_START_OFFSET = 16;
private static final int TRY_ITEM_SIZE = 8;
public DexBackedMethodImplementation(@Nonnull DexFile dexFile,
int codeOffset) {
this.dexFile = dexFile;
this.codeOffset = codeOffset;
this.registerCount = dexFile.readUshort(codeOffset);
instructions = buildInstructionList();
instructionOffsetMap = buildInstructionOffsetMap();
}
@Override
public int getRegisterCount() {
return 0;
}
@Nonnull
@Override
public List<? extends Instruction> getInstructions() {
return null;
}
@Override public int getRegisterCount() { return registerCount; }
@Nonnull @Override public ImmutableList<? extends Instruction> getInstructions() { return instructions; }
@Nonnull
@Override
public List<? extends TryBlock> getTryBlocks() {
return null;
final int triesSize = dexFile.readUshort(codeOffset + TRIES_SIZE_OFFSET);
if (triesSize > 0) {
int instructionsSize = dexFile.readSmallUint(codeOffset + INSTRUCTIONS_SIZE_OFFSET);
final int triesStartOffset = AlignmentUtils.alignOffset(
codeOffset + INSTRUCTIONS_START_OFFSET + (instructionsSize*2), 4);
final int handlersStartOffset = triesStartOffset + triesSize*TRY_ITEM_SIZE;
return new FixedSizeList<TryBlock>() {
@Override
public TryBlock readItem(int index) {
return new DexBackedTryBlock(dexFile,
triesStartOffset + index*TRY_ITEM_SIZE,
handlersStartOffset,
instructionOffsetMap);
}
@Override
public int size() {
return triesSize;
}
};
}
return ImmutableList.of();
}
private ImmutableList<? extends Instruction> buildInstructionList() {
// instructionsSize is the number of 16-bit code units in the instruction list, not the number of instructions
int instructionsSize = dexFile.readSmallUint(codeOffset + INSTRUCTIONS_SIZE_OFFSET);
// we can use instructionsSize as an upper bound on the number of instructions there will be
ArrayList<Instruction> instructions = new ArrayList<Instruction>(instructionsSize);
int instructionsStartOffset = codeOffset + INSTRUCTIONS_START_OFFSET;
DexFileReader reader = dexFile.readerAt(instructionsStartOffset);
int endOffset = instructionsStartOffset + (instructionsSize*2);
while (reader.getOffset() < endOffset) {
instructions.add(DexBackedInstruction.readFrom(reader));
}
return ImmutableList.copyOf(instructions);
}
/**
* Builds an InstructionOffsetMap that maps an instruction offset to its index.
*
* This must be called after the instructions field has been set
*
* @return An InstructionOffsetMap object
*/
private InstructionOffsetMap buildInstructionOffsetMap() {
int[] offsets = new int[instructions.size()];
int currentOffset = 0;
for (int i=0; i<offsets.length; i++) {
offsets[i] = currentOffset;
// TODO: need to handle variable size instructions
currentOffset += instructions.get(i).getOpcode().format.size;
}
return new InstructionOffsetMap(offsets);
}
}

36
dexlib2/src/main/java/org/jf/dexlib2/dexbacked/DexBackedTryBlock.java
View File

@ -33,6 +33,7 @@ package org.jf.dexlib2.dexbacked;
import org.jf.dexlib2.DexFile;
import org.jf.dexlib2.DexFileReader;
import org.jf.dexlib2.dexbacked.util.InstructionOffsetMap;
import org.jf.dexlib2.iface.ExceptionHandler;
import org.jf.dexlib2.iface.TryBlock;
import org.jf.dexlib2.dexbacked.util.VariableSizeList;
@ -42,19 +43,38 @@ import java.util.List;
public class DexBackedTryBlock implements TryBlock {
public final DexFile dexFile;
private final InstructionOffsetMap instructionOffsetMap;
public final int startIndex;
public final int instructionCount;
private final int exceptionHandlersOffset;
private static final int START_ADDRESS_OFFSET = 0;
private static final int CODE_UNIT_COUNT_OFFSET = 4;
private static final int HANDLER_OFFSET_OFFSET = 6;
public DexBackedTryBlock(DexFile dexFile,
int offset,
int handlersStartOffset) {
int tryItemOffset,
int handlersStartOffset,
InstructionOffsetMap instructionOffsetMap) {
this.dexFile = dexFile;
this.startIndex = dexFile.readSmallUint(offset);
this.instructionCount = dexFile.readUshort(offset+4);
this.exceptionHandlersOffset = handlersStartOffset + dexFile.readUshort(6);
this.instructionOffsetMap = instructionOffsetMap;
int startOffset = dexFile.readSmallUint(tryItemOffset + START_ADDRESS_OFFSET);
// map the code unit offset to the instruction index
this.startIndex = instructionOffsetMap.getInstructionIndexAtOffsetExact(startOffset);
int codeUnitCount = dexFile.readUshort(tryItemOffset + CODE_UNIT_COUNT_OFFSET);
// TODO: check if dalivk accepts insns_size = 0
if (codeUnitCount == 0) {
this.instructionCount = 0;
} else {
int lastIndex = instructionOffsetMap.getInstructionIndexAtOffset(startOffset + codeUnitCount - 1);
this.instructionCount = lastIndex - startIndex + 1;
}
this.exceptionHandlersOffset = handlersStartOffset + dexFile.readUshort(tryItemOffset + HANDLER_OFFSET_OFFSET);
}
@Override public int getStartIndex() { return startIndex; }
@ -72,7 +92,7 @@ public class DexBackedTryBlock implements TryBlock {
@Nonnull
@Override
protected ExceptionHandler readItem(DexFileReader dexFileReader, int index) {
return new DexBackedExceptionHandler(dexFileReader);
return new DexBackedExceptionHandler(dexFileReader, instructionOffsetMap);
}
@Override public int size() { return encodedSize; }
};
@ -84,9 +104,9 @@ public class DexBackedTryBlock implements TryBlock {
@Override
protected ExceptionHandler readItem(DexFileReader dexFileReader, int index) {
if (index == sizeWithCatchAll-1) {
return new DexBackedCatchAllExceptionHandler(dexFileReader);
return new DexBackedCatchAllExceptionHandler(dexFileReader, instructionOffsetMap);
} else {
return new DexBackedExceptionHandler(dexFileReader);
return new DexBackedExceptionHandler(dexFileReader, instructionOffsetMap);
}
}
@Override public int size() { return sizeWithCatchAll; }

62
dexlib2/src/main/java/org/jf/dexlib2/dexbacked/util/InstructionOffsetMap.java Normal file
View File

@ -0,0 +1,62 @@
/*
* Copyright 2012, Google Inc.
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are
* met:
*
* * Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* * 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.
* * Neither the name of Google Inc. nor the names of its
* contributors may be used to endorse or promote products derived from
* this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* "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 COPYRIGHT
* OWNER OR CONTRIBUTORS 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.dexlib2.dexbacked.util;
import org.jf.util.ExceptionWithContext;
import java.util.Arrays;
public class InstructionOffsetMap {
private final int[] instructionOffsets;
public InstructionOffsetMap(int[] instructionOffsets) {
this.instructionOffsets = instructionOffsets;
}
public int getInstructionIndexAtOffsetExact(int offset) {
int index = Arrays.binarySearch(instructionOffsets, offset);
if (index < 0) {
throw new ExceptionWithContext("No instruction at offset %d", offset);
}
return index;
}
public int getInstructionIndexAtOffset(int offset) {
int index = Arrays.binarySearch(instructionOffsets, offset);
if (index < 0) {
// This would fail if index was -1 (i.e. insertion point of 0). Luckily, we can ignore this case, because
// offset will always be non-negative, and the offset of the first instruction will always be 0.
return (~index) - 1;
}
return index;
}
}