/*
* Copyright (C) 2008 The Android Open Source Project
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
/*
* Dalvik instruction utility functions.
*
* IMPORTANT NOTE: Much of the contents of this file are generated
* automatically by the opcode-gen tool. Any edits to the generated
* sections will get wiped out the next time the tool is run.
*/
#include "InstrUtils.h"
#include <stdlib.h>
/*
* Table that maps each opcode to the full width of instructions that
* use that opcode, in (16-bit) code units. Unimplemented opcodes as
* well as the "breakpoint" opcode have a width of zero.
*/
static InstructionWidth gInstructionWidthTable[kNumPackedOpcodes] = {
// BEGIN(libdex-widths); GENERATED AUTOMATICALLY BY opcode-gen
1, 1, 2, 3, 1, 2, 3, 1, 2, 3, 1, 1, 1, 1, 1, 1,
1, 1, 1, 2, 3, 2, 2, 3, 5, 2, 2, 3, 2, 1, 1, 2,
2, 1, 2, 2, 3, 3, 3, 1, 1, 2, 3, 3, 3, 2, 2, 2,
2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 0, 0,
0, 0, 0, 0, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 3, 3,
3, 3, 3, 0, 3, 3, 3, 3, 3, 0, 0, 1, 1, 1, 1, 1,
1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 0, 2, 3, 3,
3, 1, 2, 2, 2, 2, 2, 2, 3, 3, 3, 3, 2, 2, 2, 0,
4, 4, 5, 4, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
5, 5, 5, 5, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
4, 4, 5, 5, 5, 5, 5, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 5, 5, 5, 5, 5, 5, 5, 4, 4, 4, 4, 4, 4, 4,
// END(libdex-widths)
};
/*
* Table that maps each opcode to the flags associated with that
* opcode.
*/
static u1 gOpcodeFlagsTable[kNumPackedOpcodes] = {
// BEGIN(libdex-flags); GENERATED AUTOMATICALLY BY opcode-gen
kInstrCanContinue,
kInstrCanContinue,
kInstrCanContinue,
kInstrCanContinue,
kInstrCanContinue,
kInstrCanContinue,
kInstrCanContinue,
kInstrCanContinue,
kInstrCanContinue,
kInstrCanContinue,
kInstrCanContinue,
kInstrCanContinue,
kInstrCanContinue,
kInstrCanContinue,
kInstrCanReturn,
kInstrCanReturn,
kInstrCanReturn,
kInstrCanReturn,
kInstrCanContinue,
kInstrCanContinue,
kInstrCanContinue,
kInstrCanContinue,
kInstrCanContinue,
kInstrCanContinue,
kInstrCanContinue,
kInstrCanContinue,
kInstrCanContinue|kInstrCanThrow,
kInstrCanContinue|kInstrCanThrow,
kInstrCanContinue|kInstrCanThrow,
kInstrCanContinue|kInstrCanThrow,
kInstrCanContinue|kInstrCanThrow,
kInstrCanContinue|kInstrCanThrow,
kInstrCanContinue|kInstrCanThrow,
kInstrCanContinue|kInstrCanThrow,
kInstrCanContinue|kInstrCanThrow,
kInstrCanContinue|kInstrCanThrow,
kInstrCanContinue|kInstrCanThrow,
kInstrCanContinue|kInstrCanThrow,
kInstrCanContinue,
kInstrCanThrow,
kInstrCanBranch,
kInstrCanBranch,
kInstrCanBranch,
kInstrCanContinue|kInstrCanSwitch,
kInstrCanContinue|kInstrCanSwitch,
kInstrCanContinue,
kInstrCanContinue,
kInstrCanContinue,
kInstrCanContinue,
kInstrCanContinue,
kInstrCanContinue|kInstrCanBranch,
kInstrCanContinue|kInstrCanBranch,
kInstrCanContinue|kInstrCanBranch,
kInstrCanContinue|kInstrCanBranch,
kInstrCanContinue|kInstrCanBranch,
kInstrCanContinue|kInstrCanBranch,
kInstrCanContinue|kInstrCanBranch,
kInstrCanContinue|kInstrCanBranch,
kInstrCanContinue|kInstrCanBranch,
kInstrCanContinue|kInstrCanBranch,
kInstrCanContinue|kInstrCanBranch,
kInstrCanContinue|kInstrCanBranch,
0,
0,
0,
0,
0,
0,
kInstrCanContinue|kInstrCanThrow,
kInstrCanContinue|kInstrCanThrow,
kInstrCanContinue|kInstrCanThrow,
kInstrCanContinue|kInstrCanThrow,
kInstrCanContinue|kInstrCanThrow,
kInstrCanContinue|kInstrCanThrow,
kInstrCanContinue|kInstrCanThrow,
kInstrCanContinue|kInstrCanThrow,
kInstrCanContinue|kInstrCanThrow,
kInstrCanContinue|kInstrCanThrow,
kInstrCanContinue|kInstrCanThrow,
kInstrCanContinue|kInstrCanThrow,
kInstrCanContinue|kInstrCanThrow,
kInstrCanContinue|kInstrCanThrow,
kInstrCanContinue|kInstrCanThrow,
kInstrCanContinue|kInstrCanThrow,
kInstrCanContinue|kInstrCanThrow,
kInstrCanContinue|kInstrCanThrow,
kInstrCanContinue|kInstrCanThrow,
kInstrCanContinue|kInstrCanThrow,
kInstrCanContinue|kInstrCanThrow,
kInstrCanContinue|kInstrCanThrow,
kInstrCanContinue|kInstrCanThrow,
kInstrCanContinue|kInstrCanThrow,
kInstrCanContinue|kInstrCanThrow,
kInstrCanContinue|kInstrCanThrow,
kInstrCanContinue|kInstrCanThrow,
kInstrCanContinue|kInstrCanThrow,
kInstrCanContinue|kInstrCanThrow,
kInstrCanContinue|kInstrCanThrow,
kInstrCanContinue|kInstrCanThrow,
kInstrCanContinue|kInstrCanThrow,
kInstrCanContinue|kInstrCanThrow,
kInstrCanContinue|kInstrCanThrow,
kInstrCanContinue|kInstrCanThrow,
kInstrCanContinue|kInstrCanThrow,
kInstrCanContinue|kInstrCanThrow,
kInstrCanContinue|kInstrCanThrow,
kInstrCanContinue|kInstrCanThrow,
kInstrCanContinue|kInstrCanThrow,
kInstrCanContinue|kInstrCanThrow,
kInstrCanContinue|kInstrCanThrow,
kInstrCanContinue|kInstrCanThrow|kInstrInvoke,
kInstrCanContinue|kInstrCanThrow|kInstrInvoke,
kInstrCanContinue|kInstrCanThrow|kInstrInvoke,
kInstrCanContinue|kInstrCanThrow|kInstrInvoke,
kInstrCanContinue|kInstrCanThrow|kInstrInvoke,
0,
kInstrCanContinue|kInstrCanThrow|kInstrInvoke,
kInstrCanContinue|kInstrCanThrow|kInstrInvoke,
kInstrCanContinue|kInstrCanThrow|kInstrInvoke,
kInstrCanContinue|kInstrCanThrow|kInstrInvoke,
kInstrCanContinue|kInstrCanThrow|kInstrInvoke,
0,
0,
kInstrCanContinue,
kInstrCanContinue,
kInstrCanContinue,
kInstrCanContinue,
kInstrCanContinue,
kInstrCanContinue,
kInstrCanContinue,
kInstrCanContinue,
kInstrCanContinue,
kInstrCanContinue,
kInstrCanContinue,
kInstrCanContinue,
kInstrCanContinue,
kInstrCanContinue,
kInstrCanContinue,
kInstrCanContinue,
kInstrCanContinue,
kInstrCanContinue,
kInstrCanContinue,
kInstrCanContinue,
kInstrCanContinue,
kInstrCanContinue,
kInstrCanContinue,
kInstrCanContinue,
kInstrCanContinue|kInstrCanThrow,
kInstrCanContinue|kInstrCanThrow,
kInstrCanContinue,
kInstrCanContinue,
kInstrCanContinue,
kInstrCanContinue,
kInstrCanContinue,
kInstrCanContinue,
kInstrCanContinue,
kInstrCanContinue,
kInstrCanContinue,
kInstrCanContinue|kInstrCanThrow,
kInstrCanContinue|kInstrCanThrow,
kInstrCanContinue,
kInstrCanContinue,
kInstrCanContinue,
kInstrCanContinue,
kInstrCanContinue,
kInstrCanContinue,
kInstrCanContinue,
kInstrCanContinue,
kInstrCanContinue,
kInstrCanContinue,
kInstrCanContinue,
kInstrCanContinue,
kInstrCanContinue,
kInstrCanContinue,
kInstrCanContinue,
kInstrCanContinue,
kInstrCanContinue,
kInstrCanContinue,
kInstrCanContinue,
kInstrCanContinue|kInstrCanThrow,
kInstrCanContinue|kInstrCanThrow,
kInstrCanContinue,
kInstrCanContinue,
kInstrCanContinue,
kInstrCanContinue,
kInstrCanContinue,
kInstrCanContinue,
kInstrCanContinue,
kInstrCanContinue,
kInstrCanContinue,
kInstrCanContinue|kInstrCanThrow,
kInstrCanContinue|kInstrCanThrow,
kInstrCanContinue,
kInstrCanContinue,
kInstrCanContinue,
kInstrCanContinue,
kInstrCanContinue,
kInstrCanContinue,
kInstrCanContinue,
kInstrCanContinue,
kInstrCanContinue,
kInstrCanContinue,
kInstrCanContinue,
kInstrCanContinue,
kInstrCanContinue,
kInstrCanContinue,
kInstrCanContinue,
kInstrCanContinue,
kInstrCanContinue,
kInstrCanContinue,
kInstrCanContinue,
kInstrCanContinue|kInstrCanThrow,
kInstrCanContinue|kInstrCanThrow,
kInstrCanContinue,
kInstrCanContinue,
kInstrCanContinue,
kInstrCanContinue,
kInstrCanContinue,
kInstrCanContinue,
kInstrCanContinue|kInstrCanThrow,
kInstrCanContinue|kInstrCanThrow,
kInstrCanContinue,
kInstrCanContinue,
kInstrCanContinue,
kInstrCanContinue,
kInstrCanContinue,
kInstrCanContinue,
kInstrCanContinue|kInstrCanThrow,
kInstrCanContinue|kInstrCanThrow,
kInstrCanContinue|kInstrCanThrow,
kInstrCanContinue|kInstrCanThrow,
kInstrCanContinue|kInstrCanThrow,
kInstrCanContinue|kInstrCanThrow,
kInstrCanContinue|kInstrCanThrow,
kInstrCanContinue|kInstrCanThrow,
kInstrCanContinue|kInstrCanThrow,
0,
kInstrCanThrow,
kInstrCanContinue|kInstrCanThrow,
kInstrCanContinue|kInstrCanThrow,
kInstrCanContinue|kInstrCanThrow|kInstrInvoke,
kInstrCanReturn,
kInstrCanContinue|kInstrCanThrow,
kInstrCanContinue|kInstrCanThrow,
kInstrCanContinue|kInstrCanThrow,
kInstrCanContinue|kInstrCanThrow,
kInstrCanContinue|kInstrCanThrow,
kInstrCanContinue|kInstrCanThrow,
kInstrCanContinue|kInstrCanThrow|kInstrInvoke,
kInstrCanContinue|kInstrCanThrow|kInstrInvoke,
kInstrCanContinue|kInstrCanThrow|kInstrInvoke,
kInstrCanContinue|kInstrCanThrow|kInstrInvoke,
kInstrCanContinue|kInstrCanThrow,
kInstrCanContinue|kInstrCanThrow,
kInstrCanContinue|kInstrCanThrow,
0,
kInstrCanContinue|kInstrCanThrow,
kInstrCanContinue|kInstrCanThrow,
kInstrCanContinue|kInstrCanThrow,
kInstrCanContinue|kInstrCanThrow,
kInstrCanContinue|kInstrCanThrow,
kInstrCanContinue|kInstrCanThrow,
kInstrCanContinue|kInstrCanThrow,
kInstrCanContinue|kInstrCanThrow,
kInstrCanContinue|kInstrCanThrow,
kInstrCanContinue|kInstrCanThrow,
kInstrCanContinue|kInstrCanThrow,
kInstrCanContinue|kInstrCanThrow,
kInstrCanContinue|kInstrCanThrow,
kInstrCanContinue|kInstrCanThrow,
kInstrCanContinue|kInstrCanThrow,
kInstrCanContinue|kInstrCanThrow,
kInstrCanContinue|kInstrCanThrow,
kInstrCanContinue|kInstrCanThrow,
kInstrCanContinue|kInstrCanThrow,
kInstrCanContinue|kInstrCanThrow,
kInstrCanContinue|kInstrCanThrow,
kInstrCanContinue|kInstrCanThrow,
kInstrCanContinue|kInstrCanThrow,
kInstrCanContinue|kInstrCanThrow,
kInstrCanContinue|kInstrCanThrow,
kInstrCanContinue|kInstrCanThrow,
kInstrCanContinue|kInstrCanThrow,
kInstrCanContinue|kInstrCanThrow,
kInstrCanContinue|kInstrCanThrow,
kInstrCanContinue|kInstrCanThrow,
kInstrCanContinue|kInstrCanThrow,
kInstrCanContinue|kInstrCanThrow,
kInstrCanContinue|kInstrCanThrow,
kInstrCanContinue|kInstrCanThrow,
kInstrCanContinue|kInstrCanThrow|kInstrInvoke,
kInstrCanContinue|kInstrCanThrow|kInstrInvoke,
kInstrCanContinue|kInstrCanThrow|kInstrInvoke,
kInstrCanContinue|kInstrCanThrow|kInstrInvoke,
kInstrCanContinue|kInstrCanThrow|kInstrInvoke,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
kInstrCanContinue|kInstrCanThrow|kInstrInvoke,
kInstrCanContinue|kInstrCanThrow,
kInstrCanContinue|kInstrCanThrow,
kInstrCanContinue|kInstrCanThrow,
kInstrCanContinue|kInstrCanThrow,
kInstrCanContinue|kInstrCanThrow,
kInstrCanContinue|kInstrCanThrow,
kInstrCanContinue|kInstrCanThrow,
kInstrCanContinue|kInstrCanThrow,
kInstrCanContinue|kInstrCanThrow,
kInstrCanContinue|kInstrCanThrow,
kInstrCanContinue|kInstrCanThrow,
kInstrCanContinue|kInstrCanThrow,
kInstrCanThrow,
// END(libdex-flags)
};
/*
* Table that maps each opcode to the instruction format associated
* that opcode.
*/
static u1 gInstructionFormatTable[kNumPackedOpcodes] = {
// BEGIN(libdex-formats); GENERATED AUTOMATICALLY BY opcode-gen
kFmt10x, kFmt12x, kFmt22x, kFmt32x, kFmt12x, kFmt22x, kFmt32x,
kFmt12x, kFmt22x, kFmt32x, kFmt11x, kFmt11x, kFmt11x, kFmt11x,
kFmt10x, kFmt11x, kFmt11x, kFmt11x, kFmt11n, kFmt21s, kFmt31i,
kFmt21h, kFmt21s, kFmt31i, kFmt51l, kFmt21h, kFmt21c, kFmt31c,
kFmt21c, kFmt11x, kFmt11x, kFmt21c, kFmt22c, kFmt12x, kFmt21c,
kFmt22c, kFmt35c, kFmt3rc, kFmt31t, kFmt11x, kFmt10t, kFmt20t,
kFmt30t, kFmt31t, kFmt31t, kFmt23x, kFmt23x, kFmt23x, kFmt23x,
kFmt23x, kFmt22t, kFmt22t, kFmt22t, kFmt22t, kFmt22t, kFmt22t,
kFmt21t, kFmt21t, kFmt21t, kFmt21t, kFmt21t, kFmt21t, kFmt00x,
kFmt00x, kFmt00x, kFmt00x, kFmt00x, kFmt00x, kFmt23x, kFmt23x,
kFmt23x, kFmt23x, kFmt23x, kFmt23x, kFmt23x, kFmt23x, kFmt23x,
kFmt23x, kFmt23x, kFmt23x, kFmt23x, kFmt23x, kFmt22c, kFmt22c,
kFmt22c, kFmt22c, kFmt22c, kFmt22c, kFmt22c, kFmt22c, kFmt22c,
kFmt22c, kFmt22c, kFmt22c, kFmt22c, kFmt22c, kFmt21c, kFmt21c,
kFmt21c, kFmt21c, kFmt21c, kFmt21c, kFmt21c, kFmt21c, kFmt21c,
kFmt21c, kFmt21c, kFmt21c, kFmt21c, kFmt21c, kFmt35c, kFmt35c,
kFmt35c, kFmt35c, kFmt35c, kFmt00x, kFmt3rc, kFmt3rc, kFmt3rc,
kFmt3rc, kFmt3rc, kFmt00x, kFmt00x, kFmt12x, kFmt12x, kFmt12x,
kFmt12x, kFmt12x, kFmt12x, kFmt12x, kFmt12x, kFmt12x, kFmt12x,
kFmt12x, kFmt12x, kFmt12x, kFmt12x, kFmt12x, kFmt12x, kFmt12x,
kFmt12x, kFmt12x, kFmt12x, kFmt12x, kFmt23x, kFmt23x, kFmt23x,
kFmt23x, kFmt23x, kFmt23x, kFmt23x, kFmt23x, kFmt23x, kFmt23x,
kFmt23x, kFmt23x, kFmt23x, kFmt23x, kFmt23x, kFmt23x, kFmt23x,
kFmt23x, kFmt23x, kFmt23x, kFmt23x, kFmt23x, kFmt23x, kFmt23x,
kFmt23x, kFmt23x, kFmt23x, kFmt23x, kFmt23x, kFmt23x, kFmt23x,
kFmt23x, kFmt12x, kFmt12x, kFmt12x, kFmt12x, kFmt12x, kFmt12x,
kFmt12x, kFmt12x, kFmt12x, kFmt12x, kFmt12x, kFmt12x, kFmt12x,
kFmt12x, kFmt12x, kFmt12x, kFmt12x, kFmt12x, kFmt12x, kFmt12x,
kFmt12x, kFmt12x, kFmt12x, kFmt12x, kFmt12x, kFmt12x, kFmt12x,
kFmt12x, kFmt12x, kFmt12x, kFmt12x, kFmt12x, kFmt22s, kFmt22s,
kFmt22s, kFmt22s, kFmt22s, kFmt22s, kFmt22s, kFmt22s, kFmt22b,
kFmt22b, kFmt22b, kFmt22b, kFmt22b, kFmt22b, kFmt22b, kFmt22b,
kFmt22b, kFmt22b, kFmt22b, kFmt22c, kFmt22c, kFmt21c, kFmt21c,
kFmt22c, kFmt22c, kFmt22c, kFmt21c, kFmt21c, kFmt00x, kFmt20bc,
kFmt35mi, kFmt3rmi, kFmt35c, kFmt10x, kFmt22cs, kFmt22cs, kFmt22cs,
kFmt22cs, kFmt22cs, kFmt22cs, kFmt35ms, kFmt3rms, kFmt35ms, kFmt3rms,
kFmt22c, kFmt21c, kFmt21c, kFmt00x, kFmt41c, kFmt41c, kFmt52c,
kFmt41c, kFmt52c, kFmt5rc, kFmt52c, kFmt52c, kFmt52c, kFmt52c,
kFmt52c, kFmt52c, kFmt52c, kFmt52c, kFmt52c, kFmt52c, kFmt52c,
kFmt52c, kFmt52c, kFmt52c, kFmt41c, kFmt41c, kFmt41c, kFmt41c,
kFmt41c, kFmt41c, kFmt41c, kFmt41c, kFmt41c, kFmt41c, kFmt41c,
kFmt41c, kFmt41c, kFmt41c, kFmt5rc, kFmt5rc, kFmt5rc, kFmt5rc,
kFmt5rc, kFmt00x, kFmt00x, kFmt00x, kFmt00x, kFmt00x, kFmt00x,
kFmt00x, kFmt00x, kFmt00x, kFmt00x, kFmt00x, kFmt00x, kFmt00x,
kFmt00x, kFmt00x, kFmt00x, kFmt00x, kFmt00x, kFmt00x, kFmt00x,
kFmt00x, kFmt00x, kFmt00x, kFmt00x, kFmt00x, kFmt00x, kFmt00x,
kFmt00x, kFmt00x, kFmt00x, kFmt00x, kFmt00x, kFmt00x, kFmt00x,
kFmt00x, kFmt00x, kFmt00x, kFmt00x, kFmt00x, kFmt00x, kFmt00x,
kFmt00x, kFmt00x, kFmt00x, kFmt00x, kFmt00x, kFmt00x, kFmt00x,
kFmt00x, kFmt00x, kFmt00x, kFmt00x, kFmt00x, kFmt00x, kFmt00x,
kFmt00x, kFmt00x, kFmt00x, kFmt00x, kFmt00x, kFmt00x, kFmt00x,
kFmt00x, kFmt00x, kFmt00x, kFmt00x, kFmt00x, kFmt00x, kFmt00x,
kFmt00x, kFmt00x, kFmt00x, kFmt00x, kFmt00x, kFmt00x, kFmt00x,
kFmt00x, kFmt00x, kFmt00x, kFmt00x, kFmt00x, kFmt00x, kFmt00x,
kFmt00x, kFmt00x, kFmt00x, kFmt00x, kFmt00x, kFmt00x, kFmt00x,
kFmt00x, kFmt00x, kFmt00x, kFmt00x, kFmt00x, kFmt00x, kFmt00x,
kFmt00x, kFmt00x, kFmt00x, kFmt00x, kFmt00x, kFmt00x, kFmt00x,
kFmt00x, kFmt00x, kFmt00x, kFmt00x, kFmt00x, kFmt00x, kFmt00x,
kFmt00x, kFmt00x, kFmt00x, kFmt00x, kFmt00x, kFmt00x, kFmt00x,
kFmt00x, kFmt00x, kFmt00x, kFmt00x, kFmt00x, kFmt00x, kFmt00x,
kFmt00x, kFmt00x, kFmt00x, kFmt00x, kFmt00x, kFmt00x, kFmt00x,
kFmt00x, kFmt00x, kFmt00x, kFmt00x, kFmt00x, kFmt00x, kFmt00x,
kFmt00x, kFmt00x, kFmt00x, kFmt00x, kFmt00x, kFmt00x, kFmt00x,
kFmt00x, kFmt00x, kFmt00x, kFmt00x, kFmt00x, kFmt00x, kFmt00x,
kFmt00x, kFmt00x, kFmt00x, kFmt00x, kFmt00x, kFmt00x, kFmt00x,
kFmt00x, kFmt00x, kFmt00x, kFmt00x, kFmt00x, kFmt00x, kFmt00x,
kFmt00x, kFmt00x, kFmt00x, kFmt00x, kFmt00x, kFmt00x, kFmt00x,
kFmt00x, kFmt00x, kFmt00x, kFmt00x, kFmt00x, kFmt00x, kFmt00x,
kFmt00x, kFmt00x, kFmt00x, kFmt00x, kFmt00x, kFmt00x, kFmt00x,
kFmt00x, kFmt00x, kFmt00x, kFmt00x, kFmt00x, kFmt00x, kFmt00x,
kFmt00x, kFmt00x, kFmt00x, kFmt00x, kFmt00x, kFmt00x, kFmt00x,
kFmt00x, kFmt5rc, kFmt52c, kFmt52c, kFmt52c, kFmt52c, kFmt52c,
kFmt52c, kFmt41c, kFmt41c, kFmt41c, kFmt41c, kFmt41c, kFmt41c,
kFmt40sc,
// END(libdex-formats)
};
/*
* Table that maps each opcode to the index type implied by that
* opcode.
*/
static u1 gInstructionIndexTypeTable[kNumPackedOpcodes] = {
// BEGIN(libdex-index-types); GENERATED AUTOMATICALLY BY opcode-gen
kIndexNone, kIndexNone, kIndexNone,
kIndexNone, kIndexNone, kIndexNone,
kIndexNone, kIndexNone, kIndexNone,
kIndexNone, kIndexNone, kIndexNone,
kIndexNone, kIndexNone, kIndexNone,
kIndexNone, kIndexNone, kIndexNone,
kIndexNone, kIndexNone, kIndexNone,
kIndexNone, kIndexNone, kIndexNone,
kIndexNone, kIndexNone, kIndexStringRef,
kIndexStringRef, kIndexTypeRef, kIndexNone,
kIndexNone, kIndexTypeRef, kIndexTypeRef,
kIndexNone, kIndexTypeRef, kIndexTypeRef,
kIndexTypeRef, kIndexTypeRef, kIndexNone,
kIndexNone, kIndexNone, kIndexNone,
kIndexNone, kIndexNone, kIndexNone,
kIndexNone, kIndexNone, kIndexNone,
kIndexNone, kIndexNone, kIndexNone,
kIndexNone, kIndexNone, kIndexNone,
kIndexNone, kIndexNone, kIndexNone,
kIndexNone, kIndexNone, kIndexNone,
kIndexNone, kIndexNone, kIndexUnknown,
kIndexUnknown, kIndexUnknown, kIndexUnknown,
kIndexUnknown, kIndexUnknown, kIndexNone,
kIndexNone, kIndexNone, kIndexNone,
kIndexNone, kIndexNone, kIndexNone,
kIndexNone, kIndexNone, kIndexNone,
kIndexNone, kIndexNone, kIndexNone,
kIndexNone, kIndexFieldRef, kIndexFieldRef,
kIndexFieldRef, kIndexFieldRef, kIndexFieldRef,
kIndexFieldRef, kIndexFieldRef, kIndexFieldRef,
kIndexFieldRef, kIndexFieldRef, kIndexFieldRef,
kIndexFieldRef, kIndexFieldRef, kIndexFieldRef,
kIndexFieldRef, kIndexFieldRef, kIndexFieldRef,
kIndexFieldRef, kIndexFieldRef, kIndexFieldRef,
kIndexFieldRef, kIndexFieldRef, kIndexFieldRef,
kIndexFieldRef, kIndexFieldRef, kIndexFieldRef,
kIndexFieldRef, kIndexFieldRef, kIndexMethodRef,
kIndexMethodRef, kIndexMethodRef, kIndexMethodRef,
kIndexMethodRef, kIndexUnknown, kIndexMethodRef,
kIndexMethodRef, kIndexMethodRef, kIndexMethodRef,
kIndexMethodRef, kIndexUnknown, kIndexUnknown,
kIndexNone, kIndexNone, kIndexNone,
kIndexNone, kIndexNone, kIndexNone,
kIndexNone, kIndexNone, kIndexNone,
kIndexNone, kIndexNone, kIndexNone,
kIndexNone, kIndexNone, kIndexNone,
kIndexNone, kIndexNone, kIndexNone,
kIndexNone, kIndexNone, kIndexNone,
kIndexNone, kIndexNone, kIndexNone,
kIndexNone, kIndexNone, kIndexNone,
kIndexNone, kIndexNone, kIndexNone,
kIndexNone, kIndexNone, kIndexNone,
kIndexNone, kIndexNone, kIndexNone,
kIndexNone, kIndexNone, kIndexNone,
kIndexNone, kIndexNone, kIndexNone,
kIndexNone, kIndexNone, kIndexNone,
kIndexNone, kIndexNone, kIndexNone,
kIndexNone, kIndexNone, kIndexNone,
kIndexNone, kIndexNone, kIndexNone,
kIndexNone, kIndexNone, kIndexNone,
kIndexNone, kIndexNone, kIndexNone,
kIndexNone, kIndexNone, kIndexNone,
kIndexNone, kIndexNone, kIndexNone,
kIndexNone, kIndexNone, kIndexNone,
kIndexNone, kIndexNone, kIndexNone,
kIndexNone, kIndexNone, kIndexNone,
kIndexNone, kIndexNone, kIndexNone,
kIndexNone, kIndexNone, kIndexNone,
kIndexNone, kIndexNone, kIndexNone,
kIndexNone, kIndexNone, kIndexNone,
kIndexNone, kIndexNone, kIndexNone,
kIndexNone, kIndexNone, kIndexNone,
kIndexNone, kIndexNone, kIndexNone,
kIndexNone, kIndexNone, kIndexNone,
kIndexNone, kIndexNone, kIndexNone,
kIndexNone, kIndexNone, kIndexFieldRef,
kIndexFieldRef, kIndexFieldRef, kIndexFieldRef,
kIndexFieldRef, kIndexFieldRef, kIndexFieldRef,
kIndexFieldRef, kIndexFieldRef, kIndexUnknown,
kIndexVaries, kIndexInlineMethod, kIndexInlineMethod,
kIndexMethodRef, kIndexNone, kIndexFieldOffset,
kIndexFieldOffset, kIndexFieldOffset, kIndexFieldOffset,
kIndexFieldOffset, kIndexFieldOffset, kIndexVtableOffset,
kIndexVtableOffset, kIndexVtableOffset, kIndexVtableOffset,
kIndexFieldRef, kIndexFieldRef, kIndexFieldRef,
kIndexUnknown, kIndexTypeRef, kIndexTypeRef,
kIndexTypeRef, kIndexTypeRef, kIndexTypeRef,
kIndexTypeRef, kIndexFieldRef, kIndexFieldRef,
kIndexFieldRef, kIndexFieldRef, kIndexFieldRef,
kIndexFieldRef, kIndexFieldRef, kIndexFieldRef,
kIndexFieldRef, kIndexFieldRef, kIndexFieldRef,
kIndexFieldRef, kIndexFieldRef, kIndexFieldRef,
kIndexFieldRef, kIndexFieldRef, kIndexFieldRef,
kIndexFieldRef, kIndexFieldRef, kIndexFieldRef,
kIndexFieldRef, kIndexFieldRef, kIndexFieldRef,
kIndexFieldRef, kIndexFieldRef, kIndexFieldRef,
kIndexFieldRef, kIndexFieldRef, kIndexMethodRef,
kIndexMethodRef, kIndexMethodRef, kIndexMethodRef,
kIndexMethodRef, kIndexUnknown, kIndexUnknown,
kIndexUnknown, kIndexUnknown, kIndexUnknown,
kIndexUnknown, kIndexUnknown, kIndexUnknown,
kIndexUnknown, kIndexUnknown, kIndexUnknown,
kIndexUnknown, kIndexUnknown, kIndexUnknown,
kIndexUnknown, kIndexUnknown, kIndexUnknown,
kIndexUnknown, kIndexUnknown, kIndexUnknown,
kIndexUnknown, kIndexUnknown, kIndexUnknown,
kIndexUnknown, kIndexUnknown, kIndexUnknown,
kIndexUnknown, kIndexUnknown, kIndexUnknown,
kIndexUnknown, kIndexUnknown, kIndexUnknown,
kIndexUnknown, kIndexUnknown, kIndexUnknown,
kIndexUnknown, kIndexUnknown, kIndexUnknown,
kIndexUnknown, kIndexUnknown, kIndexUnknown,
kIndexUnknown, kIndexUnknown, kIndexUnknown,
kIndexUnknown, kIndexUnknown, kIndexUnknown,
kIndexUnknown, kIndexUnknown, kIndexUnknown,
kIndexUnknown, kIndexUnknown, kIndexUnknown,
kIndexUnknown, kIndexUnknown, kIndexUnknown,
kIndexUnknown, kIndexUnknown, kIndexUnknown,
kIndexUnknown, kIndexUnknown, kIndexUnknown,
kIndexUnknown, kIndexUnknown, kIndexUnknown,
kIndexUnknown, kIndexUnknown, kIndexUnknown,
kIndexUnknown, kIndexUnknown, kIndexUnknown,
kIndexUnknown, kIndexUnknown, kIndexUnknown,
kIndexUnknown, kIndexUnknown, kIndexUnknown,
kIndexUnknown, kIndexUnknown, kIndexUnknown,
kIndexUnknown, kIndexUnknown, kIndexUnknown,
kIndexUnknown, kIndexUnknown, kIndexUnknown,
kIndexUnknown, kIndexUnknown, kIndexUnknown,
kIndexUnknown, kIndexUnknown, kIndexUnknown,
kIndexUnknown, kIndexUnknown, kIndexUnknown,
kIndexUnknown, kIndexUnknown, kIndexUnknown,
kIndexUnknown, kIndexUnknown, kIndexUnknown,
kIndexUnknown, kIndexUnknown, kIndexUnknown,
kIndexUnknown, kIndexUnknown, kIndexUnknown,
kIndexUnknown, kIndexUnknown, kIndexUnknown,
kIndexUnknown, kIndexUnknown, kIndexUnknown,
kIndexUnknown, kIndexUnknown, kIndexUnknown,
kIndexUnknown, kIndexUnknown, kIndexUnknown,
kIndexUnknown, kIndexUnknown, kIndexUnknown,
kIndexUnknown, kIndexUnknown, kIndexUnknown,
kIndexUnknown, kIndexUnknown, kIndexUnknown,
kIndexUnknown, kIndexUnknown, kIndexUnknown,
kIndexUnknown, kIndexUnknown, kIndexUnknown,
kIndexUnknown, kIndexUnknown, kIndexUnknown,
kIndexUnknown, kIndexUnknown, kIndexUnknown,
kIndexUnknown, kIndexUnknown, kIndexUnknown,
kIndexUnknown, kIndexUnknown, kIndexUnknown,
kIndexUnknown, kIndexUnknown, kIndexUnknown,
kIndexUnknown, kIndexUnknown, kIndexUnknown,
kIndexUnknown, kIndexUnknown, kIndexUnknown,
kIndexUnknown, kIndexUnknown, kIndexUnknown,
kIndexUnknown, kIndexUnknown, kIndexUnknown,
kIndexUnknown, kIndexUnknown, kIndexUnknown,
kIndexUnknown, kIndexUnknown, kIndexUnknown,
kIndexUnknown, kIndexUnknown, kIndexUnknown,
kIndexUnknown, kIndexUnknown, kIndexUnknown,
kIndexUnknown, kIndexUnknown, kIndexUnknown,
kIndexUnknown, kIndexUnknown, kIndexUnknown,
kIndexUnknown, kIndexUnknown, kIndexUnknown,
kIndexUnknown, kIndexUnknown, kIndexUnknown,
kIndexUnknown, kIndexUnknown, kIndexUnknown,
kIndexUnknown, kIndexUnknown, kIndexUnknown,
kIndexUnknown, kIndexUnknown, kIndexUnknown,
kIndexUnknown, kIndexUnknown, kIndexUnknown,
kIndexUnknown, kIndexUnknown, kIndexUnknown,
kIndexUnknown, kIndexUnknown, kIndexUnknown,
kIndexMethodRef, kIndexFieldRef, kIndexFieldRef,
kIndexFieldRef, kIndexFieldRef, kIndexFieldRef,
kIndexFieldRef, kIndexFieldRef, kIndexFieldRef,
kIndexFieldRef, kIndexFieldRef, kIndexFieldRef,
kIndexFieldRef, kIndexVaries,
// END(libdex-index-types)
};
/*
* Global InstructionInfoTables struct.
*/
InstructionInfoTables gDexOpcodeInfo = {
gInstructionFormatTable,
gInstructionIndexTypeTable,
gOpcodeFlagsTable,
gInstructionWidthTable
};
/*
* Handy macros for helping decode instructions.
*/
#define FETCH(_offset) (insns[(_offset)])
#define FETCH_u4(_offset) (fetch_u4_impl((_offset), insns))
#define INST_A(_inst) (((u2)(_inst) >> 8) & 0x0f)
#define INST_B(_inst) ((u2)(_inst) >> 12)
#define INST_AA(_inst) ((_inst) >> 8)
/* Helper for FETCH_u4, above. */
static inline u4 fetch_u4_impl(u4 offset, const u2* insns) {
return insns[offset] | ((u4) insns[offset+1] << 16);
}
/*
* Decode the instruction pointed to by "insns".
*
* Fills out the pieces of "pDec" that are affected by the current
* instruction. Does not touch anything else.
*/
void dexDecodeInstruction(const u2* insns, DecodedInstruction* pDec)
{
u2 inst = *insns;
Opcode opcode = dexOpcodeFromCodeUnit(inst);
InstructionFormat format = dexGetFormatFromOpcode(opcode);
pDec->opcode = opcode;
pDec->indexType = dexGetIndexTypeFromOpcode(opcode);
switch (format) {
case kFmt10x: // op
/* nothing to do; copy the AA bits out for the verifier */
pDec->vA = INST_AA(inst);
break;
case kFmt12x: // op vA, vB
pDec->vA = INST_A(inst);
pDec->vB = INST_B(inst);
break;
case kFmt11n: // op vA, #+B
pDec->vA = INST_A(inst);
pDec->vB = (s4) (INST_B(inst) << 28) >> 28; // sign extend 4-bit value
break;
case kFmt11x: // op vAA
pDec->vA = INST_AA(inst);
break;
case kFmt10t: // op +AA
pDec->vA = (s1) INST_AA(inst); // sign-extend 8-bit value
break;
case kFmt20t: // op +AAAA
pDec->vA = (s2) FETCH(1); // sign-extend 16-bit value
break;
case kFmt20bc: // [opt] op AA, thing@BBBB
case kFmt21c: // op vAA, thing@BBBB
case kFmt22x: // op vAA, vBBBB
pDec->vA = INST_AA(inst);
pDec->vB = FETCH(1);
break;
case kFmt21s: // op vAA, #+BBBB
case kFmt21t: // op vAA, +BBBB
pDec->vA = INST_AA(inst);
pDec->vB = (s2) FETCH(1); // sign-extend 16-bit value
break;
case kFmt21h: // op vAA, #+BBBB0000[00000000]
pDec->vA = INST_AA(inst);
/*
* The value should be treated as right-zero-extended, but we don't
* actually do that here. Among other things, we don't know if it's
* the top bits of a 32- or 64-bit value.
*/
pDec->vB = FETCH(1);
break;
case kFmt23x: // op vAA, vBB, vCC
pDec->vA = INST_AA(inst);
pDec->vB = FETCH(1) & 0xff;
pDec->vC = FETCH(1) >> 8;
break;
case kFmt22b: // op vAA, vBB, #+CC
pDec->vA = INST_AA(inst);
pDec->vB = FETCH(1) & 0xff;
pDec->vC = (s1) (FETCH(1) >> 8); // sign-extend 8-bit value
break;
case kFmt22s: // op vA, vB, #+CCCC
case kFmt22t: // op vA, vB, +CCCC
pDec->vA = INST_A(inst);
pDec->vB = INST_B(inst);
pDec->vC = (s2) FETCH(1); // sign-extend 16-bit value
break;
case kFmt22c: // op vA, vB, thing@CCCC
case kFmt22cs: // [opt] op vA, vB, field offset CCCC
pDec->vA = INST_A(inst);
pDec->vB = INST_B(inst);
pDec->vC = FETCH(1);
break;
case kFmt30t: // op +AAAAAAAA
pDec->vA = FETCH_u4(1); // signed 32-bit value
break;
case kFmt31t: // op vAA, +BBBBBBBB
case kFmt31c: // op vAA, string@BBBBBBBB
pDec->vA = INST_AA(inst);
pDec->vB = FETCH_u4(1); // 32-bit value
break;
case kFmt32x: // op vAAAA, vBBBB
pDec->vA = FETCH(1);
pDec->vB = FETCH(2);
break;
case kFmt31i: // op vAA, #+BBBBBBBB
pDec->vA = INST_AA(inst);
pDec->vB = FETCH_u4(1); // signed 32-bit value
break;
case kFmt35c: // op {vC, vD, vE, vF, vG}, thing@BBBB
case kFmt35ms: // [opt] invoke-virtual+super
case kFmt35mi: // [opt] inline invoke
{
/*
* Note that the fields mentioned in the spec don't appear in
* their "usual" positions here compared to most formats. This
* was done so that the field names for the argument count and
* reference index match between this format and the corresponding
* range formats (3rc and friends).
*
* Bottom line: The argument count is always in vA, and the
* method constant (or equivalent) is always in vB.
*/
u2 regList;
int i, count;
pDec->vA = INST_B(inst); // This is labeled A in the spec.
pDec->vB = FETCH(1);
regList = FETCH(2);
count = pDec->vA;
/*
* Copy the argument registers into the arg[] array, and
* also copy the first argument (if any) into vC. (The
* DecodedInstruction structure doesn't have separate
* fields for {vD, vE, vF, vG}, so there's no need to make
* copies of those.) Note that cases 5..2 fall through.
*/
switch (count) {
case 5: {
if (format == kFmt35mi) {
/* A fifth arg is verboten for inline invokes. */
LOGW("Invalid arg count in 35mi (5)");
goto bail;
}
/*
* Per note at the top of this format decoder, the
* fifth argument comes from the A field in the
* instruction, but it's labeled G in the spec.
*/
pDec->arg[4] = INST_A(inst);
}
case 4: pDec->arg[3] = (regList >> 12) & 0x0f;
case 3: pDec->arg[2] = (regList >> 8) & 0x0f;
case 2: pDec->arg[1] = (regList >> 4) & 0x0f;
case 1: pDec->vC = pDec->arg[0] = regList & 0x0f; break;
case 0: break; // Valid, but no need to do anything.
default:
LOGW("Invalid arg count in 35c/35ms/35mi (%d)", count);
goto bail;
}
}
break;
case kFmt3rc: // op {vCCCC .. v(CCCC+AA-1)}, meth@BBBB
case kFmt3rms: // [opt] invoke-virtual+super/range
case kFmt3rmi: // [opt] execute-inline/range
pDec->vA = INST_AA(inst);
pDec->vB = FETCH(1);
pDec->vC = FETCH(2);
break;
case kFmt51l: // op vAA, #+BBBBBBBBBBBBBBBB
pDec->vA = INST_AA(inst);
pDec->vB_wide = FETCH_u4(1) | ((u8) FETCH_u4(3) << 32);
break;
case kFmt33x: // exop vAA, vBB, vCCCC
pDec->vA = FETCH(1) & 0xff;
pDec->vB = FETCH(1) >> 8;
pDec->vC = FETCH(2);
break;
case kFmt32s: // exop vAA, vBB, #+CCCC
pDec->vA = FETCH(1) & 0xff;
pDec->vB = FETCH(1) >> 8;
pDec->vC = (s2) FETCH(2); // sign-extend 16-bit value
break;
case kFmt40sc: // [opt] exop AAAA, thing@BBBBBBBB
case kFmt41c: // exop vAAAA, thing@BBBBBBBB
/*
* The order of fields for this format in the spec is {B, A},
* to match formats 21c and 31c.
*/
pDec->vB = FETCH_u4(1); // 32-bit value
pDec->vA = FETCH(3);
break;
case kFmt52c: // exop vAAAA, vBBBB, thing@CCCCCCCC
/*
* The order of fields for this format in the spec is {C, A, B},
* to match formats 22c and 22cs.
*/
pDec->vC = FETCH_u4(1); // 32-bit value
pDec->vA = FETCH(3);
pDec->vB = FETCH(4);
break;
case kFmt5rc: // exop {vCCCC .. v(CCCC+AAAA-1)}, meth@BBBBBBBB
/*
* The order of fields for this format in the spec is {B, A, C},
* to match formats 3rc and friends.
*/
pDec->vB = FETCH_u4(1); // 32-bit value
pDec->vA = FETCH(3);
pDec->vC = FETCH(4);
break;
default:
LOGW("Can't decode unexpected format %d (op=%d)", format, opcode);
assert(false);
break;
}
bail:
;
}
/*
* Return the width of the specified instruction, or 0 if not defined. Also
* works for special OP_NOP entries, including switch statement data tables
* and array data.
*/
size_t dexGetWidthFromInstruction(const u2* insns)
{
size_t width;
if (*insns == kPackedSwitchSignature) {
width = 4 + insns[1] * 2;
} else if (*insns == kSparseSwitchSignature) {
width = 2 + insns[1] * 4;
} else if (*insns == kArrayDataSignature) {
u2 elemWidth = insns[1];
u4 len = insns[2] | (((u4)insns[3]) << 16);
// The plus 1 is to round up for odd size and width.
width = 4 + (elemWidth * len + 1) / 2;
} else {
width = dexGetWidthFromOpcode(dexOpcodeFromCodeUnit(insns[0]));
}
return width;
}