รูปแบบไบต์ของ Dalvik

การออกแบบทั่วไป

  • โมเดลเครื่องและรูปแบบการโทรมีจุดมุ่งหมายเพื่อเลียนแบบสถาปัตยกรรมจริงทั่วไปและรูปแบบการโทรแบบ C โดยประมาณ:
    • เครื่องเป็นแบบรีจิสเตอร์ และเฟรมจะมีขนาดคงที่เมื่อสร้าง แต่ละเฟรมประกอบด้วยจำนวนรีจิสเตอร์เฉพาะ (ระบุโดยวิธีการ) เช่นเดียวกับข้อมูลเสริมที่จำเป็นในการดำเนินการวิธีการ เช่น (แต่ไม่จำกัดเพียง) ตัวนับโปรแกรม และการอ้างอิงไปยังไฟล์ .dex ที่มีวิธีการ .
    • เมื่อใช้กับค่าบิต (เช่นจำนวนเต็มและตัวเลขทศนิยม) รีจิสเตอร์จะถือว่ามีความกว้าง 32 บิต คู่รีจิสเตอร์ที่อยู่ติดกันใช้สำหรับค่า 64 บิต ไม่มีข้อกำหนดการจัดตำแหน่งสำหรับคู่รีจิสเตอร์
    • เมื่อใช้สำหรับการอ้างอิงออบเจ็กต์ รีจิสเตอร์จะถือว่ากว้างพอที่จะเก็บการอ้างอิงดังกล่าวได้เพียงรายการเดียว
    • ในแง่ของการแสดงระดับบิต (Object) null == (int) 0
    • อาร์กิวเมนต์ N ของวิธีการลงจอดในการลงทะเบียน N สุดท้ายของกรอบการเรียกใช้ของวิธีการตามลำดับ อาร์กิวเมนต์แบบกว้างใช้สองรีจิสเตอร์ วิธีการอินสแตนซ์จะถูกส่งผ่านการอ้างอิง this เป็นอาร์กิวเมนต์แรก
  • หน่วยจัดเก็บข้อมูลในสตรีมคำสั่งเป็นปริมาณที่ไม่ได้ลงนาม 16 บิต บิตบางคำสั่งจะถูกละเว้น / ต้องเป็นศูนย์
  • คำแนะนำไม่ได้จำกัดอยู่เพียงประเภทใดประเภทหนึ่งโดยไม่จำเป็น ตัวอย่างเช่น คำแนะนำที่ย้ายค่ารีจิสเตอร์ 32 บิตโดยไม่มีการตีความ ไม่จำเป็นต้องระบุว่ากำลังย้าย ints หรือ float
  • มีพูลคงที่ที่แจกแจงและจัดทำดัชนีแยกต่างหากสำหรับการอ้างอิงถึงสตริง ชนิด ฟิลด์ และวิธีการ
  • ข้อมูลตามตัวอักษรระดับ Bitwise จะแสดงแบบอินไลน์ในสตรีมคำสั่ง
  • เนื่องจากในทางปฏิบัติ เป็นเรื่องปกติที่วิธีการจะต้องมีการลงทะเบียนมากกว่า 16 รายการ และเนื่องจากการจำเป็นต้องมีการลงทะเบียนมากกว่าแปดรายการนั้น เป็น เรื่องปกติธรรมดา คำสั่งจำนวนมากจึงจำกัดอยู่เพียงการจัดการกับการลงทะเบียน 16 รายการแรกเท่านั้น เมื่อเป็นไปได้ตามสมควร คำแนะนำจะอนุญาตให้อ้างอิงได้ถึงรีจิสเตอร์ 256 ตัวแรก นอกจากนี้ คำสั่งบางคำสั่งยังมีตัวแปรที่ช่วยให้สามารถนับจำนวนรีจิสเตอร์ได้มากขึ้น รวมถึงคู่คำสั่ง move ที่รับทั้งหมดที่สามารถจัดการกับรีจิสเตอร์ในช่วง v0 – v65535 ในกรณีที่ตัวแปรคำสั่งไม่พร้อมใช้งานเพื่อจัดการกับรีจิสเตอร์ที่ต้องการ คาดว่าเนื้อหารีจิสเตอร์จะถูกย้ายจากรีจิสเตอร์เดิมไปยังรีจิสเตอร์ต่ำ (ก่อนการดำเนินการ) และ/หรือย้ายจากรีจิสเตอร์ผลลัพธ์ต่ำไปสูง ลงทะเบียน (หลังการดำเนินการ)
  • มี "คำแนะนำหลอก" หลายประการที่ใช้เพื่อเก็บเพย์โหลดข้อมูลที่มีความยาวผันแปรได้ ซึ่งอ้างอิงโดยคำสั่งทั่วไป (เช่น fill-array-data ) คำสั่งดังกล่าวจะต้องไม่ถูกพบในระหว่างขั้นตอนการดำเนินการปกติ นอกจากนี้ คำแนะนำจะต้องอยู่บนออฟเซ็ตโค้ดไบต์ที่เป็นเลขคู่ (นั่นคือ จัดแนว 4 ไบต์) เพื่อให้เป็นไปตามข้อกำหนดนี้ เครื่องมือสร้าง dex จะต้องปล่อยคำสั่ง nop พิเศษเป็นตัวเว้นวรรค หากคำสั่งดังกล่าวไม่อยู่ในแนวเดียวกัน ท้ายที่สุด แม้ว่าจะไม่จำเป็น แต่คาดว่าเครื่องมือส่วนใหญ่จะเลือกที่จะปล่อยคำสั่งเหล่านี้ที่ส่วนท้ายของวิธีการ เนื่องจากไม่เช่นนั้น อาจเป็นกรณีที่จำเป็นต้องมีคำสั่งเพิ่มเติมเพื่อแยกสาขาออกไป
  • เมื่อติดตั้งบนระบบที่ทำงานอยู่ คำแนะนำบางอย่างอาจมีการเปลี่ยนแปลง โดยเปลี่ยนรูปแบบเป็นการเพิ่มประสิทธิภาพการเชื่อมโยงแบบคงที่เวลาติดตั้ง นี่คือเพื่อให้สามารถดำเนินการได้เร็วขึ้นเมื่อทราบการเชื่อมโยงแล้ว ดู เอกสารรูปแบบคำแนะนำ ที่เกี่ยวข้องสำหรับรุ่นที่แนะนำ แนะนำให้ใช้คำว่า "แนะนำ" ไม่จำเป็นต้องปฏิบัติตามสิ่งเหล่านี้
  • ไวยากรณ์ของมนุษย์และการช่วยจำ:
    • ลำดับปลายทางแล้วแหล่งที่มาสำหรับอาร์กิวเมนต์
    • opcode บางตัวมีคำต่อท้ายชื่อที่ไม่คลุมเครือเพื่อระบุประเภทที่ใช้:
      • opcodes 32 บิตทั่วไปประเภทไม่มีเครื่องหมาย
      • opcodes 64 บิตประเภททั่วไปต่อท้ายด้วย -wide
      • opcode เฉพาะประเภทต่อท้ายด้วยประเภท (หรือตัวย่อที่ตรงไปตรงมา) หนึ่งใน: -boolean -byte -char -short -int -long -float -double -object -string -class -void
    • opcode บางตัวมีส่วนต่อท้ายที่ไม่คลุมเครือเพื่อแยกแยะการดำเนินการที่เหมือนกันซึ่งมีรูปแบบคำสั่งหรือตัวเลือกที่แตกต่างกัน ส่วนต่อท้ายเหล่านี้แยกออกจากชื่อหลักด้วยเครื่องหมายทับ (" / ") และส่วนใหญ่มีอยู่เพื่อให้มีการแมปแบบหนึ่งต่อหนึ่งพร้อมค่าคงที่คงที่ในโค้ดที่สร้างและตีความไฟล์ปฏิบัติการ (นั่นคือเพื่อลดความคลุมเครือ สำหรับมนุษย์)
    • ในคำอธิบายที่นี่ ความกว้างของค่า (บ่งชี้ เช่น ช่วงของค่าคงที่หรือจำนวนรีจิสเตอร์ที่อาจระบุได้) ถูกเน้นโดยการใช้อักขระต่อความกว้างสี่บิต
    • ตัวอย่างเช่น ในคำสั่ง " move-wide/from16 vAA, vBBBB ":
      • " move " เป็น opcode พื้นฐานซึ่งระบุการดำเนินการพื้นฐาน (ย้ายค่าของรีจิสเตอร์)
      • " wide " คือส่วนต่อท้ายชื่อ ซึ่งบ่งชี้ว่าทำงานบนข้อมูลแบบกว้าง (64 บิต)
      • " from16 " คือส่วนต่อท้าย opcode ซึ่งระบุตัวแปรที่มีการอ้างอิงรีจิสเตอร์ 16 บิตเป็นแหล่งที่มา
      • " vAA " คือรีจิสเตอร์ปลายทาง (โดยนัยจากการดำเนินการ กฎก็คืออาร์กิวเมนต์ปลายทางมาก่อนเสมอ) ซึ่งต้องอยู่ในช่วง v0 – v255
      • " vBBBB " คือรีจิสเตอร์ต้นทาง ซึ่งจะต้องอยู่ในช่วง v0 – v65535
  • ดู เอกสารรูปแบบคำสั่ง สำหรับรายละเอียดเพิ่มเติมเกี่ยวกับรูปแบบคำสั่งต่างๆ (แสดงอยู่ใน "Op & รูปแบบ") รวมถึงรายละเอียดเกี่ยวกับไวยากรณ์ opcode
  • ดู เอกสารรูปแบบไฟล์ .dex สำหรับรายละเอียดเพิ่มเติมเกี่ยวกับตำแหน่งที่โค้ดไบต์พอดีกับภาพรวม

สรุปชุดไบต์โค้ด

ปฏิบัติการและรูปแบบ ช่วยในการจำ / ไวยากรณ์ ข้อโต้แย้ง คำอธิบาย
00 10x ไม่ วงจรของเสีย

หมายเหตุ: คำแนะนำหลอกที่มีข้อมูลจะถูกแท็กด้วย opcode นี้ ซึ่งในกรณีนี้ไบต์ที่มีลำดับสูงของหน่วย opcode จะระบุถึงลักษณะของข้อมูล ดู "รูปแบบ packed-switch-payload ", "รูปแบบ sparse-switch-payload " และ "รูปแบบ fill-array-data-payload " ด้านล่าง

01 12x ย้าย vA, vB A: การลงทะเบียนปลายทาง (4 บิต)
B: แหล่งรีจิสเตอร์ (4 บิต)		 ย้ายเนื้อหาของการลงทะเบียนที่ไม่ใช่วัตถุหนึ่งไปยังอีกที่หนึ่ง
02 22x ย้าย/จาก16 vAA, vBBBB A: การลงทะเบียนปลายทาง (8 บิต)
B: แหล่งรีจิสเตอร์ (16 บิต)		 ย้ายเนื้อหาของการลงทะเบียนที่ไม่ใช่วัตถุหนึ่งไปยังอีกที่หนึ่ง
03 32x ย้าย/16 vAAAA, vBBBB A: การลงทะเบียนปลายทาง (16 บิต)
B: แหล่งรีจิสเตอร์ (16 บิต)		 ย้ายเนื้อหาของการลงทะเบียนที่ไม่ใช่วัตถุหนึ่งไปยังอีกที่หนึ่ง
04 12x vA, vB แบบเคลื่อนที่ A: คู่รีจิสเตอร์ปลายทาง (4 บิต)
B: คู่รีจิสเตอร์ต้นทาง (4 บิต)		 ย้ายเนื้อหาของคู่รีจิสเตอร์หนึ่งไปยังอีกคู่หนึ่ง

หมายเหตุ: การย้ายจาก v N ไปเป็น v N-1 หรือ v N+1 เป็นเรื่องถูกกฎหมาย ดังนั้นการใช้งานจะต้องจัดให้คู่รีจิสเตอร์ทั้งสองครึ่งหนึ่งถูกอ่านก่อนที่จะเขียนสิ่งใดๆ

05 22x เคลื่อนที่กว้าง/จาก 16 vAA, vBBBB A: คู่รีจิสเตอร์ปลายทาง (8 บิต)
B: คู่รีจิสเตอร์ต้นทาง (16 บิต)		 ย้ายเนื้อหาของคู่รีจิสเตอร์หนึ่งไปยังอีกคู่หนึ่ง

หมายเหตุ: ข้อควรพิจารณาในการติดตั้งใช้งานจะเหมือนกับ move-wide ด้านบน

06 32x ย้ายกว้าง/16 vAAAA, vBBBB A: คู่รีจิสเตอร์ปลายทาง (16 บิต)
B: คู่รีจิสเตอร์ต้นทาง (16 บิต)		 ย้ายเนื้อหาของคู่รีจิสเตอร์หนึ่งไปยังอีกคู่หนึ่ง

หมายเหตุ: ข้อควรพิจารณาในการติดตั้งใช้งานจะเหมือนกับ move-wide ด้านบน

07 12x ย้ายวัตถุ vA, vB A: การลงทะเบียนปลายทาง (4 บิต)
B: แหล่งรีจิสเตอร์ (4 บิต)		 ย้ายเนื้อหาของรีจิสเตอร์แบริ่งวัตถุหนึ่งไปยังอีกอันหนึ่ง
08 22x ย้ายวัตถุ / from16 vAA, vBBBB A: การลงทะเบียนปลายทาง (8 บิต)
B: แหล่งรีจิสเตอร์ (16 บิต)		 ย้ายเนื้อหาของรีจิสเตอร์แบริ่งวัตถุหนึ่งไปยังอีกอันหนึ่ง
09 32x ย้ายวัตถุ / 16 vAAAA, vBBBB A: การลงทะเบียนปลายทาง (16 บิต)
B: แหล่งรีจิสเตอร์ (16 บิต)		 ย้ายเนื้อหาของรีจิสเตอร์แบริ่งวัตถุหนึ่งไปยังอีกอันหนึ่ง
0a 11x ผลการย้าย vAA A: การลงทะเบียนปลายทาง (8 บิต) ย้ายผลลัพธ์คำเดียวที่ไม่ใช่วัตถุของ invoke- kind ครั้งล่าสุดไปยังรีจิสเตอร์ที่ระบุ สิ่งนี้จะต้องทำเป็นคำสั่งทันทีหลังจาก invoke- kind ซึ่งมีผลลัพธ์ (คำเดียว ไม่ใช่วัตถุ) ที่ไม่ควรละเลย ที่อื่นไม่ถูกต้อง
0b 11x vAA ทั่วทั้งผลลัพธ์ A: คู่รีจิสเตอร์ปลายทาง (8 บิต) ย้ายผลลัพธ์แบบ double-word ของ invoke- kind ล่าสุดไปยังคู่รีจิสเตอร์ที่ระบุ สิ่งนี้จะต้องทำเป็นคำสั่งทันทีหลังจาก invoke- kind ซึ่งมีผลลัพธ์ (สองคำ) ที่ไม่ควรละเลย ที่อื่นไม่ถูกต้อง
0c 11x ย้ายผลวัตถุ vAA A: การลงทะเบียนปลายทาง (8 บิต) ย้ายผลลัพธ์อ็อบเจ็กต์ของ invoke- kind ล่าสุดไปยังรีจิสเตอร์ที่ระบุ สิ่งนี้จะต้องทำเป็นคำสั่งทันทีหลังจาก invoke- kind หรือ filled-new-array ซึ่งผลลัพธ์ (อ็อบเจ็กต์) ไม่ควรถูกละเลย ที่อื่นไม่ถูกต้อง
0d 11x ข้อยกเว้นการย้าย vAA A: การลงทะเบียนปลายทาง (8 บิต) บันทึกข้อยกเว้นที่เพิ่งพบลงในการลงทะเบียนที่กำหนด นี่จะต้องเป็นคำสั่งแรกของตัวจัดการข้อยกเว้นใดๆ ที่มีข้อยกเว้นที่จับได้และไม่ควรละเลย และคำสั่งนี้จะต้องเกิดขึ้นเป็นคำสั่งแรกของตัวจัดการข้อยกเว้น เท่านั้น ที่อื่นไม่ถูกต้อง
0e 10x กลับเป็นโมฆะ กลับจากวิธี void
0f 11x ส่งกลับ vAA A: รีจิสเตอร์ค่าส่งคืน (8 บิต) ส่งกลับจากวิธีการส่งกลับค่าที่ไม่ใช่วัตถุที่มีความกว้างเดียว (32 บิต)
10 11x vAA แบบย้อนกลับ A: ค่าส่งคืนรีจิสเตอร์คู่ (8 บิต) ส่งกลับจากวิธีการส่งกลับค่าแบบ double-width (64 บิต)
11 11x กลับวัตถุ vAA A: รีจิสเตอร์ค่าส่งคืน (8 บิต) กลับจากวิธีการส่งคืนวัตถุ
12 11น const/4 vA, #+B A: การลงทะเบียนปลายทาง (4 บิต)
B: ลงนาม int (4 บิต)		 ย้ายค่าตัวอักษรที่กำหนด (ขยายเครื่องหมายเป็น 32 บิต) ไปยังรีจิสเตอร์ที่ระบุ
13 21ส const/16 vAA, #+BBBB A: การลงทะเบียนปลายทาง (8 บิต)
B: ลงนาม int (16 บิต)		 ย้ายค่าตัวอักษรที่กำหนด (ขยายเครื่องหมายเป็น 32 บิต) ไปยังรีจิสเตอร์ที่ระบุ
14 31i const vAA, #+BBBBBBBB A: การลงทะเบียนปลายทาง (8 บิต)
B: ค่าคงที่ 32 บิตตามอำเภอใจ		 ย้ายค่าตามตัวอักษรที่กำหนดไปยังรีจิสเตอร์ที่ระบุ
15 21ชม const/high16 vAA, #+BBBB0000 A: การลงทะเบียนปลายทาง (8 บิต)
B: ลงนาม int (16 บิต)		 ย้ายค่าตัวอักษรที่กำหนด (ขยายไปทางขวาเป็นศูนย์เป็น 32 บิต) ไปยังรีจิสเตอร์ที่ระบุ
16 21ส const-wide/16 vAA, #+BBBB A: การลงทะเบียนปลายทาง (8 บิต)
B: ลงนาม int (16 บิต)		 ย้ายค่าตัวอักษรที่กำหนด (ขยายเครื่องหมายเป็น 64 บิต) ไปยังคู่รีจิสเตอร์ที่ระบุ
17 31i const-wide/32 vAA, #+BBBBBBBB A: การลงทะเบียนปลายทาง (8 บิต)
B: ลงนาม int (32 บิต)		 ย้ายค่าตัวอักษรที่กำหนด (ขยายเครื่องหมายเป็น 64 บิต) ไปยังคู่รีจิสเตอร์ที่ระบุ
18 51ล vAA ทั่วทั้ง const, #+BBBBBBBBBBBBBBBB A: การลงทะเบียนปลายทาง (8 บิต)
B: ค่าคงที่ความกว้างสองเท่า (64 บิต) โดยพลการ		 ย้ายค่าตัวอักษรที่กำหนดไปยังคู่รีจิสเตอร์ที่ระบุ
19 21ชม const-กว้าง/สูง16 vAA, #+BBBB000000000000 A: การลงทะเบียนปลายทาง (8 บิต)
B: ลงนาม int (16 บิต)		 ย้ายค่าตัวอักษรที่กำหนด (ขยายไปทางขวาเป็นศูนย์เป็น 64 บิต) ไปยังคู่รีจิสเตอร์ที่ระบุ
1a 21ค const-สตริง vAA, string@BBBB A: การลงทะเบียนปลายทาง (8 บิต)
B: ดัชนีสตริง		 ย้ายการอ้างอิงไปยังสตริงที่ระบุโดยดัชนีที่กำหนดไปยังรีจิสเตอร์ที่ระบุ
1b 31c const-string/jumbo vAA, string@BBBBBBBB A: การลงทะเบียนปลายทาง (8 บิต)
B: ดัชนีสตริง		 ย้ายการอ้างอิงไปยังสตริงที่ระบุโดยดัชนีที่กำหนดไปยังรีจิสเตอร์ที่ระบุ
1c 21c vAA คลาส const พิมพ์@BBBB A: การลงทะเบียนปลายทาง (8 บิต)
B: ประเภทดัชนี		 ย้ายการอ้างอิงไปยังคลาสที่ระบุโดยดัชนีที่กำหนดไปยังรีจิสเตอร์ที่ระบุ ในกรณีที่ประเภทที่ระบุเป็นประเภทดั้งเดิม สิ่งนี้จะจัดเก็บการอ้างอิงถึงคลาสที่เสื่อมถอยของประเภทดั้งเดิม
1วัน 11x จอภาพป้อน vAA A: รีจิสเตอร์แบริ่งอ้างอิง (8 บิต) รับจอภาพสำหรับวัตถุที่ระบุ
1e 11x vAA ของจอภาพ A: รีจิสเตอร์แบริ่งอ้างอิง (8 บิต) ปล่อยจอภาพสำหรับวัตถุที่ระบุ

หมายเหตุ: หากคำสั่งนี้จำเป็นต้องมีข้อยกเว้น จะต้องดำเนินการเสมือนว่าพีซีได้ก้าวข้ามคำสั่งนั้นไปแล้ว อาจมีประโยชน์ที่จะคิดว่าสิ่งนี้เนื่องจากคำสั่งดำเนินการได้สำเร็จ (ในแง่หนึ่ง) และข้อยกเว้นเกิดขึ้น หลังจาก คำสั่ง แต่ ก่อนที่ คำสั่งถัดไปจะมีโอกาสรัน คำจำกัดความนี้ทำให้เป็นไปได้สำหรับวิธีการใช้บล็อกการล้างข้อมูลมอนิเตอร์ catch-all (เช่น finally ) เป็นการล้างข้อมูลมอนิเตอร์สำหรับบล็อกนั้นเอง เป็นวิธีจัดการกับข้อยกเว้นตามอำเภอใจที่อาจถูกโยนทิ้งเนื่องจากการใช้งาน Thread.stop() ที่ผ่านมา Thread.stop() ในขณะที่ยังคงจัดการให้มีสุขอนามัยของจอภาพที่เหมาะสม

1f 21ค เช็คคาสท์ vAA พิมพ์@BBBB A: รีจิสเตอร์แบริ่งอ้างอิง (8 บิต)
B: ประเภทดัชนี (16 บิต)		 โยน ClassCastException หากการอ้างอิงในการลงทะเบียนที่กำหนดไม่สามารถส่งไปยังประเภทที่ระบุได้

หมายเหตุ: เนื่องจาก A ต้องเป็นการอ้างอิงเสมอ (และไม่ใช่ค่าดั้งเดิม) จึงจำเป็นต้องล้มเหลวในขณะรันไทม์ (นั่นคือ มันจะส่งข้อยกเว้น) หาก B อ้างถึงประเภทดั้งเดิม

20 22ค อินสแตนซ์ของ vA, vB, type@CCCC A: การลงทะเบียนปลายทาง (4 บิต)
B: รีจิสเตอร์แบริ่งอ้างอิง (4 บิต)
C: ประเภทดัชนี (16 บิต)		 เก็บในรีจิสเตอร์ปลายทางที่กำหนด 1 หากการอ้างอิงที่ระบุเป็นอินสแตนซ์ของประเภทที่กำหนด หรือ 0 หากไม่ใช่

หมายเหตุ: เนื่องจาก B ต้องเป็นข้อมูลอ้างอิงเสมอ (และไม่ใช่ค่าดั้งเดิม) ซึ่งจะส่งผลให้มีการจัดเก็บ 0 เสมอหาก C อ้างถึงประเภทดั้งเดิม

21 12x vA, vB ที่มีความยาวอาร์เรย์ A: การลงทะเบียนปลายทาง (4 บิต)
B: รีจิสเตอร์แบริ่งอ้างอิงอาเรย์ (4 บิต)		 เก็บในปลายทางที่กำหนดลงทะเบียนความยาวของอาร์เรย์ที่ระบุในรายการ
22 21ค vAA อินสแตนซ์ใหม่ พิมพ์@BBBB A: การลงทะเบียนปลายทาง (8 บิต)
B: ประเภทดัชนี		 สร้างอินสแตนซ์ใหม่ของประเภทที่ระบุ โดยจัดเก็บข้อมูลอ้างอิงไว้ในปลายทาง ประเภทจะต้องอ้างอิงถึงคลาสที่ไม่ใช่อาร์เรย์
23 22ค อาร์เรย์ใหม่ vA, vB, type@CCCC A: การลงทะเบียนปลายทาง (4 บิต)
B: การลงทะเบียนขนาด
C: ดัชนีประเภท		 สร้างอาร์เรย์ใหม่ของประเภทและขนาดที่ระบุ ประเภทจะต้องเป็นประเภทอาร์เรย์
24 35ค เติมอาร์เรย์ใหม่ {vC, vD, veE, vF, vG}, type@BBBB A: ขนาดอาร์เรย์และจำนวนคำอาร์กิวเมนต์ (4 บิต)
B: ประเภทดัชนี (16 บิต)
C..G: อาร์กิวเมนต์รีจิสเตอร์ (อันละ 4 บิต)		 สร้างอาร์เรย์ตามประเภทและขนาดที่กำหนด โดยกรอกเนื้อหาที่ให้มา ประเภทจะต้องเป็นประเภทอาร์เรย์ เนื้อหาของอาร์เรย์ต้องเป็นคำเดียว (กล่าวคือ ไม่มีอาร์เรย์แบบ long หรือ double แต่ประเภทการอ้างอิงเป็นที่ยอมรับได้) อินสแตนซ์ที่สร้างขึ้นจะถูกจัดเก็บเป็น "ผลลัพธ์" ในลักษณะเดียวกับที่คำแนะนำการเรียกใช้เมธอดจัดเก็บผลลัพธ์ ดังนั้นอินสแตนซ์ที่สร้างขึ้นจะต้องถูกย้ายไปยังรีจิสเตอร์พร้อมกับคำสั่ง move-result-object ที่ตามมาทันที (หากจำเป็นต้องใช้ ).
25 3rc เติมอาร์เรย์ใหม่ / ช่วง {vCCCC .. vNNNN}, type@BBBB A: ขนาดอาร์เรย์และจำนวนคำอาร์กิวเมนต์ (8 บิต)
B: ประเภทดัชนี (16 บิต)
C: การลงทะเบียนอาร์กิวเมนต์แรก (16 บิต)
N = A + C - 1		 สร้างอาร์เรย์ตามประเภทและขนาดที่กำหนด โดยกรอกเนื้อหาที่ให้มา การชี้แจงและข้อจำกัดเหมือนกับ filled-new-array ตามที่อธิบายไว้ข้างต้น
26 31ต fill-array-data vAA, +BBBBBBBB (พร้อมข้อมูลเพิ่มเติมตามที่ระบุด้านล่างใน " fill-array-data-payload Format") A: การอ้างอิงอาร์เรย์ (8 บิต)
B: ลงนาม "สาขา" ชดเชยคำแนะนำหลอกข้อมูลตาราง (32 บิต)		 กรอกอาร์เรย์ที่กำหนดด้วยข้อมูลที่ระบุ การอ้างอิงต้องเป็นอาร์เรย์ของค่าพื้นฐาน และตารางข้อมูลจะต้องตรงกับประเภทและต้องไม่มีองค์ประกอบเกินกว่าที่จะพอดีกับอาร์เรย์ นั่นคืออาร์เรย์อาจมีขนาดใหญ่กว่าตาราง และหากเป็นเช่นนั้น จะมีการตั้งค่าเฉพาะองค์ประกอบเริ่มต้นของอาร์เรย์เท่านั้น โดยปล่อยให้ส่วนที่เหลืออยู่ตามลำพัง
27 11x โยน vAA A: การลงทะเบียนที่มีข้อยกเว้น (8 บิต)
 โยนข้อยกเว้นที่ระบุ
28 10ต ไปที่ +AA A: ออฟเซ็ตสาขาที่ลงนาม (8 บิต) ข้ามไปยังคำสั่งที่ระบุโดยไม่มีเงื่อนไข

หมายเหตุ: สาขาออฟเซ็ตจะต้องไม่เป็น 0 (สปินลูปอาจถูกสร้างขึ้นอย่างถูกต้องตามกฎหมายด้วย goto/32 หรือโดยรวม nop เป็นเป้าหมายก่อนแบรนช์)

29 20ต ไปที่/16 +AAAA A: ออฟเซ็ตสาขาที่ลงนาม (16 บิต)
 ข้ามไปยังคำสั่งที่ระบุโดยไม่มีเงื่อนไข

หมายเหตุ: สาขาออฟเซ็ตจะต้องไม่เป็น 0 (สปินลูปอาจถูกสร้างขึ้นอย่างถูกต้องตามกฎหมายด้วย goto/32 หรือโดยรวม nop เป็นเป้าหมายก่อนแบรนช์)

2a 30t ไปที่/32 +AAAAAAA A: ออฟเซ็ตสาขาที่ลงนาม (32 บิต)
 ข้ามไปยังคำสั่งที่ระบุโดยไม่มีเงื่อนไข
2b 31t Packed-Switch vAA, +BBBBBBBB (พร้อมข้อมูลเพิ่มเติมตามที่ระบุไว้ด้านล่างใน " รูปแบบ packed-switch-payload ") A: ลงทะเบียนเพื่อทดสอบ
B: ลงนาม "สาขา" ชดเชยคำแนะนำหลอกข้อมูลตาราง (32 บิต)		 ข้ามไปยังคำสั่งใหม่ตามค่าในรีจิสเตอร์ที่กำหนด โดยใช้ตารางออฟเซ็ตที่สอดคล้องกับแต่ละค่าในช่วงอินทิกรัลเฉพาะ หรือเลื่อนไปที่คำสั่งถัดไปหากไม่มีค่าที่ตรงกัน
2c 31t sparse-switch vAA, +BBBBBBBB (พร้อมข้อมูลเพิ่มเติมตามที่ระบุไว้ด้านล่างใน " รูปแบบ sparse-switch-payload ") A: ลงทะเบียนเพื่อทดสอบ
B: ลงนาม "สาขา" ชดเชยคำแนะนำหลอกข้อมูลตาราง (32 บิต)		 ข้ามไปยังคำสั่งใหม่ตามค่าในรีจิสเตอร์ที่กำหนด โดยใช้ตารางลำดับของคู่ค่า-ออฟเซ็ต หรือเลื่อนไปที่คำสั่งถัดไปหากไม่มีค่าที่ตรงกัน
2วัน..31 23x cmp ชนิด vAA, vBB, vCC
2d: cmpl-float (อคติเล็กน้อย)
2e: cmpg-float (อคติ gt)
2f: cmpl-double (อคติเล็กน้อย)
30: cmpg-double (อคติ gt)
31: cmp-ยาว		 A: การลงทะเบียนปลายทาง (8 บิต)
B: การลงทะเบียนหรือจับคู่แหล่งแรก
C: การลงทะเบียนหรือจับคู่แหล่งที่สอง		 ดำเนินการจุดลอยตัวที่ระบุหรือการเปรียบเทียบ long โดยตั้งค่า a เป็น 0 ถ้า b == c , 1 ถ้า b > c หรือ -1 ถ้า b < c "อคติ" ที่แสดงไว้สำหรับการดำเนินการจุดลอยตัวบ่งชี้ว่าการเปรียบเทียบ NaN ได้รับการปฏิบัติอย่างไร: คำสั่ง "gt bias" ส่งคืน 1 สำหรับการเปรียบเทียบ NaN และคำสั่ง "lt bias" ส่งคืน -1

ตัวอย่างเช่น หากต้องการตรวจสอบว่าจุดลอยตัว x < y แนะนำให้ใช้ cmpg-float ; ผลลัพธ์ของ -1 บ่งชี้ว่าการทดสอบเป็นจริง และค่าอื่นๆ ระบุว่าเป็นเท็จเนื่องจากการเปรียบเทียบที่ถูกต้องหรือเนื่องจากค่าใดค่าหนึ่งคือ NaN

32..37 22ต ถ้า- ทดสอบ vA, vB, + CCCC
32: ถ้า-EQ
33: ถ้า-ใช่
34: ถ้า-lt
35: ถ้า-ge
36: ถ้า-gt
37: ถ้า-le
 A: ลงทะเบียนครั้งแรกเพื่อทดสอบ (4 บิต)
B: การลงทะเบียนครั้งที่สองเพื่อทดสอบ (4 บิต)
C: ออฟเซ็ตสาขาที่เซ็นชื่อ (16 บิต)		 แยกสาขาไปยังปลายทางที่กำหนดหากค่าของรีจิสเตอร์สองตัวที่กำหนดเปรียบเทียบตามที่ระบุ

หมายเหตุ: สาขาออฟเซ็ตจะต้องไม่เป็น 0 (สปินลูปอาจถูกสร้างขึ้นอย่างถูกต้องตามกฎหมายโดยการแตกแขนงรอบ goto ย้อนกลับหรือโดยรวม nop เป็นเป้าหมายก่อนแบรนช์)

38..3วัน 21ต ถ้า- ทดสอบ z vAA, +BBBB
38: ถ้า-eqz
39: ถ้า-nez
3a: ถ้า-ltz
3b: ถ้า-gez
3c: ถ้า-gtz
3d: ถ้า-lez
 A: ลงทะเบียนเพื่อทดสอบ (8 บิต)
B: ออฟเซ็ตสาขาที่เซ็นชื่อ (16 บิต)		 แยกไปยังปลายทางที่กำหนดหากค่าของการลงทะเบียนที่กำหนดเปรียบเทียบกับ 0 ตามที่ระบุไว้

หมายเหตุ: สาขาออฟเซ็ตจะต้องไม่เป็น 0 (สปินลูปอาจถูกสร้างขึ้นอย่างถูกต้องตามกฎหมายโดยการแตกแขนงรอบ goto ย้อนกลับหรือโดยรวม nop เป็นเป้าหมายก่อนแบรนช์)

3e..43 10x (ไม่ได้ใช้) (ไม่ได้ใช้)
44..51 23x อาร์เรย์ vAA, vBB, vCC
44: อายุ
45: ทั่วทั้งช่วงอายุ
46: age-วัตถุ
47: เอจ-บูลีน
48: อายุไบต์
49: เอจ-ถ่าน
4a: อายุสั้น
4b: เอาล่ะ
4c: aput-wide
4d: aput-วัตถุ
4e: aput-บูลีน
4f: aput-ไบต์
50: aput-char
51: aput-สั้น		 A: ค่าลงทะเบียนหรือคู่; อาจเป็นแหล่งที่มาหรือปลายทาง (8 บิต)
B: การลงทะเบียนอาร์เรย์ (8 บิต)
C: การลงทะเบียนดัชนี (8 บิต)		 ดำเนินการดำเนินการอาร์เรย์ที่ระบุที่ดัชนีที่ระบุของอาร์เรย์ที่กำหนด โหลดหรือจัดเก็บลงในการลงทะเบียนค่า
52..5f 22ค ฉัน อินสแตนซ์ vA, vB, field@CCCC
52: เข้าใจแล้ว
53: ทั่วทั้ง iget
54: iget-วัตถุ
55: iget-boolean
56: iget-ไบต์
57: iget-char
58: iget-สั้น
59: iput
5a: iput-wide
5b: iput-วัตถุ
5c: iput-boolean
5d: iput-ไบต์
5e: iput-char
5f: iput-short		 A: ค่าลงทะเบียนหรือคู่; อาจเป็นแหล่งที่มาหรือปลายทาง (4 บิต)
B: การลงทะเบียนวัตถุ (4 บิต)
C: ดัชนีอ้างอิงฟิลด์อินสแตนซ์ (16 บิต)		 ดำเนินการฟิลด์อินสแตนซ์วัตถุที่ระบุกับฟิลด์ที่ระบุ โหลดหรือจัดเก็บลงในการลงทะเบียนค่า

หมายเหตุ: opcode เหล่านี้เป็นตัวเลือกที่สมเหตุสมผลสำหรับการเชื่อมโยงแบบคงที่ โดยเปลี่ยนอาร์กิวเมนต์ของฟิลด์ให้เป็นออฟเซ็ตที่ตรงมากขึ้น

60..6วัน 21ค ของ staticop vAA, field@BBBB
60: เก็ท
61: ทั่วทั้งพื้นที่
62: sget-วัตถุ
63: sget-บูลีน
64: sget-ไบต์
65: sget-char
66: sget-สั้น
67: น้ำลาย
68: กว้างปาก
69: วัตถุพ่น
6a: สปัต-บูลีน
6b: สปัตไบต์
6c: เสมหะถ่าน
6d: สั้นมาก		 A: ค่าลงทะเบียนหรือคู่; อาจเป็นแหล่งที่มาหรือปลายทาง (8 บิต)
B: ดัชนีอ้างอิงฟิลด์คงที่ (16 บิต)		 ดำเนินการดำเนินการฟิลด์คงที่ของวัตถุที่ระบุด้วยฟิลด์คงที่ที่ระบุ โหลดหรือจัดเก็บลงในการลงทะเบียนค่า

หมายเหตุ: opcode เหล่านี้เป็นตัวเลือกที่สมเหตุสมผลสำหรับการเชื่อมโยงแบบคงที่ โดยเปลี่ยนอาร์กิวเมนต์ของฟิลด์ให้เป็นออฟเซ็ตที่ตรงมากขึ้น

6e..72 35c เรียกใช้ ชนิด {vC, vD, veE, vF, vG}, meth@BBBB
6e: เรียกใช้-เสมือน
6f: เรียกใช้-super
70: เรียกใช้โดยตรง
71: เรียกใช้แบบคงที่
72: เรียกใช้อินเทอร์เฟซ		 A: จำนวนคำอาร์กิวเมนต์ (4 บิต)
B: ดัชนีอ้างอิงวิธีการ (16 บิต)
C..G: อาร์กิวเมนต์รีจิสเตอร์ (อันละ 4 บิต)		 โทรตามวิธีที่ระบุ ผลลัพธ์ (ถ้ามี) อาจถูกจัดเก็บไว้พร้อมกับ move-result* ที่เหมาะสมเป็นคำสั่งที่ตามมาทันที

invoke-virtual ใช้เพื่อเรียกใช้เมธอดเสมือนปกติ (เมธอดที่ไม่ใช่ private , static หรือ final และไม่ใช่ Constructor ด้วย)

เมื่อ method_id อ้างอิงถึงเมธอดของคลาสที่ไม่ใช่อินเทอร์เฟซ invoke-super จะถูกใช้เพื่อเรียกใช้เมธอดเสมือนของซูเปอร์คลาสที่ใกล้เคียงที่สุด (ตรงข้ามกับเมธอดที่มี method_id เดียวกันในคลาสการเรียก) ข้อจำกัดของวิธีการเดียวกันนี้ถือเป็นการ invoke-virtual

ในไฟล์ Dex เวอร์ชัน 037 หรือใหม่กว่า หาก method_id อ้างถึงวิธีอินเทอร์เฟซ ระบบจะใช้การ invoke-super เพื่อเรียกใช้เวอร์ชันที่เจาะจงที่สุดและไม่ถูกแทนที่ของวิธีการนั้นที่กำหนดไว้บนอินเทอร์เฟซนั้น ข้อจำกัดของวิธีการเดียวกันนี้ถือเป็นการ invoke-virtual ในไฟล์ Dex ก่อนหน้าเวอร์ชัน 037 การมีอินเทอร์เฟซ method_id ถือเป็นสิ่งผิดกฎหมายและไม่ได้กำหนดไว้

invoke-direct ใช้เพื่อเรียกใช้วิธีการโดยตรงที่ไม่ static (นั่นคือ วิธีการอินสแตนซ์ที่โดยธรรมชาติแล้วไม่สามารถแทนที่ได้ กล่าวคือ วิธีการอินสแตนซ์ private หรือตัวสร้าง)

invoke-static ใช้เพื่อเรียกใช้เมธอดแบบ static (ซึ่งถือว่าเป็นเมธอดโดยตรงเสมอ)

เรียกใช้ invoke-interface เพื่อเรียกใช้วิธี interface ซ นั่นคือบนอ็อบเจ็กต์ที่ไม่รู้จักคลาสที่เป็นรูปธรรม โดยใช้ method_id ที่อ้างถึง interface

หมายเหตุ: opcode เหล่านี้เป็นตัวเลือกที่สมเหตุสมผลสำหรับการเชื่อมโยงแบบคงที่ โดยเปลี่ยนอาร์กิวเมนต์ของเมธอดให้เป็นออฟเซ็ตที่ตรงมากขึ้น (หรือจับคู่กัน)

73 10x (ไม่ได้ใช้) (ไม่ได้ใช้)
74..78 3rc เรียกใช้ ชนิด / ช่วง {vCCCC .. vNNNN}, meth@BBBB
74: เรียกใช้-เสมือน/ช่วง
75: เรียกใช้-super/range
76: เรียกใช้โดยตรง/ช่วง
77: เรียกใช้-คงที่/ช่วง
78: เรียกใช้อินเทอร์เฟซ/ช่วง		 A: จำนวนคำอาร์กิวเมนต์ (8 บิต)
B: ดัชนีอ้างอิงวิธีการ (16 บิต)
C: การลงทะเบียนอาร์กิวเมนต์แรก (16 บิต)
N = A + C - 1		 โทรตามวิธีที่ระบุ ดูคำอธิบาย invoke- kind ครั้งแรกด้านบนสำหรับรายละเอียด คำเตือน และคำแนะนำ
79..7a 10x (ไม่ได้ใช้) (ไม่ได้ใช้)
7b..8f 12x ยกเลิก vA, vB
7b: neg-int
7c: ไม่ใช่ int
7d: neg-long
7e: ไม่นาน
7f: neg-ลอย
80: neg-ดับเบิ้ล
81: int-to-long
82: จากภายในสู่ลอย
83: จากภายในเป็นสองเท่า
84: ยาวถึง int
85: ยาวถึงลอย
86: ยาวเป็นสองเท่า
87: float-to-int
88: ลอยไปยาว
89: ลอยเป็นสองเท่า
8a: สองเท่าถึง int
8b: สองเท่าถึงยาว
8c: สองเท่าถึงลอย
8d: เป็นหน่วยเป็นไบต์
8e: int-to-char
8f: จากภายในถึงสั้น		 A: รีจิสเตอร์ปลายทางหรือคู่ (4 บิต)
B: รีจิสเตอร์ต้นทางหรือคู่ (4 บิต)		 ดำเนินการการดำเนินการเอกนารีที่ระบุในรีจิสเตอร์ต้นทาง โดยจัดเก็บผลลัพธ์ไว้ในรีจิสเตอร์ปลายทาง
90..อัฟ23x binop vAA, vBB, vCC
90: ส่วนเสริม
91: ย่อย int
92: mul-int
93: div-int
94: rem-int
95: และ-int
96: หรือ-int
97: xor-int
98: shl-int
99: shr-int
9a: ushr-int
9b: เพิ่มยาว
9c: ยาวย่อย
9d: มัลยาว
9e: div ยาว
9f: ยาวมาก
a0: และ-ยาว
a1: หรือ-ยาว
a2: xor ยาว
a3: shl ยาว
a4: shr ยาว
a5: ushr ยาว
a6: เพิ่ม-ลอย
a7: ย่อยลอย
a8: มัลโฟลต
a9: div-ลอย
aa: rem-ลอย
ab: เพิ่มสองเท่า
ac: ซับดับเบิ้ล
โฆษณา: มัล-ดับเบิ้ล
th: div-สองเท่า
af: rem-ดับเบิ้ล		 A: รีจิสเตอร์ปลายทางหรือคู่ (8 บิต)
B: รีจิสเตอร์แหล่งแรกหรือคู่ (8 บิต)
C: รีจิสเตอร์แหล่งที่สองหรือคู่ (8 บิต)		 ดำเนินการดำเนินการไบนารีที่ระบุบนรีจิสเตอร์ต้นทางทั้งสอง โดยจัดเก็บผลลัพธ์ไว้ในรีจิสเตอร์ปลายทาง

หมายเหตุ: ตรงกันข้ามกับการดำเนินการทางคณิตศาสตร์ -long อื่นๆ (ซึ่งใช้คู่รีจิสเตอร์สำหรับทั้งแหล่งที่มาแรกและแหล่งที่สอง) shl-long , shr-long และ ushr-long ใช้คู่รีจิสเตอร์สำหรับแหล่งที่มาแรก (ค่าที่จะเปลี่ยน ) แต่เป็นรีจิสเตอร์เดียวสำหรับแหล่งที่สอง (ระยะการเลื่อน)

b0..cf 12x บินอป /2addr vA, vB
b0: เพิ่ม-int/2addr
b1: ย่อย int/2addr
b2: mul-int/2addr
b3: div-int/2addr
b4: rem-int/2addr
b5: และ-int/2addr
b6: หรือ-int/2addr
b7: xor-int/2addr
b8: shl-int/2addr
b9: shr-int/2addr
บริติชแอร์เวย์: ushr-int/2addr
bb: เพิ่ม-ยาว/2addr
bc: ย่อยยาว/2addr
bd: mul-long/2addr
เป็น: div-long/2addr
bf: rem-long/2addr
c0: และ-ยาว/2addr
c1: หรือ-long/2addr
c2: xor-long/2addr
c3: shl-long/2addr
c4: shr-long/2addr
c5: ushr-long/2addr
c6: เพิ่ม-ลอย/2addr
c7: ย่อยโฟลต/2addr
c8: mul-float/2addr
c9: div-float/2addr
แคลิฟอร์เนีย: rem-float/2addr
cb: เพิ่ม-สองเท่า/2addr
ซีซี: ซับดับเบิ้ล/2แอดเดอร์
ซีดี: mul-double/2addr
ce: div-double/2addr
cf: rem-double/2addr		 A: ปลายทางและรีจิสเตอร์ต้นทางหรือคู่ (4 บิต)
B: รีจิสเตอร์แหล่งที่สองหรือคู่ (4 บิต)		 ดำเนินการดำเนินการไบนารีที่ระบุบนรีจิสเตอร์ต้นทางทั้งสอง โดยจัดเก็บผลลัพธ์ไว้ในรีจิสเตอร์ต้นทางแรก

หมายเหตุ: ตรงกันข้ามกับการดำเนินการทางคณิตศาสตร์ -long/2addr อื่นๆ (ซึ่งรับคู่รีจิสเตอร์สำหรับทั้งปลายทาง/ต้นทางและแหล่งที่สอง) shl-long/2addr , shr-long/2addr และ ushr-long/2addr ทำการลงทะเบียน จับคู่กับปลายทาง/แหล่งที่มาแรก (ค่าที่จะเลื่อน) แต่เป็นการลงทะเบียนเดียวสำหรับแหล่งที่มาที่สอง (ระยะทางที่เลื่อน)

วัน0..d7 22วิ binop /lit16 vA, vB, #+CCCC
d0: add-int/lit16
d1: rsub-int (ลบแบบย้อนกลับ)
d2: mul-int/lit16
d3: div-int/lit16
d4: rem-int/lit16
d5: และ-int/lit16
d6: หรือ-int/lit16
d7: xor-int/lit16		 A: การลงทะเบียนปลายทาง (4 บิต)
B: แหล่งรีจิสเตอร์ (4 บิต)
C: ลงนาม int คงที่ (16 บิต)		 ดำเนินการไบนารี่ op ที่ระบุบนรีจิสเตอร์ที่ระบุ (อาร์กิวเมนต์แรก) และค่าตามตัวอักษร (อาร์กิวเมนต์ที่สอง) โดยจัดเก็บผลลัพธ์ไว้ในรีจิสเตอร์ปลายทาง

หมายเหตุ: rsub-int ไม่มีส่วนต่อท้ายเนื่องจากเวอร์ชันนี้เป็น opcode หลักของตระกูล นอกจากนี้ โปรดดูรายละเอียดด้านล่างเกี่ยวกับความหมายของมัน

d8..e2 22b binop /lit8 vAA, vBB, #+CC
d8: เพิ่ม int/lit8
d9: rsub-int/lit8
ดา: mul-int/lit8
db: div-int/lit8
dc: rem-int/lit8
dd: และ-int/lit8
โดย: หรือ-int/lit8
df: xor-int/lit8
e0: shl-int/lit8
e1: shr-int/lit8
e2: ushr-int/lit8		 A: การลงทะเบียนปลายทาง (8 บิต)
B: แหล่งรีจิสเตอร์ (8 บิต)
C: ลงนาม int คงที่ (8 บิต)		 ดำเนินการไบนารี่ op ที่ระบุบนรีจิสเตอร์ที่ระบุ (อาร์กิวเมนต์แรก) และค่าตามตัวอักษร (อาร์กิวเมนต์ที่สอง) โดยจัดเก็บผลลัพธ์ไว้ในรีจิสเตอร์ปลายทาง

หมายเหตุ: ดูรายละเอียดด้านล่างเกี่ยวกับความหมายของ rsub-int

e3..f9 10x (ไม่ได้ใช้) (ไม่ได้ใช้)
ฟ้า 45cc เรียกใช้-polymorphic {vC, vD, veE, vF, vG}, meth@BBBB, proto@HHHH A: จำนวนคำอาร์กิวเมนต์ (4 บิต)
B: ดัชนีอ้างอิงวิธีการ (16 บิต)
C: ตัวรับ (4 บิต)
D..G: อาร์กิวเมนต์รีจิสเตอร์ (อันละ 4 บิต)
H: ดัชนีอ้างอิงต้นแบบ (16 บิต)		 เรียกใช้เมธอด polymorphic ลายเซ็นที่ระบุ ผลลัพธ์ (ถ้ามี) อาจถูกจัดเก็บไว้พร้อมกับ move-result* ที่เหมาะสมเป็นคำสั่งที่ตามมาทันที

การอ้างอิงเมธอดต้องเป็นเมธอด polymorphic ที่เป็นเอกลักษณ์ เช่น java.lang.invoke.MethodHandle.invoke หรือ java.lang.invoke.MethodHandle.invokeExact

ผู้รับจะต้องเป็นอ็อบเจ็กต์ที่รองรับเมธอด polymorphic ลายเซ็นที่กำลังเรียกใช้

การอ้างอิงต้นแบบจะอธิบายประเภทอาร์กิวเมนต์ที่ให้ไว้และประเภทการส่งคืนที่คาดหวัง

รหัสไบต์ invoke-polymorphic อาจเพิ่มข้อยกเว้นเมื่อดำเนินการ ข้อยกเว้นอธิบายไว้ในเอกสารประกอบ API สำหรับวิธีลายเซ็น polymorphic ที่กำลังเรียกใช้

นำเสนอในไฟล์ Dex ตั้งแต่เวอร์ชัน 038 เป็นต้นไป
fb4rcc เรียกใช้-polymorphic/ช่วง {vCCCC .. vNNNN}, meth@BBBB, proto@HHHH A: จำนวนคำอาร์กิวเมนต์ (8 บิต)
B: ดัชนีอ้างอิงวิธีการ (16 บิต)
C: ตัวรับ (16 บิต)
H: ดัชนีอ้างอิงต้นแบบ (16 บิต)
N = A + C - 1		 เรียกใช้ตัวจัดการวิธีการที่ระบุ ดูคำอธิบาย invoke-polymorphic ด้านบนเพื่อดูรายละเอียด

นำเสนอในไฟล์ Dex ตั้งแต่เวอร์ชัน 038 เป็นต้นไป
เอฟซี 35ซี เรียกใช้ {vC, vD, veE, vF, vG}, call_site@BBBB แบบกำหนดเอง A: จำนวนคำอาร์กิวเมนต์ (4 บิต)
B: ดัชนีอ้างอิงไซต์การโทร (16 บิต)
C..G: อาร์กิวเมนต์รีจิสเตอร์ (อันละ 4 บิต)		 แก้ไขและเรียกใช้ไซต์การโทรที่ระบุ ผลลัพธ์จากการร้องขอ (ถ้ามี) อาจถูกจัดเก็บไว้พร้อมกับตัวแปร move-result* ที่เหมาะสมเป็นคำสั่งที่ตามมาทันที

คำสั่งนี้ดำเนินการในสองขั้นตอน: การแก้ไขไซต์การโทรและการเรียกใช้ไซต์การโทร

การแก้ไขไซต์การโทรจะตรวจสอบว่าไซต์การโทรที่ระบุมีอินสแตนซ์ java.lang.invoke.CallSite ที่เกี่ยวข้องหรือไม่ ถ้าไม่เช่นนั้น เมธอด bootstrap linker สำหรับไซต์การโทรที่ระบุจะถูกเรียกใช้โดยใช้อาร์กิวเมนต์ที่มีอยู่ในไฟล์ DEX (ดู call_site_item ) เมธอด bootstrap linker ส่งคืนอินสแตนซ์ java.lang.invoke.CallSite ที่จะเชื่อมโยงกับไซต์การโทรที่ระบุ หากไม่มีการเชื่อมโยงอยู่ เธรดอื่นอาจสร้างการเชื่อมโยงไว้ก่อนแล้ว และหากเป็นเช่นนั้น การดำเนินการของคำสั่งจะดำเนินต่อไปด้วยอินสแตนซ์ java.lang.invoke.CallSite แรกที่เกี่ยวข้อง

การเรียกใช้ไซต์การโทรเกิดขึ้นบนเป้าหมาย java.lang.invoke.MethodHandle ของอินสแตนซ์ java.lang.invoke.CallSite ที่ได้รับการแก้ปัญหา เป้าหมายถูกเรียกใช้ราวกับว่ากำลังดำเนินการ invoke-polymorphic (อธิบายไว้ข้างต้น) โดยใช้ตัวจัดการเมธอดและอาร์กิวเมนต์ไปยังคำสั่ง invoke-custom เป็นอาร์กิวเมนต์ของตัวจัดการเมธอดที่แน่นอนในการเรียกใช้

ข้อยกเว้นที่เกิดขึ้นโดยวิธี bootstrap linker จะถูกรวมไว้ใน java.lang.BootstrapMethodError BootstrapMethodError จะเพิ่มขึ้นเช่นกันหาก:
  • เมธอด bootstrap linker ไม่สามารถส่งคืนอินสแตนซ์ java.lang.invoke.CallSite
  • java.lang.invoke.CallSite ที่ส่งคืนมีเป้าหมายการจัดการเมธอด null
  • เป้าหมายการจัดการวิธีการไม่ใช่ประเภทที่ร้องขอ
นำเสนอในไฟล์ Dex ตั้งแต่เวอร์ชัน 038 เป็นต้นไป
fd3rc เรียกใช้กำหนดเอง/ช่วง {vCCCC .. vNNNN}, call_site@BBBB A: จำนวนคำอาร์กิวเมนต์ (8 บิต)
B: ดัชนีอ้างอิงไซต์การโทร (16 บิต)
C: การลงทะเบียนอาร์กิวเมนต์แรก (16 บิต)
N = A + C - 1		 แก้ไขและเรียกใช้ไซต์การโทร ดูคำอธิบาย invoke-custom ด้านบนสำหรับรายละเอียด

นำเสนอในไฟล์ Dex ตั้งแต่เวอร์ชัน 038 เป็นต้นไป
เฟอ 21ค const-วิธีจัดการ vAA, method_handle@BBBB A: การลงทะเบียนปลายทาง (8 บิต)
B: ดัชนีการจัดการวิธีการ (16 บิต)		 ย้ายการอ้างอิงไปยังตัวจัดการวิธีการที่ระบุโดยดัชนีที่กำหนดลงในการลงทะเบียนที่ระบุ

นำเสนอในไฟล์ Dex ตั้งแต่เวอร์ชัน 039 เป็นต้นไป
เอฟเอฟ 21ซี vAA ประเภทวิธี const, proto@BBBB A: การลงทะเบียนปลายทาง (8 บิต)
B: การอ้างอิงต้นแบบวิธีการ (16 บิต)		 ย้ายการอ้างอิงไปยังต้นแบบวิธีการที่ระบุโดยดัชนีที่กำหนดไปยังรีจิสเตอร์ที่ระบุ

นำเสนอในไฟล์ Dex ตั้งแต่เวอร์ชัน 039 เป็นต้นไป

รูปแบบแพ็คเก็ตสวิตช์เพย์โหลด

ชื่อ รูปแบบ คำอธิบาย
ระบุตัวตน ยูชอร์ต = 0x0100 ระบุ pseudo-opcode
ขนาด ushort จำนวนรายการในตาราง
first_key ภายใน ค่าเคสสวิตช์แรก (และต่ำสุด)
เป้าหมาย อินท์[] รายการ size เป้าหมายสาขาสัมพันธ์ เป้าหมายจะสัมพันธ์กับที่อยู่ของ opcode ของสวิตช์ ไม่ใช่ของตารางนี้

หมายเหตุ: จำนวนหน่วยโค้ดทั้งหมดสำหรับอินสแตนซ์ของตารางนี้คือ (size * 2) + 4

รูปแบบเพย์โหลดแบบเบาบางสวิตช์

ชื่อ รูปแบบ คำอธิบาย
ระบุตัวตน ยูชอร์ต = 0x0200 ระบุ pseudo-opcode
ขนาด ushort จำนวนรายการในตาราง
กุญแจ อินท์[] รายการค่าคีย์ size เรียงลำดับจากต่ำไปสูง
เป้าหมาย อินท์[] รายการเป้าหมายสาขาสัมพันธ์ size ซึ่งแต่ละเป้าหมายสอดคล้องกับค่าคีย์ที่ดัชนีเดียวกัน เป้าหมายจะสัมพันธ์กับที่อยู่ของ opcode ของสวิตช์ ไม่ใช่ของตารางนี้

หมายเหตุ: จำนวนหน่วยโค้ดทั้งหมดสำหรับอินสแตนซ์ของตารางนี้คือ (size * 4) + 2

รูปแบบการเติมอาร์เรย์ข้อมูลเพย์โหลด

ชื่อ รูปแบบ คำอธิบาย
ระบุตัวตน ยูชอร์ต = 0x0300 ระบุ pseudo-opcode
องค์ประกอบ_ความกว้าง ushort จำนวนไบต์ในแต่ละองค์ประกอบ
ขนาด ไม่ได้ จำนวนองค์ประกอบในตาราง
ข้อมูล ยูไบต์[] ค่าข้อมูล

หมายเหตุ: จำนวนหน่วยโค้ดทั้งหมดสำหรับอินสแตนซ์ของตารางนี้คือ (size * element_width + 1) / 2 + 4

รายละเอียดการดำเนินการทางคณิตศาสตร์

หมายเหตุ: การดำเนินการจุดลอยตัวต้องเป็นไปตามกฎ IEEE 754 โดยใช้อันเดอร์โฟลว์แบบปัดเศษไปใกล้ที่สุดและแบบค่อยเป็นค่อยไป ยกเว้นในกรณีที่ระบุไว้เป็นอย่างอื่น

ออปโค้ด ซี ความหมาย หมายเหตุ
neg-int int32 ก;
ผลลัพธ์ int32 = -a;		 ส่วนเสริมสองเอกนารี
ไม่ใช่-int int32 ก;
ผลลัพธ์ int32 = ~a;		 Unary คนเสริม
neg ยาว int64 ก;
ผลลัพธ์ int64 = -a;		 ส่วนเสริมสองเอกนารี
ไม่นาน int64 ก;
ผลลัพธ์ int64 = ~a;		 Unary คนเสริม
Neg-ลอย ลอย;
ผลลอย = -a;		 การปฏิเสธจุดลอยตัว
Neg-สองครั้ง ดับเบิ้ลเอ;
ผลลัพธ์สองเท่า = -a;		 การปฏิเสธจุดลอยตัว
int-to-long int32 ก;
ผลลัพธ์ int64 = (int64) ก;		 ลงชื่อขยาย int32 เป็น int64
Int-to-ลอย int32 ก;
ลอยผลลัพธ์ = (ลอย) a;		 การแปลง int32 เป็น float โดยใช้แบบกลมถึงผู้คน สิ่งนี้สูญเสียความแม่นยำสำหรับค่าบางอย่าง
int-to-double int32 a;
ผลลัพธ์สองเท่า = (สองเท่า) a;		 การแปลง int32 เป็น double
ยาวนาน int64 a;
int32 result = (int32) a;		 การตัดทอน int64 เป็น int32
ยาวเหยียด int64 a;
ลอยผลลัพธ์ = (ลอย) a;		 การแปลง int64 เป็น float โดยใช้แบบกลมถึงผู้คน สิ่งนี้สูญเสียความแม่นยำสำหรับค่าบางอย่าง
ยาวถึงสองครั้ง int64 a;
ผลลัพธ์สองเท่า = (สองเท่า) a;		 การแปลง int64 เป็น double โดยใช้การรับรู้แบบกลมถึง สิ่งนี้สูญเสียความแม่นยำสำหรับค่าบางอย่าง
ล่องลอย ลอย A;
int32 result = (int32) a;		 การแปลง float เป็น int32 โดยใช้ Round-Toward-Zero NaN และ -0.0 (ลบศูนย์) แปลงเป็นจำนวนเต็ม 0 Infinities และค่าที่มีขนาดใหญ่เกินไปที่จะแสดงได้รับการแปลงเป็น 0x7fffffff หรือ -0x80000000 ขึ้นอยู่กับเครื่องหมาย
ลอยไปมานาน ลอย A;
int64 result = (int64) a;		 การแปลง float เป็น int64 โดยใช้ Round-Toward-Zero กฎกรณีพิเศษเช่นเดียวกับสำหรับ float-to-int การใช้งานที่นี่ยกเว้นว่าค่านอกช่วงจะถูกแปลงเป็น 0x7fffffffffffffff หรือ -0x8000000000000000 ขึ้นอยู่กับเครื่องหมาย
ลอยเป็นสองเท่า ลอย A;
ผลลัพธ์สองเท่า = (สองเท่า) a;		 การแปลงของ float เป็น double รักษาค่าอย่างแน่นอน
เป็นสองเท่า สองเท่า;
int32 result = (int32) a;		 การแปลงของ double เป็น int32 โดยใช้ Round-Toward-Zero กฎกรณีพิเศษเช่นเดียวกับสำหรับ float-to-int การใช้งานที่นี่
สองถึงยาว สองเท่า;
int64 result = (int64) a;		 การแปลงของ double เป็น int64 โดยใช้ Round-Toward-Zero กฎกรณีพิเศษเช่นเดียวกับการใช้งาน float-to-long ที่นี่
สองถึงสอง สองเท่า;
ลอยผลลัพธ์ = (ลอย) a;		 การแปลงของ double เป็น float โดยใช้แบบกลมถึงผู้คน สิ่งนี้สูญเสียความแม่นยำสำหรับค่าบางอย่าง
Int-to-byte int32 a;
int32 result = (a << 24) >> 24;		 การตัดทอน int32 ถึง int8 ลงชื่อขยายผลลัพธ์
int-to-char int32 a;
int32 result = a & 0xffff;		 การตัดทอน int32 ถึง uint16 โดยไม่มีการขยายสัญญาณ
การสั้น ๆ int32 a;
int32 result = (a << 16) >> 16;		 การตัดทอน int32 ถึง int16 ลงนามในการขยายผลลัพธ์
ส่วนเสริม int32 a, b;
int32 result = a + b;		 การเพิ่ม TwoS-complement
ส่วนย่อย int32 a, b;
int32 result = a - b;		 การลบ Twos-complement
rsub-int int32 a, b;
int32 result = b - a;		 การลบย้อนกลับ TwoS-complement
Mul-int int32 a, b;
int32 result = a * b;		 การคูณสองครั้ง
div-int int32 a, b;
int32 result = a / b;		 แผนกการเติม Twos, ปัดเศษเป็นศูนย์ (นั่นคือถูกตัดทอนเป็นจำนวนเต็ม) สิ่งนี้จะโยน ArithmeticException ถ้า b == 0
อุณหภูมิ int32 a, b;
int32 result = a % b;		 ส่วนที่เหลืออีกสองครั้งหลังจากการแบ่ง สัญญาณของผลลัพธ์นั้นเหมือนกับของ a และมีการกำหนดอย่างแม่นยำมากขึ้นเป็น result == a - (a / b) * b สิ่งนี้จะโยน ArithmeticException ถ้า b == 0
และผิด int32 a, b;
int32 result = a & b;		 ระดับบิตและ
หรือ int32 a, b;
int32 result = a | ข;		 บิตไวส์หรือ
Xor-int int32 a, b;
int32 ผลลัพธ์ = a ^ b;		 บิตไวซ์ XOR
shl-int int32 a, b;
int32 result = a << (b & 0x1f);		 Bitwise Shift ซ้าย (พร้อมอาร์กิวเมนต์สวมหน้ากาก)
shr-int int32 a, b;
int32 result = a >> (b & 0x1f);		 SIGNED SHIFT RIGHT (พร้อมอาร์กิวเมนต์สวมหน้ากาก)
ushr-int UINT32 A, B;
int32 result = a >> (b & 0x1f);		 การเปลี่ยนแปลงที่ไม่ได้ลงนาม Bitwise (พร้อมอาร์กิวเมนต์สวมหน้ากาก)
เพิ่มความยาว int64 a, b;
int64 result = a + b;		 การเพิ่ม TwoS-complement
ย่อยยาว int64 a, b;
int64 result = a - b;		 การลบ Twos-complement
ความยาว int64 a, b;
int64 result = a * b;		 การคูณสองครั้ง
การแบ่งตัวยาว int64 a, b;
int64 result = a / b;		 แผนกการเติม Twos, ปัดเศษเป็นศูนย์ (นั่นคือถูกตัดทอนเป็นจำนวนเต็ม) สิ่งนี้จะโยน ArithmeticException ถ้า b == 0
ยาว int64 a, b;
int64 ผลลัพธ์ = a % b;		 ส่วนที่เหลืออีกสองครั้งหลังจากการแบ่ง สัญญาณของผลลัพธ์นั้นเหมือนกับของ a และมีการกำหนดอย่างแม่นยำมากขึ้นเป็น result == a - (a / b) * b สิ่งนี้จะโยน ArithmeticException ถ้า b == 0
และยาว int64 a, b;
int64 result = a & b;		 ระดับบิตและ
หรือนาน int64 a, b;
int64 result = a | ข;		 บิตไวส์หรือ
ความยาว int64 a, b;
int64 ผลลัพธ์ = a ^ b;		 บิตไวซ์ XOR
ความยาว int64 a;
int32 b;
int64 result = a << (b & 0x3f);		 Bitwise Shift ซ้าย (พร้อมอาร์กิวเมนต์สวมหน้ากาก)
SHR-LONG int64 a;
int32 b;
int64 result = a >> (b & 0x3f);		 SIGNED SHIFT RIGHT (พร้อมอาร์กิวเมนต์สวมหน้ากาก)
ushr-long UINT64 A;
int32 b;
int64 result = a >> (b & 0x3f);		 การเปลี่ยนแปลงที่ไม่ได้ลงนาม Bitwise (พร้อมอาร์กิวเมนต์สวมหน้ากาก)
เพิ่มความโลดโผน ลอย A, B;
ผลลัพธ์ลอย = a + b;		 การเพิ่มจุดลอยตัว
ท่องย่อย ลอย A, B;
ผลลัพธ์ลอย = a - b;		 การลบจุดลอยตัว
มัลฟล็อต ลอย A, B;
ผลลัพธ์ลอย = a * b;		 การคูณจุดลอยตัว
การแบ่งแยก ลอย A, B;
ผลลัพธ์ลอย = a / b;		 แผนกจุดลอยตัว
rem-float ลอย A, B;
ผลลัพธ์ลอย = a % b;		 จุดลอยตัวที่เหลือหลังจากการแบ่ง ฟังก์ชั่นนี้แตกต่างจาก IEEE 754 ที่เหลือและถูกกำหนดเป็น result == a - roundTowardZero(a / b) * b
เพิ่มเติม Double A, B;
ผลลัพธ์สองเท่า = a + b;		 การเพิ่มจุดลอยตัว
สองเท่า Double A, B;
ผลลัพธ์สองเท่า = a - b;		 การลบจุดลอยตัว
Mul-Double Double A, B;
ผลลัพธ์สองเท่า = a * b;		 การคูณจุดลอยตัว
div-double Double A, B;
ผลลัพธ์สองเท่า = a / b;		 แผนกจุดลอยตัว
rem-double Double A, B;
ผลลัพธ์สองเท่า = a % b;		 จุดลอยตัวที่เหลือหลังจากการแบ่ง ฟังก์ชั่นนี้แตกต่างจาก IEEE 754 ที่เหลือและถูกกำหนดเป็น result == a - roundTowardZero(a / b) * b