इस पेज का अनुवाद Cloud Translation API से किया गया है.

Delvik बाइट कोड फ़ॉर्मैट

सामान्य डिज़ाइन

मशीन मॉडल और कॉलिंग कन्वेंशंस का मकसद, आम तौर पर इस्तेमाल होने वाले रीयल आर्किटेक्चर और C-स्टाइल कॉलिंग कन्वेंशंस को करीब-करीब कॉपी करना है:
- यह मशीन रजिस्टर पर आधारित होती है और फ़्रेम बनाने के बाद, उनका साइज़ तय हो जाता है. हर फ़्रेम में, रजिस्टर की एक तय संख्या होती है (जिसे तरीका तय करता है). साथ ही, इसमें तरीका लागू करने के लिए ज़रूरी अन्य डेटा भी होता है. जैसे, प्रोग्राम काउंटर और उस .dex फ़ाइल का रेफ़रंस जिसमें तरीका शामिल होता है. हालांकि, इनके अलावा और भी चीज़ें शामिल हो सकती हैं.
- बिट वैल्यू (जैसे, पूर्णांक और फ़्लोटिंग पॉइंट संख्याएं) के लिए इस्तेमाल किए जाने पर, रजिस्टर को 32 बिट चौड़ा माना जाता है. आस-पास के रजिस्टर के जोड़े का इस्तेमाल, 64-बिट वैल्यू के लिए किया जाता है. रजिस्टर किए गए पेयर के लिए, अलाइनमेंट की ज़रूरत नहीं होती.
- ऑब्जेक्ट रेफ़रंस के लिए इस्तेमाल किए जाने पर, रजिस्टर को इतना बड़ा माना जाता है कि उसमें एक ही रेफ़रंस हो.
- बिटवाइज़ रिप्रज़ेंटेशन के हिसाब से, (Object) null == (int) 0.
- किसी मेथड के N आर्ग्युमेंट, मेथड के invocatio वाइड आर्ग्युमेंट के लिए, दो रजिस्टर का इस्तेमाल किया जाता है. इंस्टेंस के तरीकों को पहले आर्ग्युमेंट के तौर पर this रेफ़रंस दिया जाता है.
निर्देश स्ट्रीम में स्टोरेज यूनिट, 16-बिट की बिना साइन वाली वैल्यू होती है. कुछ निर्देशों में कुछ बिट को अनदेखा किया जाता है / उन्हें शून्य होना चाहिए.
निर्देशों को किसी खास टाइप तक सीमित नहीं किया जाता. उदाहरण के लिए, ऐसे निर्देश जिनमें 32-बिट रजिस्टर वैल्यू को बिना किसी बदलाव के एक जगह से दूसरी जगह भेजा जाता है, उनके लिए यह बताना ज़रूरी नहीं है कि वे ints या floats में से किस तरह की वैल्यू को भेज रहे हैं.
स्ट्रिंग, टाइप, फ़ील्ड, और तरीकों के रेफ़रंस के लिए, अलग-अलग क्रम में और इंडेक्स किए गए कॉन्स्टेंट पूल होते हैं.
बिटवाइज़ लिटरल डेटा, निर्देश स्ट्रीम में इन-लाइन दिखाया जाता है.
आम तौर पर, किसी तरीके के लिए 16 से ज़्यादा रजिस्टर की ज़रूरत नहीं होती. साथ ही, आठ से ज़्यादा रजिस्टर की ज़रूरत होना आम बात है. इसलिए, कई निर्देश सिर्फ़ पहले 16 रजिस्टर को ऐड्रेस करने तक सीमित होते हैं. जब संभव हो, तो निर्देशों में पहले 256 रजिस्टर के रेफ़रंस शामिल किए जा सकते हैं. इसके अलावा, कुछ निर्देशों के वैरिएंट ऐसे होते हैं जिनकी मदद से रजिस्टर की संख्या काफ़ी ज़्यादा की जा सकती है. इनमें, सभी के लिए बने move निर्देशों का एक जोड़ा भी शामिल है. ये निर्देश, v0 से v65535 तक की रेंज में रजिस्टर को ऐड्रेस कर सकते हैं. जिन मामलों में किसी रजिस्टर को ऐड्रेस करने के लिए, निर्देश का कोई वैरिएंट उपलब्ध नहीं होता है उनमें यह उम्मीद की जाती है कि रजिस्टर का कॉन्टेंट, ऑपरेशन से पहले ओरिजनल रजिस्टर से लो रजिस्टर में और/या ऑपरेशन के बाद लो नतीजे वाले रजिस्टर से हाई रजिस्टर में चला जाए.
कई "स्यूडो-इंस्ट्रक्शन" होते हैं, जिनका इस्तेमाल वैरिएबल-लेंथ डेटा पेलोड को होल्ड करने के लिए किया जाता है. इन्हें सामान्य निर्देशों (उदाहरण के लिए, fill-array-data) से रेफ़र किया जाता है. ऐसे निर्देशों को कभी भी, एक्ज़ीक्यूशन के सामान्य फ़्लो के दौरान नहीं मिलना चाहिए. इसके अलावा, निर्देशों को बराबर संख्या वाले बाइटकोड ऑफ़सेट (यानी, चार बाइट के अलाइन किए गए) पर होना चाहिए. इस ज़रूरी शर्त को पूरा करने के लिए, डीईएक्स जनरेशन टूल को स्पैसर के तौर पर एक अतिरिक्त nop निर्देश उत्सर्जित करना होगा. ऐसा तब करना होगा, जब ऐसा निर्देश अलाइन न हो. आखिर में, ऐसा करना ज़रूरी नहीं है, लेकिन ऐसा माना जाता है कि ज़्यादातर टूल, तरीकों के आखिर में ये निर्देश दिखाएंगे. ऐसा इसलिए, क्योंकि ऐसा न करने पर, इनके लिए अलग से निर्देश देने पड़ सकते हैं.
किसी चल रहे सिस्टम पर इंस्टॉल करने पर, कुछ निर्देशों में बदलाव किया जा सकता है. इसके लिए, इंस्टॉल के समय स्टैटिक लिंकिंग ऑप्टिमाइज़ेशन के तौर पर, उनके फ़ॉर्मैट में बदलाव किया जाता है. इससे, लिंक होने के बाद, प्रोसेस को तेज़ी से पूरा किया जा सकता है. सुझाए गए वैरिएंट के लिए, इससे जुड़ा निर्देश फ़ॉर्मैट दस्तावेज़ देखें. "सुझाया गया" शब्द का इस्तेमाल सोच-समझकर किया गया है; इन सुझावों को लागू करना ज़रूरी नहीं है.
मानव-सिंटैक्स और मेनेमोनिक्स:
- आर्ग्युमेंट के लिए, डेस्टिनेशन के बाद सोर्स का क्रम.
- कुछ ऑपरेंड कोड के नाम के साथ सफ़िक्स होता है, ताकि यह पता चल सके कि वे किस तरह के ऑपरेंड पर काम करते हैं:
  - टाइप-जनरल 32-बिट ऑपरेंड को मार्क नहीं किया जाता.
  - टाइप-जनरल 64-बिट ऑपरेंड कोड के आखिर में -wide जोड़ा जाता है.
  - टाइप के हिसाब से ऑपरेटर कोड के आखिर में, उनके टाइप (या आसानी से समझ आने वाला कोई छोटा नाम) जोड़ा जाता है. इनमें से कोई एक: -boolean -byte -char -short -int -long -float -double -object -string -class -void.
- कुछ ऑपरेंड कोड में, एक जैसे दिखने वाले उन ऑपरेशन को अलग करने के लिए सफ़िक्स होता है जिनके निर्देश लेआउट या विकल्प अलग-अलग होते हैं. इन सफ़िक्स को मुख्य नामों से स्लैश ("/") से अलग किया जाता है. ये मुख्य तौर पर, कोड में स्टैटिक कॉन्स्टेंट के साथ एक-एक मैपिंग बनाने के लिए मौजूद होते हैं. ये कॉन्स्टेंट, एक्ज़ीक्यूटेबल जनरेट और उनका विश्लेषण करते हैं. इसका मतलब है कि इनका मकसद, लोगों के लिए ग़लतफ़हमी को कम करना है.
- यहां दिए गए ब्यौरे में, वैल्यू की चौड़ाई (जैसे, किसी कॉन्सटेंट की रेंज या संभावित तौर पर ऐड्रेस किए गए रजिस्टर की संख्या) पर चार बिट की चौड़ाई के हिसाब से एक वर्ण का इस्तेमाल करके ज़ोर दिया गया है.
- उदाहरण के लिए, निर्देश में "move-wide/from16 vAA, vBBBB":
  - "move" बेस ऑपरेंड कोड है, जो बेस ऑपरेशन के बारे में बताता है (रजिस्टर की वैल्यू को मूव करना).
  - "wide" नाम का सफ़िक्स है. इससे पता चलता है कि यह वाइड (64 बिट) डेटा पर काम करता है.
  - "from16" ऑपरेंड के बाद का सफ़िक्स है. इससे उस वैरिएंट का पता चलता है जिसमें सोर्स के तौर पर 16-बिट रजिस्टर का रेफ़रंस है.
  - "vAA" डेस्टिनेशन रजिस्टर है (यह ऑपरेशन से पता चलता है; फिर से, नियम यह है कि डेस्टिनेशन आर्ग्युमेंट हमेशा पहले आते हैं). यह v0 – v255 की रेंज में होना चाहिए.
  - "vBBBB" सोर्स रजिस्टर है, जो v0 से v65535 के बीच होना चाहिए.
अलग-अलग निर्देश फ़ॉर्मैट ("ऑपरेशन और फ़ॉर्मैट" में दिए गए) के बारे में ज़्यादा जानकारी के लिए, निर्देश फ़ॉर्मैट वाला दस्तावेज़ देखें. साथ ही, ऑपरेंड कोड के सिंटैक्स के बारे में भी जानें.
बाइटकोड, पूरी प्रोसेस में कहां फ़िट होता है, इस बारे में ज़्यादा जानकारी के लिए .dex फ़ाइल फ़ॉर्मैट वाला दस्तावेज़ देखें.

बाइटकोड सेट की खास जानकारी

ऑपरेशन और फ़ॉर्मैट	मेमोनिक / सिंटैक्स	तर्क	ब्यौरा
00 10x	nop		वेस्ट साइकल. ध्यान दें: डेटा वाले स्यूडो-इंस्ट्रक्शन को इस ऑपरेंड कोड से टैग किया जाता है. इस मामले में, ऑपरेंड कोड यूनिट का हाई-ऑर्डर बाइट, डेटा के टाइप के बारे में बताता है. नीचे "`packed-switch-payload` फ़ॉर्मैट", "`sparse-switch-payload` फ़ॉर्मैट", और "`fill-array-data-payload` फ़ॉर्मैट" देखें.
01 12x	move vA, vB	`A:` डेस्टिनेशन रजिस्टर (4 बिट) `B:` सोर्स रजिस्टर (4 बिट)	किसी नॉन-ऑब्जेक्ट रजिस्टर के कॉन्टेंट को दूसरे में ले जाना.
02 22x	move/from16 vAA, vBBBB	`A:` डेस्टिनेशन रजिस्टर (8 बिट) `B:` सोर्स रजिस्टर (16 बिट)	किसी नॉन-ऑब्जेक्ट रजिस्टर के कॉन्टेंट को दूसरे में ले जाना.
03 32x	move/16 vAAAA, vBBBB	`A:` डेस्टिनेशन रजिस्टर (16 बिट) `B:` सोर्स रजिस्टर (16 बिट)	किसी नॉन-ऑब्जेक्ट रजिस्टर के कॉन्टेंट को दूसरे में ले जाना.
04 12x	move-wide vA, vB	`A:` डेस्टिनेशन रजिस्टर पेयर (4 बिट) `B:` सोर्स रजिस्टर पेयर (4 बिट)	एक रजिस्टर-पेयर के कॉन्टेंट को दूसरे में ले जाना. ध्यान दें: `vN` से `vN-1` या `vN+1` में जाने की अनुमति है. इसलिए, कुछ भी लिखने से पहले, रजिस्टर के दोनों हिस्सों को पढ़ने की व्यवस्था करनी होगी.
05 22x	move-wide/from16 vAA, vBBBB	`A:` डेस्टिनेशन रजिस्टर पेयर (8 बिट) `B:` सोर्स रजिस्टर पेयर (16 बिट)	एक रजिस्टर-पेयर के कॉन्टेंट को दूसरे में ले जाना. ध्यान दें: लागू करने से जुड़ी बातें, ऊपर बताई गई `move-wide` के जैसी ही हैं.
06 32x	move-wide/16 vAAAA, vBBBB	`A:` डेस्टिनेशन रजिस्टर पेयर (16 बिट) `B:` सोर्स रजिस्टर पेयर (16 बिट)	एक रजिस्टर-पेयर के कॉन्टेंट को दूसरे में ले जाना. ध्यान दें: लागू करने से जुड़ी बातें, ऊपर बताई गई `move-wide` के जैसी ही हैं.
07 12x	move-object vA, vB	`A:` डेस्टिनेशन रजिस्टर (4 बिट) `B:` सोर्स रजिस्टर (4 बिट)	ऑब्जेक्ट वाले एक रजिस्टर के कॉन्टेंट को दूसरे में ले जाना.
08 22x	move-object/from16 vAA, vBBBB	`A:` डेस्टिनेशन रजिस्टर (8 बिट) `B:` सोर्स रजिस्टर (16 बिट)	ऑब्जेक्ट वाले एक रजिस्टर के कॉन्टेंट को दूसरे में ले जाना.
09 32x	move-object/16 vAAAA, vBBBB	`A:` डेस्टिनेशन रजिस्टर (16 बिट) `B:` सोर्स रजिस्टर (16 बिट)	ऑब्जेक्ट वाले एक रजिस्टर के कॉन्टेंट को दूसरे में ले जाना.
0a 11x	move-result vAA	`A:` डेस्टिनेशन रजिस्टर (8 बिट)	सबसे हाल ही में डाले गए `invoke-kind` के एक शब्द वाले नॉन-ऑब्जेक्ट नतीजे को, बताए गए रजिस्टर में ले जाएं. ऐसा करना ज़रूरी है, क्योंकि यह निर्देश, `invoke-kind` के तुरंत बाद दिया जाना चाहिए, जिसका (एक शब्द वाला, नॉन-ऑब्जेक्ट) नतीजा अनदेखा नहीं किया जाना चाहिए. इसे कहीं और इस्तेमाल करना अमान्य है.
0b 11x	move-result-wide vAA	`A:` डेस्टिनेशन रजिस्टर पेयर (8 बिट)	सबसे हाल ही के `invoke-kind` के दो शब्दों वाले नतीजे को, दिखाए गए रजिस्टर पेयर में ले जाएं. ऐसा करना ज़रूरी है, क्योंकि यह निर्देश, `invoke-kind` के तुरंत बाद दिया जाना चाहिए, जिसके (दो शब्दों वाले) नतीजे को अनदेखा नहीं किया जाना है. इसे कहीं और देना अमान्य है.
0c 11x	move-result-object vAA	`A:` डेस्टिनेशन रजिस्टर (8 बिट)	हाल ही में किए गए `invoke-kind` के ऑब्जेक्ट के नतीजे को, बताए गए रजिस्टर में ले जाएं. ऐसा करना ज़रूरी है, क्योंकि निर्देश को `invoke-kind` या `filled-new-array` के तुरंत बाद डाला जाना चाहिए. ऐसा इसलिए, क्योंकि `invoke-kind` या `filled-new-array` के (ऑब्जेक्ट) नतीजे को अनदेखा नहीं किया जा सकता.
0d 11x	move-exception vAA	`A:` डेस्टिनेशन रजिस्टर (8 बिट)	दिए गए रजिस्टर में, हाल ही में पकड़ा गया अपवाद सेव करें. यह किसी भी अपवाद हैंडलर का पहला निर्देश होना चाहिए, जिसे पकड़े गए अपवाद को अनदेखा नहीं करना है. साथ ही, यह निर्देश सिर्फ़ किसी अपवाद हैंडलर के पहले निर्देश के तौर पर होना चाहिए. किसी और जगह पर यह अमान्य है.
0e 10x	return-void		`void` वाले तरीके से लौटें.
0f 11x	return vAA	`A:` रिटर्न वैल्यू रजिस्टर (8 बिट)	सिंगल-विड्थ (32-बिट) वाले ऐसे तरीके से वापस आना जो ऑब्जेक्ट की वैल्यू नहीं दिखाता.
10 11x	पूरी रिटर्न के लिए vAA	`A:` रिटर्न वैल्यू रजिस्टर-पेयर (8 बिट)	वैल्यू दिखाने वाले डबल-विड्थ (64-बिट) तरीके से वापस आना.
11 11x	return-object vAA	`A:` रिटर्न वैल्यू रजिस्टर (8 बिट)	ऑब्जेक्ट लौटाने वाले तरीके से वापस आना.
12 11n	const/4 vA, #+B	`A:` डेस्टिनेशन रजिस्टर (4 बिट) `B:` साइन किया गया int (4 बिट)	दी गई लिटरल वैल्यू (32 बिट तक साइन-एक्सटेंड की गई) को तय किए गए रजिस्टर में ले जाएं.
13 21s	const/16 vAA, #+BBBB	`A:` डेस्टिनेशन रजिस्टर (8 बिट) `B:` साइन किया गया इंटिजर (16 बिट)	दी गई लिटरल वैल्यू (32 बिट तक साइन-एक्सटेंड की गई) को तय किए गए रजिस्टर में ले जाएं.
14 31i	const vAA, #+BBBBBBBB	`A:` डेस्टिनेशन रजिस्टर (8 बिट) `B:` मनमुताबिक 32-बिट का कॉन्स्टेंट	दी गई लिटरल वैल्यू को तय किए गए रजिस्टर में ले जाएं.
15 21h	const/high16 vAA, #+BBBB0000	`A:` डेस्टिनेशन रजिस्टर (8 बिट) `B:` साइन किया गया इंटिजर (16 बिट)	दी गई लिटरल वैल्यू (32 बिट तक राइट-ज़ीरो-एक्सटेंडेड) को तय किए गए रजिस्टर में ले जाएं.
16 21s	const-wide/16 vAA, #+BBBB	`A:` डेस्टिनेशन रजिस्टर (8 बिट) `B:` साइन किया गया इंटिजर (16 बिट)	दी गई लिटरल वैल्यू (64 बिट तक साइन-एक्सटेंड की गई) को तय किए गए रजिस्टर-पेयर में ले जाएं.
17 31i	const-wide/32 vAA, #+BBBBBBBB	`A:` डेस्टिनेशन रजिस्टर (8 बिट) `B:` साइन वाला इंटिजर (32 बिट)	दी गई लिटरल वैल्यू (64 बिट तक साइन-एक्सटेंड की गई) को तय किए गए रजिस्टर-पेयर में ले जाएं.
18 51l	const-wide vAA, #+BBBBBBBBBBBBBBBB	`A:` डेस्टिनेशन रजिस्टर (8 बिट) `B:` मनमुताबिक डबल-विड्थ (64-बिट) का कॉन्स्टेंट	दी गई लिटरल वैल्यू को तय किए गए रजिस्टर-पेयर में ले जाएं.
19 21h	const-wide/high16 vAA, #+BBBB000000000000	`A:` डेस्टिनेशन रजिस्टर (8 बिट) `B:` साइन किया गया इंटिजर (16 बिट)	दी गई लिटरल वैल्यू (64 बिट तक राइट-ज़ीरो-एक्सटेंडेड) को तय किए गए रजिस्टर-पेयर में ले जाएं.
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:` टाइप इंडेक्स	दिए गए इंडेक्स से तय की गई क्लास के रेफ़रंस को, दिए गए रजिस्टर में ले जाएं. अगर दिखाया गया टाइप प्रिमिटिव है, तो यह प्रिमिटिव टाइप की डीजनरेट क्लास का रेफ़रंस सेव करेगा.
1 दिन 11x	monitor-enter vAA	`A:` रेफ़रंस-बेअरिंग रजिस्टर (8 बिट)	चुने गए ऑब्जेक्ट के लिए मॉनिटर पाएं.
1e 11x	monitor-exit vAA	`A:` रेफ़रंस-बेअरिंग रजिस्टर (8 बिट)	चुने गए ऑब्जेक्ट के लिए मॉनिटर को रिलीज़ करें. ध्यान दें: अगर इस निर्देश को कोई अपवाद फेंकना है, तो ऐसा करना चाहिए जैसे कि पीसी पहले ही निर्देश से आगे बढ़ चुका है. इसे इस तरह समझा जा सकता है कि निर्देश (एक तरह से) सही तरीके से लागू हो गया है और अपवाद, निर्देश के बाद, लेकिन अगले निर्देश के पहले दिखता है. इस परिभाषा की मदद से, किसी तरीके में मॉनिटर क्लीनअप कैच-ऑल का इस्तेमाल किया जा सकता है (उदाहरण के लिए, `finally`) को उस ब्लॉक के लिए, मॉनिटर के क्लीनअप के तौर पर ब्लॉक किया जाता है. ऐसा इसलिए किया जाता है, ताकि `Thread.stop()` के पुराने वर्शन के लागू होने की वजह से, अचानक दिखने वाली गड़बड़ियों को मैनेज किया जा सके. साथ ही, मॉनिटर को सही तरीके से मैनेज किया जा सके.
1f 21c	check-cast vAA, type@BBBB	`A:` रेफ़रंस-बेअरिंग रजिस्टर (8 बिट) `B:` टाइप इंडेक्स (16 बिट)	अगर दिए गए रजिस्टर में मौजूद रेफ़रंस को बताए गए टाइप में कास्ट नहीं किया जा सकता, तो `ClassCastException` दिखाएं. ध्यान दें: `A` हमेशा रेफ़रंस होना चाहिए, न कि प्राइमिटिव वैल्यू. इसलिए, अगर `B` किसी प्राइमिटिव टाइप का रेफ़रंस देता है, तो यह रनटाइम पर काम नहीं करेगा. इसका मतलब है कि यह कोई अपवाद दिखाएगा.
20 22c	instance-of vA, vB, type@CCCC	`A:` डेस्टिनेशन रजिस्टर (4 बिट) `B:` रेफ़रंस-बेअरिंग रजिस्टर (4 बिट) `C:` टाइप इंडेक्स (16 बिट)	अगर दिए गए रेफ़रंस में दिए गए टाइप का कोई इंस्टेंस है, तो उसे दिए गए डेस्टिनेशन रजिस्टर `1` में सेव करें. अगर ऐसा नहीं है, तो `0` में सेव करें. ध्यान दें: `B` हमेशा रेफ़रंस होना चाहिए, न कि प्राइमिटिव वैल्यू. इसलिए, अगर `C` किसी प्राइमिटिव टाइप का रेफ़रंस देता है, तो `0` हमेशा स्टोर किया जाएगा.
21 12x	array-length vA, vB	`A:` डेस्टिनेशन रजिस्टर (4 बिट) `B:` ऐरे रेफ़रंस-बेरिंग रजिस्टर (4 बिट)	दिए गए डेस्टिनेशन रजिस्टर में, एलिमेंट की संख्या को एंट्री में सेव करें
22 21c	new-instance vAA, type@BBBB	`A:` डेस्टिनेशन रजिस्टर (8 बिट) `B:` टाइप इंडेक्स	बताए गए टाइप का नया इंस्टेंस बनाएं और डेस्टिनेशन में उसका रेफ़रंस सेव करें. टाइप, किसी ऐसी क्लास का रेफ़रंस होना चाहिए जो ऐरे न हो.
23 22c	new-array vA, vB, type@CCCC	`A:` डेस्टिनेशन रजिस्टर (4 बिट) `B:` साइज़ रजिस्टर `C:` टाइप इंडेक्स	बताए गए टाइप और साइज़ का नया ऐरे बनाएं. टाइप, ऐरे टाइप होना चाहिए.
24 35c	filled-new-array {vC, vD, vE, vF, vG}, type@BBBB	`A:` ऐरे का साइज़ और ऑर्ग्युमेंट के शब्दों की संख्या (4 बिट) `B:` टाइप इंडेक्स (16 बिट) `C..G:` ऑर्ग्युमेंट रजिस्टर (हर एक 4 बिट)	दिए गए टाइप और साइज़ का ऐरे बनाएं और उसे दिए गए कॉन्टेंट से भरें. टाइप, ऐरे टाइप होना चाहिए. ऐरे में एक ही शब्द होना चाहिए. इसका मतलब है कि `long` या `double` के ऐरे नहीं होने चाहिए. हालांकि, रेफ़रंस टाइप स्वीकार किए जाते हैं. बनाए गए इंस्टेंस को "नतीजे" के तौर पर उसी तरह से सेव किया जाता है जिस तरह से, मेथड को कॉल करने के निर्देश अपने नतीजे सेव करते हैं. इसलिए, अगर बनाए गए इंस्टेंस का इस्तेमाल करना है, तो उसे तुरंत बाद दिए जाने वाले `move-result-object` निर्देश के साथ रजिस्टर में ले जाया जाना चाहिए.
25 3rc	filled-new-array/range {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` फ़ॉर्मैट" में नीचे बताया गया है)	`A:` ऐरे रेफ़रंस (8 बिट) `B:` टेबल डेटा के सूडो-इंस्ट्रक्शन में साइन वाला "शाखा" ऑफ़सेट (32 बिट)	दिए गए ऐरे में, दिखाए गए डेटा को भरें. रेफ़रंस, प्राइमिटिव के ऐरे का होना चाहिए. साथ ही, डेटा टेबल का टाइप उससे मेल खाना चाहिए और उसमें ऐरे में फ़िट होने से ज़्यादा एलिमेंट नहीं होने चाहिए. इसका मतलब है कि टेबल से बड़ा ऐरे हो सकता है. अगर ऐसा है, तो ऐरे के सिर्फ़ शुरुआती एलिमेंट सेट किए जाते हैं और बाकी एलिमेंट को छोड़ दिया जाता है.
27 11x	throw vAA	`A:` अपवाद वाला रजिस्टर (8 बिट)	बताए गए अपवाद को थ्रो करें.
28 10t	goto +AA	`A:` साइन किया गया शाखा ऑफ़सेट (8 बिट)	बिना किसी शर्त के, दिए गए निर्देश पर जाएं. ध्यान दें: ब्रांच ऑफ़सेट `0` नहीं होना चाहिए. (स्पिन लूप को `goto/32` के साथ या फिर शाखा से पहले टारगेट के तौर पर `nop` को शामिल करके, कानूनी तौर पर बनाया जा सकता है.)
29 20t	goto/16 +AAAA	`A:` साइन किया गया ब्रैंच ऑफ़सेट (16 बिट)	बिना किसी शर्त के, दिए गए निर्देश पर जाएं. ध्यान दें: शाखा का ऑफ़सेट `0` नहीं होना चाहिए. (स्पिन लूप को `goto/32` के साथ या फिर शाखा से पहले टारगेट के तौर पर `nop` को शामिल करके, कानूनी तौर पर बनाया जा सकता है.)
2a 30t	goto/32 +AAAAAAAA	`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 बिट)	वैल्यू-ऑफ़सेट जोड़े की क्रम से लगाई गई टेबल का इस्तेमाल करके, दिए गए रजिस्टर में मौजूद वैल्यू के आधार पर, किसी नए निर्देश पर जाएं. अगर कोई मैच नहीं होता है, तो अगले निर्देश पर जाएं.
2d..31 23x	cmpkind vAA, vBB, vCC 2d: cmpl-float (lt bias) 2e: cmpg-float (gt bias) 2f: cmpl-double (lt bias) 30: cmpg-double (gt bias) 31: cmp-long	`A:` डेस्टिनेशन रजिस्टर (8 बिट) `B:` पहला सोर्स रजिस्टर या पेयर `C:` दूसरा सोर्स रजिस्टर या पेयर	दिए गए फ़्लोटिंग पॉइंट या `long` की तुलना करें. इसके लिए, `b == c` होने पर `a` को `0` पर, `b > c` होने पर `1` पर या `b < c` होने पर `-1` पर सेट करें. फ़्लोटिंग पॉइंट ऑपरेशन के लिए सूची में दिया गया "बायस", `NaN` तुलनाओं को कैसे माना जाता है, यह बताता है: "gt bias" निर्देश, `NaN` तुलनाओं के लिए `1` दिखाते हैं और "lt bias" निर्देश `-1` दिखाते हैं. उदाहरण के लिए, यह पता लगाने के लिए कि फ़्लोटिंग पॉइंट `x < y` है या नहीं, `cmpg-float` का इस्तेमाल करना बेहतर होता है. `-1` का नतीजा यह दिखाता है कि जांच सही थी. दूसरी वैल्यू से पता चलता है कि जांच गलत थी. ऐसा, मान्य तुलना की वजह से या वैल्यू में से किसी एक वैल्यू के `NaN` होने की वजह से होता है.
32..37 22t	if-test 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 बिट)	अगर दिए गए दो रजिस्टर की वैल्यू, तय की गई वैल्यू से मेल खाती हैं, तो दिए गए डेस्टिनेशन पर जाएं. ध्यान दें: शाखा का ऑफ़सेट `0` नहीं होना चाहिए. (स्पिन लूप को कानूनी तौर पर, पीछे की ओर वाले `goto` के आस-पास शाखा बनाकर या शाखा से पहले टारगेट के तौर पर `nop` को शामिल करके बनाया जा सकता है.)
38..3d 21t	if-testz 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 से मेल खाती है, तो दिए गए डेस्टिनेशन पर ब्रैंच करें. ध्यान दें: शाखा का ऑफ़सेट `0` नहीं होना चाहिए. (स्पिन लूप को कानूनी तौर पर, पीछे की ओर वाले `goto` के आस-पास शाखा बनाकर या शाखा से पहले टारगेट के तौर पर `nop` को शामिल करके बनाया जा सकता है.)
3e..43 10x	(इस्तेमाल नहीं किया गया)		(इस्तेमाल नहीं किया गया)
44..51 23x	arrayop vAA, vBB, vCC 44: aget 45: aget-wide 46: aget-object 47: aget-boolean 48: aget-byte 49: aget-char 4a: aget-short 4b: aput 4c: aput-wide 4d: aput-object 4e: aput-boolean 4f: aput-byte 50: aput-char 51: aput-short	`A:` वैल्यू रजिस्टर या पेयर; सोर्स या डेस्टिनेशन हो सकता है (8 बिट) `B:` ऐरे रजिस्टर (8 बिट) `C:` इंडेक्स रजिस्टर (8 बिट)	दिए गए ऐरे के पहचाने गए इंडेक्स पर, पहचाने गए ऐरे ऑपरेशन को लागू करें. इसके बाद, वैल्यू रजिस्टर में लोड करें या स्टोर करें.
52..5f 22c	iinstanceop vA, vB, field@CCCC 52: iget 53: iget-wide 54: iget-object 55: iget-boolean 56: iget-byte 57: iget-char 58: iget-short 59: iput 5a: iput-wide 5b: iput-object 5c: iput-boolean 5d: iput-byte 5e: iput-char 5f: iput-short	`A:` वैल्यू रजिस्टर या पेयर; सोर्स या डेस्टिनेशन हो सकता है (4 बिट) `B:` ऑब्जेक्ट रजिस्टर (4 बिट) `C:` इंस्टेंस फ़ील्ड रेफ़रंस इंडेक्स (16 बिट)	पहचाने गए ऑब्जेक्ट इंस्टेंस फ़ील्ड ऑपरेशन को, पहचाने गए फ़ील्ड के साथ, वैल्यू रजिस्टर में लोड या स्टोर करके करें. ध्यान दें: ये ऑपरेटर कोड, स्टैटिक लिंकिंग के लिए सही विकल्प हैं. इनकी मदद से, फ़ील्ड आर्ग्युमेंट को ज़्यादा सीधे ऑफ़सेट में बदला जा सकता है.
60..6d 21c	sstaticop vAA, field@BBBB 60: sget 61: sget-wide 62: sget-object 63: sget-boolean 64: sget-byte 65: sget-char 66: sget-short 67: sput 68: sput-wide 69: sput-object 6a: sput-boolean 6b: sput-byte 6c: sput-char 6d: sput-short	`A:` वैल्यू रजिस्टर या पेयर; सोर्स या डेस्टिनेशन हो सकता है (8 बिट) `B:` स्टैटिक फ़ील्ड रेफ़रंस इंडेक्स (16 बिट)	पहचाने गए ऑब्जेक्ट के स्टैटिक फ़ील्ड पर, वैल्यू रजिस्टर में लोड करने या स्टोर करने के लिए, स्टैटिक फ़ील्ड पर पहचाने गए ऑब्जेक्ट के स्टैटिक फ़ील्ड ऑपरेशन को लागू करें. ध्यान दें: ये ऑपरेटर कोड, स्टैटिक लिंकिंग के लिए सही विकल्प हैं. इनकी मदद से, फ़ील्ड आर्ग्युमेंट को ज़्यादा सीधे ऑफ़सेट में बदला जा सकता है.
6e..72 35c	invoke-kind {vC, vD, vE, vF, vG}, meth@BBBB 6e: invoke-virtual 6f: invoke-super 70: invoke-direct 71: invoke-static 72: invoke-interface	`A:` आर्ग्युमेंट के शब्दों की संख्या (चार बिट) `B:` मेथड का रेफ़रंस इंडेक्स (16 बिट) `C..G:` आर्ग्युमेंट रजिस्टर (हर एक चार बिट)	बताए गए तरीके को कॉल करें. नतीजे (अगर कोई है) को तुरंत दिए जाने वाले निर्देश के तौर पर, सही `move-result` वैरिएंट के साथ सेव किया जा सकता है. `invoke-virtual` का इस्तेमाल, किसी सामान्य वर्चुअल विधि को कॉल करने के लिए किया जाता है. यह वह तरीका होता है जो `static`, `private` या कन्स्ट्रक्टर नहीं होता. जब `method_id` किसी ऐसे इंटरफ़ेस के तरीके का रेफ़रंस देता है जो इंटरफ़ेस क्लास नहीं है, तो `invoke-super` का इस्तेमाल, सबसे करीब के सुपरक्लास के वर्चुअल तरीके को कॉल करने के लिए किया जाता है. यह तरीका, कॉल करने वाली क्लास में मौजूद उसी `method_id` के मुकाबले अलग होता है. इस तरीके पर भी वही पाबंदियां लागू होती हैं जो `invoke-virtual` पर लागू होती हैं. Dex फ़ाइलों के `037` या उसके बाद के वर्शन में, अगर `method_id` किसी इंटरफ़ेस के तरीके को रेफ़र करता है, तो `invoke-super` का इस्तेमाल उस इंटरफ़ेस पर बताए गए उस तरीके के सबसे सटीक और ऐसे वर्शन को लागू करने के लिए किया जाता है जिसे बदला नहीं गया है. `invoke-virtual` के लिए, इस तरीके पर भी वही पाबंदियां लागू होती हैं. `037` वर्शन से पहले की Dex फ़ाइलों में, इंटरफ़ेस `method_id` का इस्तेमाल करना गैर-कानूनी और अमान्य है. `invoke-direct` का इस्तेमाल, `static` के अलावा किसी और डायरेक्ट तरीके को शुरू करने के लिए किया जाता है. इसका मतलब है कि यह एक ऐसा इंस्टेंस तरीका है जिसे अपने तौर पर बदला नहीं जा सकता. जैसे, `private` इंस्टेंस तरीका या कंस्ट्रक्टर. `invoke-static` का इस्तेमाल, `static` विधि को लागू करने के लिए किया जाता है. इसे हमेशा डायरेक्ट तरीका माना जाता है. `invoke-interface` का इस्तेमाल, किसी ऑब्जेक्ट पर `interface` का तरीका शुरू करने के लिए किया जाता है. यह ऑब्जेक्ट ऐसा होता है जिसकी असल क्लास की जानकारी नहीं होती. इसके लिए, `method_id` का इस्तेमाल किया जाता है, जो `interface` का रेफ़रंस देता है. ध्यान दें:* ये ऑपरेटर कोड, स्टैटिक लिंकिंग के लिए सही विकल्प हैं. इनसे, मेथड आर्ग्युमेंट को ज़्यादा सीधे ऑफ़सेट (या उसके पेयर) में बदला जा सकता है.
73 10x	(इस्तेमाल नहीं किया गया)		(इस्तेमाल नहीं किया गया)
74..78 3rc	invoke-kind/range {vCCCC .. vNNNN}, meth@BBBB 74: invoke-virtual/range 75: invoke-super/range 76: invoke-direct/range 77: invoke-static/range 78: invoke-interface/range	`A:` आर्ग्युमेंट के शब्दों की संख्या (8 बिट) `B:` तरीके का रेफ़रंस इंडेक्स (16 बिट) `C:` पहला आर्ग्युमेंट रजिस्टर (16 बिट) `N = A + C - 1`	बताए गए तरीके को कॉल करें. ज़्यादा जानकारी, सावधानियां, और सुझावों के लिए, ऊपर दिया गया पहला `invoke-kind` ब्यौरा देखें.
79..7a 10x	(इस्तेमाल नहीं किया गया)		(इस्तेमाल नहीं किया गया)
7b..8f 12x	unop vA, vB 7b: neg-int 7c: not-int 7d: neg-long 7e: not-long 7f: neg-float 80: neg-double 81: int-to-long 82: int-to-float 83: int-to-double 84: long-to-int 85: long-to-float 86: long-to-double 87: float-to-int 88: float-to-long 89: float-to-double 8a: double-to-int 8b: double-to-long 8c: double-to-float 8d: int-to-byte 8e: int-to-char 8f: int-to-short	`A:` डेस्टिनेशन रजिस्टर या पेयर (4 बिट) `B:` सोर्स रजिस्टर या पेयर (4 बिट)	सोर्स रजिस्टर पर, पहचाने गए यूनीऐरी ऑपरेशन को लागू करें और नतीजे को डेस्टिनेशन रजिस्टर में सेव करें.
90..af 23x	binop vAA, vBB, vCC 90: add-int 91: sub-int 92: mul-int 93: div-int 94: rem-int 95: and-int 96: or-int 97: xor-int 98: shl-int 99: shr-int 9a: ushr-int 9b: add-long 9c: sub-long 9d: mul-long 9e: div-long 9f: rem-long a0: and-long a1: or-long a2: xor-long a3: shl-long a4: shr-long a5: ushr-long a6: add-float a7: sub-float a8: mul-float a9: div-float aa: rem-float ab: add-double ac: sub-double ad: mul-double ae: div-double af: rem-double	`A:` डेस्टिनेशन रजिस्टर या पेयर (8 बिट) `B:` पहला सोर्स रजिस्टर या पेयर (8 बिट) `C:` दूसरा सोर्स रजिस्टर या पेयर (8 बिट)	दो सोर्स रजिस्टर पर, पहचाने गए बाइनरी ऑपरेशन को लागू करें और नतीजे को डेस्टिनेशन रजिस्टर में सेव करें. ध्यान दें: अन्य `-long` गणितीय ऑपरेशन के उलट (जो अपने पहले और दूसरे सोर्स, दोनों के लिए रजिस्टर पेयर लेते हैं), `shl-long`, `shr-long`, और `ushr-long` अपने पहले सोर्स (वैल्यू को शिफ़्ट किया जाना है) के लिए एक रजिस्टर पेयर लेते हैं, लेकिन अपने दूसरे सोर्स (शिफ़्ट करने की दूरी) के लिए एक रजिस्टर लेते हैं.
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: and-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 be: div-long/2addr bf: rem-long/2addr c0: and-long/2addr c1: or-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 ca: rem-float/2addr cb: add-double/2addr cc: sub-double/2addr cd: mul-double/2addr ce: div-double/2addr cf: rem-double/2addr	`A:` डेस्टिनेशन और पहला सोर्स रजिस्टर या पेयर (चार बिट) `B:` दूसरा सोर्स रजिस्टर या पेयर (चार बिट)	दो सोर्स रजिस्टर पर, पहचाने गए बाइनरी ऑपरेशन को लागू करें और नतीजे को पहले सोर्स रजिस्टर में सेव करें. ध्यान दें: `-long/2addr` के अन्य गणितीय ऑपरेशन के उलट, `shl-long/2addr`, `shr-long/2addr`, और `ushr-long/2addr`, अपने डेस्टिनेशन/पहले सोर्स (वैल्यू को शिफ़्ट किया जाना है) के लिए एक रजिस्टर पेयर लेते हैं. हालांकि, अपने दूसरे सोर्स (शिफ़्ट करने की दूरी) के लिए एक रजिस्टर लेते हैं.
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: and-int/lit16 d6: or-int/lit16 d7: xor-int/lit16	`A:` डेस्टिनेशन रजिस्टर (4 बिट) `B:` सोर्स रजिस्टर (4 बिट) `C:` साइन वाला इंट कॉन्स्टेंट (16 बिट)	दिए गए रजिस्टर (पहला आर्ग्युमेंट) और लिटरल वैल्यू (दूसरा आर्ग्युमेंट) पर, दिए गए बाइनरी ऑपरेशन को लागू करें. साथ ही, नतीजे को डेस्टिनेशन रजिस्टर में सेव करें. ध्यान दें: `rsub-int` में कोई सफ़िक्स नहीं होता, क्योंकि यह वर्शन अपनी फ़ैमिली का मुख्य ऑपरेंड कोड है. इसके सेमेंटेक्स के बारे में ज़्यादा जानकारी के लिए, नीचे देखें.
d8..e2 22b	binop/lit8 vAA, vBB, #+CC d8: add-int/lit8 d9: rsub-int/lit8 da: mul-int/lit8 db: div-int/lit8 dc: rem-int/lit8 dd: and-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 बिट)	दिए गए रजिस्टर (पहला आर्ग्युमेंट) और लिटरल वैल्यू (दूसरा आर्ग्युमेंट) पर, दिए गए बाइनरी ऑपरेशन को लागू करें. साथ ही, नतीजे को डेस्टिनेशन रजिस्टर में सेव करें. ध्यान दें: `rsub-int` के सेमेटिक्स के बारे में ज़्यादा जानकारी के लिए, यहां देखें.
e3..f9 10x	(इस्तेमाल नहीं किया गया)		(इस्तेमाल नहीं किया गया)
fa 45cc	invoke-polymorphic {vC, vD, vE, vF, vG}, meth@BBBB, proto@HHHH	`A:` आर्ग्युमेंट वर्ड की संख्या (4 बिट) `B:` तरीके का रेफ़रंस इंडेक्स (16 बिट) `C:` रिसीवर (4 बिट) `D..G:` आर्ग्युमेंट रजिस्टर (हर एक 4 बिट) `H:` प्रोटोटाइप का रेफ़रंस इंडेक्स (16 बिट)	दिए गए हस्ताक्षर के पॉलीमोर्फ़िक तरीके को लागू करें. नतीजे (अगर कोई है) को तुरंत दिए जाने वाले निर्देश के तौर पर, सही `move-result*` वैरिएंट के साथ सेव किया जा सकता है. यह ज़रूरी है कि मेथड का रेफ़रंस, सिग्नेचर पॉलीमरफ़िक मेथड का हो, जैसे कि `java.lang.invoke.MethodHandle.invoke` या `java.lang.invoke.MethodHandle.invokeExact`. रिसीवर, ऐसा ऑब्जेक्ट होना चाहिए जो इस्तेमाल किए जा रहे सिग्नेचर के पॉलीमरफ़िक तरीकों के साथ काम करता हो. प्रोटोटाइप रेफ़रंस में, दिए गए आर्ग्युमेंट टाइप और रिटर्न टाइप के बारे में बताया गया है. `invoke-polymorphic` बाइटकोड, लागू होने पर अपवाद दिखा सकता है. अपवादों के बारे में, एपीआई दस्तावेज़ में बताया गया है. यह `038` वर्शन के बाद की dex फ़ाइलों में मौजूद है.
fb 4rcc	invoke-polymorphic/range {vCCCC .. vNNNN}, meth@BBBB, proto@HHHH	`A:` आर्ग्युमेंट वर्ड काउंट (8 बिट) `B:` तरीके का रेफ़रंस इंडेक्स (16 बिट) `C:` रिसीवर (16 बिट) `H:` प्रोटोटाइप का रेफ़रंस इंडेक्स (16 बिट) `N = A + C - 1`	बताए गए तरीके के हैंडल को चालू करें. ज़्यादा जानकारी के लिए, ऊपर `invoke-polymorphic` के बारे में दी गई जानकारी देखें. `038` वर्शन से, dex फ़ाइलों में मौजूद है.
fc 35c	invoke-custom {vC, vD, vE, vF, vG}, call_site@BBBB	`A:` आर्ग्युमेंट के शब्दों की संख्या (चार बिट) `B:` कॉल साइट का रेफ़रंस इंडेक्स (16 बिट) `C..G:` आर्ग्युमेंट रजिस्टर (हर एक चार बिट)	बताई गई कॉल साइट को हल और चालू करता है. अगर कोई नतीजा मिलता है, तो उसे तुरंत दिए जाने वाले निर्देश के तौर पर, सही `move-result*` वैरिएंट के साथ सेव किया जा सकता है. यह निर्देश दो चरणों में पूरा होता है: कॉल साइट रिज़ॉल्यूशन और कॉल साइट को कॉल करना. कॉल साइट रिज़ॉल्यूशन यह जांच करता है कि बताई गई कॉल साइट से कोई `java.lang.invoke.CallSite` इंस्टेंस जुड़ा है या नहीं. अगर ऐसा नहीं है, तो बताई गई कॉल साइट के लिए, बूस्टरैप लिंकर का तरीका, DEX फ़ाइल में मौजूद आर्ग्युमेंट का इस्तेमाल करके शुरू किया जाता है (call_site_item देखें). बूस्टरैप लिंकर का तरीका, एक `java.lang.invoke.CallSite` इंस्टेंस दिखाता है. अगर कोई असोसिएशन मौजूद नहीं है, तो इसे बताई गई कॉल साइट से जोड़ दिया जाएगा. हो सकता है कि किसी दूसरी थ्रेड ने पहले ही असोसिएशन बना लिया हो. अगर ऐसा है, तो निर्देश को पहले असोसिएट किए गए `java.lang.invoke.CallSite` इंस्टेंस के साथ चलाया जाता रहेगा. सुलझाए गए `java.lang.invoke.CallSite` इंस्टेंस के `java.lang.invoke.MethodHandle` टारगेट पर, कॉल साइट को शुरू किया जाता है. टारगेट को वैसे ही शुरू किया जाता है जैसे कि `invoke-polymorphic` (ऊपर बताया गया है) को लागू करने के लिए, `invoke-custom` निर्देश के आर्ग्युमेंट को एग्ज़ैक्ट मेथड हैंडल के आर्ग्युमेंट के तौर पर इस्तेमाल किया जाता है. बूटस्ट्रैप लिंकर तरीके से मिले अपवादों को `java.lang.BootstrapMethodError` में रैप किया जाता है. `BootstrapMethodError` तब भी दिखता है, जब: बूटस्ट्रैप लिंकर का तरीका, `java.lang.invoke.CallSite` इंस्टेंस नहीं दिखा पाता. दिखाए गए `java.lang.invoke.CallSite` में, `null` तरीका हैंडल टारगेट है. जिस टाइप के लिए अनुरोध किया गया है उस टाइप का मेथड हैंडल टारगेट नहीं है. `038` वर्शन से, dex फ़ाइलों में मौजूद है.
fd 3rc	invoke-custom/range {vCCCC .. vNNNN}, call_site@BBBB	`A:` आर्ग्युमेंट के शब्दों की संख्या (8 बिट) `B:` कॉल साइट का रेफ़रंस इंडेक्स (16 बिट) `C:` पहला आर्ग्युमेंट रजिस्टर (16-बिट) `N = A + C - 1`	कॉल साइट को हल और लागू करना. ज़्यादा जानकारी के लिए, ऊपर `invoke-custom` के बारे में दी गई जानकारी देखें. `038` वर्शन से, dex फ़ाइलों में मौजूद है.
fe 21c	const-method-handle vAA, method_handle@BBBB	`A:` डेस्टिनेशन रजिस्टर (8 बिट) `B:` मेथड हैंडल इंडेक्स (16 बिट)	दिए गए इंडेक्स से तय किए गए मेथड हैंडल के रेफ़रंस को, दिए गए रजिस्टर में ले जाएं. `039` वर्शन से, dex फ़ाइलों में मौजूद है.
ff 21c	const-method-type vAA, proto@BBBB	`A:` डेस्टिनेशन रजिस्टर (8 बिट) `B:` तरीके के प्रोटोटाइप का रेफ़रंस (16 बिट)	दिए गए इंडेक्स के हिसाब से, दिए गए रजिस्टर में दिए गए प्रोटोटाइप के रेफ़रंस को मूव करें. `039` वर्शन से, dex फ़ाइलों में मौजूद है.

packed-switch-payload फ़ॉर्मैट

नाम	फ़ॉर्मैट	ब्यौरा
ident	ushort = 0x0100	सूडो-ऑपकोड की पहचान करना
साइज़	ushort	टेबल में एंट्री की संख्या
first_key	आईएनटी	पहली (और सबसे कम) स्विच केस वैल्यू
टारगेट	int[]	`size` रिलेटिव ब्रैंच टारगेट की सूची. टारगेट, इस टेबल के बजाय, स्विच ऑपरेंड कोड के पते से जुड़े होते हैं.

ध्यान दें: इस टेबल के किसी इंस्टेंस के लिए, कोड यूनिट की कुल संख्या (size * 2) + 4 है.

sparse-switch-payload फ़ॉर्मैट

नाम	फ़ॉर्मैट	ब्यौरा
ident	ushort = 0x0200	सूडो-ऑपकोड की पहचान करना
साइज़	ushort	टेबल में एंट्री की संख्या
बटन	int[]	`size` की-वैल्यू की सूची, कम से ज़्यादा के क्रम में लगाई गई
टारगेट	int[]	`size` रिलेटिव ब्रैंच टारगेट की सूची, जिसमें हर टारगेट एक ही इंडेक्स में मौजूद की वैल्यू से जुड़ा होता है. टारगेट, इस टेबल के बजाय, स्विच ऑपरेंड कोड के पते से जुड़े होते हैं.

ध्यान दें: इस टेबल के किसी इंस्टेंस के लिए, कोड यूनिट की कुल संख्या (size * 4) + 2 है.

fill-array-data-payload फ़ॉर्मैट

नाम	फ़ॉर्मैट	ब्यौरा
ident	ushort = 0x0300	सूडो-ऑपकोड की पहचान करना
element_width	ushort	हर एलिमेंट में बाइट की संख्या
साइज़	uint	टेबल में एलिमेंट की संख्या
डेटा	ubyte[]	डेटा वैल्यू

ध्यान दें: इस टेबल के किसी इंस्टेंस के लिए, कोड यूनिट की कुल संख्या (size * element_width + 1) / 2 + 4 है.

गणितीय ऑपरेशन की जानकारी

ध्यान दें: फ़्लोटिंग पॉइंट ऑपरेशन के लिए, IEEE 754 नियमों का पालन करना ज़रूरी है. इसके लिए, सबसे नज़दीकी वैल्यू पर राउंड-ऑफ़ और धीरे-धीरे अंकों की संख्या कम करने की सुविधा का इस्तेमाल किया जाता है. हालांकि, ऐसा तब नहीं किया जाता, जब कुछ और कहा गया हो.

ऑपकोड	C सिमेंटिक्स	नोट
neg-int	int32 a; int32 result = -a;	यूनीरी टूज़-कंप्लीमेंट.
not-int	int32 a; int32 result = ~a;	यूनीरी वन्स-कंप्लीमेंट.
neg-long	int64 a; int64 result = -a;	यूनीरी टूज़-कंप्लीमेंट.
not-long	int64 a; int64 result = ~a;	यूनीऐरी वन्स-कंप्लीमेंट.
neg-float	float a; float result = -a;	फ़्लोटिंग पॉइंट की संख्या को नेगेटिव करना.
neg-double	double a; double result = -a;	फ़्लोटिंग पॉइंट की संख्या को नेगेटिव करना.
int-to-long	int32 a; int64 result = (int64) a;	`int32` के एक्सटेंशन को `int64` में साइन करें.
int-to-float	int32 a; float result = (float) a;	सबसे नज़दीकी वैल्यू पर राउंड-ऑफ़ करने की सुविधा का इस्तेमाल करके, `int32` को `float` में बदलना. इससे कुछ वैल्यू सटीक नहीं रहतीं.
int-to-double	int32 a; double result = (double) a;	`int32` को `double` में बदलना.
long-to-int	int64 a; int32 result = (int32) a;	`int64` को `int32` में काट-छांट करके बदलना.
long-to-float	int64 a; float result = (float) a;	सबसे नज़दीकी वैल्यू पर राउंड-ऑफ़ करने की सुविधा का इस्तेमाल करके, `int64` को `float` में बदलना. इससे कुछ वैल्यू सटीक नहीं रहतीं.
long-to-double	int64 a; double result = (double) a;	सबसे नज़दीकी वैल्यू पर राउंड-ऑफ़ करने की सुविधा का इस्तेमाल करके, `int64` को `double` में बदलना. इससे कुछ वैल्यू सटीक नहीं रहतीं.
float-to-int	float a; int32 result = (int32) a;	`float` को `int32` में बदलना. इसके लिए, 'शून्य के करीब राउंड करें' का इस्तेमाल किया गया है. `NaN` और `-0.0` (नेगेटिव शून्य) को `0` पूर्णांक में बदला जाता है. अनंत और ऐसी वैल्यू जिन्हें दिखाने के लिए, बहुत ज़्यादा मैग्नीट्यूड की ज़रूरत होती है उन्हें साइन के आधार पर, `0x7fffffff` या `-0x80000000` में बदल दिया जाता है.
float-to-long	float a; int64 result = (int64) a;	`float` को `int64` में बदलना. इसके लिए, 'शून्य के करीब राउंड करें' का इस्तेमाल किया गया है. यहां भी वही खास नियम लागू होते हैं जो `float-to-int` के लिए लागू होते हैं. हालांकि, रेंज से बाहर की वैल्यू, साइन के आधार पर `0x7fffffffffffffff` या `-0x8000000000000000` में बदल जाती हैं.
float-to-double	float a; double result = (double) a;	`float` को `double` में बदलना, वैल्यू को पूरी तरह से बनाए रखना.
double-to-int	double a; int32 result = (int32) a;	`double` को `int32` में बदलना. इसके लिए, 'शून्य के करीब राउंड करें' का इस्तेमाल किया गया है. यहां भी `float-to-int` के लिए लागू होने वाले स्पेशल-केस नियम लागू होते हैं.
डबल-टू-लॉन्ग	double a; int64 result = (int64) a;	`double` को `int64` में बदलना. इसके लिए, 'शून्य के करीब राउंड करें' का इस्तेमाल किया गया है. यहां भी `float-to-long` के लिए लागू होने वाले स्पेशल-केस नियम लागू होते हैं.
double-to-float	double a; float result = (float) 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` में छोटा किया गया.
int-to-short	int32 a; int32 result = (a << 16) >> 16;	`int32` को `int16` तक काटना, साइन का मतलब है कि नतीजे को बड़ा किया जा रहा है.
add-int	int32 a, b; int32 result = a + b;	दो का पूरक जोड़ना.
sub-int	int32 a, b; int32 result = a - b;	दो का पूरक घटाना.
rsub-int	int32 a, b; int32 result = b - a;	दो का पूरक, रिवर्स घटाव.
mul-int	int32 a, b; int32 result = a * b;	दो का पूरक गुणा.
div-int	int32 a, b; int32 result = a / b;	टूज़-कंप्लीमेंट डिवीज़न, जिसे शून्य की ओर राउंड किया गया है (यानी, पूर्णांक तक काट दिया गया है). अगर `b == 0` है, तो यह `ArithmeticException` दिखाता है.
rem-int	int32 a, b; int32 result = a % b;	भाग देने के बाद, दो के पूरक में शेषफल. नतीजे का साइन वही है जो `a` का है. इसे `result == a - (a / b) * b` के तौर पर ज़्यादा सटीक तरीके से परिभाषित किया गया है. अगर `b == 0` है, तो यह `ArithmeticException` दिखाता है.
and-int	int32 a, b; int32 result = a & b;	बिट के हिसाब से AND.
or-int	int32 a, b; int32 result = a \| b;	बिट के हिसाब से OR.
xor-int	int32 a, b; int32 result = a ^ b;	बिट के हिसाब से XOR.
shl-int	int32 a, b; int32 result = a << (b & 0x1f);	बाईं ओर बिटवाइज़ शिफ़्ट (मास्क किए गए आर्ग्युमेंट के साथ).
shr-int	int32 a, b; int32 result = a >> (b & 0x1f);	बाइटवाइज़ साइन किया गया, दाईं ओर शिफ़्ट (मास्क किए गए आर्ग्युमेंट के साथ).
ushr-int	uint32 a, b; int32 result = a >> (b & 0x1f);	बिना साइन वाले बिटवाइज़ राइट शिफ़्ट (मास्क किए गए आर्ग्युमेंट के साथ).
add-long	int64 a, b; int64 result = a + b;	दो का पूरक जोड़ना.
सब-लॉन्ग	int64 a, b; int64 result = a - b;	दो का पूरक घटाना.
mul-long	int64 a, b; int64 result = a * b;	दो का पूरक गुणा.
div-long	int64 a, b; int64 result = a / b;	टूज़-कंप्लीमेंट डिवीज़न, जिसे शून्य की ओर राउंड किया गया है (यानी, पूर्णांक तक काट दिया गया है). अगर `b == 0` है, तो यह `ArithmeticException` दिखाता है.
rem-long	int64 a, b; int64 result = a % b;	भाग देने के बाद, दो के पूरक में शेषफल. नतीजे का साइन वही है जो `a` का है. इसे `result == a - (a / b) * b` के तौर पर ज़्यादा सटीक तरीके से परिभाषित किया गया है. अगर `b == 0` है, तो यह `ArithmeticException` दिखाता है.
and-long	int64 a, b; int64 result = a & b;	बिट के हिसाब से AND.
or-long	int64 a, b; int64 result = a \| b;	बिट के हिसाब से OR.
xor-long	int64 a, b; int64 result = a ^ b;	बिट के हिसाब से XOR.
shl-long	int64 a; int32 b; int64 result = a << (b & 0x3f);	बाईं ओर बिटवाइज़ शिफ़्ट (मास्क किए गए आर्ग्युमेंट के साथ).
shr-long	int64 a; int32 b; int64 result = a >> (b & 0x3f);	बाइटवाइज़ साइन किया गया दाईं ओर शिफ़्ट (मास्क किए गए आर्ग्युमेंट के साथ).
ushr-long	uint64 a; int32 b; int64 result = a >> (b & 0x3f);	बिना साइन वाले बिटवाइज़ राइट शिफ़्ट (मास्क किए गए आर्ग्युमेंट के साथ).
add-float	float a, b; float result = a + b;	फ़्लोटिंग पॉइंट जोड़ना.
सब-फ़्लोट	float a, b; float result = a - b;	फ़्लोटिंग पॉइंट अंकों को घटाना.
mul-float	float a, b; float result = a * b;	फ़्लोटिंग पॉइंट का गुणा.
div-float	float a, b; float result = a / b;	फ़्लोटिंग पॉइंट डिवीज़न.
rem-float	float a, b; float result = a % b;	भाग देने के बाद, फ़्लोटिंग पॉइंट वाला शेषफल. यह फ़ंक्शन, IEEE 754 के बाकी हिस्से से अलग है और इसे `result == a - roundTowardZero(a / b) * b` के तौर पर परिभाषित किया गया है.
add-double	double a, b; double result = a + b;	फ़्लोटिंग पॉइंट जोड़ना.
सब-डबल	double a, b; double result = a - b;	फ़्लोटिंग पॉइंट अंकों को घटाना.
mul-double	double a, b; double result = a * b;	फ़्लोटिंग पॉइंट का गुणा.
div-double	double a, b; double result = a / b;	फ़्लोटिंग पॉइंट डिवीज़न.
rem-double	double a, b; double result = a % b;	भाग देने के बाद, फ़्लोटिंग पॉइंट वाला शेषफल. यह फ़ंक्शन, आईईईई 754 के बाकी हिस्से से अलग है और इसे `result == a - roundTowardZero(a / b) * b` के तौर पर परिभाषित किया गया है.