Lines Matching full:code
37 <code>.dex</code> file that contains the method.
47 <li>In terms of bitwise representation, <code>(Object) null == (int)
48 0</code>.
52 two registers. Instance methods are passed a <code>this</code> reference
74 <code>move</code> instructions that can address registers in the range
75 <code>v0</code> – <code>v65535</code>.
85 <code>fill-array-data</code>). Such instructions must never be
89 must emit an extra <code>nop</code> instruction as a spacer if such an
110 <li>Type-general 64-bit opcodes are suffixed with <code>-wide</code>.</li>
112 straightforward abbreviation), one of: <code>-boolean</code>
113 <code>-byte</code> <code>-char</code> <code>-short</code>
114 <code>-int</code> <code>-long</code> <code>-float</code>
115 <code>-double</code> <code>-object</code> <code>-string</code>
116 <code>-class</code> <code>-void</code>.</li>
122 ("<code>/</code>") and mainly exist at all to make there be a one-to-one
123 mapping with static constants in the code that generates and interprets
131 "<code>move-wide/from16 vAA, vBBBB</code>":
133 <li>"<code>move</code>" is the base opcode, indicating the base operation
135 <li>"<code>wide</code>" is the name suffix, indicating that it operates
137 <li>"<code>from16</code>" is the opcode suffix, indicating a variant
139 <li>"<code>vAA</code>" is the destination register (implied by the
141 first), which must be in the range <code>v0</code> –
142 <code>v255</code>.</li>
143 <li>"<code>vBBBB</code>" is the source register, which must be in the
144 range <code>v0</code> – <code>v65535</code>.</li>
154 <li>See the <a href="dex-format.html"><code>.dex</code> file format
180 the data. See "<code>packed-switch-payload</code> Format",
181 "<code>sparse-switch-payload</code> Format", and
182 "<code>fill-array-data-payload</code> Format" below.</p>
188 <td><code>A:</code> destination register (4 bits)<br/>
189 <code>B:</code> source register (4 bits)</td>
195 <td><code>A:</code> destination register (8 bits)<br/>
196 <code>B:</code> source register (16 bits)</td>
202 <td><code>A:</code> destination register (16 bits)<br/>
203 <code>B:</code> source register (16 bits)</td>
209 <td><code>A:</code> destination register pair (4 bits)<br/>
210 <code>B:</code> source register pair (4 bits)</td>
213 It is legal to move from <code>v<i>N</i></code> to either
214 <code>v<i>N-1</i></code> or <code>v<i>N+1</i></code>, so implementations
222 <td><code>A:</code> destination register pair (8 bits)<br/>
223 <code>B:</code> source register pair (16 bits)</td>
226 Implementation considerations are the same as <code>move-wide</code>,
233 <td><code>A:</code> destination register pair (16 bits)<br/>
234 <code>B:</code> source register pair (16 bits)</td>
237 Implementation considerations are the same as <code>move-wide</code>,
244 <td><code>A:</code> destination register (4 bits)<br/>
245 <code>B:</code> source register (4 bits)</td>
251 <td><code>A:</code> destination register (8 bits)<br/>
252 <code>B:</code> source register (16 bits)</td>
258 <td><code>A:</code> destination register (16 bits)<br/>
259 <code>B:</code> source register (16 bits)</td>
265 <td><code>A:</code> destination register (8 bits)</td>
267 <code>invoke-<i>kind</i></code> into the indicated register.
269 <code>invoke-<i>kind</i></code> whose (single-word, non-object) result
275 <td><code>A:</code> destination register pair (8 bits)</td>
277 <code>invoke-<i>kind</i></code> into the indicated register pair.
279 <code>invoke-<i>kind</i></code> whose (double-word) result
285 <td><code>A:</code> destination register (8 bits)</td>
286 <td>Move the object result of the most recent <code>invoke-<i>kind</i></code>
288 immediately after an <code>invoke-<i>kind</i></code> or
289 <code>filled-new-array</code>
295 <td><code>A:</code> destination register (8 bits)</td>
306 <td>Return from a <code>void</code> method.</td>
311 <td><code>A:</code> return value register (8 bits)</td>
319 <td><code>A:</code> return value register-pair (8 bits)</td>
325 <td><code>A:</code> return value register (8 bits)</td>
331 <td><code>A:</code> destination register (4 bits)<br/>
332 <code>B:</code> signed int (4 bits)</td>
339 <td><code>A:</code> destination register (8 bits)<br/>
340 <code>B:</code> signed int (16 bits)</td>
347 <td><code>A:</code> destination register (8 bits)<br/>
348 <code>B:</code> arbitrary 32-bit constant</td>
354 <td><code>A:</code> destination register (8 bits)<br/>
355 <code>B:</code> signed int (16 bits)</td>
362 <td><code>A:</code> destination register (8 bits)<br/>
363 <code>B:</code> signed int (16 bits)</td>
370 <td><code>A:</code> destination register (8 bits)<br/>
371 <code>B:</code> signed int (32 bits)</td>
378 <td><code>A:</code> destination register (8 bits)<br/>
379 <code>B:</code> arbitrary double-width (64-bit) constant</td>
386 <td><code>A:</code> destination register (8 bits)<br/>
387 <code>B:</code> signed int (16 bits)</td>
394 <td><code>A:</code> destination register (8 bits)<br/>
395 <code>B:</code> string index</td>
402 <td><code>A:</code> destination register (8 bits)<br/>
403 <code>B:</code> string index</td>
410 <td><code>A:</code> destination register (8 bits)<br/>
411 <code>B:</code> type index</td>
420 <td><code>A:</code
426 <td><code>A:</code> reference-bearing register (8 bits)</td>
435 a monitor cleanup catch-all (e.g., <code>finally</code>) block as
438 implementation of <code>Thread.stop()</code>, while still managing
445 <td><code>A:</code> reference-bearing register (8 bits)<br/>
446 <code>B:</code> type index (16 bits)</td>
447 <td>Throw a <code>ClassCastException</code> if the reference in the
449 <p class="note"><strong>Note:</strong> Since <code>A</code> must always be a reference
451 (that is, it will throw an exception) if <code>B</code> refers to a
458 <td><code>A:</code> destination register (4 bits)<br/>
459 <code>B:</code> reference-bearing register (4 bits)<br/>
460 <code>C:</code> type index (16 bits)</td>
461 <td>Store in the given destination register <code>1</code>
463 or <code>0</code> if not.
464 <p class="note"><strong>Note:</strong> Since <code>B</code> must always be a reference
466 in <code>0</code> being stored if <code>C</code> refers to a primitive
472 <td><code>A:</code> destination register (4 bits)<br/>
473 <code>B:</code> array reference-bearing register (4 bits)</td>
480 <td><code>A:</code> destination register (8 bits)<br/>
481 <code>B:</code> type index</td>
489 <td><code>A:</code> destination register (8 bits)<br/>
490 <code>B:</code> size register<br/>
491 <code>C:</code> type index</td>
499 <code>A:</code> array size and argument word count (4 bits)<br/>
500 <code>B:</code> type index (16 bits)<br/>
501 <code>C..G:</code> argument registers (4 bits each)
506 no arrays of <code>long</code> or <code>double</code>, but reference
511 <code>move-result-object</code> instruction (if it is to be used).</td>
516 <td><code>A:</code> array size and argument word count (8 bits)<br/>
517 <code>B:</code> type index (16 bits)<br/>
518 <code>C:</code> first argument register (16 bits)<br/>
519 <code>N = A + C - 1</code></td>
522 as <code>filled-new-array</code>, described above.</td>
527 below in "<code>fill-array-data-payload</code> Format")</i></td>
528 <td><code>A:</code> array reference (8 bits)<br/>
529 <code>B:</code> signed "branch" offset to table data pseudo-instruction
542 <td><code>A:</code> exception-bearing register (8 bits)<br/></td>
548 <td><code>A:</code> signed branch offset (8 bits)</td>
551 The branch offset must not be <code>0</code>. (A spin
552 loop may be legally constructed either with <code>goto/32</code> or
553 by including a <code>nop</code> as a target before the branch.)</p>
559 <td><code>A:</code> signed branch offset (16 bits)<br/></td>
562 The branch offset must not be <code>0</code>. (A spin
563 loop may be legally constructed either with <code>goto/32</code> or
564 by including a <code>nop</code> as a target before the branch.)</p>
570 <td><code>A:</code> signed branch offset (32 bits)<br/></td>
576 specified below in "<code>packed-switch-payload</code> Format")</i></td>
577 <td><code>A:</code> register to test<br/>
578 <code>B:</code> signed "branch" offset to table data pseudo-instruction
590 specified below in "<code>sparse-switch-payload</code> Format")</i></td>
591 <td><code>A:</code> register to test<br/>
592 <code>B:</code> signed "branch" offset to table data pseudo-instruction
609 <td><code>A:</code> destination register (8 bits)<br/>
610 <code>B:</code> first source register or pair<br/>
611 <code>C:</code> second source register or pair</td>
612 <td>Perform the indicated floating point or <code>long</code> comparison,
613 setting <code>a</code> to <code>0</code> if <code>b == c</code>,
614 <code>1</code> if <code>b > c</code>,
615 or <code>-1</code> if <code>b < c</code>.
617 indicates how <code>NaN</code> comparisons are treated: "gt bias"
618 instructions return <code>1</code> for <code>NaN</code> comparisons,
619 and "lt bias" instructions return <code>-1</code>.
621 <code>x < y</code> it is advisable to use
622 <code>cmpg-float</code>; a result of <code>-1</code> indicates that
625 <code>NaN</code>.</p>
638 <td><code>A:</code> first register to test (4 bits)<br/>
639 <code>B:</code> second register to test (4 bits)<br/>
640 <code>C:</code> signed branch offset (16 bits)</td>
644 The branch offset must not be <code>0</code>. (A spin
646 backward <code>goto</code> or by including a <code>nop</code> as
660 <td><code>A:</code> register to test (8 bits)<br/>
661 <code>B:</code> signed branch offset (16 bits)</td>
665 The branch offset must not be <code>0</code>. (A spin
667 backward <code>goto</code> or by including a <code>nop</code> as
695 <td><code>A:</code> value register or pair; may be source or dest
697 <code>B:</code> array register (8 bits)<br/>
698 <code>C:</code> index register (8 bits)</td>
720 <td><code>A:</code> value register or pair; may be source or dest
722 <code>B:</code> object register (4 bits)<br/>
723 <code>C:</code> instance field reference index (16 bits)</td>
748 <td><code>A:</code> value register or pair; may be source or dest
750 <code>B:</code> static field reference index (16 bits)</td>
767 <code>A:</code> argument word count (4 bits)<br/>
768 <code>B:</code> method reference index (16 bits)<br/>
769 <code>C..G:</code> argument registers (4 bits each)
772 with an appropriate <code>move-result*</code> variant as the immediately
774 <p><code>invoke-virtual</code> is used to invoke a normal virtual
775 method (a method that is not <code>private</code>, <code>static</code>,
776 or <code>final</code>, and is also not a constructor).</p>
777 <p>When the <code>method_id</code> references a method of a non-interface
778 class, <code>invoke-super</code> is used to invoke the closest superclass's
779 virtual method (as opposed to the one with the same <code>method_id</code>
781 <code>invoke-virtual</code>.</p>
782 <p>In Dex files version <code>037</code> or later, if the
783 <code>method_id</code> refers to an interface method,
784 <code>invoke-super</code> is used to invoke the most specific,
786 method restrictions hold as for <code>invoke-virtual</code>. In Dex files
787 prior to version <code>037</code>, having an interface
788 <code>method_id</code> is illegal and undefined.</p>
789 <p><code>invoke-direct</code> is used to invoke a non-<code>static</code>
791 non-overridable, namely either a <code>private</code> instance method or a
793 <p><code>invoke-static</code> is used to invoke a <code>static</code>
795 <p><code>invoke-interface</code> is used to invoke an
796 <code>interface</code> method, that is, on an object whose concrete
797 class isn't known, using a <code>method_id</code> that refers to
798 an <code>interface</code>.</p>
819 <td><code>A:</code> argument word count (8 bits)<br/>
820 <code>B:</code> method reference index (16 bits)<br/>
821 <code>C:</code> first argument register (16 bits)<br/>
822 <code>N = A + C - 1</code></td>
823 <td>Call the indicated method. See first <code>invoke-<i>kind</i></code>
858 <td><code>A:</code> destination register or pair (4 bits)<br/>
859 <code>B:</code> source register or pair (4 bits)</td>
900 <td><code>A:</code> destination register or pair (8 bits)<br/>
901 <code>B:</code> first source register or pair (8 bits)<br/>
902 <code>C:</code> second source register or pair (8 bits)</td>
942 <td><code>A:</code> destination and first source register or pair
944 <code>B:</code> second source register or pair (4 bits)</td>
960 <td><code>A:</code> destination register (4 bits)<br/>
961 <code>B:</code> source register (4 bits)<br/>
962 <code>C:</code> signed int constant (16 bits)</td>
967 <code>rsub-int</code> does not have a suffix since this version is the
987 <td><code>A:</code> destination register (8 bits)<br/>
988 <code>B:</code> source register (8 bits)<br/>
989 <code>C:</code> signed int constant (8 bits)</td>
994 <code>rsub-int</code>.</p>
1035 <td>list of <code>size</code> relative branch targets. The targets are
1042 <p class="note"><strong>Note:</strong> The total number of code units for an instance of this
1043 table is <code>(size * 2) + 4</code>.</p>
1069 <td>list of <code>size</code> key values, sorted low-to-high</td>
1074 <td>list of <code>size</code> relative branch targets, each corresponding
1082 <p class="note"><strong>Note:</strong> The total number of code units for an instance of this
1083 table is <code>(size * 4) + 2</code>.</p>
1119 <p class="note"><strong>Note:</strong> The total number of code units for an instance of this
1120 table is <code>(size * element_width + 1) / 2 + 4</code>.</p>
1184 <td>Sign extension of <code>int32</code> into <code>int64</code>.</td>
1191 <td>Conversion of <code>int32</code> to <code>float</code>, using
1200 <td>Conversion of <code>int32</code> to <code>double</code>.</td>
1207 <td>Truncation of <code>int64</code> into <code>int32</code>.</td>
1214 <td>Conversion of <code>int64</code> to <code>float</code>, using
1223 <td>Conversion of <code>int64</code> to <code>double</code>, using
1232 <td>Conversion of <code>float</code> to <code>int32</code>, using
1233 round-toward-zero. <code>NaN</code> and <code>-0.0</code> (negative zero)
1234 convert to the integer <code>0</code>. Infinities and values with
1236 <code>0x7fffffff</code> or <code>-0x80000000</code> depending on sign.
1244 <td>Conversion of <code>float</code> to <code>int64</code>, using
1246 <code>float-to-int</code> apply here, except that out-of-range values
1247 get converted to either <code>0x7fffffffffffffff</code> or
1248 <code>-0x8000000000000000</code> depending on sign.
1256 <td>Conversion of <code>float</code> to <code>double</code>, preserving
1265 <td>Conversion of <code>double</code> to <code>int32</code>, using
1267 <code>float-to-int</code> apply here.
1275 <td>Conversion of <code>double</code> to <code>int64</code>, using
1277 <code>float-to-long</code> apply here.
1285 <td>Conversion of <code>double</code> to <code>float</code>, using
1294 <td>Truncation of <code>int32</code> to <code>int8</code>, sign
1303 <td>Truncation of <code>int32</code> to <code>uint16</code>, without
1312 <td>Truncation of <code>int32</code> to <code>int16</code>, sign
1350 integer). This throws <code>ArithmeticException</code> if
1351 <code>b == 0</code>.
1360 is the same as that of <code>a</code>, and it is more precisely
1361 defined as <code>result == a - (a / b) * b</code>. This throws
1362 <code>ArithmeticException</code> if <code>b == 0</code>.
1434 integer). This throws <code>ArithmeticException</code> if
1435 <code>b == 0</code>.
1444 is the same as that of <code>a</code>, and it is more precisely
1445 defined as <code>result == a - (a / b) * b</code>. This throws
1446 <code>ArithmeticException</code> if <code>b == 0</code>.
1526 <code>result == a - roundTowardZero(a / b) * b</code>.
1564 <code>result == a - roundTowardZero(a / b) * b</code>.
