हमारा सुझाव है कि 27 मार्च, 2025 से AOSP को बनाने और उसमें योगदान देने के लिए, aosp-main के बजाय android-latest-release का इस्तेमाल करें. ज़्यादा जानकारी के लिए, AOSP में हुए बदलाव लेख पढ़ें.

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

Dalvik के लिए एक्ज़ीक्यूटेबल निर्देश के फ़ॉर्मैट
संग्रह की मदद से व्यवस्थित रहें अपनी प्राथमिकताओं के आधार पर, कॉन्टेंट को सेव करें और कैटगरी में बांटें.

इस पेज पर, Dalvik executable (DEX) फ़ॉर्मैट और Dalvik बाइटकोड के इस्तेमाल किए जाने वाले निर्देश फ़ॉर्मैट की सूची दी गई है. इसका इस्तेमाल, बाइटकोड रेफ़रंस दस्तावेज़ के साथ किया जाना चाहिए.

बिटवाइज़ ब्यौरे

फ़ॉर्मैट टेबल के पहले कॉलम में, फ़ॉर्मैट का बिटवाइज़ लेआउट दिखता है. इसमें एक या एक से ज़्यादा "शब्द" होते हैं, जिन्हें स्पेस से अलग किया जाता है. इनमें से हर शब्द, 16-बिट कोड यूनिट के बारे में बताता है. किसी शब्द के हर वर्ण में चार बिट होते हैं. इन्हें पढ़ने के लिए, वर्टिकल बार ("|") का इस्तेमाल किया जाता है. इन बिट को ज़्यादा से कम के क्रम में पढ़ा जाता है. "A" से शुरू होने वाले क्रम में अंग्रेज़ी के बड़े अक्षरों का इस्तेमाल, फ़ॉर्मैट में फ़ील्ड को दिखाने के लिए किया जाता है. इसके बाद, सिंटैक्स कॉलम से इन फ़ील्ड की जानकारी मिलती है. "op" शब्द का इस्तेमाल, फ़ॉर्मैट में आठ-बिट ऑपरेंड कोड की पोज़िशन दिखाने के लिए किया जाता है. स्लैश वाला शून्य ("Ø") इस्तेमाल करके यह दिखाया जाता है कि बताई गई पोज़िशन में सभी बिट शून्य होने चाहिए.

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

उदाहरण के लिए, फ़ॉर्मैट "B|A|op CCCC" से पता चलता है कि फ़ॉर्मैट में दो 16-बिट कोड यूनिट हैं. पहले शब्द के आठ निचले बिट में ऑपरेंड कोड होता है और आठ ऊपरी बिट में चार बिट की दो वैल्यू होती हैं. दूसरे शब्द में, एक 16-बिट वैल्यू होती है.

फ़ॉर्मैट आईडी

फ़ॉर्मैट टेबल के दूसरे कॉलम में, फ़ॉर्मैट के लिए छोटा आइडेंटिफ़ायर दिखता है. इसका इस्तेमाल, दूसरे दस्तावेज़ों और कोड में फ़ॉर्मैट की पहचान करने के लिए किया जाता है.

ज़्यादातर फ़ॉर्मैट आईडी में तीन वर्ण होते हैं. इनमें दो अंक और एक अक्षर होता है. पहला अंक, फ़ॉर्मैट में 16-बिट कोड यूनिट की संख्या दिखाता है. दूसरा अंक, फ़ॉर्मैट में मौजूद रजिस्टर की ज़्यादा से ज़्यादा संख्या दिखाता है. ऐसा इसलिए है, क्योंकि कुछ फ़ॉर्मैट में अलग-अलग संख्या में रजिस्टर हो सकते हैं. "r" से पता चलता है कि रजिस्टर की एक रेंज को कोड में बदला गया है. आखिरी अक्षर से, फ़ॉर्मैट में एन्कोड किए गए अतिरिक्त डेटा के टाइप का पता चलता है. उदाहरण के लिए, फ़ॉर्मैट "21t" की लंबाई दो है. इसमें एक रजिस्टर रेफ़रंस है और साथ ही, एक शाखा टारगेट भी है.

सुझाए गए स्टैटिक लिंकिंग फ़ॉर्मैट में एक और "s" सफ़िक्स होता है. इस वजह से, इनमें कुल चार वर्ण होते हैं. इसी तरह, सुझाए गए "इनलाइन" लिंकिंग फ़ॉर्मैट में एक अतिरिक्त "i" सफ़िक्स होता है. (इस संदर्भ में, इनलाइन लिंकिंग, स्टैटिक लिंकिंग की तरह ही होती है. हालांकि, इसमें मशीन के लागू होने के ज़्यादा सीधे संबंध होते हैं.) आखिर में, कुछ ऐसे फ़ॉर्मैट के सुझाव दिए गए हैं जो आम तौर पर इस्तेमाल नहीं किए जाते (उदाहरण के लिए, "20bc") में दो तरह का डेटा शामिल होता है, जिसे फ़ॉर्मैट आईडी में दिखाया जाता है.

टाइपकोड के अक्षरों की पूरी सूची यहां दी गई है. ध्यान दें कि फ़ॉर्मैट के हिसाब से, कुछ फ़ॉर्म का साइज़ अलग-अलग हो सकता है:

याद रखने का तरीका	बिट साइज़	मतलब
b	8	तुरंत हस्ताक्षर किया गया byte
c	16, 32	कंस्टैंट पूल इंडेक्स
f	16	इंटरफ़ेस काॅन्सटेंट (सिर्फ़ स्टैटिक तौर पर लिंक किए गए फ़ॉर्मैट में इस्तेमाल किए जाते हैं)
h	16	तुरंत साइन किया गया hat (32 या 64-बिट वैल्यू के हाई-ऑर्डर बिट; सभी लो-ऑर्डर बिट `0` हैं)
i	32	तुरंत साइन किया गया int या 32-बिट फ़्लोट
l	64	तुरंत साइन किया गया long या 64-बिट डबल
m	16	method constants (only used in statically linked formats)
n	4	तुरंत साइन किया गया nibble
s	16	तुरंत साइन किया गया short
t	8, 16, 32	branch target
x	0	कोई अतिरिक्त डेटा नहीं

वाक्य-विन्यास

फ़ॉर्मैट टेबल के तीसरे कॉलम में, दिए गए फ़ॉर्मैट का इस्तेमाल करने वाले निर्देशों के लिए, लोगों के हिसाब से सिंटैक्स दिखता है. हर निर्देश, नाम वाले ऑपरेंड से शुरू होता है. इसके बाद, एक या एक से ज़्यादा आर्ग्युमेंट होते हैं. इन्हें कॉमा लगाकर अलग किया जाता है.

जहां भी कोई आर्ग्युमेंट पहले कॉलम के किसी फ़ील्ड को रेफ़र करता है, वहां उस फ़ील्ड के लिए अक्षर को सिंटैक्स में दिखाया जाता है. साथ ही, फ़ील्ड के हर चार बिट के लिए, अक्षर को एक बार दोहराया जाता है. उदाहरण के लिए, पहले कॉलम में "BB" लेबल वाला आठ-बिट फ़ील्ड, सिंटैक्स कॉलम में भी "BB" लेबल वाला होगा.

रजिस्टर का नाम बताने वाले आर्ग्युमेंट का फ़ॉर्म "vX" होता है. आम तौर पर इस्तेमाल होने वाले "r" के बजाय, प्रीफ़िक्स "v" को इसलिए चुना गया था, ताकि उन (नॉन-वर्चुअल) आर्किटेक्चर के साथ कोई विरोध न हो जिन पर Dalvik Executable फ़ॉर्मैट लागू किया जा सकता है. ये आर्किटेक्चर अपने रजिस्टर के लिए, प्रीफ़िक्स "r" का इस्तेमाल करते हैं. (इसका मतलब है कि इस फ़ैसले की मदद से, वर्चुअल और रीयल रजिस्टर, दोनों के बारे में एक साथ बात की जा सकती है. इसके लिए, आपको अलग से कुछ नहीं कहना पड़ेगा.)

ऐसे आर्ग्युमेंट जिनमें लिटरल वैल्यू होती है उनका फ़ॉर्मैट "#+X" होता है. कुछ फ़ॉर्मैट में ऐसे लिटरल होते हैं जिनके हाई-ऑर्डर बिट में सिर्फ़ नॉन-ज़ीरो बिट होते हैं. इनके लिए, सिंटैक्स में साफ़ तौर पर शून्य दिखाए जाते हैं, भले ही वे बिटवाइज़ रिप्रज़ेंटेशन में न दिखें.

जिन आर्ग्युमेंट से रिलेटिव निर्देश पते के ऑफ़सेट का पता चलता है उनका फ़ॉर्मैट "+X" होता है.

लिटरल कॉन्स्टेंट पूल इंडेक्स को दिखाने वाले आर्ग्युमेंट का फ़ॉर्मैट "kind@X" होता है. इसमें "kind" से पता चलता है कि किस कॉन्स्टेंट पूल का रेफ़रंस दिया जा रहा है. इस तरह के फ़ॉर्मैट का इस्तेमाल करने वाले हर ऑपरेंड कोड में, सिर्फ़ एक तरह के कॉन्स्टेंट का इस्तेमाल किया जा सकता है. इनके बीच के संबंध को समझने के लिए, ऑपरेंड कोड का रेफ़रंस देखें. कॉन्स्टेंट पूल के टाइप ये हैं: "string" (स्ट्रिंग पूल इंडेक्स), "type" (टाइप पूल इंडेक्स), "field" (फ़ील्ड पूल इंडेक्स), "meth" (मेथड पूल इंडेक्स), और "site" (कॉल साइट इंडेक्स).

कॉन्स्टेंट पूल इंडेक्स के तौर पर, पहले से लिंक किए गए ऑफ़सेट या इंडेक्स दिखाने वाले फ़ॉर्म भी सुझाए जाते हैं. हालांकि, इनका इस्तेमाल करना ज़रूरी नहीं है. पहले से लिंक की गई वैल्यू के दो टाइप होते हैं: vtable ऑफ़सेट (जिन्हें "vtaboff" के तौर पर दिखाया जाता है) और फ़ील्ड ऑफ़सेट (जिन्हें "fieldoff" के तौर पर दिखाया जाता है).

जिन मामलों में फ़ॉर्मैट वैल्यू, सिंटैक्स का हिस्सा नहीं है, लेकिन वैरिएंट चुनती है उनमें हर वैरिएंट को "[X=N]" प्रीफ़िक्स के साथ लिस्ट किया जाता है. उदाहरण के लिए, "[A=2]") का इस्तेमाल करें.

फ़ॉर्मैट

फ़ॉर्मैट करें	आईडी	वाक्य-विन्यास	शामिल किए गए अहम ऑपरेंड कोड
N/A	00x	`N/A`	इस्तेमाल न किए गए ऑपरेंड कोड के लिए इस्तेमाल किया जाने वाला सूडो-फ़ॉर्मैट; ब्रेकपॉइंट ऑपरेंड कोड के लिए, नाममात्र फ़ॉर्मैट के तौर पर इस्तेमाल करने का सुझाव दिया गया है
ØØ\|op	10 गुना	`op`
B\|A\|op	12x	`op` vA, vB
B\|A\|op	11n	`op` vA, #+B
AA\|op	11x	`op` vAA
AA\|op	10t	`op` +AA	इस पर जाएं
ØØ\|op AAAA	20t	`op` +AAAA	goto/16
AA\|op BBBB	20bc	`op` AA, kind@BBBB	पुष्टि से जुड़ी गड़बड़ियों के लिए, स्टैटिक तौर पर तय किए गए फ़ॉर्मैट का सुझाव; A, गड़बड़ी का टाइप है और B, टाइप के हिसाब से टेबल में एक इंडेक्स है (उदाहरण के लिए, कोई ऐसा तरीका नहीं है जिससे गड़बड़ी का पता चल सके)
AA\|op BBBB	22x	`op` vAA, vBBBB
	21t	`op` vAA, +BBBB
	21 सेकंड	`op` vAA, #+BBBB
	21 घंटे	`op` vAA, #+BBBB0000 `op` vAA, #+BBBB000000000000
	21c	`op` vAA, type@BBBB `op` vAA, field@BBBB `op` vAA, method_handle@BBBB `op` vAA, proto@BBBB `op` vAA, string@BBBB	check-cast const-class const-method-handle const-method-type const-string
AA\|op CC\|BB	23x	`op` vAA, vBB, vCC
AA\|op CC\|BB	22b	`op` vAA, vBB, #+CC
B\|A\|op CCCC	22t	`op` vA, vB, +CCCC
	22 सेकंड	`op` vA, vB, #+CCCC
	22c	`op` vA, vB, type@CCCC `op` vA, vB, field@CCCC	instance-of
	22cs	`op` vA, vB, fieldoff@CCCC	फ़ॉर्मैट 22c के स्टैटिक तौर पर लिंक किए गए फ़ील्ड के ऐक्सेस के निर्देशों के लिए सुझाया गया फ़ॉर्मैट
ØØ\|op AAAA_lo AAAA_hi	30t	`op` +AAAAAAAA	goto/32
ØØ\|op AAAA BBBB	32x	`op` vAAAA, vBBBB
AA\|op BBBB_lo BBBB_hi	31i	`op` vAA, #+BBBBBBBB
	31t	`op` vAA, +BBBBBBBB
	31c	`op` vAA, string@BBBBBBBB	const-string/jumbo
A\|G\|op BBBB F\|E\|D\|C	35c	[`A=5`] `op` {vC, vD, vE, vF, vG}, meth@BBBB [`A=5`] `op` {vC, vD, vE, vF, vG}, site@BBBB [`A=5`] `op` {vC, vD, vE, vF, vG}, type@BBBB [`A=4`] `op` {vC, vD, vE, vF}, `kind`@BBBB [`A=3`] `op` {vC, vD, vE}, `kind`@BBBB [`A=2`] `op` {vC, vD}, `kind`@BBBB [`A=1`] `op` {vC}, `kind`@BBBB [`A=0`] `op` {}, `kind`@BBBB अक्षरों के लिए असामान्य विकल्प चुनने का मतलब है कि आपको गिनती और रेफ़रंस इंडेक्स के लिए, 3rc फ़ॉर्मैट में इस्तेमाल किए गए लेबल का ही इस्तेमाल करना है.
	35 मिलीसेकंड	[`A=5`] `op` {vC, vD, vE, vF, vG}, vtaboff@BBBB [`A=4`] `op` {vC, vD, vE, vF}, vtaboff@BBBB [`A=3`] `op` {vC, vD, vE}, vtaboff@BBBB [`A=2`] `op` {vC, vD}, vtaboff@BBBB [`A=1`] `op` {vC}, vtaboff@BBBB अक्षरों के लिए असामान्य विकल्प चुनने का मतलब है कि आपको गिनती और रेफ़रंस इंडेक्स के लिए, 3rms फ़ॉर्मैट में इस्तेमाल किए गए लेबल का ही इस्तेमाल करना है.	स्टैटिक तौर पर लिंक किए गए `invoke-virtual` के लिए सुझाया गया फ़ॉर्मैट और `invoke-super` के लिए फ़ॉर्मैट 35c के निर्देश
	35 मील	[`A=5`] `op` {vC, vD, vE, vF, vG}, inline@BBBB [`A=4`] `op` {vC, vD, vE, vF}, inline@BBBB [`A=3`] `op` {vC, vD, vE}, inline@BBBB [`A=2`] `op` {vC, vD}, inline@BBBB [`A=1`] `op` {vC}, inline@BBBB अक्षरों के लिए यहां असामान्य विकल्प चुनने का मतलब है कि आपको गिनती और रेफ़रंस इंडेक्स के लिए, 3rmi फ़ॉर्मैट में इस्तेमाल किए गए लेबल का ही इस्तेमाल करना है.	इनलाइन लिंक किए गए `invoke-static` के लिए सुझाया गया फ़ॉर्मैट और `invoke-virtual` फ़ॉर्मैट 35c के निर्देश
AA\|op BBBB CCCC	3rc	`op` {vCCCC .. vNNNN}, meth@BBBB `op` {vCCCC .. vNNNN}, site@BBBB `op` {vCCCC .. vNNNN}, type@BBBB जहां `NNNN = CCCC+AA-1`, यानी `A` गिनती `0..255` तय करता है और `C` पहला रजिस्टर तय करता है
	3rms	`op` {vCCCC .. vNNNN}, vtaboff@BBBB जहां `NNNN = CCCC+AA-1`, यानी `A` गिनती `0..255` तय करता है और `C` पहला रजिस्टर तय करता है	स्टैटिक तौर पर लिंक किए गए `invoke-virtual` के लिए सुझाया गया फ़ॉर्मैट और `invoke-super` के फ़ॉर्मैट `3rc` के निर्देश
	3rmi	`op` {vCCCC .. vNNNN}, inline@BBBB जहां `NNNN = CCCC+AA-1`, यानी `A` गिनती `0..255` तय करता है और `C` पहला रजिस्टर तय करता है	इनलाइन लिंक किए गए `invoke-static` के लिए सुझाया गया फ़ॉर्मैट और `invoke-virtual` फ़ॉर्मैट 3rc के निर्देश
A\|G\|op BBBB F\|E\|D\|C HHHH	45 सीसी	[`A=5`] `op` {vC, vD, vE, vF, vG}, meth@BBBB, proto@HHHH [`A=4`] `op` {vC, vD, vE, vF}, meth@BBBB, proto@HHHH [`A=3`] `op` {vC, vD, vE}, meth@BBBB, proto@HHHH [`A=2`] `op` {vC, vD}, meth@BBBB, proto@HHHH [`A=1`] `op` {vC}, meth@BBBB, proto@HHHH	invoke-polymorphic
AA\|op BBBB CCCC HHHH	4rcc	`op>` {vCCCC .. vNNNN}, meth@BBBB, proto@HHHH जहां `NNNN = CCCC+AA-1`, यानी `A` गिनती `0..255` तय करता है और `C` पहला रजिस्टर तय करता है	invoke-polymorphic/range
AA\|op BBBB_lo BBBB BBBB BBBB_hi	51l	`op` vAA, #+BBBBBBBBBBBBBBBB	const-wide