การออกแบบทั่วไป
- โมเดลเครื่องและแบบแผนการเรียกมีขึ้นเพื่อเลียนแบบสถาปัตยกรรมจริงทั่วไปและแบบแผนการโทรแบบ C:
- เครื่องเป็นแบบลงทะเบียน และเฟรมถูกกำหนดขนาดเมื่อสร้าง แต่ละเฟรมประกอบด้วยรีจิสเตอร์จำนวนหนึ่ง (ระบุโดยเมธอด) เช่นเดียวกับข้อมูลเสริมที่จำเป็นในการดำเนินการเมธอด เช่น (แต่ไม่จำกัดเฉพาะ) ตัวนับโปรแกรมและการอ้างอิงไปยังไฟล์
.dex
ที่มีเมธอด . - เมื่อใช้สำหรับค่าบิต (เช่น จำนวนเต็มและเลขทศนิยม) รีจิสเตอร์จะถือว่ากว้าง 32 บิต คู่รีจิสเตอร์ที่อยู่ติดกันใช้สำหรับค่า 64 บิต ไม่มีข้อกำหนดการจัดตำแหน่งสำหรับคู่ลงทะเบียน
- เมื่อใช้สำหรับการอ้างอิงอ็อบเจ็กต์ รีจิสเตอร์จะถือว่ากว้างพอที่จะเก็บข้อมูลอ้างอิงดังกล่าวได้เพียงรายการเดียว
- ในแง่ของการแสดงระดับบิต
(Object) null == (int) 0
- อาร์กิวเมนต์ N ของเมธอดจะเข้าสู่ N รีจิสเตอร์สุดท้ายของเฟรมการเรียกใช้เมธอดตามลำดับ อาร์กิวเมนต์กว้างใช้สองรีจิสเตอร์ เมธอดของอินสแตนซ์จะถูกส่งผ่านการอ้างอิง
this
เป็นอาร์กิวเมนต์แรก
- เครื่องเป็นแบบลงทะเบียน และเฟรมถูกกำหนดขนาดเมื่อสร้าง แต่ละเฟรมประกอบด้วยรีจิสเตอร์จำนวนหนึ่ง (ระบุโดยเมธอด) เช่นเดียวกับข้อมูลเสริมที่จำเป็นในการดำเนินการเมธอด เช่น (แต่ไม่จำกัดเฉพาะ) ตัวนับโปรแกรมและการอ้างอิงไปยังไฟล์
- หน่วยเก็บข้อมูลในสตรีมคำสั่งเป็นปริมาณที่ไม่ได้ลงชื่อ 16 บิต บางบิตในบางคำสั่งจะถูกละเว้น / ต้องเป็นศูนย์
- คำแนะนำไม่ได้จำกัดไว้เฉพาะบางประเภทเท่านั้น ตัวอย่างเช่น คำสั่งที่ย้ายค่ารีจิสเตอร์ 32 บิตโดยไม่มีการตีความไม่จำเป็นต้องระบุว่ากำลังย้ายค่า int หรือ float
- มีพูลค่าคงที่ที่แจกแจงและจัดทำดัชนีแยกต่างหากสำหรับการอ้างอิงถึงสตริง ชนิด ฟิลด์ และวิธีการ
- ข้อมูลตามตัวอักษรระดับบิตจะแสดงในบรรทัดในสตรีมคำสั่ง
- เนื่องจากในทางปฏิบัติ เป็นเรื่องปกติสำหรับวิธีการที่ต้องการการลงทะเบียนมากกว่า 16 รายการ และเนื่องจากความต้องการการลงทะเบียนมากกว่าแปดรายการ เป็น เรื่องปกติที่สมเหตุสมผล คำแนะนำจำนวนมากจึงจำกัดให้ระบุเฉพาะการลงทะเบียน 16 รายการแรกเท่านั้น เมื่อเป็นไปได้อย่างสมเหตุสมผล คำแนะนำอนุญาตให้มีการอ้างอิงถึงการลงทะเบียน 256 รายการแรก นอกจากนี้ คำสั่งบางคำสั่งยังมีรูปแบบต่างๆ ที่ช่วยให้สามารถนับจำนวนรีจิสเตอร์ได้มากขึ้น ซึ่งรวมถึงคำแนะนำการ
move
ที่รับทั้งหมด ซึ่งระบุที่อยู่ของรีจิสเตอร์ในช่วงv0
–v65535
ในกรณีที่ไม่มีชุดคำสั่งสำหรับจัดการกับการลงทะเบียนที่ต้องการ คาดว่าเนื้อหาการลงทะเบียนจะถูกย้ายจากการลงทะเบียนดั้งเดิมไปยังการลงทะเบียนระดับต่ำ (ก่อนการดำเนินการ) และ/หรือย้ายจากการลงทะเบียนผลลัพธ์ต่ำไปยังระดับสูง ลงทะเบียน (หลังการดำเนินการ) - มี "pseudo-instructions" หลายแบบที่ใช้ในการเก็บข้อมูลความยาวผันแปรได้ ซึ่งอ้างอิงตามคำสั่งปกติ (เช่น
fill-array-data
) คำสั่งดังกล่าวจะต้องไม่ถูกพบในระหว่างการดำเนินการตามปกติ นอกจากนี้ คำแนะนำจะต้องอยู่บนออฟเซ็ตของ bytecode ที่เป็นเลขคู่ (นั่นคือ 4 ไบต์ในแนวเดียวกัน) เพื่อให้เป็นไปตามข้อกำหนดนี้ เครื่องมือสร้าง dex ต้องปล่อยคำสั่งnop
พิเศษเป็นตัวเว้นวรรค หากคำสั่งดังกล่าวไม่อยู่ในแนวเดียวกัน สุดท้าย แม้ว่าจะไม่จำเป็น แต่คาดว่าเครื่องมือส่วนใหญ่จะเลือกที่จะเผยแพร่คำสั่งเหล่านี้ที่ส่วนท้ายของเมธอด มิฉะนั้น อาจเป็นกรณีที่จำเป็นต้องมีคำสั่งเพิ่มเติมเพื่อแยกสาขารอบๆ - เมื่อติดตั้งบนระบบที่กำลังทำงานอยู่ คำแนะนำบางอย่างอาจมีการเปลี่ยนแปลง โดยเปลี่ยนรูปแบบเป็นการปรับให้เหมาะสมสำหรับการเชื่อมโยงเวลาคงที่ในการติดตั้ง เพื่อให้ดำเนินการได้เร็วขึ้นเมื่อทราบการเชื่อมโยง ดู เอกสารรูปแบบคำสั่ง ที่เกี่ยวข้องสำหรับตัวแปรที่แนะนำ แนะนำให้ใช้คำว่า "แนะนำ" ไม่จำเป็นต้องดำเนินการเหล่านี้
- ไวยากรณ์ของมนุษย์และตัวช่วยจำ:
- ลำดับปลายทางแล้วต้นทางสำหรับอาร์กิวเมนต์
- opcodes บางตัวมีส่วนต่อท้ายชื่อที่ทำให้สับสนเพื่อระบุประเภทที่พวกเขาใช้งาน:
- opcodes 32 บิตทั่วไปประเภทไม่มีเครื่องหมาย
- opcodes แบบ 64 บิตทั่วไปต่อท้ายด้วย
-wide
- opcodes เฉพาะประเภทต่อ
-void
ด้วยประเภท (หรือตัวย่อตรงไปตรงมา) หนึ่งใน:-boolean
-byte-string
-byte
-char
-short
-int
-long
-float
-object
-class
-double
- opcodes บางตัวมีส่วนต่อท้ายที่แก้ความกำกวมเพื่อแยกแยะการดำเนินการที่เหมือนกันซึ่งมีรูปแบบคำสั่งหรือตัวเลือกที่แตกต่างกัน คำต่อท้ายเหล่านี้แยกจากชื่อหลักด้วยเครื่องหมายทับ ("
/
") และส่วนใหญ่มีอยู่เพื่อให้มีการแมปแบบหนึ่งต่อหนึ่งด้วยค่าคงที่คงที่ในโค้ดที่สร้างและตีความไฟล์เรียกทำงาน (นั่นคือ เพื่อลดความกำกวม สำหรับมนุษย์) - ในคำอธิบายนี้ ความกว้างของค่า (ระบุ เช่น ช่วงของค่าคงที่หรือจำนวนรีจิสเตอร์ที่อาจระบุได้) ถูกเน้นโดยการใช้อักขระต่อความกว้างสี่บิต
- ตัวอย่างเช่น ในคำสั่ง "
move-wide/from16 vAA, vBBBB
":- "
move
" คือ opcode ฐาน ซึ่งระบุการดำเนินการพื้นฐาน (ย้ายค่าของ register) - "
wide
" เป็นคำต่อท้ายชื่อ ซึ่งบ่งชี้ว่าทำงานบนข้อมูลแบบกว้าง (64 บิต) - "
from16
" เป็นคำต่อท้าย opcode ซึ่งระบุตัวแปรที่มีการอ้างอิงการลงทะเบียน 16 บิตเป็นแหล่งที่มา - "
vAA
" คือรีจิสเตอร์ปลายทาง (โดยนัยจากการดำเนินการ กฎก็คืออาร์กิวเมนต์ปลายทางจะมาก่อนเสมอ) ซึ่งต้องอยู่ในช่วงv0
–v255
- "
vBBBB
" คือรีจิสเตอร์ต้นทาง ซึ่งต้องอยู่ในช่วงv0
–v65535
- "
- ดู เอกสารรูปแบบคำสั่ง สำหรับรายละเอียดเพิ่มเติมเกี่ยวกับรูปแบบคำสั่งต่างๆ (อยู่ภายใต้ "Op & Format") รวมทั้งรายละเอียดเกี่ยวกับไวยากรณ์ opcode
- ดู เอกสารรูปแบบไฟล์
.dex
สำหรับรายละเอียดเพิ่มเติมเกี่ยวกับตำแหน่งที่ bytecode พอดีกับภาพที่ใหญ่ขึ้น
สรุปชุดไบต์โค้ด
Op & รูปแบบ | Mnemonic / ไวยากรณ์ | ข้อโต้แย้ง | คำอธิบาย |
---|---|---|---|
00 10x | นพ | วัฏจักรของเสีย หมายเหตุ: คำสั่งหลอกที่มีข้อมูลถูกแท็กด้วย opcode นี้ ซึ่งในกรณีนี้ ไบต์ลำดับสูงของหน่วย opcode จะระบุลักษณะของข้อมูล ดู " รูปแบบ | |
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 บิต) | ย้ายเนื้อหาของคู่ลงทะเบียนหนึ่งไปยังอีกคู่หนึ่ง หมายเหตุ: การย้ายจาก |
05 22x | ขยับขยาย/จาก 16 vAA, vBBBB | A: คู่ลงทะเบียนปลายทาง (8 บิต)B: คู่รีจิสเตอร์ต้นทาง (16 บิต) | ย้ายเนื้อหาของคู่ลงทะเบียนหนึ่งไปยังอีกคู่หนึ่ง หมายเหตุ: ข้อควรพิจารณาในการนำไปใช้จะเหมือนกับ |
06 32x | ขยับกว้าง/16 vAAAA, vBBBB | A: คู่ลงทะเบียนปลายทาง (16 บิต)B: คู่รีจิสเตอร์ต้นทาง (16 บิต) | ย้ายเนื้อหาของคู่ลงทะเบียนหนึ่งไปยังอีกคู่หนึ่ง หมายเหตุ: ข้อควรพิจารณาในการนำไปใช้จะเหมือนกับ |
07 12x | ย้ายวัตถุ vA, vB | A: ลงทะเบียนปลายทาง (4 บิต)B: รีจิสเตอร์ต้นทาง (4 บิต) | ย้ายเนื้อหาของรีจิสเตอร์ที่มีวัตถุหนึ่งไปยังอีกอันหนึ่ง |
08 22x | ย้ายวัตถุ/จาก 16 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 บิต) | ย้ายผลลัพธ์คำสองคำของการเรียกใช้ล่าสุดไปยัง 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: return value register (8 บิต) | ส่งคืนจากวิธีการคืนค่าที่ไม่ใช่วัตถุแบบความกว้างเดียว (32 บิต) |
10 11x | vAA . แบบกว้างกลับ | A: ส่งคืนค่าคู่ลงทะเบียน (8 บิต) | ส่งคืนจากวิธีการคืนค่าแบบ double-width (64 บิต) |
11 11x | ส่งคืนวัตถุ vAA | A: return value register (8 บิต) | กลับจากวิธีการส่งคืนวัตถุ |
12 11น | const/4 vA, #+B | A: ลงทะเบียนปลายทาง (4 บิต)B: ลงชื่อเข้าใช้ (4 บิต) | ย้ายค่าตามตัวอักษรที่กำหนด (ขยายเครื่องหมายเป็น 32 บิต) ไปยังรีจิสเตอร์ที่ระบุ |
13 21วินาที | const/16 vAA, #+BBBB | A: ลงทะเบียนปลายทาง (8 บิต)B: ลงชื่อเข้าใช้ (16 บิต) | ย้ายค่าตามตัวอักษรที่กำหนด (ขยายเครื่องหมายเป็น 32 บิต) ไปยังรีจิสเตอร์ที่ระบุ |
14 31i | const vAA, #+BBBBBBBB | A: ลงทะเบียนปลายทาง (8 บิต)B: ค่าคงที่ 32 บิตโดยพลการ | ย้ายค่าตามตัวอักษรที่กำหนดไปยังรีจิสเตอร์ที่ระบุ |
15 21 ชม | const/high16 vAA, #+BBBB0000 | A: ลงทะเบียนปลายทาง (8 บิต)B: ลงชื่อเข้าใช้ (16 บิต) | ย้ายค่าตามตัวอักษรที่กำหนด (right-zero-extended to 32 bits) ลงในรีจิสเตอร์ที่ระบุ |
16 21วิ | const-wide/16 vAA, #+BBBB | A: ลงทะเบียนปลายทาง (8 บิต)B: ลงชื่อเข้าใช้ (16 บิต) | ย้ายค่าตามตัวอักษรที่กำหนด (ขยายเครื่องหมายเป็น 64 บิต) ไปยังคู่ลงทะเบียนที่ระบุ |
17 31i | const-wide/32 vAA, #+BBBBBBBB | A: ลงทะเบียนปลายทาง (8 บิต)B: ลงชื่อเข้าใช้ (32 บิต) | ย้ายค่าตามตัวอักษรที่กำหนด (ขยายเครื่องหมายเป็น 64 บิต) ไปยังคู่ลงทะเบียนที่ระบุ |
18 51l | vAA กว้าง const, #+BBBBBBBBBBBBBBBB | A: ลงทะเบียนปลายทาง (8 บิต)B: ค่าคงที่ความกว้างสองเท่า (64 บิต) โดยพลการ | ย้ายค่าตามตัวอักษรที่กำหนดไปยังคู่ลงทะเบียนที่ระบุ |
19 21 ชม | const-wide/high16 vAA, #+BBBB000000000000 | A: ลงทะเบียนปลายทาง (8 บิต)B: ลงชื่อเข้าใช้ (16 บิต) | ย้ายค่าตามตัวอักษรที่กำหนด (right-zero-extended to 64 bits) ไปเป็น register-pair ที่ระบุ |
1a 21c | const-string vAA, string@BBBB | A: ลงทะเบียนปลายทาง (8 บิต)B: ดัชนีสตริง | ย้ายการอ้างอิงไปยังสตริงที่ระบุโดยดัชนีที่กำหนดลงในการลงทะเบียนที่ระบุ |
1b 31c | const-string/jumbo vAA, string@BBBBBBBB | A: ลงทะเบียนปลายทาง (8 บิต)B: ดัชนีสตริง | ย้ายการอ้างอิงไปยังสตริงที่ระบุโดยดัชนีที่กำหนดลงในการลงทะเบียนที่ระบุ |
1c 21c | const-class vAA, type@BBBB | A: ลงทะเบียนปลายทาง (8 บิต)B: พิมพ์ดัชนี | ย้ายการอ้างอิงไปยังคลาสที่ระบุโดยดัชนีที่กำหนดไปยังการลงทะเบียนที่ระบุ ในกรณีที่ประเภทที่ระบุเป็นประเภทดั้งเดิม สิ่งนี้จะเก็บข้อมูลอ้างอิงถึงคลาสที่เสื่อมของประเภทดั้งเดิม |
1d 11x | มอนิเตอร์-ป้อน vAA | A: รีจิสเตอร์แบริ่งอ้างอิง (8 บิต) | รับจอภาพสำหรับวัตถุที่ระบุ |
1e 11x | ตรวจสอบ-ออก vAA | A: รีจิสเตอร์แบริ่งอ้างอิง (8 บิต) | ปล่อยจอภาพสำหรับวัตถุที่ระบุ หมายเหตุ: หากคำสั่งนี้จำเป็นต้องส่งข้อยกเว้น ต้องทำเสมือนว่าพีซีได้ผ่านคำสั่งไปแล้ว อาจเป็นประโยชน์ที่จะคิดว่าสิ่งนี้เป็นคำสั่งที่ดำเนินการได้สำเร็จ (ในแง่หนึ่ง) และข้อยกเว้นที่เกิด ขึ้นหลังจาก คำสั่งนั้น แต่ ก่อนที่ คำสั่งถัดไปจะมีโอกาสเรียกใช้ คำจำกัดความนี้ทำให้สามารถใช้วิธีการล้างข้อมูลจอภาพ catch-all (เช่น |
1f 21c | check-cast vAA, type@BBBB | A: รีจิสเตอร์แบริ่งอ้างอิง (8 บิต)B: ประเภทดัชนี (16 บิต) | โยน ClassCastException หากการอ้างอิงในการลงทะเบียนที่กำหนดไม่สามารถส่งไปยังประเภทที่ระบุได้ หมายเหตุ: เนื่องจาก |
20 22c | อินสแตนซ์ของ vA, vB, type@CCCC | A: ลงทะเบียนปลายทาง (4 บิต)B: รีจิสเตอร์แบริ่งอ้างอิง (4 บิต)C: ประเภทดัชนี (16 บิต) | จัดเก็บในทะเบียนปลายทางที่กำหนด 1 หากการอ้างอิงที่ระบุเป็นอินสแตนซ์ของประเภทที่กำหนด หรือ 0 หากไม่ใช่ หมายเหตุ: เนื่องจาก |
21 12x | ความยาวอาร์เรย์ vA, vB | A: ลงทะเบียนปลายทาง (4 บิต)B: รีจิสเตอร์แบริ่งอ้างอิงอาร์เรย์ (4 บิต) | จัดเก็บในปลายทางที่กำหนดให้ลงทะเบียนความยาวของอาร์เรย์ที่ระบุในรายการ |
22 21c | อินสแตนซ์ใหม่ vAA, type@BBBB | A: ลงทะเบียนปลายทาง (8 บิต)B: พิมพ์ดัชนี | สร้างอินสแตนซ์ใหม่ของประเภทที่ระบุ โดยจัดเก็บการอ้างอิงถึงอินสแตนซ์ดังกล่าวในปลายทาง ประเภทต้องอ้างถึงคลาสที่ไม่ใช่อาร์เรย์ |
23 22c | อาร์เรย์ใหม่ vA, vB, type@CCCC | A: ลงทะเบียนปลายทาง (4 บิต)B: ทะเบียนขนาดC: พิมพ์ดัชนี | สร้างอาร์เรย์ใหม่ของประเภทและขนาดที่ระบุ ประเภทต้องเป็นประเภทอาร์เรย์ |
24 35c | เติมอาร์เรย์ใหม่ {vC, vD, vE, 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 31t | fill-array-data vAA, +BBBBBBBB (พร้อมข้อมูลเสริมตามที่ระบุด้านล่างใน " fill-array-data-payload Format") | A: การอ้างอิงอาร์เรย์ (8 บิต)B: เซ็นชื่อ "สาขา" ออฟเซ็ตเป็นคำสั่งหลอกข้อมูลตาราง (32 บิต) | เติมอาร์เรย์ที่กำหนดด้วยข้อมูลที่ระบุ การอ้างอิงต้องเป็นอาร์เรย์ของพื้นฐาน และตารางข้อมูลต้องตรงกับประเภทและต้องไม่มีองค์ประกอบมากกว่าที่จะพอดีกับอาร์เรย์ นั่นคืออาร์เรย์อาจมีขนาดใหญ่กว่าตาราง และถ้าเป็นเช่นนั้น จะมีการตั้งค่าเฉพาะองค์ประกอบเริ่มต้นของอาร์เรย์ โดยปล่อยให้ส่วนที่เหลืออยู่ตามลำพัง |
27 11x | โยน vAA | A: รีจิสเตอร์ที่มีข้อยกเว้น (8 บิต) | โยนข้อยกเว้นที่ระบุ |
28 10t | ไปที่ +AA | A: ออฟเซ็ตสาขาที่ลงนาม (8 บิต) | ข้ามไปยังคำแนะนำที่ระบุโดยไม่มีเงื่อนไข หมายเหตุ: สาขาออฟเซ็ตต้องไม่เป็น |
29 20t | ไปที่/16 +AAAA | A: ออฟเซ็ตสาขาที่ลงนาม (16 บิต) | ข้ามไปยังคำแนะนำที่ระบุโดยไม่มีเงื่อนไข หมายเหตุ: สาขาออฟเซ็ตต้องไม่เป็น |
2a 30t | goto/32 +AAAAAAA | A: ออฟเซ็ตสาขาที่ลงนาม (32 บิต) | ข้ามไปยังคำแนะนำที่ระบุโดยไม่มีเงื่อนไข |
2b 31t | pack-switch vAA, +BBBBBBBB (พร้อมข้อมูลเสริมตามที่ระบุด้านล่างใน "รูปแบบ pack packed-switch-payload ") | A: ลงทะเบียนเพื่อทดสอบB: เซ็นชื่อ "สาขา" ออฟเซ็ตเป็นคำสั่งหลอกข้อมูลตาราง (32 บิต) | ข้ามไปยังคำสั่งใหม่ตามค่าในรีจิสเตอร์ที่กำหนด โดยใช้ตารางออฟเซ็ตที่สอดคล้องกับแต่ละค่าในช่วงอินทิกรัลเฉพาะ หรือข้ามไปยังคำสั่งถัดไปหากไม่มีการจับคู่ |
2c 31t | sparse-switch vAA, +BBBBBBBB (พร้อมข้อมูลเสริมตามที่ระบุด้านล่างใน " sparse-switch-payload Format") | A: ลงทะเบียนเพื่อทดสอบB: เซ็นชื่อ "สาขา" ออฟเซ็ตเป็นคำสั่งหลอกข้อมูลตาราง (32 บิต) | ข้ามไปที่คำสั่งใหม่ตามค่าในการลงทะเบียนที่กำหนด โดยใช้ตารางที่เรียงลำดับของคู่ค่าออฟเซ็ต หรือข้ามไปที่คำสั่งถัดไปหากไม่มีการจับคู่ |
2d..31 23x | ชนิด cmp vAA, vBB, vCC 2d: cmpl-float (อคติ lt) 2e: cmpg-float (อคติ gt) 2f: cmpl-double (อคติ lt) 30: cmpg-double (อคติ gt) 31: cmp-ยาว | A: ลงทะเบียนปลายทาง (8 บิต)B: การลงทะเบียนแหล่งแรกหรือคู่C: รีจิสเตอร์แหล่งที่สองหรือ pair | ดำเนินการตามจุดลอยตัวที่ระบุหรือการเปรียบเทียบแบบ long โดยตั้งค่า a 0 if b == c , 1 if b > c หรือ -1 if b < c "อคติ" ที่ระบุไว้สำหรับการดำเนินการจุดทศนิยมระบุว่าการเปรียบเทียบ NaN ได้รับการปฏิบัติ: คำแนะนำ "gt bias" ส่งคืน 1 สำหรับการเปรียบเทียบ NaN และคำแนะนำ "lt bias" ส่งคืน -1 ตัวอย่างเช่น หากต้องการตรวจสอบดูว่าจุดลอยตัว |
32..37 22t | ถ้า- ทดสอบ vA, vB, +CCCC 32: if-eq 33: if-ne 34: if-lt 35: if-ge 36: if-gt 37: if-le | A: ลงทะเบียนครั้งแรกเพื่อทดสอบ (4 บิต)B: รีจิสเตอร์ที่สองเพื่อทดสอบ (4 บิต)C: ออฟเซ็ตสาขาที่ลงนาม (16 บิต) | แยกสาขาไปยังปลายทางที่กำหนด หากค่าของรีจิสเตอร์ทั้งสองให้เปรียบเทียบตามที่ระบุ หมายเหตุ: สาขาออฟเซ็ตต้องไม่เป็น |
38.3d 21t | ถ้า- ทดสอบ z vAA, +BBBB 38: if-eqz 39: if-nez 3a: if-ltz 3b: if-gez 3c: if-gtz 3d: if-lez | A: ลงทะเบียนเพื่อทดสอบ (8 บิต)B: ออฟเซ็ตสาขาที่ลงนาม (16 บิต) | สาขาไปยังปลายทางที่กำหนดหากค่าของการลงทะเบียนที่กำหนดเปรียบเทียบกับ 0 ตามที่ระบุ หมายเหตุ: สาขาออฟเซ็ตต้องไม่เป็น |
3e..43 10x | (ไม่ได้ใช้) | (ไม่ได้ใช้) | |
44..51 23x | arrayop vAA, vBB, vCC 44: อายุ 45: กว้างอายุ 46: อายุวัตถุ 47: age-บูลีน 48: ไบต์-ไบต์ 49: age-char 4a: อายุสั้น 4b: aput 4c: aput-wide 4d: aput-object 4e: aput-บูลีน 4f: aput-byte 50: aput-char 51: สั้นสั้น | A: ลงทะเบียนค่าหรือคู่; อาจเป็นต้นทางหรือปลายทาง (8 บิต)B: การลงทะเบียนอาร์เรย์ (8 บิต)C: การลงทะเบียนดัชนี (8 บิต) | ดำเนินการดำเนินการอาร์เรย์ที่ระบุที่ดัชนีที่ระบุของอาร์เรย์ที่กำหนด โหลดหรือจัดเก็บลงในรีจิสเตอร์ค่า |
52.5.5f 22c | ฉัน Instanceop vA, vB, field@CCCC 52: iget 53: iget กว้าง 54: iget-วัตถุ 55: iget-บูลีน 56: iget-ไบต์ 57: iget-char 58: iget-สั้น 59: ไอพุท 5a: iput-wide 5b: iput-object 5c: iput-บูลีน 5d: iput-byte 5e: iput-char 5f: iput-สั้น | A: ลงทะเบียนค่าหรือคู่; อาจเป็นต้นทางหรือปลายทาง (4 บิต)B: การลงทะเบียนวัตถุ (4 บิต)C: ดัชนีอ้างอิงฟิลด์อินสแตนซ์ (16 บิต) | ดำเนินการฟิลด์อินสแตนซ์อ็อบเจ็กต์ที่ระบุด้วยฟิลด์ที่ระบุ กำลังโหลดหรือจัดเก็บในรีจิสเตอร์ค่า หมายเหตุ: opcodes เหล่านี้เป็นตัวเลือกที่เหมาะสมสำหรับการลิงก์แบบสแตติก โดยเปลี่ยนอาร์กิวเมนต์ฟิลด์ให้เป็นออฟเซ็ตโดยตรงมากขึ้น |
6..6d 21c | s staticop vAA, field@BBBB 60: sget 61: sget-wide 62: sget-object 63: sget-บูลีน 64: sget-byte 65: sget-char 66: sget สั้น 67: พ่นออกมา 68: พ่นกว้าง 69: วัตถุพ่นพิษ 6a: เสมหะบูลีน 6b: สพุตไบต์ 6c: พ่นถ่าน 6d: พ่นสั้น | A: ลงทะเบียนค่าหรือคู่; อาจเป็นต้นทางหรือปลายทาง (8 บิต)B: ดัชนีอ้างอิงฟิลด์คงที่ (16 บิต) | ดำเนินการกับฟิลด์สแตติกของอ็อบเจ็กต์ที่ระบุด้วยฟิลด์สแตติกที่ระบุ กำลังโหลดหรือจัดเก็บลงในรีจิสเตอร์ค่า หมายเหตุ: opcodes เหล่านี้เป็นตัวเลือกที่เหมาะสมสำหรับการลิงก์แบบสแตติก โดยเปลี่ยนอาร์กิวเมนต์ฟิลด์ให้เป็นออฟเซ็ตโดยตรงมากขึ้น |
6e..72 35c | วิงวอน- ชนิด {vC, vD, vE, vF, vG}, meth@BBBB 6e: เรียกใช้เสมือน 6f: วิงวอน super 70: วิงวอนโดยตรง 71: เรียกแบบคงที่ 72: เรียกใช้อินเทอร์เฟซ | A: จำนวนคำอาร์กิวเมนต์ (4 บิต)B: ดัชนีอ้างอิงเมธอด (16 บิต)C..G: รีจิสเตอร์อาร์กิวเมนต์ (4 บิตต่ออัน) | เรียกวิธีการที่ระบุ ผลลัพธ์ (ถ้ามี) อาจถูกจัดเก็บด้วยตัวแปร move-result* ที่เหมาะสมตามคำสั่งที่ตามมาทันที เมื่อ ในไฟล์ Dex เวอร์ชัน หมายเหตุ: opcodes เหล่านี้เป็นตัวเลือกที่สมเหตุสมผลสำหรับการเชื่อมโยงแบบสแตติก โดยเปลี่ยนวิธีอาร์กิวเมนต์ให้เป็นออฟเซ็ตโดยตรงมากขึ้น (หรือคู่กัน) |
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 | unop vA, vB 7b: ลบ int 7c: ไม่ใช่ int 7d: neg-long 7e: ไม่นาน 7f: neg-float 80: เน็ก-ดับเบิ้ล 81: เต็มถึงยาว 82: int-to-float 83: int-to-double 84: ยาวถึงยาว 85: ลอยยาว 86: ยาวเป็นสองเท่า 87: ลอยไปเป็น int 88: ลอยไปยาว 89: ลอยเป็นสองเท่า 8a: สองเท่าถึง int 8b: สองเท่าถึงยาว 8c: สองเท่าเพื่อลอย 8d: int-to-byte 8e: int-to-char 8f: เต็มถึงสั้น | A: ลงทะเบียนปลายทางหรือคู่ (4 บิต)B: รีจิสเตอร์ต้นทางหรือคู่ (4 บิต) | ดำเนินการ unary ที่ระบุบนรีจิสเตอร์ต้นทาง จัดเก็บผลลัพธ์ในรีจิสเตอร์ปลายทาง |
90..af 23x | binop vAA, vBB, vCC 90: ส่วนเสริม 91: sub-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: mul-long 9e: div-long 9f: เรม-ลอง a0: และ-ยาว a1: or-long a2: xor-long a3: shl-long a4: ชร-ลอง a5: ushr-long a6: เพิ่มลอย a7: sub-float a8: mul-float a9: div-float aa: rem-float ab: เพิ่มคู่ ac: ซับ-ดับเบิ้ล โฆษณา: mul-double ae: div-double af: rem-double | A: ลงทะเบียนปลายทางหรือคู่ (8 บิต)B: การลงทะเบียนแหล่งแรกหรือคู่ (8 บิต)C: รีจิสเตอร์แหล่งที่สองหรือคู่ (8 บิต) | ทำการดำเนินการไบนารีที่ระบุบนรีจิสเตอร์ต้นทางทั้งสองรายการ โดยเก็บผลลัพธ์ไว้ในรีจิสเตอร์ปลายทาง หมายเหตุ: ตรงกันข้ามกับการดำเนินการทางคณิตศาสตร์แบบ |
b0..cf 12x | binop /2addr vA, vB b0: add-int/2addr b1: sub-int/2addr b2: mul-int/2addr b3: div-int/2addr b4: rem-int/2addr b5: และ-int/2addr b6: or-int/2addr b7: xor-int/2addr b8: shl-int/2addr b9: shr-int/2addr ba: ushr-int/2addr bb: add-long/2addr bc: sub-long/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: add-float/2addr c7: sub-float/2addr c8: mul-float/2addr c9: div-float/2addr แคลิฟอร์เนีย: rem-float/2addr cb: add-double/2addr ซีซี: ซับ-ดับเบิ้ล/2addr cd: mul-double/2addr ce: div-double/2addr cf: rem-double/2addr | A: ปลายทางและการลงทะเบียนต้นทางแรกหรือคู่ (4 บิต)B: รีจิสเตอร์แหล่งที่สองหรือคู่ (4 บิต) | ทำการดำเนินการไบนารีที่ระบุบนรีจิสเตอร์ต้นทางสองรายการ โดยเก็บผลลัพธ์ไว้ในรีจิสเตอร์ต้นทางแรก หมายเหตุ: ตรงกันข้ามกับการดำเนินการทางคณิตศาสตร์ |
d0..d7 22s | 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: or-int/lit16 d7: xor-int/lit16 | A: ลงทะเบียนปลายทาง (4 บิต)B: รีจิสเตอร์ต้นทาง (4 บิต)C: ค่าคงที่แบบลงนาม (16 บิต) | ดำเนินการไบนารี่ที่ระบุบนรีจิสเตอร์ที่ระบุ (อาร์กิวเมนต์แรก) และค่าตามตัวอักษร (อาร์กิวเมนต์ที่สอง) จัดเก็บผลลัพธ์ในรีจิสเตอร์ปลายทาง หมายเหตุ: |
d8..e2 22b | binop /lit8 vAA, vBB, #+CC d8: add-int/lit8 d9: rsub-int/lit8 ดา: mul-int/lit8 db: div-int/lit8 กระแสตรง: rem-int/lit8 dd: และ-int/lit8 de: or-int/lit8 df: xor-int/lit8 e0: shl-int/lit8 e1: shr-int/lit8 e2: ushr-int/lit8 | A: ลงทะเบียนปลายทาง (8 บิต)B: รีจิสเตอร์ต้นทาง (8 บิต)C: ค่าคงที่แบบลงนาม (8 บิต) | ดำเนินการไบนารี่ที่ระบุบนรีจิสเตอร์ที่ระบุ (อาร์กิวเมนต์แรก) และค่าตามตัวอักษร (อาร์กิวเมนต์ที่สอง) จัดเก็บผลลัพธ์ในรีจิสเตอร์ปลายทาง หมายเหตุ: ดูรายละเอียดเกี่ยวกับความหมายของ |
e3..f9 10x | (ไม่ได้ใช้) | (ไม่ได้ใช้) | |
เอฟเอ45cc | เรียกใช้-polymorphic {vC, vD, vE, 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 ผู้รับต้องเป็นอ็อบเจ็กต์ที่สนับสนุนเมธอดโพลิมอร์ฟิกลายเซ็นที่ถูกเรียกใช้ การอ้างอิงต้นแบบอธิบายประเภทอาร์กิวเมนต์ที่มีให้และประเภทการส่งคืนที่คาดไว้ bytecode ที่ invoke-polymorphic -polymorphic อาจเพิ่มข้อยกเว้นเมื่อดำเนินการ ข้อยกเว้นได้อธิบายไว้ในเอกสารประกอบ API สำหรับวิธี Signature Polymorphic ที่ถูกเรียกใช้นำเสนอในไฟล์ Dex ตั้งแต่เวอร์ชัน 038 เป็นต้นไป |
fb 4rcc | เรียกใช้-polymorphic/ช่วง {vCCCC .. vNNNN}, meth@BBBB, proto@HHHH | A: จำนวนคำอาร์กิวเมนต์ (8 บิต)B: ดัชนีอ้างอิงเมธอด (16 บิต)C: ตัวรับ (16 บิต)H: ดัชนีอ้างอิงต้นแบบ (16 บิต)N = A + C - 1 | เรียกใช้แฮนเดิลเมธอดที่ระบุ ดูคำอธิบายที่ invoke-polymorphic ด้านบนสำหรับรายละเอียดนำเสนอในไฟล์ Dex ตั้งแต่เวอร์ชัน 038 เป็นต้นไป |
fc 35c | เรียกกำหนดเอง {vC, vD, vE, vF, vG}, call_site@BBBB | A: จำนวนคำอาร์กิวเมนต์ (4 บิต)B: ดัชนีอ้างอิงไซต์การโทร (16 บิต)C..G: รีจิสเตอร์อาร์กิวเมนต์ (4 บิตต่ออัน) | แก้ไขและเรียกใช้ไซต์การโทรที่ระบุ ผลลัพธ์จากการเรียก (ถ้ามี) อาจถูกจัดเก็บด้วยตัวแปร move-result* ที่เหมาะสมตามคำสั่งที่ตามมาทันทีคำสั่งนี้ดำเนินการในสองขั้นตอน: การแก้ปัญหาไซต์การโทรและการเรียกใช้ไซต์การโทร การแก้ปัญหาไซต์การโทรตรวจสอบว่าไซต์การโทรที่ระบุมีอินสแตนซ์ java.lang.invoke.CallSite ที่เกี่ยวข้องหรือไม่ หากไม่เป็นเช่นนั้น เมธอด bootstrap linker สำหรับไซต์การโทรที่ระบุจะถูกเรียกใช้โดยใช้อาร์กิวเมนต์ที่มีอยู่ในไฟล์ DEX (ดู call_site_item ) เมธอดตัวเชื่อมโยงบูตสแตรปส่งคืนอินสแตนซ์ java.lang.invoke.CallSite ที่จะเชื่อมโยงกับไซต์การโทรที่ระบุหากไม่มีการเชื่อมโยง เธรดอื่นอาจสร้างการเชื่อมโยงไว้ก่อนแล้ว และหากการดำเนินการของคำสั่งดำเนินต่อไปด้วยอินสแตนซ์ java.lang.invoke.CallSite ที่เชื่อมโยงครั้งแรกการเรียกไซต์เรียกทำบนเป้าหมาย java.lang.invoke.MethodHandle ของอินสแตนซ์ java.lang.invoke.CallSite ที่แก้ไขแล้ว เป้าหมายถูกเรียกใช้ราวกับว่ากำลังดำเนินการ invoke-polymorphic (อธิบายไว้ด้านบน) โดยใช้วิธีการจัดการและอาร์กิวเมนต์ของคำสั่ง invoke-custom เป็นอาร์กิวเมนต์ของวิธีการจัดการการเรียกใช้ที่แน่นอนข้อยกเว้นที่เกิดจากวิธีตัวเชื่อมโยงบูตสแตรปถูกรวมไว้ใน java.lang.BootstrapMethodError BootstrapMethodError ยังถูกยกขึ้นหาก:
038 เป็นต้นไป |
fd 3rc | เรียกใช้-กำหนดเอง/ช่วง {vCCCC .. vNNNN}, call_site@BBBB | A: จำนวนคำอาร์กิวเมนต์ (8 บิต)B: ดัชนีอ้างอิงไซต์การโทร (16 บิต)C: การลงทะเบียนอาร์กิวเมนต์แรก (16 บิต)N = A + C - 1 | แก้ไขและเรียกใช้ไซต์การโทร ดูคำอธิบาย invoke-custom ด้านบนสำหรับรายละเอียดนำเสนอในไฟล์ Dex ตั้งแต่เวอร์ชัน 038 เป็นต้นไป |
fe 21c | const-method-handle vAA, method_handle@BBBB | A: ลงทะเบียนปลายทาง (8 บิต)B: ดัชนีการจัดการเมธอด (16 บิต) | ย้ายการอ้างอิงไปยังหมายเลขอ้างอิงของเมธอดที่ระบุโดยดัชนีที่กำหนดลงในรีจิสเตอร์ที่ระบุ นำเสนอในไฟล์ Dex ตั้งแต่เวอร์ชัน 039 เป็นต้นไป |
ff 21c | const-method-type vAA, proto@BBBB | A: ลงทะเบียนปลายทาง (8 บิต)B: วิธีการอ้างอิงต้นแบบ (16 บิต) | ย้ายการอ้างอิงไปยังวิธีการต้นแบบที่ระบุโดยดัชนีที่กำหนดลงในการลงทะเบียนที่ระบุ นำเสนอในไฟล์ Dex ตั้งแต่เวอร์ชัน 039 เป็นต้นไป |
รูปแบบ pack-switch-payload
ชื่อ | รูปแบบ | คำอธิบาย |
---|---|---|
ตัวตน | ushort = 0x0100 | การระบุ pseudo-opcode |
ขนาด | ushort | จำนวนรายการในตาราง |
first_key | int | ค่าเคสสวิตช์แรก (และต่ำสุด) |
เป้าหมาย | ภายใน[] | รายการเป้าหมายสาขาสัมพันธ์ size เป้าหมายสัมพันธ์กับที่อยู่ของสวิตช์ opcode ไม่ใช่ของตารางนี้ |
หมายเหตุ: จำนวนหน่วยโค้ดทั้งหมดสำหรับอินสแตนซ์ของตารางนี้คือ (size * 2) + 4
กระจัดกระจาย-สลับ-รูปแบบเพย์โหลด
ชื่อ | รูปแบบ | คำอธิบาย |
---|---|---|
ตัวตน | ushort = 0x0200 | การระบุ pseudo-opcode |
ขนาด | ushort | จำนวนรายการในตาราง |
กุญแจ | ภายใน[] | รายการค่าคีย์ size เรียงจากต่ำไปสูง |
เป้าหมาย | ภายใน[] | รายการเป้าหมายสาขาสัมพันธ์ size โดยแต่ละรายการสอดคล้องกับค่าคีย์ที่ดัชนีเดียวกัน เป้าหมายสัมพันธ์กับที่อยู่ของสวิตช์ opcode ไม่ใช่ของตารางนี้ |
หมายเหตุ: จำนวนหน่วยโค้ดทั้งหมดสำหรับอินสแตนซ์ของตารางนี้คือ (size * 4) + 2
รูปแบบการเติมข้อมูล-ข้อมูล-เพย์โหลด
ชื่อ | รูปแบบ | คำอธิบาย |
---|---|---|
ตัวตน | ushort = 0x0300 | การระบุ pseudo-opcode |
element_width | ushort | จำนวนไบต์ในแต่ละองค์ประกอบ |
ขนาด | uint | จำนวนองค์ประกอบในตาราง |
ข้อมูล | ยูไบต์[] | ค่าข้อมูล |
หมายเหตุ: จำนวนหน่วยรหัสทั้งหมดสำหรับอินสแตนซ์ของตารางนี้คือ (size * element_width + 1) / 2 + 4
รายละเอียดการดำเนินการทางคณิตศาสตร์
หมายเหตุ: การดำเนินการจุดลอยตัวต้องเป็นไปตามกฎ IEEE 754 โดยใช้อันเดอร์โฟลว์แบบปัดเศษไปใกล้ที่สุดและค่อยเป็นค่อยไป ยกเว้นที่ระบุไว้เป็นอย่างอื่น
Opcode | ซี ความหมาย | หมายเหตุ |
---|---|---|
neg-int | int32 ก; ผลลัพธ์ int32 = -a; | ยูนารี ทู-คอมพลีเมนต์ |
ไม่ใช่ int | int32 ก; ผลลัพธ์ int32 = ~a; | Unary one-complement. |
เน็ก-ลอง | int64 ก; ผลลัพธ์ int64 = -a; | ยูนารี ทู-คอมพลีเมนต์ |
ไม่นาน | int64 ก; ผลลัพธ์ int64 = ~a; | Unary one-complement. |
neg-float | ลอย a; float result = -a; | Floating point negation. |
neg-double | double a; double result = -a; | Floating point negation. |
int-to-long | int32 a; int64 result = (int64) a; | Sign extension of int32 into int64 . |
int-to-float | int32 a; float result = (float) a; | Conversion of int32 to float , using round-to-nearest. This loses precision for some values. |
int-to-double | int32 a; double result = (double) a; | Conversion of int32 to double . |
long-to-int | int64 a; int32 result = (int32) a; | Truncation of int64 into int32 . |
long-to-float | int64 a; float result = (float) a; | Conversion of int64 to float , using round-to-nearest. This loses precision for some values. |
long-to-double | int64 a; double result = (double) a; | Conversion of int64 to double , using round-to-nearest. This loses precision for some values. |
float-to-int | float a; int32 result = (int32) a; | Conversion of float to int32 , using round-toward-zero. NaN and -0.0 (negative zero) convert to the integer 0 . Infinities and values with too large a magnitude to be represented get converted to either 0x7fffffff or -0x80000000 depending on sign. |
float-to-long | float a; int64 result = (int64) a; | Conversion of float to int64 , using round-toward-zero. The same special case rules as for float-to-int apply here, except that out-of-range values get converted to either 0x7fffffffffffffff or -0x8000000000000000 depending on sign. |
float-to-double | float a; double result = (double) a; | Conversion of float to double , preserving the value exactly. |
double-to-int | double a; int32 result = (int32) a; | Conversion of double to int32 , using round-toward-zero. The same special case rules as for float-to-int apply here. |
double-to-long | double a; int64 result = (int64) a; | Conversion of double to int64 , using round-toward-zero. The same special case rules as for float-to-long apply here. |
double-to-float | double a; float result = (float) a; | Conversion of double to float , using round-to-nearest. This loses precision for some values. |
int-to-byte | int32 a; int32 result = (a << 24) >> 24; | Truncation of int32 to int8 , sign extending the result. |
int-to-char | int32 a; int32 result = a & 0xffff; | Truncation of int32 to uint16 , without sign extension. |
int-to-short | int32 a; int32 result = (a << 16) >> 16; | Truncation of int32 to int16 , sign extending the result. |
add-int | int32 a, b; int32 result = a + b; | Twos-complement addition. |
sub-int | int32 a, b; int32 result = a - b; | Twos-complement subtraction. |
rsub-int | int32 a, b; int32 result = b - a; | Twos-complement reverse subtraction. |
mul-int | int32 a, b; int32 result = a * b; | Twos-complement multiplication. |
div-int | int32 a, b; int32 result = a / b; | Twos-complement division, rounded towards zero (that is, truncated to integer). This throws ArithmeticException if b == 0 . |
rem-int | int32 a, b; int32 result = a % b; | Twos-complement remainder after division. The sign of the result is the same as that of a , and it is more precisely defined as result == a - (a / b) * b . This throws ArithmeticException if b == 0 . |
and-int | int32 a, b; int32 result = a & b; | Bitwise AND. |
or-int | int32 a, b; int32 result = a | b; | Bitwise OR. |
xor-int | int32 a, b; int32 result = a ^ b; | Bitwise XOR. |
shl-int | int32 a, b; int32 result = a << (b & 0x1f); | Bitwise shift left (with masked argument). |
shr-int | int32 a, b; int32 result = a >> (b & 0x1f); | Bitwise signed shift right (with masked argument). |
ushr-int | uint32 a, b; int32 result = a >> (b & 0x1f); | Bitwise unsigned shift right (with masked argument). |
add-long | int64 a, b; int64 result = a + b; | Twos-complement addition. |
sub-long | int64 a, b; int64 result = a - b; | Twos-complement subtraction. |
mul-long | int64 a, b; int64 result = a * b; | Twos-complement multiplication. |
div-long | int64 a, b; int64 result = a / b; | Twos-complement division, rounded towards zero (that is, truncated to integer). This throws ArithmeticException if b == 0 . |
rem-long | int64 a, b; int64 result = a % b; | Twos-complement remainder after division. The sign of the result is the same as that of a , and it is more precisely defined as result == a - (a / b) * b . This throws ArithmeticException if b == 0 . |
and-long | int64 a, b; int64 result = a & b; | Bitwise AND. |
or-long | int64 a, b; int64 result = a | b; | Bitwise OR. |
xor-long | int64 a, b; int64 result = a ^ b; | Bitwise XOR. |
shl-long | int64 a; int32 b; int64 result = a << (b & 0x3f); | Bitwise shift left (with masked argument). |
shr-long | int64 a; int32 b; int64 result = a >> (b & 0x3f); | Bitwise signed shift right (with masked argument). |
ushr-long | uint64 a; int32 b; int64 result = a >> (b & 0x3f); | Bitwise unsigned shift right (with masked argument). |
add-float | float a, b; float result = a + b; | Floating point addition. |
sub-float | float a, b; float result = a - b; | Floating point subtraction. |
mul-float | float a, b; float result = a * b; | Floating point multiplication. |
div-float | float a, b; float result = a / b; | Floating point division. |
rem-float | float a, b; float result = a % b; | Floating point remainder after division. This function is different than IEEE 754 remainder and is defined as result == a - roundTowardZero(a / b) * b . |
add-double | double a, b; double result = a + b; | Floating point addition. |
sub-double | double a, b; double result = a - b; | Floating point subtraction. |
mul-double | double a, b; double result = a * b; | Floating point multiplication. |
div-double | double a, b; double result = a / b; | Floating point division. |
rem-double | double a, b; double result = a % b; | Floating point remainder after division. This function is different than IEEE 754 remainder and is defined as result == a - roundTowardZero(a / b) * b . |