repo_id string | size int64 | file_path string | content string |
|---|---|---|---|
anestisb/oatdump_plus | 1,475 | runtime/interpreter/mterp/arm/op_shl_long.S | /*
* Long integer shift. This is different from the generic 32/64-bit
* binary operations because vAA/vBB are 64-bit but vCC (the shift
* distance) is 32-bit. Also, Dalvik requires us to mask off the low
* 6 bits of the shift distance.
*/
/* shl-long vAA, vBB, vCC */
FETCH r0, 1 ... |
anestisb/oatdump_plus | 2,605 | runtime/interpreter/mterp/arm/entry.S | /*
* Copyright (C) 2016 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 app... |
anestisb/oatdump_plus | 1,599 | runtime/interpreter/mterp/arm/binop2addr.S | %default {"preinstr":"", "result":"r0", "chkzero":"0"}
/*
* Generic 32-bit "/2addr" binary operation. Provide an "instr" line
* that specifies an instruction that performs "result = r0 op r1".
* This could be an ARM instruction or a function call. (If the result
* comes back in a register othe... |
anestisb/oatdump_plus | 9,736 | runtime/interpreter/mterp/arm/header.S | /*
* Copyright (C) 2016 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 app... |
anestisb/oatdump_plus | 1,512 | runtime/interpreter/mterp/arm/op_aput.S | %default { "store":"str", "shift":"2", "data_offset":"MIRROR_INT_ARRAY_DATA_OFFSET" }
/*
* Array put, 32 bits or less. vBB[vCC] <- vAA.
*
* Note: using the usual FETCH/and/shift stuff, this fits in exactly 17
* instructions. We use a pair of FETCH_Bs instead.
*
* for: aput, aput-bool... |
anestisb/oatdump_plus | 1,279 | runtime/interpreter/mterp/arm/op_rem_int.S | %default {}
/*
* Specialized 32-bit binary operation
*
* Performs "r1 = r0 rem r1". The selection between sdiv block or the gcc helper
* depends on the compile time value of __ARM_ARCH_EXT_IDIV__ (defined for
* ARMv7 CPUs that have hardware division support).
*
* NOTE: idivmod ret... |
anestisb/oatdump_plus | 1,037 | runtime/interpreter/mterp/arm/op_instance_of.S | /*
* Check to see if an object reference is an instance of a class.
*
* Most common situation is a non-null object, being compared against
* an already-resolved class.
*/
/* instance-of vA, vB, class@CCCC */
EXPORT_PC
FETCH r0, 1 @ r0<- CCCC
mov ... |
anestisb/oatdump_plus | 1,186 | runtime/interpreter/mterp/arm/op_rem_int_lit16.S | %default {}
/*
* Specialized 32-bit binary operation
*
* Performs "r1 = r0 rem r1". The selection between sdiv block or the gcc helper
* depends on the compile time value of __ARM_ARCH_EXT_IDIV__ (defined for
* ARMv7 CPUs that have hardware division support).
*
* NOTE: idivmod ret... |
anestisb/oatdump_plus | 1,163 | runtime/interpreter/mterp/arm/op_shr_long_2addr.S | /*
* Long integer shift, 2addr version. vA is 64-bit value/result, vB is
* 32-bit shift distance.
*/
/* shr-long/2addr vA, vB */
mov r3, rINST, lsr #12 @ r3<- B
ubfx r9, rINST, #8, #4 @ r9<- A
GET_VREG r2, r3 @ r2<- vB
CLEAR_SHADOW_PA... |
anestisb/oatdump_plus | 1,046 | runtime/interpreter/mterp/arm/op_iget.S | %default { "is_object":"0", "helper":"artGet32InstanceFromCode"}
/*
* General instance field get.
*
* for: iget, iget-object, iget-boolean, iget-byte, iget-char, iget-short
*/
EXPORT_PC
FETCH r0, 1 @ r0<- field ref CCCC
mov r1, rINST, lsr #12 ... |
anestisb/oatdump_plus | 1,065 | runtime/interpreter/mterp/arm/op_div_int_2addr.S | %default {}
/*
* Specialized 32-bit binary operation
*
* Performs "r0 = r0 div r1". The selection between sdiv or the gcc helper
* depends on the compile time value of __ARM_ARCH_EXT_IDIV__ (defined for
* ARMv7 CPUs that have hardware division support).
*
* div-int/2addr
*
... |
anestisb/oatdump_plus | 1,166 | runtime/interpreter/mterp/arm/op_ushr_long_2addr.S | /*
* Long integer shift, 2addr version. vA is 64-bit value/result, vB is
* 32-bit shift distance.
*/
/* ushr-long/2addr vA, vB */
mov r3, rINST, lsr #12 @ r3<- B
ubfx r9, rINST, #8, #4 @ r9<- A
GET_VREG r2, r3 @ r2<- vB
CLEAR_SHADOW_P... |
anestisb/oatdump_plus | 1,093 | runtime/interpreter/mterp/arm/unopWide.S | %default {"preinstr":""}
/*
* Generic 64-bit unary operation. Provide an "instr" line that
* specifies an instruction that performs "result = op r0/r1".
* This could be an ARM instruction or a function call.
*
* For: neg-long, not-long, neg-double, long-to-double, double-to-long
*/
... |
anestisb/oatdump_plus | 1,404 | runtime/interpreter/mterp/arm/op_cmpg_float.S | /*
* Compare two floating-point values. Puts 0, 1, or -1 into the
* destination register based on the results of the comparison.
*
* int compare(x, y) {
* if (x == y) {
* return 0;
* } else if (x < y) {
* return -1;
* } else if (x > y) {
... |
anestisb/oatdump_plus | 1,071 | runtime/interpreter/mterp/arm/unopNarrower.S | %default {"preinstr":""}
/*
* Generic 64bit-to-32bit unary operation. Provide an "instr" line
* that specifies an instruction that performs "result = op r0/r1", where
* "result" is a 32-bit quantity in r0.
*
* For: long-to-float, double-to-int, double-to-float
*
* (This would wor... |
anestisb/oatdump_plus | 1,029 | runtime/interpreter/mterp/arm/unopWider.S | %default {"preinstr":""}
/*
* Generic 32bit-to-64bit unary operation. Provide an "instr" line
* that specifies an instruction that performs "result = op r0", where
* "result" is a 64-bit quantity in r0/r1.
*
* For: int-to-long, int-to-double, float-to-long, float-to-double
*/
/* u... |
anestisb/oatdump_plus | 1,782 | runtime/interpreter/mterp/arm/binopLit8.S | %default {"extract":"asr r1, r3, #8", "result":"r0", "chkzero":"0"}
/*
* Generic 32-bit "lit8" binary operation. Provide an "instr" line
* that specifies an instruction that performs "result = r0 op r1".
* This could be an ARM instruction or a function call. (If the result
* comes back in ... |
anestisb/oatdump_plus | 1,104 | runtime/interpreter/mterp/arm/fbinop.S | /*
* Generic 32-bit floating-point operation. Provide an "instr" line that
* specifies an instruction that performs "s2 = s0 op s1". Because we
* use the "softfp" ABI, this must be an instruction, not a function call.
*
* For: add-float, sub-float, mul-float, div-float
*/
/* floa... |
anestisb/oatdump_plus | 1,165 | runtime/interpreter/mterp/arm/op_rem_int_2addr.S | %default {}
/*
* Specialized 32-bit binary operation
*
* Performs "r1 = r0 rem r1". The selection between sdiv block or the gcc helper
* depends on the compile time value of __ARM_ARCH_EXT_IDIV__ (defined for
* ARMv7 CPUs that have hardware division support).
*
* NOTE: idivmod ret... |
anestisb/oatdump_plus | 1,374 | runtime/interpreter/mterp/arm/binopLit16.S | %default {"result":"r0", "chkzero":"0"}
/*
* Generic 32-bit "lit16" binary operation. Provide an "instr" line
* that specifies an instruction that performs "result = r0 op r1".
* This could be an ARM instruction or a function call. (If the result
* comes back in a register other than r0, you c... |
anestisb/oatdump_plus | 1,164 | runtime/interpreter/mterp/arm/op_shl_long_2addr.S | /*
* Long integer shift, 2addr version. vA is 64-bit value/result, vB is
* 32-bit shift distance.
*/
/* shl-long/2addr vA, vB */
mov r3, rINST, lsr #12 @ r3<- B
ubfx r9, rINST, #8, #4 @ r9<- A
GET_VREG r2, r3 @ r2<- vB
CLEAR_SHADOW_PA... |
anestisb/oatdump_plus | 1,086 | runtime/interpreter/mterp/arm/op_div_int_lit16.S | %default {}
/*
* Specialized 32-bit binary operation
*
* Performs "r0 = r0 div r1". The selection between sdiv or the gcc helper
* depends on the compile time value of __ARM_ARCH_EXT_IDIV__ (defined for
* ARMv7 CPUs that have hardware division support).
*
* div-int/lit16
*
... |
anestisb/oatdump_plus | 1,106 | runtime/interpreter/mterp/arm/fbinopWide.S | /*
* Generic 64-bit double-precision floating point binary operation.
* Provide an "instr" line that specifies an instruction that performs
* "d2 = d0 op d1".
*
* for: add-double, sub-double, mul-double, div-double
*/
/* doubleop vAA, vBB, vCC */
FETCH r0, 1 ... |
anestisb/oatdump_plus | 1,366 | runtime/interpreter/mterp/arm/op_aget_wide.S | /*
* Array get, 64 bits. vAA <- vBB[vCC].
*
* Arrays of long/double are 64-bit aligned, so it's okay to use LDRD.
*/
/* aget-wide vAA, vBB, vCC */
FETCH r0, 1 @ r0<- CCBB
mov r9, rINST, lsr #8 @ r9<- AA
and r2, r0, #255 @ ... |
anestisb/oatdump_plus | 1,297 | runtime/interpreter/mterp/arm/op_double_to_long.S | %include "arm/unopWide.S" {"instr":"bl d2l_doconv"}
%break
/*
* Convert the double in r0/r1 to a long in r0/r1.
*
* We have to clip values to long min/max per the specification. The
* expected common case is a "reasonable" value that converts directly
* to modest integer. The EABI convert function isn't do... |
anestisb/oatdump_plus | 1,166 | runtime/interpreter/mterp/arm/op_div_int_lit8.S | %default {}
/*
* Specialized 32-bit binary operation
*
* Performs "r0 = r0 div r1". The selection between sdiv or the gcc helper
* depends on the compile time value of __ARM_ARCH_EXT_IDIV__ (defined for
* ARMv7 CPUs that have hardware division support).
*
* div-int/lit8
*
... |
anestisb/oatdump_plus | 1,781 | runtime/interpreter/mterp/arm/binopWide2addr.S | %default {"preinstr":"", "result0":"r0", "result1":"r1", "chkzero":"0"}
/*
* Generic 64-bit "/2addr" binary operation. Provide an "instr" line
* that specifies an instruction that performs "result = r0-r1 op r2-r3".
* This could be an ARM instruction or a function call. (If the result
* comes ... |
anestisb/oatdump_plus | 1,937 | runtime/interpreter/mterp/arm/binopWide.S | %default {"preinstr":"", "result0":"r0", "result1":"r1", "chkzero":"0"}
/*
* Generic 64-bit binary operation. Provide an "instr" line that
* specifies an instruction that performs "result = r0-r1 op r2-r3".
* This could be an ARM instruction or a function call. (If the result
* comes back in a... |
anestisb/oatdump_plus | 1,254 | runtime/interpreter/mterp/arm/op_float_to_long.S | %include "arm/unopWider.S" {"instr":"bl f2l_doconv"}
%break
/*
* Convert the float in r0 to a long in r0/r1.
*
* We have to clip values to long min/max per the specification. The
* expected common case is a "reasonable" value that converts directly
* to modest integer. The EABI convert function isn't doing... |
anestisb/oatdump_plus | 1,408 | runtime/interpreter/mterp/arm/op_cmpl_double.S | /*
* Compare two floating-point values. Puts 0, 1, or -1 into the
* destination register based on the results of the comparison.
*
* int compare(x, y) {
* if (x == y) {
* return 0;
* } else if (x > y) {
* return 1;
* } else if (x < y) {
... |
anestisb/oatdump_plus | 1,299 | runtime/interpreter/mterp/arm/op_aput_wide.S | /*
* Array put, 64 bits. vBB[vCC] <- vAA.
*
* Arrays of long/double are 64-bit aligned, so it's okay to use STRD.
*/
/* aput-wide vAA, vBB, vCC */
FETCH r0, 1 @ r0<- CCBB
mov r9, rINST, lsr #8 @ r9<- AA
and r2, r0, #255 @ ... |
anestisb/oatdump_plus | 1,577 | runtime/interpreter/mterp/arm/op_mul_long.S | /*
* Signed 64-bit integer multiply.
*
* Consider WXxYZ (r1r0 x r3r2) with a long multiply:
* WX
* x YZ
* --------
* ZW ZX
* YW YX
*
* The low word of the result holds ZX, the high word holds
* (ZW+YX) + (the high overflow from ZX). YW doesn'... |
anestisb/oatdump_plus | 1,165 | runtime/interpreter/mterp/arm/op_mul_long_2addr.S | /*
* Signed 64-bit integer multiply, "/2addr" version.
*
* See op_mul_long for an explanation.
*
* We get a little tight on registers, so to avoid looking up &fp[A]
* again we stuff it into rINST.
*/
/* mul-long/2addr vA, vB */
mov r1, rINST, lsr #12 @ r1<- B
... |
anestisb/oatdump_plus | 1,164 | runtime/interpreter/mterp/arm/op_div_int.S | %default {}
/*
* Specialized 32-bit binary operation
*
* Performs "r0 = r0 div r1". The selection between sdiv or the gcc helper
* depends on the compile time value of __ARM_ARCH_EXT_IDIV__ (defined for
* ARMv7 CPUs that have hardware division support).
*
* div-int
*
*/
... |
anestisb/oatdump_plus | 1,477 | runtime/interpreter/mterp/arm/op_ushr_long.S | /*
* Long integer shift. This is different from the generic 32/64-bit
* binary operations because vAA/vBB are 64-bit but vCC (the shift
* distance) is 32-bit. Also, Dalvik requires us to mask off the low
* 6 bits of the shift distance.
*/
/* ushr-long vAA, vBB, vCC */
FETCH r0, 1 ... |
anestisb/oatdump_plus | 11,114 | runtime/interpreter/mterp/arm64/footer.S | /*
* ===========================================================================
* Common subroutines and data
* ===========================================================================
*/
/*
* We've detected a condition that will result in an exception, but the exception
* has not yet been thrown. Just ba... |
anestisb/oatdump_plus | 1,476 | runtime/interpreter/mterp/arm64/op_aget.S | %default { "load":"ldr", "shift":"2", "data_offset":"MIRROR_INT_ARRAY_DATA_OFFSET" }
/*
* Array get, 32 bits or less. vAA <- vBB[vCC].
*
* Note: using the usual FETCH/and/shift stuff, this fits in exactly 17
* instructions. We use a pair of FETCH_Bs instead.
*
* for: aget, aget-boole... |
anestisb/oatdump_plus | 1,680 | runtime/interpreter/mterp/arm64/binop.S | %default {"preinstr":"", "result":"w0", "chkzero":"0"}
/*
* Generic 32-bit binary operation. Provide an "instr" line that
* specifies an instruction that performs "result = w0 op w1".
* This could be an ARM instruction or a function call. (If the result
* comes back in a register other than w0... |
anestisb/oatdump_plus | 2,512 | runtime/interpreter/mterp/arm64/entry.S | /*
* Copyright (C) 2016 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 app... |
anestisb/oatdump_plus | 1,546 | runtime/interpreter/mterp/arm64/binop2addr.S | %default {"preinstr":"", "result":"w0", "chkzero":"0"}
/*
* Generic 32-bit "/2addr" binary operation. Provide an "instr" line
* that specifies an instruction that performs "result = w0 op w1".
* This could be an ARM instruction or a function call. (If the result
* comes back in a register othe... |
anestisb/oatdump_plus | 10,342 | runtime/interpreter/mterp/arm64/header.S | /*
* Copyright (C) 2016 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 app... |
anestisb/oatdump_plus | 1,469 | runtime/interpreter/mterp/arm64/op_aput.S | %default { "store":"str", "shift":"2", "data_offset":"MIRROR_INT_ARRAY_DATA_OFFSET" }
/*
* Array put, 32 bits or less. vBB[vCC] <- vAA.
*
* Note: using the usual FETCH/and/shift stuff, this fits in exactly 17
* instructions. We use a pair of FETCH_Bs instead.
*
* for: aput, aput-bool... |
anestisb/oatdump_plus | 1,062 | runtime/interpreter/mterp/arm64/op_iget.S | %default { "extend":"", "is_object":"0", "helper":"artGet32InstanceFromCode"}
/*
* General instance field get.
*
* for: iget, iget-object, iget-boolean, iget-byte, iget-char, iget-short
*/
EXPORT_PC
FETCH w0, 1 // w0<- field ref CCCC
lsr w1, wINST, #12... |
anestisb/oatdump_plus | 1,825 | runtime/interpreter/mterp/arm64/binopLit8.S | %default {"extract": "asr w1, w3, #8", "preinstr":"", "result":"w0", "chkzero":"0"}
/*
* Generic 32-bit "lit8" binary operation. Provide an "instr" line
* that specifies an instruction that performs "result = w0 op w1".
* This could be an ARM instruction or a function call. (If the result
... |
anestisb/oatdump_plus | 1,349 | runtime/interpreter/mterp/arm64/binopLit16.S | %default {"preinstr":"", "result":"w0", "chkzero":"0"}
/*
* Generic 32-bit "lit16" binary operation. Provide an "instr" line
* that specifies an instruction that performs "result = w0 op w1".
* This could be an ARM instruction or a function call. (If the result
* comes back in a register other... |
anestisb/oatdump_plus | 1,089 | runtime/interpreter/mterp/arm64/op_aget_wide.S | /*
* Array get, 64 bits. vAA <- vBB[vCC].
*
*/
/* aget-wide vAA, vBB, vCC */
FETCH w0, 1 // w0<- CCBB
lsr w4, wINST, #8 // w4<- AA
and w2, w0, #255 // w2<- BB
lsr w3, w0, #8 // w3<- CC
GET_VREG ... |
anestisb/oatdump_plus | 1,413 | runtime/interpreter/mterp/arm64/binopWide2addr.S | %default {"preinstr":"", "instr":"add x0, x0, x1", "r0":"x0", "r1":"x1", "chkzero":"0"}
/*
* Generic 64-bit "/2addr" binary operation. Provide an "instr" line
* that specifies an instruction that performs "x0 = x0 op x1".
* This must not be a function call, as we keep w2 live across it.
*
... |
anestisb/oatdump_plus | 1,522 | runtime/interpreter/mterp/arm64/binopWide.S | %default {"preinstr":"", "instr":"add x0, x1, x2", "result":"x0", "r1":"x1", "r2":"x2", "chkzero":"0"}
/*
* Generic 64-bit binary operation. Provide an "instr" line that
* specifies an instruction that performs "result = x1 op x2".
* This could be an ARM instruction or a function call. (If the resu... |
anestisb/oatdump_plus | 1,070 | runtime/interpreter/mterp/arm64/op_aput_wide.S | /*
* Array put, 64 bits. vBB[vCC] <- vAA.
*
*/
/* aput-wide vAA, vBB, vCC */
FETCH w0, 1 // w0<- CCBB
lsr w4, wINST, #8 // w4<- AA
and w2, w0, #255 // w2<- BB
lsr w3, w0, #8 // w3<- CC
GET_VREG ... |
anestisb/oatdump_plus | 1,149 | runtime/interpreter/mterp/x86/op_shr_long.S | /*
* Long integer shift. This is different from the generic 32/64-bit
* binary operations because vAA/vBB are 64-bit but vCC (the shift
* distance) is 32-bit. Also, Dalvik requires us to mask off the low
* 6 bits of the shift distance. x86 shifts automatically mask off
* the low 5 bits of %cl, so have to handle... |
anestisb/oatdump_plus | 9,998 | runtime/interpreter/mterp/x86/footer.S | /*
* ===========================================================================
* Common subroutines and data
* ===========================================================================
*/
.text
.align 2
/*
* We've detected a condition that will result in an exception, but the exception
* has not y... |
anestisb/oatdump_plus | 1,142 | runtime/interpreter/mterp/x86/op_shl_long.S | /*
* Long integer shift. This is different from the generic 32/64-bit
* binary operations because vAA/vBB are 64-bit but vCC (the shift
* distance) is 32-bit. Also, Dalvik requires us to mask off the low
* 6 bits of the shift distance. x86 shifts automatically mask off
* the low 5 bits of %cl, so have to handle... |
anestisb/oatdump_plus | 2,156 | runtime/interpreter/mterp/x86/entry.S | /*
* Copyright (C) 2016 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 app... |
anestisb/oatdump_plus | 9,367 | runtime/interpreter/mterp/x86/header.S | /*
* Copyright (C) 2016 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 app... |
anestisb/oatdump_plus | 1,125 | runtime/interpreter/mterp/x86/op_iget.S | %default { "is_object":"0", "helper":"artGet32InstanceFromCode"}
/*
* General instance field get.
*
* for: iget, iget-object, iget-boolean, iget-byte, iget-char, iget-short
*/
EXPORT_PC
movzwl 2(rPC), %eax # eax <- 0000CCCC
movl %eax, OUT_ARG0(%esp) # field ref CCCC
... |
anestisb/oatdump_plus | 2,083 | runtime/interpreter/mterp/x86/cvtfp_int.S | %default {"srcdouble":"1","tgtlong":"1"}
/* On fp to int conversions, Java requires that
* if the result > maxint, it should be clamped to maxint. If it is less
* than minint, it should be clamped to minint. If it is a nan, the result
* should be zero. Further, the rounding mode is to truncate. This model
* dif... |
anestisb/oatdump_plus | 1,709 | runtime/interpreter/mterp/x86/bindiv.S | %default {"result":"","special":"","rem":""}
/*
* 32-bit binary div/rem operation. Handles special case of op0=minint and
* op1=-1.
*/
/* div/rem vAA, vBB, vCC */
movzbl 2(rPC), %eax # eax <- BB
movzbl 3(rPC), %ecx # ecx <- CC
GET_VREG %eax, %eax ... |
anestisb/oatdump_plus | 1,625 | runtime/interpreter/mterp/x86/op_mul_long.S | /*
* Signed 64-bit integer multiply.
*
* We could definately use more free registers for
* this code. We spill rINSTw (ebx),
* giving us eax, ebc, ecx and edx as computational
* temps. On top of that, we'll spill edi (rFP)
* for use as the vB pointer and esi (rPC) for use
* as the vC pointer. Yuck.
*
*/
... |
anestisb/oatdump_plus | 1,831 | runtime/interpreter/mterp/x86/op_mul_long_2addr.S | /*
* Signed 64-bit integer multiply, 2-addr version
*
* We could definately use more free registers for
* this code. We must spill %edx (rIBASE) because it
* is used by imul. We'll also spill rINST (ebx),
* giving us eax, ebc, ecx and rIBASE as computational
* temps. On top of that, we'll spill %esi (edi)
* ... |
anestisb/oatdump_plus | 1,152 | runtime/interpreter/mterp/x86/op_ushr_long.S | /*
* Long integer shift. This is different from the generic 32/64-bit
* binary operations because vAA/vBB are 64-bit but vCC (the shift
* distance) is 32-bit. Also, Dalvik requires us to mask off the low
* 6 bits of the shift distance. x86 shifts automatically mask off
* the low 5 bits of %cl, so have to handle... |
anestisb/oatdump_plus | 9,198 | runtime/interpreter/mterp/x86_64/footer.S | /*
* ===========================================================================
* Common subroutines and data
* ===========================================================================
*/
.text
.align 2
/*
* We've detected a condition that will result in an exception, but the exception
* has not y... |
anestisb/oatdump_plus | 2,059 | runtime/interpreter/mterp/x86_64/entry.S | /*
* Copyright (C) 2016 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 app... |
anestisb/oatdump_plus | 8,676 | runtime/interpreter/mterp/x86_64/header.S | /*
* Copyright (C) 2016 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 app... |
anestisb/oatdump_plus | 1,047 | runtime/interpreter/mterp/x86_64/op_iget.S | %default { "is_object":"0", "helper":"artGet32InstanceFromCode", "wide":"0"}
/*
* General instance field get.
*
* for: iget, iget-object, iget-boolean, iget-byte, iget-char, iget-short, iget-wide
*/
EXPORT_PC
movzbq rINSTbl, %rcx # rcx <- BA
movzwl 2(rPC), OUT_32_ARG0 # e... |
anestisb/oatdump_plus | 1,142 | runtime/interpreter/mterp/x86_64/bindiv2addr.S | %default {"result":"","second":"","wide":"","suffix":"","rem":"0","ext":"cdq"}
/*
* 32-bit binary div/rem operation. Handles special case of op1=-1.
*/
/* div/rem/2addr vA, vB */
movl rINST, %ecx # rcx <- BA
sarl $$4, %ecx # rcx <- B
andb $$0xf, rINS... |
anestisb/oatdump_plus | 1,052 | runtime/interpreter/mterp/x86_64/cvtfp_int.S | %default {"fp_suffix":"","i_suffix":"","max_const":"","result_reg":"","wide":""}
/* On fp to int conversions, Java requires that
* if the result > maxint, it should be clamped to maxint. If it is less
* than minint, it should be clamped to minint. If it is a nan, the result
* should be zero. Further, the rounding... |
anestisb/oatdump_plus | 1,087 | runtime/interpreter/mterp/x86_64/bindiv.S | %default {"result":"","second":"","wide":"","suffix":"","rem":"0","ext":"cdq"}
/*
* 32-bit binary div/rem operation. Handles special case of op1=-1.
*/
/* div/rem vAA, vBB, vCC */
movzbq 2(rPC), %rax # rax <- BB
movzbq 3(rPC), %rcx # rcx <- CC
.if $wide
GET... |
anestisb/oatdump_plus | 1,789 | runtime/interpreter/mterp/mips/op_cmpl_float.S | %default { "gt_bias":"0" }
/*
* Compare two floating-point values. Puts 0(==), 1(>), or -1(<)
* into the destination register based on the comparison results.
*
* for: cmpl-float, cmpg-float
*/
/* op vAA, vBB, vCC */
FETCH(a0, 1) # a0 <- CCBB
and ... |
anestisb/oatdump_plus | 1,533 | runtime/interpreter/mterp/mips/op_shr_long.S | /*
* Long integer shift. This is different from the generic 32/64-bit
* binary operations because vAA/vBB are 64-bit but vCC (the shift
* distance) is 32-bit. Also, Dalvik requires us to mask off the low
* 6 bits of the shift distance.
*/
/* shr-long vAA, vBB, vCC */
FETCH(a0, 1) ... |
anestisb/oatdump_plus | 9,747 | runtime/interpreter/mterp/mips/footer.S | /*
* ===========================================================================
* Common subroutines and data
* ===========================================================================
*/
.text
.align 2
/*
* We've detected a condition that will result in an exception, but the exception
* has not ye... |
anestisb/oatdump_plus | 1,507 | runtime/interpreter/mterp/mips/op_cmp_long.S | /*
* Compare two 64-bit values
* x = y return 0
* x < y return -1
* x > y return 1
*
* I think I can improve on the ARM code by the following observation
* slt t0, x.hi, y.hi; # (x.hi < y.hi) ? 1:0
* sgt t1, x.hi, y.hi; # (y.hi... |
anestisb/oatdump_plus | 1,418 | runtime/interpreter/mterp/mips/op_aget.S | %default { "load":"lw", "shift":"2", "data_offset":"MIRROR_INT_ARRAY_DATA_OFFSET" }
/*
* Array get, 32 bits or less. vAA <- vBB[vCC].
*
* Note: using the usual FETCH/and/shift stuff, this fits in exactly 17
* instructions. We use a pair of FETCH_Bs instead.
*
* for: aget, aget-boolea... |
anestisb/oatdump_plus | 1,530 | runtime/interpreter/mterp/mips/binop.S | %default {"preinstr":"", "result":"a0", "chkzero":"0"}
/*
* Generic 32-bit binary operation. Provide an "instr" line that
* specifies an instruction that performs "result = a0 op a1".
* This could be a MIPS instruction or a function call. (If the result
* comes back in a register other than a0... |
anestisb/oatdump_plus | 1,482 | runtime/interpreter/mterp/mips/op_shl_long.S | /*
* Long integer shift. This is different from the generic 32/64-bit
* binary operations because vAA/vBB are 64-bit but vCC (the shift
* distance) is 32-bit. Also, Dalvik requires us to mask off the low
* 6 bits of the shift distance.
*/
/* shl-long vAA, vBB, vCC */
FETCH(a0, 1) ... |
anestisb/oatdump_plus | 2,500 | runtime/interpreter/mterp/mips/entry.S | /*
* Copyright (C) 2016 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 app... |
anestisb/oatdump_plus | 1,305 | runtime/interpreter/mterp/mips/binop2addr.S | %default {"preinstr":"", "result":"a0", "chkzero":"0"}
/*
* Generic 32-bit "/2addr" binary operation. Provide an "instr" line
* that specifies an instruction that performs "result = a0 op a1".
* This could be an MIPS instruction or a function call.
*
* If "chkzero" is set to 1, we perform ... |
anestisb/oatdump_plus | 20,332 | runtime/interpreter/mterp/mips/header.S | /*
* Copyright (C) 2016 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 app... |
anestisb/oatdump_plus | 1,343 | runtime/interpreter/mterp/mips/op_aput.S | %default { "store":"sw", "shift":"2", "data_offset":"MIRROR_INT_ARRAY_DATA_OFFSET" }
/*
* Array put, 32 bits or less. vBB[vCC] <- vAA.
*
* for: aput, aput-boolean, aput-byte, aput-char, aput-short
*
* NOTE: this assumes data offset for arrays is the same for all non-wide types.
* If ... |
anestisb/oatdump_plus | 1,262 | runtime/interpreter/mterp/mips/op_shr_long_2addr.S | /*
* Long integer shift, 2addr version. vA is 64-bit value/result, vB is
* 32-bit shift distance.
*/
/* shr-long/2addr vA, vB */
GET_OPA4(t2) # t2 <- A+
GET_OPB(a3) # a3 <- B
GET_VREG(a2, a3) # a2 <- vB
... |
anestisb/oatdump_plus | 1,069 | runtime/interpreter/mterp/mips/op_iget.S | %default { "is_object":"0", "helper":"artGet32InstanceFromCode"}
/*
* General instance field get.
*
* for: iget, iget-object, iget-boolean, iget-byte, iget-char, iget-short
*/
/* op vA, vB, field@CCCC */
EXPORT_PC()
FETCH(a0, 1) # a0 <- field ref CCCC
GE... |
anestisb/oatdump_plus | 1,205 | runtime/interpreter/mterp/mips/op_ushr_long_2addr.S | /*
* Long integer shift, 2addr version. vA is 64-bit value/result, vB is
* 32-bit shift distance.
*/
/* ushr-long/2addr vA, vB */
GET_OPA4(t3) # t3 <- A+
GET_OPB(a3) # a3 <- B
GET_VREG(a2, a3) # a2 <- vB
... |
anestisb/oatdump_plus | 1,499 | runtime/interpreter/mterp/mips/binopLit8.S | %default {"preinstr":"", "result":"a0", "chkzero":"0"}
/*
* Generic 32-bit "lit8" binary operation. Provide an "instr" line
* that specifies an instruction that performs "result = a0 op a1".
* This could be an MIPS instruction or a function call. (If the result
* comes back in a register other... |
anestisb/oatdump_plus | 1,395 | runtime/interpreter/mterp/mips/op_float_to_int.S | /*
* float-to-int
*
* We have to clip values to int min/max per the specification. The
* expected common case is a "reasonable" value that converts directly
* to modest integer. The EABI convert function isn't doing this for us.
*/
/* unop vA, vB */
GET_OPB(a3) ... |
anestisb/oatdump_plus | 1,543 | runtime/interpreter/mterp/mips/op_double_to_int.S | /*
* double-to-int
*
* We have to clip values to int min/max per the specification. The
* expected common case is a "reasonable" value that converts directly
* to modest integer. The EABI convert function isn't doing this for us.
*/
/* unop vA, vB */
GET_OPB(a3) ... |
anestisb/oatdump_plus | 1,372 | runtime/interpreter/mterp/mips/binopLit16.S | %default {"preinstr":"", "result":"a0", "chkzero":"0"}
/*
* Generic 32-bit "lit16" binary operation. Provide an "instr" line
* that specifies an instruction that performs "result = a0 op a1".
* This could be an MIPS instruction or a function call. (If the result
* comes back in a register othe... |
anestisb/oatdump_plus | 1,213 | runtime/interpreter/mterp/mips/op_shl_long_2addr.S | /*
* Long integer shift, 2addr version. vA is 64-bit value/result, vB is
* 32-bit shift distance.
*/
/* shl-long/2addr vA, vB */
GET_OPA4(rOBJ) # rOBJ <- A+
GET_OPB(a3) # a3 <- B
GET_VREG(a2, a3) # a2 <- vB
... |
anestisb/oatdump_plus | 1,079 | runtime/interpreter/mterp/mips/op_aget_wide.S | /*
* Array get, 64 bits. vAA <- vBB[vCC].
*
* Arrays of long/double are 64-bit aligned.
*/
/* aget-wide vAA, vBB, vCC */
FETCH(a0, 1) # a0 <- CCBB
GET_OPA(rOBJ) # rOBJ <- AA
and a2, a0, 255 # a2 <- BB
... |
anestisb/oatdump_plus | 2,032 | runtime/interpreter/mterp/mips/op_double_to_long.S | /*
* double-to-long
*
* We have to clip values to long min/max per the specification. The
* expected common case is a "reasonable" value that converts directly
* to modest integer. The EABI convert function isn't doing this for us.
*/
/* unop vA, vB */
GET_OPA4(rOBJ) ... |
anestisb/oatdump_plus | 1,615 | runtime/interpreter/mterp/mips/binopWide2addr.S | %default {"preinstr":"", "result0":"a0", "result1":"a1", "chkzero":"0", "arg0":"a0", "arg1":"a1", "arg2":"a2", "arg3":"a3"}
/*
* Generic 64-bit "/2addr" binary operation. Provide an "instr" line
* that specifies an instruction that performs "result = a0-a1 op a2-a3".
* This could be a MIPS instructi... |
anestisb/oatdump_plus | 1,766 | runtime/interpreter/mterp/mips/binopWide.S | %default {"preinstr":"", "result0":"a0", "result1":"a1", "chkzero":"0", "arg0":"a0", "arg1":"a1", "arg2":"a2", "arg3":"a3"}
/*
* Generic 64-bit binary operation. Provide an "instr" line that
* specifies an instruction that performs "result = a0-a1 op a2-a3".
* This could be a MIPS instruction or a f... |
anestisb/oatdump_plus | 1,893 | runtime/interpreter/mterp/mips/op_float_to_long.S | /*
* float-to-long
*
* We have to clip values to long min/max per the specification. The
* expected common case is a "reasonable" value that converts directly
* to modest integer. The EABI convert function isn't doing this for us.
*/
/* unop vA, vB */
GET_OPA4(rOBJ) ... |
anestisb/oatdump_plus | 1,956 | runtime/interpreter/mterp/mips/op_cmpl_double.S | %default { "gt_bias":"0" }
/*
* Compare two floating-point values. Puts 0(==), 1(>), or -1(<)
* into the destination register based on the comparison results.
*
* For: cmpl-double, cmpg-double
*/
/* op vAA, vBB, vCC */
FETCH(a0, 1) # a0 <- CCBB
and ... |
anestisb/oatdump_plus | 1,239 | runtime/interpreter/mterp/mips/op_aput_wide.S | /*
* Array put, 64 bits. vBB[vCC] <- vAA.
*/
/* aput-wide vAA, vBB, vCC */
FETCH(a0, 1) # a0 <- CCBB
GET_OPA(t0) # t0 <- AA
and a2, a0, 255 # a2 <- BB
srl a3, a0, 8 # a3 <- CC
... |
anestisb/oatdump_plus | 1,462 | runtime/interpreter/mterp/mips/op_mul_long.S | /*
* Signed 64-bit integer multiply.
* a1 a0
* x a3 a2
* -------------
* a2a1 a2a0
* a3a0
* a3a1 (<= unused)
* ---------------
* v1 v0
*/
/* mul-long vAA, vBB, vCC */
FETCH(a0, 1) # a0 <-... |
anestisb/oatdump_plus | 1,104 | runtime/interpreter/mterp/mips/op_mul_long_2addr.S | /*
* See op_mul_long.S for more details
*/
/* mul-long/2addr vA, vB */
GET_OPA4(rOBJ) # rOBJ <- A+
EAS2(t0, rFP, rOBJ) # t0 <- &fp[A]
LOAD64(a0, a1, t0) # vAA.low / high
GET_OPB(t1) # t1 <- ... |
anestisb/oatdump_plus | 1,478 | runtime/interpreter/mterp/mips/op_ushr_long.S | /*
* Long integer shift. This is different from the generic 32/64-bit
* binary operations because vAA/vBB are 64-bit but vCC (the shift
* distance) is 32-bit. Also, Dalvik requires us to mask off the low
* 6 bits of the shift distance.
*/
/* ushr-long vAA, vBB, vCC */
FETCH(a0, 1)... |
anestisb/oatdump_plus | 2,387 | runtime/arch/mips64/jni_entrypoints_mips64.S | /*
* Copyright (C) 2014 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 app... |
anestisb/oatdump_plus | 3,119 | runtime/arch/mips64/asm_support_mips64.S | /*
* Copyright (C) 2014 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 app... |
anestisb/oatdump_plus | 83,335 | runtime/arch/mips64/quick_entrypoints_mips64.S | /*
* Copyright (C) 2014 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 app... |
anestisb/oatdump_plus | 1,251 | runtime/arch/mips64/memcmp16_mips64.S | /*
* Copyright (C) 2014 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 app... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.