Wandle einen long-Wert in einen double-Wert um.

Beispiel:

long a = 6442450944L;        0: ldc2_w #2; //long 6442450944L
                             3: lstore_1
double b = a;                4: lload_1
                             5: l2d
                             6: dstore_3

Binäre Darstellung:
6442450944L = 
  (00000000 00000000 00000000 00000001 10000000 00000000 00000000 00000000)b
6.442450944E9d = 
  (01000001 11111000 00000000 00000000 00000000 00000000 00000000 00000000)b

Die Variable b vom Typ double enthält nach der Umwandlung den Wert 6.442450944E9. Siehe dazu auch Binärdarstellung einer Gleitkommazahl (32 Bit). Der Programmausschnitt befindet sich innerhalb einer main-Methode. Mit Hilfe des Ladebefehls ldc2_w #2 wird die 2. Konstante im Konstantenpool der zum Quelltext zugehörigen Klassendatei auf den Operandenstapel geladen (Laufzeit-Konstantenpool). Der Wert der Long-Konstanten wird innerhalb der Klassendatei durch die Bytefolge 00 00 00 01 80 00 00 00 repräsentiert (hexadezimale Schreibweise der Binärdarstellung von 6442450944L).

 

 

Wandle einen long-Wert in einen float-Wert um.

Beispiel:

long a = 6442450944L;        0: ldc2_w #2; //long 6442450944L
                             3: lstore_1
float b = a;                 4: lload_1
                             5: l2f
                             6: fstore_3

Binäre Darstellung:
 6442450944L = 
  (00000000 00000000 00000000 00000001 10000000 00000000 00000000 00000000)b
6.4424509E9f =                        (01001111 11000000 00000000 00000000)b

Die Variable b vom Typ float enthält nach der Umwandlung den Wert 6.4424509E9. Siehe dazu auch Binärdarstellung einer Gleitkommazahl (32 Bit). Der Programmausschnitt befindet sich innerhalb einer main-Methode. Mit Hilfe des Ladebefehls ldc2_w #2 wird die 2. Konstante im Konstantenpool der zum Quelltext zugehörigen Klassendatei auf den Operandenstapel geladen (Laufzeit-Konstantenpool). Der Wert der Long-Konstanten wird innerhalb der Klassendatei durch die Bytefolge 00 00 00 01 80 00 00 00 repräsentiert (hexadezimale Schreibweise der Binärdarstellung von 6442450944L).

 

 

Wandle einen long-Wert in einen int-Wert um.

Für einen long-Wert werden 8 Bytes zur Verfügung gestellt; eine int-Zahl besteht aber nur aus 4 Bytes. Die Umwandlung erfolgt dahingehend, dass lediglich die unteren 4 Bytes (Bit 31-0) der ursprünglichen 8-Byte-Zahl beachtet werden. Es ist möglich, dass sich das Vorzeichen des Zahlenwertes bei dieser Operation ändert.

Beispiel:

long a = 6442450944L;        0: ldc2_w #2; //long 6442450944L
                             3: lstore_1
int b = (int)a;              4: lload_1
                             5: l2i
                             6: istore_3

Binäre Darstellung:
 6442450944L = 
  (00000000 00000000 00000000 00000001 10000000 00000000 00000000 00000000)b
-2147483648i =                        (10000000 00000000 00000000 00000000)b

Die Variable b vom Typ int enthält nach der Umwandlung den Wert -2147483648 (entspricht Integer.MIN_VALUE). Der Quelltext des Beispiels befindet sich innerhalb einer main-Methode. Mit Hilfe des Ladebefehls ldc2_w #2 wird die 2. Konstante im Konstantenpool der zum Quelltext zugehörigen Klassendatei auf den Operandenstapel geladen (Laufzeit-Konstantenpool). Der Wert der Long-Konstanten wird innerhalb der Klassendatei durch die Bytefolge 00 00 00 01 80 00 00 00 repräsentiert (hexadezimale Schreibweise der Binärdarstellung von 6442450944L).

 

 

Addiere zwei long-Werte.

Die beiden obersten Elemente werden vom Stapel genommen und addiert: result = value1 + value2.

Beispiel:

long a = 3;             0: ldc2_w #2; //long 3l
                        3: lstore_1
long b = 4;             4: ldc2_w #4; //long 4l
                        7: lstore_3
long c = a + b;         8: lload_1
                        9: lload_3
                       10: ladd
                       11: lstore 5

 

 

Lade einen long-Wert value aus einem long-Array auf den Operandenstapel.

Mit Hilfe von arrayref und index wird ein long-Wert ermittelt und auf den Stapel gelegt.

Beispiel:

long[] l = {4, 5};         0: iconst_2
                           1: newarray long
                           3: dup
                           4: iconst_0
                           5: ldc2_w #2; //long 4l
                           8: lastore
                           9: dup
                          10: iconst_1
                          11: ldc2_w #4; //long 5l
                          14: lastore
                          15: astore_1
long l0 = l[0];           16: aload_1
                          17: iconst_0
                          18: laload
                          19: lstore_2

Mit lastore werden zunächst die beiden Zahlenwerte 4 und 5 in das Array geschrieben. Anschließend erfolgt das Auslesen des ersten Elements (Index 0) mit laload.

 

 

Verknüpfe zwei long-Werte mit bitweisem UND (bitweiser Operator "&").

Es gilt: result = value1 & value2

Beispiel: 32762 & 31 = 26

long a = 32762;         0: ldc2_w #2; //long 32762l
                        3: lstore_1
long b = 31;            4: ldc2_w #4; //long 31l
                        7: lstore_3
long c = a & b;         8: lload_1
                        9: lload_3
                       10: land
                       11: lstore 5

Binäre Darstellung:

32762 = 
     (00000000 00000000 00000000 00000000 00000000 00000000 01111111 11111010)b
31 = (00000000 00000000 00000000 00000000 00000000 00000000 00000000 00011111)b
26 = (00000000 00000000 00000000 00000000 00000000 00000000 00000000 00011010)b

 

 

Speichere einen long-Wert value in ein long-Array.

Auf dem Operandenstapel befinden sich, vor der Ausführung des Befehls, die Referenz auf das Array, der Index des Elements im Array und der zu speichernde long-Wert value. Siehe auch das Beispiel zu laload.

 

 

Vergleiche zwei long-Werte.

Beispiel:

long a = 4L;               0: ldc2_w #2; //long 4L
                           3: lstore_1
long b = 3L;               4: ldc2_w #4; //long 3L
                           7: lstore_3
boolean c = a > b;         8: lload_1
                           9: lload_3
                          10: lcmp
                          11: ifle 18
                          14: iconst_1
                          15: goto 19
                          18: iconst_0
                          19: istore 5

Nachdem die Vergleichsanweisung lcmp durchgeführt wurde, befindet sich der int-Wert 1 an oberster Stelle des Operandenstapels. Da das Ergebnis von lcmp größer als 0 ist, erfolgt keine Verzweigung mittels ifle, sondern es wird mit dem JVM-Befehl incost_1 fortgefahren. Nach Abarbeitung des Programmausschnitts befindet sich der Wert 1 im Array der lokalen Variablen bei Index 5 (istore 5, Index 5 korrespondiert mit der boolean-Variablen c).

 

 

Lege die long-Konstante 0 auf den Operandenstapel.

Beispiel:

long l = 0;        0: lconst_0
                   1: lstore_1

 

 

Lege die long-Konstante 1 auf den Operandenstapel.

Beispiel: Siehe dazu lconst_0.

 

 

Lege einen Wert vom Typ int, float oder eine Referenz auf einen String (reference) vom (Laufzeit-)Konstantenpool auf den Operandenstapel.

Die (Laufzeit-)Konstante bei index kann vom Typ Integer, Float oder String sein. Eine Konstante vom Typ String verweist wiederum auf eine Konstante im Pool vom Typ Utf8, die letztendlich den Inhalt der Zeichenkette zur Verfügung stellt. Der Wert value, der auf den Stapel gelegt wird, besitzt den Typ int oder float, falls auf einen numerischen Wert indiziert wird. Anderenfalls ist value eine Referenz auf ein String-Objekt. Siehe dazu auch: Ablegen von ganzen Zahlen auf dem Operandenstapel.

Beispiel:

int i = 32768;           0: ldc #2; //int 32768
                         2: istore_1
float f = 3.0f;          3: ldc #3; //float 3.0f
                         5: fstore_2
String s = "Hallo!";     6: ldc #4; //String Hallo!
                         8: astore_3

 

 

Lege einen Wert vom Typ int, float oder eine Referenz auf einen String (reference) vom (Laufzeit-)Konstantenpool auf den Operandenstapel.

Aus den beiden vorzeichenlosen Bytes indexbyte1 und indexbyte2 kann ein Index im (Laufzeit-)Konstantenpool der aktuellen Klasse berechnet werden: (indexbyte1 << 8) | indexbyte2. Die Konstante bei diesem Index ist vom Typ Integer, Float oder String. Der Befehl ldc_w hat dieselbe Funktion wie ldc; die auf den Opcode von ldc_w folgenden zwei Indexbytes ermöglichen jedoch eine Adressierung von Konstanten im Pool, falls dieser mehr als 256 Einträge besitzt. Siehe dazu auch ldc.

 

 

Lege einen Wert vom Typ long oder double vom (Laufzeit-)Konstantenpool auf den Operandenstapel.

Aus den beiden vorzeichenlosen Bytes indexbyte1 und indexbyte2 kann ein Index im (Laufzeit-)Konstantenpool der aktuellen Klasse berechnet werden: (indexbyte1 << 8) | indexbyte2. Die Konstante bei diesem Index ist vom Typ Long oder Double.

Beispiel:

long l = 2;            0: ldc2_w #2; //long 2l
                       3: lstore_1
double d = 2.0;        4: ldc2_w #4; //double 2.0d
                       7: dstore_3

 

 

Dividiere zwei long-Werte.

Die beiden obersten Elemente werden vom Stapel genommen und die folgende Division wird durchgeführt: result = value1 / value2. Da das Ergebnis wiederum eine Ganzzahl sein muss, werden mögliche Nachkommastellen nicht beachtet.

Beispiel:

long a = 9;             0: ldc2_w #2; //long 9l
                        3: lstore_1
long b = 4;             4: ldc2_w #4; //long 4l
                        7: lstore_3
long c = a / b;         8: lload_1
                        9: lload_3
                       10: ldiv
                       11: lstore 5

Der Inhalt der Variablen c ist 2, da für das Ergebnis der Division eine Ganzzahl gefordert wird.

 

 

Lade einen long-Wert aus dem Array der lokalen Variablen auf den Operandenstapel.

Der Eintrag value im Array bei diesem Index muss vom Typ long sein.

Beispiel:

public class Test {
  public static void main(String[] args) {
    long l1 = args.length;                         0: aload_0
                                                   1: arraylength
                                                   2: i2l
                                                   3: lstore_1
    long l2 = 0;                                   4: lconst_0
                                                   5: lstore_3
    long l3 = 1;                                   6: lconst_1
                                                   7: lstore 5
    long l4 = l1 + l2 + l3;                        9: lload_1
                                                  10: lload_3
                                                  11: ladd
                                                  12: lload 5
                                                  14: ladd
                                                  15: lstore 7
  }
}

Das Laden der Zahlenwerte aus dem Array der lokalen Variablen übernehmen zunächst die mit einem Byte codierten JVM-Befehle lload_1 und lload_3. Das Laden der Zahl bei Index 5 übernimmt lload. Für eine lokale Variable vom Typ long werden zwei Einträge im Array der lokalen Variablen reserviert. Es sind daher für einen long-Wert die Inhalte bei index und index+1 zu beachten. Im Array der lokalen Variablen ist bei Index 0 eine Referenz auf ein String-Array gespeichert, dem einzigen Parameter der main-Methode.

 

 

Lade den long-Wert einer lokalen Variablen auf den Operandenstapel. Dabei steht 0 für einen Index im Array der lokalen Variablen des zugehörigen Methoden-Frames.

Der Eintrag im Array bei Index 0 muss vom Typ long sein. Für eine lokale Variable vom Typ long werden zwei Einträge im Array der lokalen Variablen reserviert. Für den long-Wert sind daher die Inhalte bei Index 0 und Index 1 zu beachten. Bei lload_0 ist der Index im entsprechenden Array implizit und es wird lediglich ein Byte für diesen Befehl benötigt, im Gegensatz zu lload index. Siehe auch das Beispiel zu lload.

 

 

Lade den long-Wert einer lokalen Variablen auf den Operandenstapel. Dabei steht 1 für einen Index im Array der lokalen Variablen des zugehörigen Methoden-Frames.

Der Eintrag im Array bei Index 1 muss vom Typ long sein. Für eine lokale Variable vom Typ long werden zwei Einträge im Array der lokalen Variablen reserviert. Für den long-Wert sind daher die Inhalte bei Index 1 und Index 2 zu beachten. Bei lload_1 ist der Index im entsprechenden Array implizit und es wird lediglich ein Byte für diesen Befehl benötigt, im Gegensatz zu lload index. Siehe auch das Beispiel zu lload.

 

 

Lade den long-Wert einer lokalen Variablen auf den Operandenstapel. Dabei steht 2 für einen Index im Array der lokalen Variablen des zugehörigen Methoden-Frames.

Der Eintrag im Array bei Index 2 muss vom Typ long sein. Für eine lokale Variable vom Typ long werden zwei Einträge im Array der lokalen Variablen reserviert. Für den long-Wert sind daher die Inhalte bei Index 2 und Index 3 zu beachten. Bei lload_2 ist der Index im entsprechenden Array implizit und es wird lediglich ein Byte für diesen Befehl benötigt, im Gegensatz zu lload index. Siehe auch das Beispiel zu lload.

 

 

Lade den long-Wert einer lokalen Variablen auf den Operandenstapel. Dabei steht 3 für einen Index im Array der lokalen Variablen des zugehörigen Methoden-Frames.

Der Eintrag im Array bei Index 3 muss vom Typ long sein. Für eine lokale Variable vom Typ long werden zwei Einträge im Array der lokalen Variablen reserviert. Für den long-Wert sind daher die Inhalte bei Index 3 und Index 4 zu beachten. Bei lload_3 ist der Index im entsprechenden Array implizit und es wird lediglich ein Byte für diesen Befehl benötigt, im Gegensatz zu lload index. Siehe auch das Beispiel zu lload.

 

 

Multipliziere zwei long-Werte.

Die beiden obersten Elemente werden vom Stapel genommen und miteinander multipliziert: result = value1 * value2.

Beispiel:

long a = 3;             0: ldc2_w #2; //long 3l
                        3: lstore_1
long b = 4;             4: ldc2_w #4; //long 4l
                        7: lstore_3
long c = a * b;         8: lload_1
                        9: lload_3
                       10: lmul
                       11: lstore 5

 

 

Negiere einen long-Wert.

Es gilt: result = -value. Die Negation eines long-Wertes entspricht der Subtraktion des Wertes von 0: -value = 0 - value.

Beispiel:

long a = 3;         0: ldc2_w #2; //long 3l
                    3: lstore_1
long b = -a;        4: lload_1
                    5: lneg
                    6: lstore_3

 

 

Der JVM-Befehl lookupswitch realisiert eine switch-Anweisung auf Bytecodeebene.

Im Anschluss an die Mnemonik lookupswitch bzw. den Operationscode ab folgen eine Reihe von Operandenbytes, die für die Codierung der switch-Anweisung notwendig sind. Dabei ist die Anzahl der Operandenbytes von der Anzahl der verwendeten case-Labels der Mehrfachverzweigung abhängig.

Eine switch-Anweisung kann wie folgt aufgebaut sein:

switch (key) {
  case konstante:
    anweisung;
    ...
  default:
    ...
}

Eine Übersetzung einer switch-Anweisung in Bytecode kann auch den JVM-Befehl tableswitch enthalten. Siehe dazu die Befehlsbeschreibung und das Beispiel zu tableswitch.

Die auf den Opcode von lookupswitch folgenden Operandenbytes codieren eine Sprungtabelle. Der auf dem Operandenstapel befindliche Wert key wird mit den case-Konstanten verglichen. Stimmt eine dieser Konstanten mit dem Vergleichswert überein (case "matches"), dann werden die Anweisungen nach diesem case-Label ausgeführt. In der Sprungtabelle werden Offsets zu diesen case- bzw. dafault-Anweisungen gespeichert. Die Offsetwerte beziehen sich auf die Bytecodestelle des Opcodes von lookupswitch. Aus jeweils vier vorzeichenlos gewerteten Operandenbytes können vorzeichenbehaftete 32-Bit-Ganzzahlen berechnet werden:

default = (default1 << 24) | (default2 << 16) | 
          (default3 << 8) | default4
 npairs = (npairs1 << 24) | (npairs2 << 16) | 
          (npairs3 << 8) | npairs4
   m1op = (mop11 << 24) | (mop12 << 16) | 
          (mop13 << 8) | mop14
   mo1p = (mop15 << 24) | (mop16 << 16) | 
          (mop17 << 8) | mop18
   m2op = (mop21 << 24) | (mop22 << 16) | 
          (mop23 << 8) | mop24
   mo2p = (mop25 << 24) | (mop26 << 16) | 
          (mop27 << 8) | mop28
...

Im unmittelbaren Anschluss an den Opcode ab können mehrere sogenannte Füllbytes (padding bytes) mit dem numerischen Wert 0 angeordnet sein (0 bis 3 dieser Bytes sind möglich). Diese Füllbytes werden eingefügt, damit die Bytecodestelle des Operandenbytes default1 ein vielfaches der Zahl 4 ist. Die genannte Stelle im Bytecode bezieht sich dabei auf die Bytecodestelle 0 einer jeden Methode. Die Operandenbytes unterliegen damit einem gewünschten 4-Byte-Raster.

Beispiel:

Eine switch-Anweisung soll auf Bytecodeebene mit Hilfe des folgenden kurzen Listings näher untersucht werden:

public class Test {
  public static void main(String[] args)   {
    int a = 2;
    int b = 0;
    switch (a) {
      case -50: b++; 
                break;
      case 230: b += 2; 
                break;
      case   2: b += 3; 
                break;
      default: b += 5;
    }  
    b--;
  }
}

Das kurze Beispielprogramm kann mittels javac in die Klassendatei Test.class übersetzt werden. Die in dieser erzeugten Datei enthaltenen Zahlenwerte (Bytecode) für die switch-Anweisung lauten in hexadezimaler Schreibweise:

ab 00 00 00 00 00 35 00 00 00 03 ff ff ff ce 00 
00 00 23 00 00 00 02 00 00 00 2f 00 00 00 e6 00 
00 00 29

Auf den Opcode ab für die zugehörigen Mnemonik lookupswitch folgen im Beispiel 34 Operandenbytes, die der Reihe nach wie folgt zugeordnet werden können:

Die folgende Übersicht listet die zum betrachteten Programmausschnitt korrespondierenden JVM-Befehle auf, wie sie mit Hilfe des Klassendatei-Disassemblers javap erhalten werden können. Die einzelnen Operandenbyte-Blöcke zu lookupswitch werden anschließend kurz erläutert.

int a = 2;                  0: iconst_2
                            1: istore_1
int b = 0;                  2: iconst_0
                            3: istore_2
switch (a) {                4: iload_1
                            5: lookupswitch { //3
                               -50: 40;
                                 2: 52;
                               230: 46;
                               default: 58 }
  case -50: b++;           40: iinc 2,1
            break;         43: goto 61
  case 230: b += 2;        46: iinc 2,2
            break;         49: goto 61
  case   2: b += 3;        52: iinc 2,3
            break;         55: goto 61
  default: b += 5;         58: iinc 2,5
}  
b--;                       61: iinc 2,-1


Operationscode des Befehls lookupswitch und dessen Operandenbytes (5 - 39):

 5: ab              Opcode lookupswitch
 6: 00 00           2 Padding-Bytes
 8: 00 00 00 35     default = 53, (5 + 53 = 58)
12: 00 00 00 03     npairs = 3, (3 Match-Offset-Paare) 

16: ff ff ff ce     m1op = -50, (1. case-Konstante bzw. 1. Match)
20: 00 00 00 23     mo1p = 35, (1. Offset, 5 + 35 = 40)

24: 00 00 00 02     m2op = 2, (2. case-Konstante, 2. Match)
28: 00 00 00 2f     mo2p = 47, (2. Offset, 5 + 47 = 52)

32: 00 00 00 e6     m3op = 230, (3. case-Konstante, 3. Match)
36: 00 00 00 29     mo3p = 41, (3. Offset, 5 + 41 = 46)

 

 

Verknüpfe zwei long-Werte mit bitweisem ODER (bitweiser Operator "|").

Es gilt: result = value1 | value2

Beispiel: 70 | 42 = 110

long a = 70;            0: ldc2_w #2; //long 70l
                        3: lstore_1
long b = 42;            4: ldc2_w #4; //long 42l
                        7: lstore_3
long c = a | b;         8: lload_1
                        9: lload_3
                       10: lor
                       11: lstore 5

Binäre Darstellung:

 70 = (00000000 00000000 00000000 00000000 00000000 00000000 00000000 01000110)b
 42 = (00000000 00000000 00000000 00000000 00000000 00000000 00000000 00101010)b
110 = (00000000 00000000 00000000 00000000 00000000 00000000 00000000 01101110)b

 

 

Berechne den long-Restwert value1 % value2.

Die beiden obersten Elemente werden vom Stapel genommen und die folgende Berechnung wird durchgeführt: result = value1 - (value1 / value2) * value2. Zur Berechnung von value1 / value2 siehe auch ldiv.

Beispiel: 11 % 4 = 3

long a = 11;            0: ldc2_w #2; //long 11l
                        3: lstore_1
long b = 4;             4: ldc2_w #4; //long 4l
                        7: lstore_3
long c = a % b;         8: lload_1
                        9: lload_3
                       10: lrem
                       11: lstore 5

Der Inhalt der Variablen c ist 3 (2 * 4 = 8, 11 - 8 = 3).

 

 

Gebe einen long-Wert der aktuellen Methode zurück.

Der Rückgabewert value wird vom Stapel genommen und an den Aufrufer der Methode zurückgegeben, indem dieser auf den Operandenstapel des Methodenaufrufers gelegt wird.

Beispiel:

public class Test {

  public static long method1() {                  public static long method1();
                                                  Code:
    long a = 3;                                   0: ldc2_w #2; //long 3l
                                                  3: lstore_0
    return a;                                     4: lload_0
  }                                               5: lreturn

  public static void main(String[] args) {
    long b = method1();
  }
}

 

 

Verschiebe die Bits eines long-Wertes nach links.

Beispiel: 15 << 4 = 240

long a = 15;             0: ldc2_w #2; //long 15l
                         3: lstore_1
long b = 4;              4: ldc2_w #4; //long 4l
                         7: lstore_3
long c = a << b;         8: lload_1
                         9: lload_3
                        10: l2i
                        11: lshl
                        12: lstore 5

Binäre Darstellung:

 15 = (00000000 00000000 00000000 00000000 00000000 00000000 00000000 00001111)b
  4 = (00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000100)b
240 = (00000000 00000000 00000000 00000000 00000000 00000000 00000000 11110000)b

 

 

Verschiebe die Bits eines long-Wertes nach rechts (rechtsschieben mit Beachtung des Vorzeichens).

Siehe auch lushr (rechtsschieben ohne Beachtung des Vorzeichens).

Beispiel: -4 >> 1 = -2

long a = -4;             0: ldc2_w #2; //long -4l
                         3: lstore_1
long b = 1;              4: lconst_1
                         5: lstore_3
long c = a >> b;         6: lload_1
                         7: lload_3
                         9: lshr
                        10: lstore 5

Binäre Darstellung:

-4 = (11111111 11111111 11111111 11111111 11111111 11111111 11111111 11111100)b
 1 = (00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000001)b
-2 = (11111111 11111111 11111111 11111111 11111111 11111111 11111111 11111110)b

 

 

Speichere einen long-Wert in das Array der lokalen Variablen.

Die long-Zahl value wird vom Stapel genommen und in das Array der lokalen Variablen geschrieben. Ein Zahlenwert vom Typ long benötigt zwei Einträge im entsprechenden Array (bei index und index+1). Siehe auch das Beispiel zu lload.

 

 

Speichere einen long-Wert in das Array der lokalen Variablen. Dabei steht 0 für einen Index im Array der lokalen Variablen des zugehörigen Methoden-Frames.

Die long-Zahl value wird vom Stapel genommen und in das Array der lokalen Variablen geschrieben (bei Index 0). Ein Zahlenwert vom Typ long benötigt zwei Einträge im entsprechenden Array (bei Index 0 und 1). Bei lstore_0 ist der Index im entsprechenden Array implizit und es wird lediglich ein Byte für diesen Befehl benötigt, im Gegensatz zu lstore index. Siehe auch das Beispiel zu lload.

 

 

Speichere einen long-Wert in das Array der lokalen Variablen. Dabei steht 1 für einen Index im Array der lokalen Variablen des zugehörigen Methoden-Frames.

Die long-Zahl value wird vom Stapel genommen und in das Array der lokalen Variablen geschrieben (bei Index 1). Ein Zahlenwert vom Typ long benötigt zwei Einträge im entsprechenden Array (bei Index 1 und 2). Bei lstore_1 ist der Index im entsprechenden Array implizit und es wird lediglich ein Byte für diesen Befehl benötigt, im Gegensatz zu lstore index. Siehe auch das Beispiel zu lload.

 

 

Speichere einen long-Wert in das Array der lokalen Variablen. Dabei steht 2 für einen Index im Array der lokalen Variablen des zugehörigen Methoden-Frames.

Die long-Zahl value wird vom Stapel genommen und in das Array der lokalen Variablen geschrieben (bei Index 2). Ein Zahlenwert vom Typ long benötigt zwei Einträge im entsprechenden Array (bei Index 2 und 3). Bei lstore_2 ist der Index im entsprechenden Array implizit und es wird lediglich ein Byte für diesen Befehl benötigt, im Gegensatz zu lstore index. Siehe auch das Beispiel zu lload.

 

 

Speichere einen long-Wert in das Array der lokalen Variablen. Dabei steht 3 für einen Index im Array der lokalen Variablen des zugehörigen Methoden-Frames.

Die long-Zahl value wird vom Stapel genommen und in das Array der lokalen Variablen geschrieben (bei Index 3). Ein Zahlenwert vom Typ long benötigt zwei Einträge im entsprechenden Array (bei Index 3 und 4). Bei lstore_3 ist der Index im entsprechenden Array implizit und es wird lediglich ein Byte für diesen Befehl benötigt, im Gegensatz zu lstore index. Siehe auch das Beispiel zu lload.

 

 

Subtrahiere zwei long-Werte.

Die beiden obersten Elemente werden vom Stapel genommen und subtrahiert: result = value1 - value2.

Beispiel:

long a = 2;            0: ldc2_w #2; //long 2l
                       3: lstore_1
long b = 1;            4: lconst_1
                       5: lstore_3
long c = a - b;        6: lload_1
                       7: lload_3
                       8: lsub
                       9: lstore 5

 

 

Verschiebe die Bits eines long-Wertes nach rechts (rechtsschieben ohne Beachtung des Vorzeichens).

Siehe auch lshr (rechtsschieben mit Beachtung des Vorzeichens).

Beispiel: -4 >>> 1 = 9223372036854775806

long a = -4;              0: ldc2_w #2; //long -4l
                          3: lstore_1
long b = 1;               4: lconst_1
                          5: lstore_3
long c = a >>> b;         6: lload_1
                          7: lload_3
                          8: l2i
                          9: lushr
                         10: lstore 5

Binäre Darstellung:

-4 = (11111111 11111111 11111111 11111111 11111111 11111111 11111111 11111100)b
 1 = (00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000001)b
9223372036854775806 = 
     (01111111 11111111 11111111 11111111 11111111 11111111 11111111 11111110)b

 

 

Verknüpfe zwei long-Werte mit bitweisem EXKLUSIV-ODER (bitweiser Operator "^").

Es gilt: result = value1 ^ value2

Beispiel: 70 ^ 42 = 108

long a = 70;            0: ldc2_w #2; //long 70l
                        3: lstore_1
long b = 42;            4: ldc2_w #4; //long 42l
                        7: lstore_3
long c = a ^ b;         8: lload_1
                        9: lload_3
                       10: lxor
                       11: lstore 5

Binäre Darstellung:

 70 = (00000000 00000000 00000000 00000000 00000000 00000000 00000000 01000110)b
 42 = (00000000 00000000 00000000 00000000 00000000 00000000 00000000 00101010)b
108 = (00000000 00000000 00000000 00000000 00000000 00000000 00000000 01101100)b