// Copyright (C) 2017 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.
//

#include "instruction_decoder.h"

#include "dex/dex_instruction_list.h"

#include <android-base/logging.h>

namespace titrace {

class ClassInstructionDecoder : public InstructionDecoder {
 public:
  size_t GetMaximumOpcode() override {
    return 0xff;
  }

  const char* GetName(size_t opcode) override {
    Bytecode::Opcode op = static_cast<Bytecode::Opcode>(opcode);
    return Bytecode::ToString(op);
  }

  virtual size_t LocationToOffset(size_t j_location) {
    return j_location;
  }

 private:
  class Bytecode {
   public:
    enum Opcode {
      // Java bytecode opcodes from 0x00 to 0xFF.
      kNop = 0x00,
      kAconst_null = 0x01,
      kIconst_m1 = 0x02,
      kIconst_0 = 0x03,
      kIconst_1 = 0x04,
      kIconst_2 = 0x05,
      kIconst_3 = 0x06,
      kIconst_4 = 0x07,
      kIconst_5 = 0x08,
      kLconst_0 = 0x09,
      kLconst_1 = 0x0a,
      kFconst_0 = 0x0b,
      kFconst_1 = 0x0c,
      kFconst_2 = 0x0d,
      kDconst_0 = 0x0e,
      kDconst_1 = 0x0f,
      kBipush = 0x10,
      kSipush = 0x11,
      kLdc = 0x12,
      kLdc_w = 0x13,
      kLdc2_w = 0x14,
      kIload = 0x15,
      kLload = 0x16,
      kFload = 0x17,
      kDload = 0x18,
      kAload = 0x19,
      kIload_0 = 0x1a,
      kIload_1 = 0x1b,
      kIload_2 = 0x1c,
      kIload_3 = 0x1d,
      kLload_0 = 0x1e,
      kLload_1 = 0x1f,
      kLload_2 = 0x20,
      kLload_3 = 0x21,
      kFload_0 = 0x22,
      kFload_1 = 0x23,
      kFload_2 = 0x24,
      kFload_3 = 0x25,
      kDload_0 = 0x26,
      kDload_1 = 0x27,
      kDload_2 = 0x28,
      kDload_3 = 0x29,
      kAload_0 = 0x2a,
      kAload_1 = 0x2b,
      kAload_2 = 0x2c,
      kAload_3 = 0x2d,
      kIaload = 0x2e,
      kLaload = 0x2f,
      kFaload = 0x30,
      kDaload = 0x31,
      kAaload = 0x32,
      kBaload = 0x33,
      kCaload = 0x34,
      kSaload = 0x35,
      kIstore = 0x36,
      kLstore = 0x37,
      kFstore = 0x38,
      kDstore = 0x39,
      kAstore = 0x3a,
      kIstore_0 = 0x3b,
      kIstore_1 = 0x3c,
      kIstore_2 = 0x3d,
      kIstore_3 = 0x3e,
      kLstore_0 = 0x3f,
      kLstore_1 = 0x40,
      kLstore_2 = 0x41,
      kLstore_3 = 0x42,
      kFstore_0 = 0x43,
      kFstore_1 = 0x44,
      kFstore_2 = 0x45,
      kFstore_3 = 0x46,
      kDstore_0 = 0x47,
      kDstore_1 = 0x48,
      kDstore_2 = 0x49,
      kDstore_3 = 0x4a,
      kAstore_0 = 0x4b,
      kAstore_1 = 0x4c,
      kAstore_2 = 0x4d,
      kAstore_3 = 0x4e,
      kIastore = 0x4f,
      kLastore = 0x50,
      kFastore = 0x51,
      kDastore = 0x52,
      kAastore = 0x53,
      kBastore = 0x54,
      kCastore = 0x55,
      kSastore = 0x56,
      kPop = 0x57,
      kPop2 = 0x58,
      kDup = 0x59,
      kDup_x1 = 0x5a,
      kDup_x2 = 0x5b,
      kDup2 = 0x5c,
      kDup2_x1 = 0x5d,
      kDup2_x2 = 0x5e,
      kSwap = 0x5f,
      kIadd = 0x60,
      kLadd = 0x61,
      kFadd = 0x62,
      kDadd = 0x63,
      kIsub = 0x64,
      kLsub = 0x65,
      kFsub = 0x66,
      kDsub = 0x67,
      kImul = 0x68,
      kLmul = 0x69,
      kFmul = 0x6a,
      kDmul = 0x6b,
      kIdiv = 0x6c,
      kLdiv = 0x6d,
      kFdiv = 0x6e,
      kDdiv = 0x6f,
      kIrem = 0x70,
      kLrem = 0x71,
      kFrem = 0x72,
      kDrem = 0x73,
      kIneg = 0x74,
      kLneg = 0x75,
      kFneg = 0x76,
      kDneg = 0x77,
      kIshl = 0x78,
      kLshl = 0x79,
      kIshr = 0x7a,
      kLshr = 0x7b,
      kIushr = 0x7c,
      kLushr = 0x7d,
      kIand = 0x7e,
      kLand = 0x7f,
      kIor = 0x80,
      kLor = 0x81,
      kIxor = 0x82,
      kLxor = 0x83,
      kIinc = 0x84,
      kI2l = 0x85,
      kI2f = 0x86,
      kI2d = 0x87,
      kL2i = 0x88,
      kL2f = 0x89,
      kL2d = 0x8a,
      kF2i = 0x8b,
      kF2l = 0x8c,
      kF2d = 0x8d,
      kD2i = 0x8e,
      kD2l = 0x8f,
      kD2f = 0x90,
      kI2b = 0x91,
      kI2c = 0x92,
      kI2s = 0x93,
      kLcmp = 0x94,
      kFcmpl = 0x95,
      kFcmpg = 0x96,
      kDcmpl = 0x97,
      kDcmpg = 0x98,
      kIfeq = 0x99,
      kIfne = 0x9a,
      kIflt = 0x9b,
      kIfge = 0x9c,
      kIfgt = 0x9d,
      kIfle = 0x9e,
      kIf_icmpeq = 0x9f,
      kIf_icmpne = 0xa0,
      kIf_icmplt = 0xa1,
      kIf_icmpge = 0xa2,
      kIf_icmpgt = 0xa3,
      kIf_icmple = 0xa4,
      kIf_acmpeq = 0xa5,
      kIf_acmpne = 0xa6,
      kGoto = 0xa7,
      kJsr = 0xa8,
      kRet = 0xa9,
      kTableswitch = 0xaa,
      kLookupswitch = 0xab,
      kIreturn = 0xac,
      kLreturn = 0xad,
      kFreturn = 0xae,
      kDreturn = 0xaf,
      kAreturn = 0xb0,
      kReturn = 0xb1,
      kGetstatic = 0xb2,
      kPutstatic = 0xb3,
      kGetfield = 0xb4,
      kPutfield = 0xb5,
      kInvokevirtual = 0xb6,
      kInvokespecial = 0xb7,
      kInvokestatic = 0xb8,
      kInvokeinterface = 0xb9,
      kInvokedynamic = 0xba,
      kNew = 0xbb,
      kNewarray = 0xbc,
      kAnewarray = 0xbd,
      kArraylength = 0xbe,
      kAthrow = 0xbf,
      kCheckcast = 0xc0,
      kInstanceof = 0xc1,
      kMonitorenter = 0xc2,
      kMonitorexit = 0xc3,
      kWide = 0xc4,
      kMultianewarray = 0xc5,
      kIfnull = 0xc6,
      kIfnonnull = 0xc7,
      kGoto_w = 0xc8,
      kJsr_w = 0xc9,
      kBreakpoint = 0xca,
      // Instructions 0xcb-0xfd are undefined.
          kImpdep1 = 0xfe,
      kImpdep2 = 0xff,
    };

    static const char* ToString(Bytecode::Opcode op) {
      switch (op) {
        case kNop: return "nop";
        case kAconst_null: return "aconst_null";
        case kIconst_m1: return "iconst_m1";
        case kIconst_0: return "iconst_0";
        case kIconst_1: return "iconst_1";
        case kIconst_2: return "iconst_2";
        case kIconst_3: return "iconst_3";
        case kIconst_4: return "iconst_4";
        case kIconst_5: return "iconst_5";
        case kLconst_0: return "lconst_0";
        case kLconst_1: return "lconst_1";
        case kFconst_0: return "fconst_0";
        case kFconst_1: return "fconst_1";
        case kFconst_2: return "fconst_2";
        case kDconst_0: return "dconst_0";
        case kDconst_1: return "dconst_1";
        case kBipush: return "bipush";
        case kSipush: return "sipush";
        case kLdc: return "ldc";
        case kLdc_w: return "ldc_w";
        case kLdc2_w: return "ldc2_w";
        case kIload: return "iload";
        case kLload: return "lload";
        case kFload: return "fload";
        case kDload: return "dload";
        case kAload: return "aload";
        case kIload_0: return "iload_0";
        case kIload_1: return "iload_1";
        case kIload_2: return "iload_2";
        case kIload_3: return "iload_3";
        case kLload_0: return "lload_0";
        case kLload_1: return "lload_1";
        case kLload_2: return "lload_2";
        case kLload_3: return "lload_3";
        case kFload_0: return "fload_0";
        case kFload_1: return "fload_1";
        case kFload_2: return "fload_2";
        case kFload_3: return "fload_3";
        case kDload_0: return "dload_0";
        case kDload_1: return "dload_1";
        case kDload_2: return "dload_2";
        case kDload_3: return "dload_3";
        case kAload_0: return "aload_0";
        case kAload_1: return "aload_1";
        case kAload_2: return "aload_2";
        case kAload_3: return "aload_3";
        case kIaload: return "iaload";
        case kLaload: return "laload";
        case kFaload: return "faload";
        case kDaload: return "daload";
        case kAaload: return "aaload";
        case kBaload: return "baload";
        case kCaload: return "caload";
        case kSaload: return "saload";
        case kIstore: return "istore";
        case kLstore: return "lstore";
        case kFstore: return "fstore";
        case kDstore: return "dstore";
        case kAstore: return "astore";
        case kIstore_0: return "istore_0";
        case kIstore_1: return "istore_1";
        case kIstore_2: return "istore_2";
        case kIstore_3: return "istore_3";
        case kLstore_0: return "lstore_0";
        case kLstore_1: return "lstore_1";
        case kLstore_2: return "lstore_2";
        case kLstore_3: return "lstore_3";
        case kFstore_0: return "fstore_0";
        case kFstore_1: return "fstore_1";
        case kFstore_2: return "fstore_2";
        case kFstore_3: return "fstore_3";
        case kDstore_0: return "dstore_0";
        case kDstore_1: return "dstore_1";
        case kDstore_2: return "dstore_2";
        case kDstore_3: return "dstore_3";
        case kAstore_0: return "astore_0";
        case kAstore_1: return "astore_1";
        case kAstore_2: return "astore_2";
        case kAstore_3: return "astore_3";
        case kIastore: return "iastore";
        case kLastore: return "lastore";
        case kFastore: return "fastore";
        case kDastore: return "dastore";
        case kAastore: return "aastore";
        case kBastore: return "bastore";
        case kCastore: return "castore";
        case kSastore: return "sastore";
        case kPop: return "pop";
        case kPop2: return "pop2";
        case kDup: return "dup";
        case kDup_x1: return "dup_x1";
        case kDup_x2: return "dup_x2";
        case kDup2: return "dup2";
        case kDup2_x1: return "dup2_x1";
        case kDup2_x2: return "dup2_x2";
        case kSwap: return "swap";
        case kIadd: return "iadd";
        case kLadd: return "ladd";
        case kFadd: return "fadd";
        case kDadd: return "dadd";
        case kIsub: return "isub";
        case kLsub: return "lsub";
        case kFsub: return "fsub";
        case kDsub: return "dsub";
        case kImul: return "imul";
        case kLmul: return "lmul";
        case kFmul: return "fmul";
        case kDmul: return "dmul";
        case kIdiv: return "idiv";
        case kLdiv: return "ldiv";
        case kFdiv: return "fdiv";
        case kDdiv: return "ddiv";
        case kIrem: return "irem";
        case kLrem: return "lrem";
        case kFrem: return "frem";
        case kDrem: return "drem";
        case kIneg: return "ineg";
        case kLneg: return "lneg";
        case kFneg: return "fneg";
        case kDneg: return "dneg";
        case kIshl: return "ishl";
        case kLshl: return "lshl";
        case kIshr: return "ishr";
        case kLshr: return "lshr";
        case kIushr: return "iushr";
        case kLushr: return "lushr";
        case kIand: return "iand";
        case kLand: return "land";
        case kIor: return "ior";
        case kLor: return "lor";
        case kIxor: return "ixor";
        case kLxor: return "lxor";
        case kIinc: return "iinc";
        case kI2l: return "i2l";
        case kI2f: return "i2f";
        case kI2d: return "i2d";
        case kL2i: return "l2i";
        case kL2f: return "l2f";
        case kL2d: return "l2d";
        case kF2i: return "f2i";
        case kF2l: return "f2l";
        case kF2d: return "f2d";
        case kD2i: return "d2i";
        case kD2l: return "d2l";
        case kD2f: return "d2f";
        case kI2b: return "i2b";
        case kI2c: return "i2c";
        case kI2s: return "i2s";
        case kLcmp: return "lcmp";
        case kFcmpl: return "fcmpl";
        case kFcmpg: return "fcmpg";
        case kDcmpl: return "dcmpl";
        case kDcmpg: return "dcmpg";
        case kIfeq: return "ifeq";
        case kIfne: return "ifne";
        case kIflt: return "iflt";
        case kIfge: return "ifge";
        case kIfgt: return "ifgt";
        case kIfle: return "ifle";
        case kIf_icmpeq: return "if_icmpeq";
        case kIf_icmpne: return "if_icmpne";
        case kIf_icmplt: return "if_icmplt";
        case kIf_icmpge: return "if_icmpge";
        case kIf_icmpgt: return "if_icmpgt";
        case kIf_icmple: return "if_icmple";
        case kIf_acmpeq: return "if_acmpeq";
        case kIf_acmpne: return "if_acmpne";
        case kGoto: return "goto";
        case kJsr: return "jsr";
        case kRet: return "ret";
        case kTableswitch: return "tableswitch";
        case kLookupswitch: return "lookupswitch";
        case kIreturn: return "ireturn";
        case kLreturn: return "lreturn";
        case kFreturn: return "freturn";
        case kDreturn: return "dreturn";
        case kAreturn: return "areturn";
        case kReturn: return "return";
        case kGetstatic: return "getstatic";
        case kPutstatic: return "putstatic";
        case kGetfield: return "getfield";
        case kPutfield: return "putfield";
        case kInvokevirtual: return "invokevirtual";
        case kInvokespecial: return "invokespecial";
        case kInvokestatic: return "invokestatic";
        case kInvokeinterface: return "invokeinterface";
        case kInvokedynamic: return "invokedynamic";
        case kNew: return "new";
        case kNewarray: return "newarray";
        case kAnewarray: return "anewarray";
        case kArraylength: return "arraylength";
        case kAthrow: return "athrow";
        case kCheckcast: return "checkcast";
        case kInstanceof: return "instanceof";
        case kMonitorenter: return "monitorenter";
        case kMonitorexit: return "monitorexit";
        case kWide: return "wide";
        case kMultianewarray: return "multianewarray";
        case kIfnull: return "ifnull";
        case kIfnonnull: return "ifnonnull";
        case kGoto_w: return "goto_w";
        case kJsr_w: return "jsr_w";
        case kBreakpoint: return "breakpoint";
        case kImpdep1: return "impdep1";
        case kImpdep2: return "impdep2";
        default: LOG(FATAL) << "Unknown opcode " << op;
       }
       return "";
     }
  };
};

class DexInstructionDecoder : public InstructionDecoder {
 public:
  size_t GetMaximumOpcode() override {
    return 0xff;
  }

  const char* GetName(size_t opcode) override {
    Bytecode::Opcode op = static_cast<Bytecode::Opcode>(opcode);
    return Bytecode::ToString(op);
  }

  virtual size_t LocationToOffset(size_t j_location) {
    // dex pc is uint16_t*, but offset needs to be in bytes.
    return j_location * (sizeof(uint16_t) / sizeof(uint8_t));
  }

 private:
  class Bytecode {
   public:
    enum Opcode {
#define MAKE_ENUM_DEFINITION(opcode, instruction_code, name, format, index, flags, extended_flags, verifier_flags) \
      instruction_code = opcode,
DEX_INSTRUCTION_LIST(MAKE_ENUM_DEFINITION)
#undef MAKE_ENUM_DEFINITION
    };

    static_assert(static_cast<uint32_t>(Bytecode::Opcode::NOP) == 0, "");
    static_assert(static_cast<uint32_t>(Bytecode::Opcode::MOVE) == 1, "");

    static const char* ToString(Bytecode::Opcode op) {
      switch (op) {
#define MAKE_ENUM_DEFINITION(opcode, instruction_code, name, format, index, flags, extended_flags, verifier_flags) \
        case instruction_code: return (name);
DEX_INSTRUCTION_LIST(MAKE_ENUM_DEFINITION)
#undef MAKE_ENUM_DEFINITION
        default: LOG(FATAL) << "Unknown opcode " << op;
      }
      return "";
    }
  };
};

InstructionDecoder* InstructionDecoder::NewInstance(InstructionFileFormat file_format) {
  switch (file_format) {
    case InstructionFileFormat::kClass:
      return new ClassInstructionDecoder();
    case InstructionFileFormat::kDex:
      return new DexInstructionDecoder();
    default:
      return nullptr;
  }
}
}  // namespace titrace