org.jf.dexlib2.dexbacked.raw.CodeItem Java Examples

@Nonnull @Override public Iterable<? extends Instruction> getInstructions() {
    // instructionsSize is the number of 16-bit code units in the instruction list, not the number of instructions
    int instructionsSize = dexFile.readSmallUint(codeOffset + CodeItem.INSTRUCTION_COUNT_OFFSET);

    final int instructionsStartOffset = codeOffset + CodeItem.INSTRUCTION_START_OFFSET;
    final int endOffset = instructionsStartOffset + (instructionsSize*2);
    return new Iterable<Instruction>() {
        @Override
        public Iterator<Instruction> iterator() {
            return new VariableSizeLookaheadIterator<Instruction>(dexFile, instructionsStartOffset) {
                @Override
                protected Instruction readNextItem(@Nonnull DexReader reader) {
                    if (reader.getOffset() >= endOffset) {
                        return null;
                    }
                    return DexBackedInstruction.readFrom(reader);
                }
            };
        }
    };
}
 

@Nonnull @Override public Iterable<? extends Instruction> getInstructions() {
    // instructionsSize is the number of 16-bit code units in the instruction list, not the number of instructions
    int instructionsSize = dexFile.readSmallUint(codeOffset + CodeItem.INSTRUCTION_COUNT_OFFSET);

    final int instructionsStartOffset = codeOffset + CodeItem.INSTRUCTION_START_OFFSET;
    final int endOffset = instructionsStartOffset + (instructionsSize*2);
    return new Iterable<Instruction>() {
        @Override
        public Iterator<Instruction> iterator() {
            return new VariableSizeLookaheadIterator<Instruction>(dexFile, instructionsStartOffset) {
                @Override
                protected Instruction readNextItem(@Nonnull DexReader reader) {
                    if (reader.getOffset() >= endOffset) {
                        return null;
                    }
                    return DexBackedInstruction.readFrom(reader);
                }
            };
        }
    };
}
 

@Nonnull @Override public Iterable<? extends Instruction> getInstructions() {
    // instructionsSize is the number of 16-bit code units in the instruction list, not the number of instructions
    int instructionsSize = dexFile.readSmallUint(codeOffset + CodeItem.INSTRUCTION_COUNT_OFFSET);

    final int instructionsStartOffset = codeOffset + CodeItem.INSTRUCTION_START_OFFSET;
    final int endOffset = instructionsStartOffset + (instructionsSize*2);
    return new Iterable<Instruction>() {
        @Override
        public Iterator<Instruction> iterator() {
            return new VariableSizeLookaheadIterator<Instruction>(dexFile, instructionsStartOffset) {
                @Override
                protected Instruction readNextItem(@Nonnull DexReader reader) {
                    if (reader.getOffset() >= endOffset) {
                        return null;
                    }
                    return DexBackedInstruction.readFrom(reader);
                }
            };
        }
    };
}
 

@Nonnull @Override public Iterable<? extends Instruction> getInstructions() {
    // instructionsSize is the number of 16-bit code units in the instruction list, not the number of instructions
    int instructionsSize = dexFile.readSmallUint(codeOffset + CodeItem.INSTRUCTION_COUNT_OFFSET);

    final int instructionsStartOffset = codeOffset + CodeItem.INSTRUCTION_START_OFFSET;
    final int endOffset = instructionsStartOffset + (instructionsSize*2);
    return new Iterable<Instruction>() {
        @Override
        public Iterator<Instruction> iterator() {
            return new VariableSizeLookaheadIterator<Instruction>(dexFile, instructionsStartOffset) {
                @Override
                protected Instruction readNextItem(@Nonnull DexReader reader) {
                    if (reader.getOffset() >= endOffset) {
                        return null;
                    }
                    return DexBackedInstruction.readFrom(reader);
                }
            };
        }
    };
}
 

@Nonnull
@Override
public List<? extends DexBackedTryBlock> getTryBlocks() {
    final int triesSize = dexFile.readUshort(codeOffset + CodeItem.TRIES_SIZE_OFFSET);
    if (triesSize > 0) {
        int instructionsSize = dexFile.readSmallUint(codeOffset + CodeItem.INSTRUCTION_COUNT_OFFSET);
        final int triesStartOffset = AlignmentUtils.alignOffset(
                codeOffset + CodeItem.INSTRUCTION_START_OFFSET + (instructionsSize*2), 4);
        final int handlersStartOffset = triesStartOffset + triesSize*CodeItem.TryItem.ITEM_SIZE;

        return new FixedSizeList<DexBackedTryBlock>() {
            @Nonnull
            @Override
            public DexBackedTryBlock readItem(int index) {
                return new DexBackedTryBlock(dexFile,
                        triesStartOffset + index*CodeItem.TryItem.ITEM_SIZE,
                        handlersStartOffset);
            }

            @Override
            public int size() {
                return triesSize;
            }
        };
    }
    return ImmutableList.of();
}
 

@Nonnull
@Override
public List<? extends DexBackedTryBlock> getTryBlocks() {
    final int triesSize = dexFile.readUshort(codeOffset + CodeItem.TRIES_SIZE_OFFSET);
    if (triesSize > 0) {
        int instructionsSize = dexFile.readSmallUint(codeOffset + CodeItem.INSTRUCTION_COUNT_OFFSET);
        final int triesStartOffset = AlignmentUtils.alignOffset(
                codeOffset + CodeItem.INSTRUCTION_START_OFFSET + (instructionsSize*2), 4);
        final int handlersStartOffset = triesStartOffset + triesSize*CodeItem.TryItem.ITEM_SIZE;

        return new FixedSizeList<DexBackedTryBlock>() {
            @Nonnull
            @Override
            public DexBackedTryBlock readItem(int index) {
                return new DexBackedTryBlock(dexFile,
                        triesStartOffset + index*CodeItem.TryItem.ITEM_SIZE,
                        handlersStartOffset);
            }

            @Override
            public int size() {
                return triesSize;
            }
        };
    }
    return ImmutableList.of();
}
 

@Nonnull
@Override
public List<? extends DexBackedTryBlock> getTryBlocks() {
    final int triesSize = dexFile.readUshort(codeOffset + CodeItem.TRIES_SIZE_OFFSET);
    if (triesSize > 0) {
        int instructionsSize = dexFile.readSmallUint(codeOffset + CodeItem.INSTRUCTION_COUNT_OFFSET);
        final int triesStartOffset = AlignmentUtils.alignOffset(
                codeOffset + CodeItem.INSTRUCTION_START_OFFSET + (instructionsSize*2), 4);
        final int handlersStartOffset = triesStartOffset + triesSize*CodeItem.TryItem.ITEM_SIZE;

        return new FixedSizeList<DexBackedTryBlock>() {
            @Nonnull
            @Override
            public DexBackedTryBlock readItem(int index) {
                return new DexBackedTryBlock(dexFile,
                        triesStartOffset + index*CodeItem.TryItem.ITEM_SIZE,
                        handlersStartOffset);
            }

            @Override
            public int size() {
                return triesSize;
            }
        };
    }
    return ImmutableList.of();
}
 

@Nonnull
@Override
public List<? extends DexBackedTryBlock> getTryBlocks() {
    final int triesSize = dexFile.readUshort(codeOffset + CodeItem.TRIES_SIZE_OFFSET);
    if (triesSize > 0) {
        int instructionsSize = dexFile.readSmallUint(codeOffset + CodeItem.INSTRUCTION_COUNT_OFFSET);
        final int triesStartOffset = AlignmentUtils.alignOffset(
                codeOffset + CodeItem.INSTRUCTION_START_OFFSET + (instructionsSize*2), 4);
        final int handlersStartOffset = triesStartOffset + triesSize*CodeItem.TryItem.ITEM_SIZE;

        return new FixedSizeList<DexBackedTryBlock>() {
            @Nonnull
            @Override
            public DexBackedTryBlock readItem(int index) {
                return new DexBackedTryBlock(dexFile,
                        triesStartOffset + index*CodeItem.TryItem.ITEM_SIZE,
                        handlersStartOffset);
            }

            @Override
            public int size() {
                return triesSize;
            }
        };
    }
    return ImmutableList.of();
}
 

@Override public int getStartCodeAddress() {
    return dexFile.readSmallUint(tryItemOffset + CodeItem.TryItem.START_ADDRESS_OFFSET);
}
 

@Nonnull
private DebugInfo getDebugInfo() {
    return DebugInfo.newOrEmpty(dexFile, dexFile.readSmallUint(codeOffset + CodeItem.DEBUG_INFO_OFFSET), this);
}
 

@Override public int getCodeUnitCount() {
    return dexFile.readUshort(tryItemOffset + CodeItem.TryItem.CODE_UNIT_COUNT_OFFSET);
}
 

@Override public int getStartCodeAddress() {
    return dexFile.readSmallUint(tryItemOffset + CodeItem.TryItem.START_ADDRESS_OFFSET);
}
 

@Nonnull
private DebugInfo getDebugInfo() {
    return DebugInfo.newOrEmpty(dexFile, dexFile.readSmallUint(codeOffset + CodeItem.DEBUG_INFO_OFFSET), this);
}
 

@Override public int getCodeUnitCount() {
    return dexFile.readUshort(tryItemOffset + CodeItem.TryItem.CODE_UNIT_COUNT_OFFSET);
}
 

@Override public int getStartCodeAddress() {
    return dexFile.readSmallUint(tryItemOffset + CodeItem.TryItem.START_ADDRESS_OFFSET);
}
 

@Nonnull
private DebugInfo getDebugInfo() {
    return DebugInfo.newOrEmpty(dexFile, dexFile.readSmallUint(codeOffset + CodeItem.DEBUG_INFO_OFFSET), this);
}
 

@Override public int getCodeUnitCount() {
    return dexFile.readUshort(tryItemOffset + CodeItem.TryItem.CODE_UNIT_COUNT_OFFSET);
}
 

@Override public int getStartCodeAddress() {
    return dexFile.readSmallUint(tryItemOffset + CodeItem.TryItem.START_ADDRESS_OFFSET);
}
 

@Nonnull
private DebugInfo getDebugInfo() {
    return DebugInfo.newOrEmpty(dexFile, dexFile.readSmallUint(codeOffset + CodeItem.DEBUG_INFO_OFFSET), this);
}
 

@Override public int getCodeUnitCount() {
    return dexFile.readUshort(tryItemOffset + CodeItem.TryItem.CODE_UNIT_COUNT_OFFSET);
}