दलविक बाइटकोड

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

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

बाइटकोड सेट का सारांश

संचालन और प्रारूप निमोनिक / सिंटैक्स बहस विवरण
00 10x नहीं अपशिष्ट चक्र।

नोट: डेटा-असर छद्म-निर्देशों को इस ऑपकोड के साथ टैग किया जाता है, इस स्थिति में ओपकोड इकाई का उच्च-क्रम बाइट डेटा की प्रकृति को इंगित करता है। नीचे " packed-switch-payload फॉर्मेट", " sparse-switch-payload फॉर्मेट", और " fill-array-data-payload फॉर्मेट" देखें।

01 12x वीए, वीबी ले जाएँ A: गंतव्य रजिस्टर (4 बिट)
B: स्रोत रजिस्टर (4 बिट)		 एक गैर-ऑब्जेक्ट रजिस्टर की सामग्री को दूसरे में ले जाएं।
02 22x चाल/से 16 वीएए, वीबीबीबीबी A: गंतव्य रजिस्टर (8 बिट)
B: स्रोत रजिस्टर (16 बिट्स)		 एक गैर-ऑब्जेक्ट रजिस्टर की सामग्री को दूसरे में ले जाएं।
03 32x मूव/16 वीएएएए, वीबीबीबीबी A: गंतव्य रजिस्टर (16 बिट्स)
B: स्रोत रजिस्टर (16 बिट्स)		 एक गैर-ऑब्जेक्ट रजिस्टर की सामग्री को दूसरे में ले जाएं।
04 12x मूव-वाइड वीए, वीबी A: गंतव्य रजिस्टर जोड़ी (4 बिट)
B: स्रोत रजिस्टर जोड़ी (4 बिट)		 एक रजिस्टर-जोड़ी की सामग्री को दूसरे में ले जाएं।

नोट: v N से या तो v N-1 या v N+1 पर जाना कानूनी है, इसलिए कार्यान्वयन को कुछ भी लिखे जाने से पहले एक रजिस्टर जोड़ी के दोनों हिस्सों को पढ़ने की व्यवस्था करनी चाहिए।

05 22x मूव-वाइड/से 16 वीएए, वीबीबीबीबी A: गंतव्य रजिस्टर जोड़ी (8 बिट)
B: स्रोत रजिस्टर जोड़ी (16 बिट्स)		 एक रजिस्टर-जोड़ी की सामग्री को दूसरे में ले जाएं।

नोट: कार्यान्वयन संबंधी विचार ऊपर दिए गए move-wide के समान हैं।

06 32x मूव-वाइड/16 वीएएएए, वीबीबीबीबी A: गंतव्य रजिस्टर जोड़ी (16 बिट्स)
B: स्रोत रजिस्टर जोड़ी (16 बिट्स)		 एक रजिस्टर-जोड़ी की सामग्री को दूसरे में ले जाएं।

नोट: कार्यान्वयन संबंधी विचार ऊपर दिए गए move-wide के समान हैं।

07 12x मूव-ऑब्जेक्ट वीए, वीबी A: गंतव्य रजिस्टर (4 बिट)
B: स्रोत रजिस्टर (4 बिट)		 एक ऑब्जेक्ट-बेयरिंग रजिस्टर की सामग्री को दूसरे में ले जाएं।
08 22x मूव-ऑब्जेक्ट/16 वीएए से, वीबीबीबीबी A: गंतव्य रजिस्टर (8 बिट)
B: स्रोत रजिस्टर (16 बिट्स)		 एक ऑब्जेक्ट-बेयरिंग रजिस्टर की सामग्री को दूसरे में ले जाएं।
09 32x मूव-ऑब्जेक्ट/16 वीएएएए, वीबीबीबीबी A: गंतव्य रजिस्टर (16 बिट्स)
B: स्रोत रजिस्टर (16 बिट्स)		 एक ऑब्जेक्ट-बेयरिंग रजिस्टर की सामग्री को दूसरे में ले जाएं।
0ए 11x चाल-परिणाम वीएए A: गंतव्य रजिस्टर (8 बिट) सबसे हाल के invoke- kind के एकल-शब्द गैर-वस्तु परिणाम को संकेतित रजिस्टर में ले जाएं। यह एक invoke- kind के तुरंत बाद निर्देश के रूप में किया जाना चाहिए जिसका (एक-शब्द, गैर-वस्तु) परिणाम अनदेखा नहीं किया जाना चाहिए; कहीं और अमान्य है।
0बी 11x चाल-परिणाम-व्यापी वीएए A: गंतव्य रजिस्टर जोड़ी (8 बिट) हाल ही के invoke- kind के डबल-वर्ड परिणाम को संकेतित रजिस्टर जोड़ी में ले जाएं। यह एक invoke- kind के तुरंत बाद निर्देश के रूप में किया जाना चाहिए जिसका (डबल-वर्ड) परिणाम अनदेखा नहीं किया जाना चाहिए; कहीं और अमान्य है।
0सी 11x चाल-परिणाम-वस्तु vAA A: गंतव्य रजिस्टर (8 बिट) सबसे हाल के invoke- kind के ऑब्जेक्ट परिणाम को संकेतित रजिस्टर में ले जाएं। यह एक invoke- kind या filled-new-array तुरंत बाद निर्देश के रूप में किया जाना चाहिए जिसका (वस्तु) परिणाम अनदेखा नहीं किया जाना चाहिए; कहीं और अमान्य है।
0डी 11x चाल-अपवाद वीएए A: गंतव्य रजिस्टर (8 बिट) दिए गए रजिस्टर में हाल ही में पकड़े गए अपवाद को सहेजें। यह किसी भी अपवाद हैंडलर का पहला निर्देश होना चाहिए जिसके पकड़े गए अपवाद को अनदेखा नहीं किया जाना चाहिए, और यह निर्देश केवल अपवाद हैंडलर के पहले निर्देश के रूप में ही होना चाहिए; कहीं और अमान्य है।
0e 10x वापसी-शून्य एक void विधि से लौटें।
0f 11x वापसी वीएए A: वापसी मूल्य रजिस्टर (8 बिट) एकल-चौड़ाई (32-बिट) गैर-ऑब्जेक्ट मान-रिटर्निंग विधि से लौटें।
10 11x वापसी-व्यापी वीएए A: वापसी मूल्य रजिस्टर-जोड़ी (8 बिट) डबल-चौड़ाई (64-बिट) मान-रिटर्निंग विधि से लौटें।
11 11x रिटर्न-ऑब्जेक्ट वीएए A: वापसी मूल्य रजिस्टर (8 बिट) ऑब्जेक्ट-रिटर्निंग विधि से लौटें।
12 11एन कॉन्स्ट / 4 वीए, #+बी A: गंतव्य रजिस्टर (4 बिट)
B: हस्ताक्षरित इंट (4 बिट)		 दिए गए शाब्दिक मान (32 बिट्स तक साइन-विस्तारित) को निर्दिष्ट रजिस्टर में ले जाएं।
13 21s कॉन्स्ट/16 वीएए, #+बीबीबीबी A: गंतव्य रजिस्टर (8 बिट)
B: हस्ताक्षरित int (16 बिट्स)		 दिए गए शाब्दिक मान (32 बिट्स तक साइन-विस्तारित) को निर्दिष्ट रजिस्टर में ले जाएं।
14 31i कॉन्स्ट वीएए, #+बीबीबीबीबीबीबीबी A: गंतव्य रजिस्टर (8 बिट)
B: मनमाना 32-बिट स्थिरांक		 दिए गए शाब्दिक मूल्य को निर्दिष्ट रजिस्टर में ले जाएं।
15 21h कॉन्स्ट/हाई16 वीएए, #+बीबीबीबी0000 A: गंतव्य रजिस्टर (8 बिट)
B: हस्ताक्षरित int (16 बिट्स)		 निर्दिष्ट रजिस्टर में दिए गए शाब्दिक मूल्य (दाएं-शून्य-विस्तारित 32 बिट्स) को स्थानांतरित करें।
16 21s कॉन्स्ट-वाइड/16 वीएए, #+बीबीबीबी A: गंतव्य रजिस्टर (8 बिट)
B: हस्ताक्षरित int (16 बिट्स)		 दिए गए शाब्दिक मूल्य (साइन-विस्तारित 64 बिट्स) को निर्दिष्ट रजिस्टर-जोड़ी में ले जाएं।
17 31i कॉन्स्ट-वाइड/32 वीएए, #+बीबीबीबीबीबीबीबी A: गंतव्य रजिस्टर (8 बिट)
B: हस्ताक्षरित int (32 बिट्स)		 दिए गए शाब्दिक मूल्य (साइन-विस्तारित 64 बिट्स) को निर्दिष्ट रजिस्टर-जोड़ी में ले जाएं।
18 51ली कॉन्स्ट-वाइड वीएए, #+बीबीबीबीबीबीबीबीबीबीबीबीबीबीबीबी A: गंतव्य रजिस्टर (8 बिट)
B: मनमाना डबल-चौड़ाई (64-बिट) स्थिर		 दिए गए शाब्दिक मूल्य को निर्दिष्ट रजिस्टर-जोड़ी में ले जाएं।
19 21h कॉन्स्ट-वाइड/हाई16 वीएए, #+बीबीबीबी000000000000 A: गंतव्य रजिस्टर (8 बिट)
B: हस्ताक्षरित int (16 बिट्स)		 निर्दिष्ट रजिस्टर-जोड़ी में दिए गए शाब्दिक मान (दाएं-शून्य-विस्तारित 64 बिट्स) को स्थानांतरित करें।
1ए 21सी कॉन्स्ट-स्ट्रिंग वीएए, स्ट्रिंग @ बीबीबीबी A: गंतव्य रजिस्टर (8 बिट)
B: स्ट्रिंग इंडेक्स		 दिए गए इंडेक्स द्वारा निर्दिष्ट स्ट्रिंग के संदर्भ को निर्दिष्ट रजिस्टर में ले जाएं।
1बी 31सी कॉन्स्ट-स्ट्रिंग/जंबो वीएए, स्ट्रिंग @ बीबीबीबीबीबीबीबी A: गंतव्य रजिस्टर (8 बिट)
B: स्ट्रिंग इंडेक्स		 दिए गए इंडेक्स द्वारा निर्दिष्ट स्ट्रिंग के संदर्भ को निर्दिष्ट रजिस्टर में ले जाएं।
1सी 21सी कॉन्स्ट-क्लास वीएए, टाइप करें @ बीबीबीबी A: गंतव्य रजिस्टर (8 बिट)
B: इंडेक्स टाइप करें		 दिए गए इंडेक्स द्वारा निर्दिष्ट वर्ग के संदर्भ को निर्दिष्ट रजिस्टर में ले जाएं। मामले में जहां संकेतित प्रकार आदिम है, यह आदिम प्रकार के पतित वर्ग के संदर्भ को संग्रहीत करेगा।
1डी 11x मॉनिटर-एंटर वीएए A: संदर्भ असर रजिस्टर (8 बिट) संकेतित वस्तु के लिए मॉनिटर प्राप्त करें।
1e 11x मॉनिटर-निकास वीएए A: संदर्भ असर रजिस्टर (8 बिट) संकेतित वस्तु के लिए मॉनिटर को छोड़ दें।

नोट: यदि इस निर्देश को अपवाद फेंकने की आवश्यकता है, तो इसे ऐसा करना चाहिए जैसे कि पीसी पहले ही निर्देश से आगे बढ़ चुका है। यह इस बारे में सोचने के लिए उपयोगी हो सकता है कि निर्देश सफलतापूर्वक निष्पादित हो रहा है (एक अर्थ में), और अपवाद को निर्देश के बाद फेंक दिया जा रहा है लेकिन अगले को चलाने का मौका मिलने से पहले । यह परिभाषा एक विधि के लिए मॉनिटर क्लीनअप कैच-ऑल (उदाहरण के लिए, finally ) ब्लॉक को उस ब्लॉक के लिए मॉनिटर क्लीनअप के रूप में उपयोग करना संभव बनाती है, जो कि Thread.stop() के ऐतिहासिक कार्यान्वयन के कारण फेंके गए मनमाने अपवादों को संभालने के तरीके के रूप में संभव बनाती है। Thread.stop() , जबकि अभी भी उचित मॉनिटर स्वच्छता का प्रबंधन कर रहा है।

1f 21c चेक-कास्ट वीएए, टाइप करें@बीबीबीबी A: संदर्भ असर रजिस्टर (8 बिट)
B: इंडेक्स टाइप करें (16 बिट्स)		 यदि दिए गए रजिस्टर में संदर्भ को इंगित प्रकार में नहीं डाला जा सकता है, तो ClassCastException को फेंक दें।

नोट: चूंकि A हमेशा एक संदर्भ होना चाहिए (और एक आदिम मूल्य नहीं), यह आवश्यक रूप से रनटाइम पर विफल हो जाएगा (अर्थात, यह एक अपवाद फेंक देगा) यदि B एक आदिम प्रकार को संदर्भित करता है।

20 22सी उदाहरण-वीए, वीबी, टाइप@सीसीसीसी A: गंतव्य रजिस्टर (4 बिट)
B: संदर्भ असर रजिस्टर (4 बिट)
C: टाइप इंडेक्स (16 बिट्स)		 दिए गए गंतव्य रजिस्टर 1 में स्टोर करें यदि संकेतित संदर्भ दिए गए प्रकार का एक उदाहरण है, या 0 यदि नहीं है।

नोट: चूंकि B हमेशा एक संदर्भ होना चाहिए (और एक आदिम मूल्य नहीं), इसका परिणाम हमेशा 0 को संग्रहीत किया जाएगा यदि C एक आदिम प्रकार को संदर्भित करता है।

21 12x सरणी-लंबाई वीए, वीबी A: गंतव्य रजिस्टर (4 बिट)
B: सरणी संदर्भ-असर रजिस्टर (4 बिट)		 दिए गए गंतव्य में स्टोर करें, प्रविष्टियों में संकेतित सरणी की लंबाई दर्ज करें
22 21सी नया उदाहरण वीएए, टाइप करें @ बीबीबीबी A: गंतव्य रजिस्टर (8 बिट)
B: इंडेक्स टाइप करें		 गंतव्य में इसके संदर्भ को संग्रहीत करते हुए, संकेतित प्रकार का एक नया उदाहरण बनाएं। प्रकार को एक गैर-सरणी वर्ग को संदर्भित करना चाहिए।
23 22सी नई-सरणी वीए, वीबी, टाइप @ सीसीसीसी A: गंतव्य रजिस्टर (4 बिट)
B: आकार रजिस्टर
C: इंडेक्स टाइप करें		 संकेतित प्रकार और आकार की एक नई सरणी बनाएं। प्रकार एक सरणी प्रकार होना चाहिए।
24 35सी भरा-नया-सरणी {vC, vD, vE, vF, vG}, type@BBBB A: सरणी आकार और तर्क शब्द गणना (4 बिट)
B: इंडेक्स टाइप करें (16 बिट्स)
C..G: तर्क रजिस्टर (प्रत्येक 4 बिट)		 दिए गए प्रकार और आकार की एक सरणी बनाएं, इसे आपूर्ति की गई सामग्री से भरें। प्रकार एक सरणी प्रकार होना चाहिए। सरणी की सामग्री एकल-शब्द होनी चाहिए (अर्थात, long या double की कोई सरणी नहीं है, लेकिन संदर्भ प्रकार स्वीकार्य हैं)। निर्मित उदाहरण को "परिणाम" के रूप में उसी तरह संग्रहीत किया जाता है जैसे विधि आमंत्रण निर्देश उनके परिणामों को संग्रहीत करते हैं, इसलिए निर्मित उदाहरण को तत्काल बाद move-result-object निर्देश के साथ एक रजिस्टर में ले जाया जाना चाहिए (यदि इसका उपयोग किया जाना है )
25 3आरसी भरा-नया-सरणी/श्रेणी {vCCCC .. vNNNN}, type@BBBB A: सरणी आकार और तर्क शब्द गणना (8 बिट)
B: इंडेक्स टाइप करें (16 बिट्स)
C: पहला तर्क रजिस्टर (16 बिट्स)
N = A + C - 1		 दिए गए प्रकार और आकार की एक सरणी बनाएं, इसे आपूर्ति की गई सामग्री से भरें। स्पष्टीकरण और प्रतिबंध ऊपर वर्णित filled-new-array के समान हैं।
26 31t भरण-सरणी-डेटा vAA, +BBBBBBBB (" fill-array-data-payload प्रारूप" में नीचे निर्दिष्ट पूरक डेटा के साथ) A: सरणी संदर्भ (8 बिट)
B: हस्ताक्षरित "शाखा" तालिका डेटा छद्म-निर्देश (32 बिट्स) के लिए ऑफसेट		 दिए गए सरणी को संकेतित डेटा से भरें। संदर्भ आदिम की एक सरणी के लिए होना चाहिए, और डेटा तालिका को इसके प्रकार से मेल खाना चाहिए और इसमें सरणी में फिट होने से अधिक तत्व नहीं होने चाहिए। यही है, सरणी तालिका से बड़ी हो सकती है, और यदि ऐसा है, तो केवल सरणी के प्रारंभिक तत्व सेट किए जाते हैं, शेष को अकेला छोड़ दिया जाता है।
27 11x वीएए फेंको A: अपवाद-असर रजिस्टर (8 बिट)
 संकेतित अपवाद फेंको।
28 10टी गोटो + एए A: हस्ताक्षरित शाखा ऑफसेट (8 बिट) संकेतित निर्देश पर बिना शर्त कूदें।

नोट: शाखा ऑफ़सेट 0 नहीं होना चाहिए। (एक स्पिन लूप कानूनी रूप से या तो goto/32 के साथ या शाखा से पहले एक लक्ष्य के रूप में एक nop शामिल करके बनाया जा सकता है।)

29 20t गोटो/16 + एएएए A: हस्ताक्षरित शाखा ऑफसेट (16 बिट्स)
 संकेतित निर्देश पर बिना शर्त कूदें।

नोट: शाखा ऑफ़सेट 0 नहीं होना चाहिए। (एक स्पिन लूप कानूनी रूप से या तो goto/32 के साथ या शाखा से पहले एक लक्ष्य के रूप में एक nop शामिल करके बनाया जा सकता है।)

2a 30t गोटो/32 + एएएएएएएएएए A: हस्ताक्षरित शाखा ऑफसेट (32 बिट्स)
 संकेतित निर्देश पर बिना शर्त कूदें।
2बी 31टी पैक्ड-स्विच वीएए, +बीबीबीबीबीबीबीबी (" packed-switch-payload प्रारूप" में नीचे निर्दिष्ट पूरक डेटा के साथ) A: परीक्षण के लिए पंजीकरण करें
B: हस्ताक्षरित "शाखा" तालिका डेटा छद्म-निर्देश (32 बिट्स) के लिए ऑफसेट		 किसी विशेष इंटीग्रल रेंज में प्रत्येक मान के अनुरूप ऑफ़सेट की तालिका का उपयोग करके दिए गए रजिस्टर में मूल्य के आधार पर एक नए निर्देश पर जाएं, या यदि कोई मेल नहीं है तो अगले निर्देश पर जाएं।
2सी 31टी विरल-स्विच वीएए, +बीबीबीबीबीबीबीबी ("स्पैस sparse-switch-payload प्रारूप" में नीचे निर्दिष्ट पूरक डेटा के साथ) A: परीक्षण के लिए पंजीकरण करें
B: हस्ताक्षरित "शाखा" तालिका डेटा छद्म-निर्देश (32 बिट्स) के लिए ऑफसेट		 दिए गए रजिस्टर में मूल्य के आधार पर एक नए निर्देश पर जाएं, मूल्य-ऑफसेट जोड़े की एक आदेशित तालिका का उपयोग करें, या यदि कोई मेल नहीं है तो अगले निर्देश पर जाएं।
2d..31 23x सीएमपी प्रकार वीएए, वीबीबी, वीसीसी
2डी: सीएमपीएल-फ्लोट (एलटी बायस)
2e: सीएमपीजी-फ्लोट (जीटी पूर्वाग्रह)
2f: cmpl-डबल (lt बायस)
30: सीएमपीजी-डबल (जीटी पूर्वाग्रह)
31: सेमी-लॉन्ग		 A: गंतव्य रजिस्टर (8 बिट)
B: पहला स्रोत रजिस्टर या जोड़ी
C: दूसरा स्रोत रजिस्टर या जोड़ी		 संकेतित फ़्लोटिंग पॉइंट या long तुलना करें, a को 0 if b == c , 1 if b > c , या -1 if b < c पर सेट करें। फ़्लोटिंग पॉइंट ऑपरेशंस के लिए सूचीबद्ध "पूर्वाग्रह" इंगित करता है कि कैसे NaN तुलना का इलाज किया जाता है: "gt पूर्वाग्रह" निर्देश NaN तुलना के लिए 1 लौटाते हैं, और "lt पूर्वाग्रह" निर्देश -1 लौटाते हैं।

उदाहरण के लिए, यह देखने के लिए कि क्या फ्लोटिंग पॉइंट x < y का उपयोग करने की सलाह दी जाती है cmpg-float ; -1 का परिणाम इंगित करता है कि परीक्षण सत्य था, और अन्य मान इंगित करते हैं कि यह एक वैध तुलना के कारण गलत था या क्योंकि मानों में से एक NaN था।

32..37 22t अगर- परीक्षण वीए, वीबी, +सीसीसीसी
32: अगर-ईक्यू
33: अगर-ने
34: अगर-एलटी
35: अगर-जीई
36: अगर-जीटी
37: अगर-ले
 A: परीक्षण के लिए पहले पंजीकरण करें (4 बिट)
B: परीक्षण के लिए दूसरा रजिस्टर (4 बिट)
C: हस्ताक्षरित शाखा ऑफसेट (16 बिट्स)		 दिए गए गंतव्य के लिए शाखा यदि दिए गए दो रजिस्टरों के मान निर्दिष्ट के अनुसार तुलना करते हैं।

नोट: शाखा ऑफ़सेट 0 नहीं होना चाहिए। (एक स्पिन लूप कानूनी रूप से या तो पिछड़े goto के चारों ओर शाखा लगाकर या शाखा से पहले एक लक्ष्य के रूप में एक nop को शामिल करके बनाया जा सकता है।)

38..3डी 21टी अगर- परीक्षण जेड वीएए, +बीबीबीबी
38: अगर-ईक्यूज़ी
39: अगर-नेज़
3ए: अगर-एलटीजेड
3बी: अगर-गीज़
3c: अगर-gtz
3डी: अगर-लेज़
 A: परीक्षण के लिए पंजीकरण करें (8 बिट)
B: हस्ताक्षरित शाखा ऑफसेट (16 बिट्स)		 दिए गए गंतव्य के लिए शाखा यदि दिए गए रजिस्टर का मान निर्दिष्ट के अनुसार 0 से तुलना करता है।

नोट: शाखा ऑफ़सेट 0 नहीं होना चाहिए। (एक स्पिन लूप कानूनी रूप से या तो पिछड़े goto के चारों ओर शाखा लगाकर या शाखा से पहले एक लक्ष्य के रूप में एक nop को शामिल करके बनाया जा सकता है।)

3e..43 10x (अप्रयुक्त) (अप्रयुक्त)
44..51 23x सरणी वीएए, वीबीबी, वीसीसी
44: अगेत
45: एगेट-वाइड
46: प्राप्त वस्तु
47: एगेट-बूलियन
48: एगेट-बाइट
49: अगेत-चार
4ए: एगेट-शॉर्ट
4बी: अपुट
4 सी: एपुट-वाइड
4d: aput-वस्तु
4e: aput-बूलियन
4f: aput-बाइट
50: अपुट-चार
51: अपुट-शॉर्ट		 A: मूल्य रजिस्टर या जोड़ी; स्रोत या गंतव्य हो सकता है (8 बिट)
B: सरणी रजिस्टर (8 बिट)
C: इंडेक्स रजिस्टर (8 बिट)		 मूल्य रजिस्टर में लोड या स्टोर करने के लिए दिए गए सरणी के पहचाने गए इंडेक्स पर पहचाने गए सरणी ऑपरेशन करें।
52.5f 22c मैं वीए, वीबी, फील्ड@ सीसीसीसी से ऊपर हूं
52: इगेट
53: इगेट-वाइड
54: इगेट-ऑब्जेक्ट
55: इगेट-बूलियन
56: इगेट-बाइट
57: इगेट-चार
58: इगेट-शॉर्ट
59: आईपुट
5a: iput-वाइड
5बी: आईपुट-ऑब्जेक्ट
5c: iput-बूलियन
5d: iput-बाइट
5e: iput-char
5f: iput-शॉर्ट		 A: मूल्य रजिस्टर या जोड़ी; स्रोत या गंतव्य हो सकता है (4 बिट)
B: ऑब्जेक्ट रजिस्टर (4 बिट)
C: इंस्टेंस फील्ड रेफरेंस इंडेक्स (16 बिट्स)		 पहचाने गए ऑब्जेक्ट इंस्टेंस फ़ील्ड ऑपरेशन को पहचाने गए फ़ील्ड के साथ करें, वैल्यू रजिस्टर में लोड या स्टोर करें।

नोट: ये ऑपकोड स्थिर लिंकिंग के लिए उचित उम्मीदवार हैं, फ़ील्ड तर्क को और अधिक प्रत्यक्ष ऑफसेट में बदलने के लिए।

60..6डी 21सी एस स्टेटिकॉप वीएए, फील्ड@बीबीबीबी
60: sget
61: sget-wide
62: sget-वस्तु
63: sget-बूलियन
64: एसगेट-बाइट
65: sget-char
66: छोटा-छोटा
67: थूक
68: थूक-चौड़ा
69: थूक-वस्तु
6a: थूक-बूलियन
6बी: थूक-बाइट
6सी: थूक-चार
6d: थूक-छोटा		 A: मूल्य रजिस्टर या जोड़ी; स्रोत या गंतव्य हो सकता है (8 बिट)
B: स्थिर क्षेत्र संदर्भ सूचकांक (16 बिट्स)		 पहचाने गए स्थिर क्षेत्र के साथ पहचाने गए ऑब्जेक्ट स्टैटिक फील्ड ऑपरेशन को वैल्यू रजिस्टर में लोड या स्टोर करना।

नोट: ये ऑपकोड स्थिर लिंकिंग के लिए उचित उम्मीदवार हैं, फ़ील्ड तर्क को और अधिक प्रत्यक्ष ऑफसेट में बदलने के लिए।

6e..72 35c आह्वान- प्रकार {vC, vD, vE, vF, vG}, meth@BBBB
6e: आह्वान-आभासी
6f: आह्वान-सुपर
70: आह्वान-प्रत्यक्ष
71: आह्वान-स्थिर
72: आह्वान-इंटरफ़ेस		 A: तर्क शब्द गणना (4 बिट)
B: विधि संदर्भ सूचकांक (16 बिट्स)
C..G: तर्क रजिस्टर (प्रत्येक 4 बिट)		 संकेतित विधि को बुलाओ। परिणाम (यदि कोई हो) को तत्काल बाद के निर्देश के रूप में उपयुक्त move-result* संस्करण के साथ संग्रहीत किया जा सकता है।

invoke-virtual का उपयोग सामान्य वर्चुअल विधि (एक विधि जो private , static या final नहीं है, और एक निर्माता भी नहीं है) को लागू करने के लिए किया जाता है।

जब method_id एक गैर-इंटरफ़ेस वर्ग की एक विधि का संदर्भ देता है, तो invoke-super का उपयोग निकटतम सुपरक्लास की वर्चुअल विधि को लागू करने के लिए किया जाता है (जैसा कि कॉलिंग क्लास में समान method_id वाले के विपरीत)। वही विधि प्रतिबंध invoke-virtual के लिए है।

डेक्स फ़ाइल संस्करण 037 या बाद के संस्करण में, यदि method_id एक इंटरफ़ेस विधि को संदर्भित करता है, तो उस इंटरफ़ेस पर परिभाषित उस विधि के सबसे विशिष्ट, गैर-ओवरराइड संस्करण को लागू करने के लिए invoke-super का उपयोग किया जाता है। वही विधि प्रतिबंध invoke-virtual के लिए है। संस्करण 037 से पहले डेक्स फाइलों में, एक इंटरफ़ेस method_id होना अवैध और अपरिभाषित है।

invoke-direct का उपयोग नॉन- static डायरेक्ट मेथड को इनवाइट करने के लिए किया जाता है (अर्थात, एक इंस्टेंस मेथड जो अपनी प्रकृति से गैर-ओवरराइडेबल है, अर्थात् या तो एक private इंस्टेंस मेथड या कंस्ट्रक्टर)।

invoke-static का इस्तेमाल static मेथड को इनवाइट करने के लिए किया जाता है (जिसे हमेशा डायरेक्ट मेथड माना जाता है)।

invoke-interface का उपयोग एक interface विधि को लागू करने के लिए किया जाता है, अर्थात, एक ऐसी वस्तु पर जिसका ठोस वर्ग ज्ञात नहीं है, एक method_id का उपयोग करके जो एक interface को संदर्भित करता है।

नोट: ये ऑपकोड स्थिर लिंकिंग के लिए उचित उम्मीदवार हैं, विधि तर्क को और अधिक प्रत्यक्ष ऑफसेट (या उसके जोड़े) में बदलने के लिए।

73 10x (अप्रयुक्त) (अप्रयुक्त)
74..78 3आरसी आह्वान- प्रकार / श्रेणी {vCCCC .. vNNNN}, meth@BBBB
74: इनवोक-वर्चुअल/रेंज
75: आह्वान-सुपर/रेंज
76: इनवोक-डायरेक्ट/रेंज
77: आह्वान-स्थिर/रेंज
78: इनवोक-इंटरफ़ेस/रेंज		 A: तर्क शब्द गणना (8 बिट)
B: विधि संदर्भ सूचकांक (16 बिट्स)
C: पहला तर्क रजिस्टर (16 बिट्स)
N = A + C - 1		 संकेतित विधि को बुलाओ। विवरण, चेतावनी और सुझावों के लिए ऊपर दिए गए पहले invoke- kind का विवरण देखें।
79..7ए 10x (अप्रयुक्त) (अप्रयुक्त)
7b..8f 12x अनॉप वीए, वीबी
7बी: नकारात्मक-इंट
7c: नहीं-इंट
7d: नकारात्मक-लंबा
7e: लंबा नहीं
7f: नकारात्मक-फ्लोट
80: नकारात्मक-डबल
81: इंट-टू-लॉन्ग
82: इंट-टू-फ्लोट
83: इंट-टू-डबल
84: लांग-टू-इंट
85: लॉन्ग-टू-फ्लोट
86: लॉन्ग-टू-डबल
87: फ्लोट-टू-इंट
88: फ्लोट-टू-लॉन्ग
89: फ्लोट-टू-डबल
8a: डबल-टू-इंट
8बी: डबल-टू-लॉन्ग
8c: डबल-टू-फ्लोट
8d: इंट-टू-बाइट
8e: इंट-टू-चार
8f: इंट-टू-शॉर्ट		 A: गंतव्य रजिस्टर या जोड़ी (4 बिट)
B: स्रोत रजिस्टर या जोड़ी (4 बिट)		 गंतव्य रजिस्टर में परिणाम संग्रहीत करते हुए, स्रोत रजिस्टर पर पहचाने गए यूनरी ऑपरेशन करें।
90..एएफ 23x बिनोप वीएए, वीबीबी, वीसीसी
90: ऐड-इन
91: सब-इंट
92: मूल-इंट
93: डिव-इंट
94: रेम-इंट
95: और-इंट
96: या-इंट
97: xor-int
98: एसएचएल-इंट
99: श्री-इंट
9ए: उशर-इंट
9बी: ऐड-लांग
9c: सब-लॉन्ग
9d: मूल-लॉन्ग
9e: डिव-लॉन्ग
9f: रेम-लॉन्ग
a0: और-लंबा
a1: या-लंबा
a2: xor-long
a3: एसएचएल-लॉन्ग
a4: shr-long
a5: उशर-लांग
a6: ऐड-फ्लोट
a7: सब-फ्लोट
a8: बहु-फ्लोट
a9: डिव-फ्लोट
आ: रेम-फ्लोट
एबी: ऐड-डबल
एसी: सब-डबल
विज्ञापन: बहु-डबल
एई: डिव-डबल
वायुसेना: रेम-डबल		 A: गंतव्य रजिस्टर या जोड़ी (8 बिट)
B: पहला स्रोत रजिस्टर या जोड़ी (8 बिट)
C: दूसरा स्रोत रजिस्टर या जोड़ी (8 बिट)		 गंतव्य रजिस्टर में परिणाम संग्रहीत करते हुए, दो स्रोत रजिस्टरों पर पहचाने गए बाइनरी ऑपरेशन करें।

नोट: अन्य- -long गणितीय संक्रियाओं के विपरीत (जो उनके पहले और उनके दूसरे स्रोत दोनों के लिए रजिस्टर जोड़े लेते हैं), shl-long , shr-long , और ushr-long अपने पहले स्रोत के लिए एक रजिस्टर जोड़ी लेते हैं (मान को स्थानांतरित किया जाना है) ), लेकिन उनके दूसरे स्रोत (स्थानांतरण दूरी) के लिए एक एकल रजिस्टर।

b0..cf 12x बिनोप / 2addr वीए, वीबी
b0: ऐड-इंट/2addr
b1: सब-इंट/2addr
b2: mul-int/2addr
b3: div-int/2addr
b4: रेम-इंट/2addr
b5: और-int/2addr
b6: or-int/2addr
b7: xor-int/2addr
b8: एसएचएल-इंट/2addr
b9: shr-int/2addr
बीए: ushr-int/2addr
bb: ऐड-लांग/2addr
बीसी: सब-लॉन्ग/2addr
बीडी: mul-long/2addr
होना: div-long/2addr
bf: रेम-लॉन्ग/2addr
c0: और-लंबा/2addr
c1: या-लंबा/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: डिव-फ्लोट/2addr
सीए: रेम-फ्लोट/2addr
cb: ऐड-डबल/2addr
cc: सब-डबल/2addr
सीडी: mul-डबल/2addr
सीई: डिव-डबल/2addr
cf: रेम-डबल/2addr		 A: गंतव्य और पहला स्रोत रजिस्टर या जोड़ी (4 बिट)
B: दूसरा स्रोत रजिस्टर या जोड़ी (4 बिट)		 पहले स्रोत रजिस्टर में परिणाम संग्रहीत करते हुए, दो स्रोत रजिस्टरों पर पहचाने गए बाइनरी ऑपरेशन करें।

नोट: अन्य -long/2addr गणितीय संक्रियाओं के विपरीत (जो उनके गंतव्य/प्रथम स्रोत और उनके दूसरे स्रोत दोनों के लिए रजिस्टर जोड़े लेते हैं), shl-long/2addr , shr-long/2addr , और ushr-long/2addr एक रजिस्टर लेते हैं उनके गंतव्य/प्रथम स्रोत के लिए जोड़ी (स्थानांतरित किया जाने वाला मान), लेकिन उनके दूसरे स्रोत (स्थानांतरण दूरी) के लिए एक एकल रजिस्टर।

d0..d7 22s बिनोप /lit16 वीए, वीबी, #+सीसीसीसी
d0: ऐड-इंट/lit16
d1: rsub-int (रिवर्स घटाना)
d2: mul-int/lit16
d3: div-int/lit16
d4: रेम-इंट/लिट16
d5: और-int/lit16
d6: or-int/lit16
d7: xor-int/lit16		 A: गंतव्य रजिस्टर (4 बिट)
B: स्रोत रजिस्टर (4 बिट)
C: हस्ताक्षरित इंट स्थिरांक (16 बिट्स)		 गंतव्य रजिस्टर में परिणाम संग्रहीत करते हुए, संकेतित रजिस्टर (पहला तर्क) और शाब्दिक मूल्य (दूसरा तर्क) पर संकेतित बाइनरी ऑप निष्पादित करें।

नोट: rsub-int में प्रत्यय नहीं है क्योंकि यह संस्करण इसके परिवार का मुख्य ओपकोड है। इसके अलावा, इसके शब्दार्थ पर विवरण के लिए नीचे देखें।

d8..e2 22b बिनोप /lit8 वीएए, वीबीबी, #+सीसी
d8: ऐड-इंट/lit8
d9: rsub-int/lit8
दा: mul-int/lit8
डीबी: div-int/lit8
डीसी: रेम-इंट/lit8
डीडी: और-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 (अप्रयुक्त) (अप्रयुक्त)
एफए 45सीसी इनवोक-पॉलीमॉर्फिक {वीसी, वीडी, वीई, वीएफ, वीजी}, मेथ@बीबीबीबी, प्रोटो@एचएचएचएच 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 से डेक्स फाइलों में मौजूद है।
एफबी 4आरसीसी इनवोक-पॉलीमॉर्फिक/रेंज {vCCCC .. vNNNN}, meth@BBBB, proto@HHHH A: तर्क शब्द गणना (8 बिट)
B: विधि संदर्भ सूचकांक (16 बिट्स)
C: रिसीवर (16 बिट्स)
H: प्रोटोटाइप संदर्भ सूचकांक (16 बिट्स)
N = A + C - 1		 संकेतित विधि हैंडल को आमंत्रित करें। विवरण के लिए ऊपर invoke-polymorphic विवरण देखें।

संस्करण 038 से डेक्स फाइलों में मौजूद है।
एफसी 35सी इनवोक-कस्टम {vC, vD, vE, vF, vG}, call_site@BBBB A: तर्क शब्द गणना (4 बिट)
B: कॉल साइट संदर्भ सूचकांक (16 बिट्स)
C..G: तर्क रजिस्टर (प्रत्येक 4 बिट)		 संकेतित कॉल साइट को हल करता है और आमंत्रित करता है। आह्वान से परिणाम (यदि कोई हो) एक उपयुक्त 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 से डेक्स फाइलों में मौजूद है।
एफडी 3आरसी इनवोक-कस्टम/रेंज {vCCCC .. vNNNN}, call_site@BBBB A: तर्क शब्द गणना (8 बिट)
B: कॉल साइट संदर्भ सूचकांक (16 बिट्स)
C: पहला तर्क रजिस्टर (16-बिट्स)
N = A + C - 1		 एक कॉल साइट को हल करें और आमंत्रित करें। विवरण के लिए ऊपर invoke-custom विवरण देखें।

संस्करण 038 से डेक्स फाइलों में मौजूद है।
फ़े 21सी कॉन्स्ट-मेथड-हैंडल वीएए, मेथड_हैंडल @ बीबीबीबी A: गंतव्य रजिस्टर (8 बिट)
B: मेथड हैंडल इंडेक्स (16 बिट्स)		 दिए गए इंडेक्स द्वारा निर्दिष्ट विधि हैंडल के संदर्भ को निर्दिष्ट रजिस्टर में ले जाएं।

संस्करण 039 से डेक्स फाइलों में मौजूद है।
एफएफ 21सी कॉन्स्ट-विधि-प्रकार वीएए, प्रोटो @ बीबीबीबी A: गंतव्य रजिस्टर (8 बिट)
B: विधि प्रोटोटाइप संदर्भ (16 बिट्स)		 दिए गए इंडेक्स द्वारा निर्दिष्ट विधि प्रोटोटाइप के संदर्भ को निर्दिष्ट रजिस्टर में ले जाएं।

संस्करण 039 से डेक्स फाइलों में मौजूद है।

पैक्ड-स्विच-पेलोड प्रारूप

नाम प्रारूप विवरण
अध्यक्ष यूशॉर्ट = 0x0100 छद्म ओपकोड की पहचान करना
आकार उशॉर्ट तालिका में प्रविष्टियों की संख्या
प्रथम_कुंजी पूर्णांक पहला (और निम्नतम) स्विच केस मान
लक्ष्यों को इंट [] size सापेक्ष शाखा लक्ष्यों की सूची। लक्ष्य स्विच ऑपकोड के पते के सापेक्ष हैं, इस तालिका के नहीं।

नोट: इस तालिका के उदाहरण के लिए कोड इकाइयों की कुल संख्या (size * 2) + 4 है।

विरल-स्विच-पेलोड प्रारूप

नाम प्रारूप विवरण
अध्यक्ष यूशॉर्ट = 0x0200 छद्म ओपकोड की पहचान करना
आकार उशॉर्ट तालिका में प्रविष्टियों की संख्या
चांबियाँ इंट [] size कुंजी मानों की सूची, निम्न-से-उच्च को क्रमबद्ध किया गया
लक्ष्यों को इंट [] size सापेक्ष शाखा लक्ष्यों की सूची, प्रत्येक एक ही सूचकांक पर प्रमुख मूल्य के अनुरूप। लक्ष्य स्विच ऑपकोड के पते के सापेक्ष हैं, इस तालिका के नहीं।

नोट: इस तालिका के उदाहरण के लिए कोड इकाइयों की कुल संख्या (size * 4) + 2 है।

भरण-सरणी-डेटा-पेलोड प्रारूप

नाम प्रारूप विवरण
अध्यक्ष यूशॉर्ट = 0x0300 छद्म ओपकोड की पहचान करना
तत्व_चौड़ाई उशॉर्ट प्रत्येक तत्व में बाइट्स की संख्या
आकार यूंट तालिका में तत्वों की संख्या
जानकारी यूबाइट [] डेटा मान

नोट: इस तालिका के उदाहरण के लिए कोड इकाइयों की कुल संख्या (size * element_width + 1) / 2 + 4 है।

गणितीय संचालन विवरण

नोट: फ़्लोटिंग पॉइंट ऑपरेशंस को आईईईई 754 नियमों का पालन करना चाहिए, राउंड-टू-निकटतम और क्रमिक अंडरफ्लो का उपयोग करते हुए, जहां अन्यथा कहा गया हो।

ओपकोड सी शब्दार्थ टिप्पणियाँ
नकारात्मक इंट32 ए;
int32 परिणाम = -ए;		 यूनरी ट्वोस-पूरक।
नॉट-इंट इंट32 ए;
int32 परिणाम = ~ ए;		 यूनरी वाले-पूरक।
नकारात्मक-लंबा इंट 64 ए;
int64 परिणाम = -ए;		 यूनरी ट्वोस-पूरक।
लंबे समय तक नहीं इंट 64 ए;
int64 परिणाम = ~ ए;		 यूनरी वाले-पूरक।
नकारात्मक फ्लोट फ्लोट ए;
फ्लोट परिणाम = -ए;		 फ्लोटिंग पॉइंट नकार।
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 .