%def unused():
    int3

%def op_const():
    /* const vAA, #+BBBBbbbb */
    movl    2(rPC), %eax                    # grab all 32 bits at once
    SET_VREG %eax, rINSTq                   # vAA<- eax
    ADVANCE_PC_FETCH_AND_GOTO_NEXT 3

%def op_const_16():
    /* const/16 vAA, #+BBBB */
    movswl  2(rPC), %ecx                    # ecx <- ssssBBBB
    SET_VREG %ecx, rINSTq                   # vAA <- ssssBBBB
    ADVANCE_PC_FETCH_AND_GOTO_NEXT 2

%def op_const_4():
    /* const/4 vA, #+B */
    movsbl  rINSTbl, %eax                   # eax <-ssssssBx
    andl    MACRO_LITERAL(0xf), rINST       # rINST <- A
    sarl    MACRO_LITERAL(4), %eax
    SET_VREG %eax, rINSTq
    ADVANCE_PC_FETCH_AND_GOTO_NEXT 1

%def op_const_high16():
    /* const/high16 vAA, #+BBBB0000 */
    movzwl  2(rPC), %eax                    # eax <- 0000BBBB
    sall    MACRO_LITERAL(16), %eax         # eax <- BBBB0000
    SET_VREG %eax, rINSTq                   # vAA <- eax
    ADVANCE_PC_FETCH_AND_GOTO_NEXT 2

%def op_const_object(jumbo=False, helper="nterp_load_object"):
%  slow_path = add_slow_path(op_const_object_slow_path, helper)
   // Fast-path which gets the object from thread-local cache.
%  fetch_from_thread_cache("%rax", miss_label=slow_path)
   cmpq MACRO_LITERAL(0), rSELF:THREAD_READ_BARRIER_MARK_REG00_OFFSET
   jne 1f
.L${opcode}_resume:
   SET_VREG_OBJECT %eax, rINSTq            # vAA <- value
%  if jumbo:
     ADVANCE_PC_FETCH_AND_GOTO_NEXT 3
%  else:
     ADVANCE_PC_FETCH_AND_GOTO_NEXT 2
%  pass
1:
   // 00 is %rax
   call art_quick_read_barrier_mark_reg00
   jmp .L${opcode}_resume

%def op_const_object_slow_path(helper):
   EXPORT_PC
   movq rSELF:THREAD_SELF_OFFSET, %rdi
   movq 0(%rsp), %rsi
   movq rPC, %rdx
   call SYMBOL($helper)
   jmp .L${opcode}_resume

%def op_const_class():
%  op_const_object(helper="nterp_get_class")

%def op_const_method_handle():
%  op_const_object()

%def op_const_method_type():
%  op_const_object()

%def op_const_string():
   /* const/string vAA, String@BBBB */
%  op_const_object()

%def op_const_string_jumbo():
   /* const/string vAA, String@BBBBBBBB */
%  op_const_object(jumbo=True)

%def op_const_wide():
    /* const-wide vAA, #+HHHHhhhhBBBBbbbb */
    movq    2(rPC), %rax                    # rax <- HHHHhhhhBBBBbbbb
    SET_WIDE_VREG %rax, rINSTq
    ADVANCE_PC_FETCH_AND_GOTO_NEXT 5

%def op_const_wide_16():
    /* const-wide/16 vAA, #+BBBB */
    movswq  2(rPC), %rax                    # rax <- ssssssssssssBBBB
    SET_WIDE_VREG %rax, rINSTq              # store
    ADVANCE_PC_FETCH_AND_GOTO_NEXT 2

%def op_const_wide_32():
    /* const-wide/32 vAA, #+BBBBbbbb */
    movslq   2(rPC), %rax                   # eax <- ssssssssBBBBbbbb
    SET_WIDE_VREG %rax, rINSTq              # store
    ADVANCE_PC_FETCH_AND_GOTO_NEXT 3

%def op_const_wide_high16():
    /* const-wide/high16 vAA, #+BBBB000000000000 */
    movzwq  2(rPC), %rax                    # eax <- 000000000000BBBB
    salq    $$48, %rax                      # eax <- 00000000BBBB0000
    SET_WIDE_VREG %rax, rINSTq              # v[AA+0] <- eax
    ADVANCE_PC_FETCH_AND_GOTO_NEXT 2

%def op_monitor_enter():
/*
 * Synchronize on an object.
 */
    /* monitor-enter vAA */
    EXPORT_PC
    GET_VREG %edi, rINSTq
    call art_quick_lock_object
    ADVANCE_PC_FETCH_AND_GOTO_NEXT 1

%def op_monitor_exit():
/*
 * Unlock an object.
 *
 * Exceptions that occur when unlocking a monitor need to appear as
 * if they happened at the following instruction.  See the Dalvik
 * instruction spec.
 */
    /* monitor-exit vAA */
    EXPORT_PC
    GET_VREG %edi, rINSTq
    call art_quick_unlock_object
    ADVANCE_PC_FETCH_AND_GOTO_NEXT 1

%def op_move(is_object=False):
    /* for move, move-object, long-to-int */
    /* op vA, vB */
    movl    rINST, %eax                     # eax <- BA
    andb    $$0xf, %al                      # eax <- A
    shrl    $$4, rINST                      # rINST <- B
    GET_VREG %edx, rINSTq
%   if is_object:
      SET_VREG_OBJECT %edx, %rax            # fp[A] <- fp[B]
%   else:
      SET_VREG %edx, %rax                   # fp[A] <- fp[B]
    ADVANCE_PC_FETCH_AND_GOTO_NEXT 1

%def op_move_16(is_object=False):
    /* for: move/16, move-object/16 */
    /* op vAAAA, vBBBB */
    movzwq  4(rPC), %rcx                    # ecx <- BBBB
    movzwq  2(rPC), %rax                    # eax <- AAAA
    GET_VREG %edx, %rcx
%   if is_object:
      SET_VREG_OBJECT %edx, %rax            # fp[A] <- fp[B]
%   else:
      SET_VREG %edx, %rax                   # fp[A] <- fp[B]
    ADVANCE_PC_FETCH_AND_GOTO_NEXT 3

%def op_move_exception():
    /* move-exception vAA */
    movl    rSELF:THREAD_EXCEPTION_OFFSET, %eax
    SET_VREG_OBJECT %eax, rINSTq            # fp[AA] <- exception object
    movl    $$0, rSELF:THREAD_EXCEPTION_OFFSET
    ADVANCE_PC_FETCH_AND_GOTO_NEXT 1

%def op_move_from16(is_object=False):
    /* for: move/from16, move-object/from16 */
    /* op vAA, vBBBB */
    movzwq  2(rPC), %rax                    # eax <- BBBB
    GET_VREG %edx, %rax                     # edx <- fp[BBBB]
%   if is_object:
      SET_VREG_OBJECT %edx, rINSTq          # fp[A] <- fp[B]
%   else:
      SET_VREG %edx, rINSTq                 # fp[A] <- fp[B]
    ADVANCE_PC_FETCH_AND_GOTO_NEXT 2

%def op_move_object():
%  op_move(is_object=True)

%def op_move_object_16():
%  op_move_16(is_object=True)

%def op_move_object_from16():
%  op_move_from16(is_object=True)

%def op_move_result(is_object=False):
    /* for: move-result, move-result-object */
    /* op vAA */
%   if is_object:
      SET_VREG_OBJECT %eax, rINSTq          # fp[A] <- fp[B]
%   else:
      SET_VREG %eax, rINSTq                 # fp[A] <- fp[B]
    ADVANCE_PC_FETCH_AND_GOTO_NEXT 1

%def op_move_result_object():
%  op_move_result(is_object=True)

%def op_move_result_wide():
    /* move-result-wide vAA */
    SET_WIDE_VREG %rax, rINSTq                   # v[AA] <- rdx
    ADVANCE_PC_FETCH_AND_GOTO_NEXT 1

%def op_move_wide():
    /* move-wide vA, vB */
    /* NOTE: regs can overlap, e.g. "move v6,v7" or "move v7,v6" */
    movl    rINST, %ecx                     # ecx <- BA
    sarl    $$4, rINST                      # rINST <- B
    andb    $$0xf, %cl                      # ecx <- A
    GET_WIDE_VREG %rdx, rINSTq              # rdx <- v[B]
    SET_WIDE_VREG %rdx, %rcx                # v[A] <- rdx
    ADVANCE_PC_FETCH_AND_GOTO_NEXT 1

%def op_move_wide_16():
    /* move-wide/16 vAAAA, vBBBB */
    /* NOTE: regs can overlap, e.g. "move v6,v7" or "move v7,v6" */
    movzwq  4(rPC), %rcx                    # ecx<- BBBB
    movzwq  2(rPC), %rax                    # eax<- AAAA
    GET_WIDE_VREG %rdx, %rcx                # rdx <- v[B]
    SET_WIDE_VREG %rdx, %rax                # v[A] <- rdx
    ADVANCE_PC_FETCH_AND_GOTO_NEXT 3

%def op_move_wide_from16():
    /* move-wide/from16 vAA, vBBBB */
    /* NOTE: regs can overlap, e.g. "move v6,v7" or "move v7,v6" */
    movzwl  2(rPC), %ecx                    # ecx <- BBBB
    GET_WIDE_VREG %rdx, %rcx                # rdx <- v[B]
    SET_WIDE_VREG %rdx, rINSTq              # v[A] <- rdx
    ADVANCE_PC_FETCH_AND_GOTO_NEXT 2

%def op_nop():
    ADVANCE_PC_FETCH_AND_GOTO_NEXT 1

%def op_unused_3e():
%  unused()

%def op_unused_3f():
%  unused()

%def op_unused_40():
%  unused()

%def op_unused_41():
%  unused()

%def op_unused_42():
%  unused()

%def op_unused_43():
%  unused()

%def op_unused_73():
%  unused()

%def op_unused_79():
%  unused()

%def op_unused_7a():
%  unused()

%def op_unused_e3():
%  unused()

%def op_unused_e4():
%  unused()

%def op_unused_e5():
%  unused()

%def op_unused_e6():
%  unused()

%def op_unused_e7():
%  unused()

%def op_unused_e8():
%  unused()

%def op_unused_e9():
%  unused()

%def op_unused_ea():
%  unused()

%def op_unused_eb():
%  unused()

%def op_unused_ec():
%  unused()

%def op_unused_ed():
%  unused()

%def op_unused_ee():
%  unused()

%def op_unused_ef():
%  unused()

%def op_unused_f0():
%  unused()

%def op_unused_f1():
%  unused()

%def op_unused_f2():
%  unused()

%def op_unused_f3():
%  unused()

%def op_unused_f4():
%  unused()

%def op_unused_f5():
%  unused()

%def op_unused_f6():
%  unused()

%def op_unused_f7():
%  unused()

%def op_unused_f8():
%  unused()

%def op_unused_f9():
%  unused()

%def op_unused_fc():
%  unused()

%def op_unused_fd():
%  unused()