डाल्विक बाइटकोड प्रारूप

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

  • मशीन मॉडल और कॉलिंग कन्वेंशन का उद्देश्य लगभग सामान्य वास्तविक आर्किटेक्चर और सी-स्टाइल कॉलिंग कन्वेंशन की नकल करना है:
    • मशीन रजिस्टर-आधारित है, और फ्रेम निर्माण पर आकार में तय किए जाते हैं। प्रत्येक फ़्रेम में एक विशेष संख्या में रजिस्टर (विधि द्वारा निर्दिष्ट) के साथ-साथ विधि को निष्पादित करने के लिए आवश्यक कोई भी सहायक डेटा होता है, जैसे (लेकिन इन्हीं तक सीमित नहीं) प्रोग्राम काउंटर और .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 -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 नहीं अपशिष्ट चक्र.

नोट: डेटा-असर छद्म-निर्देशों को इस ऑपकोड के साथ टैग किया गया है, जिस स्थिति में ऑपकोड इकाई का उच्च-ऑर्डर बाइट डेटा की प्रकृति को इंगित करता है। नीचे " 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 बिट्स)		 एक ऑब्जेक्ट-बेयरिंग रजिस्टर की सामग्री को दूसरे में ले जाएं।
0a 11x चाल-परिणाम vAA A: गंतव्य रजिस्टर (8 बिट्स) नवीनतम invoke- kind के एकल-शब्द गैर-ऑब्जेक्ट परिणाम को संकेतित रजिस्टर में ले जाएँ। इसे invoke- kind तुरंत बाद निर्देश के रूप में किया जाना चाहिए - जिसका (एकल-शब्द, गैर-वस्तु) परिणाम को नजरअंदाज नहीं किया जाना चाहिए; अन्यत्र कहीं भी अमान्य है.
0बी 11x चाल-परिणाम-व्यापी वीएए 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 वीएए वापस करें A: रिटर्न वैल्यू रजिस्टर (8 बिट्स) एकल-चौड़ाई (32-बिट) गैर-ऑब्जेक्ट मान-रिटर्निंग विधि से लौटें।
10 11x रिटर्न-वाइड वीएए A: रिटर्न वैल्यू रजिस्टर-जोड़ी (8 बिट्स) दोगुनी-चौड़ाई (64-बिट) मान-रिटर्निंग विधि से लौटें।
11 11x रिटर्न-ऑब्जेक्ट vAA A: रिटर्न वैल्यू रजिस्टर (8 बिट्स) ऑब्जेक्ट-रिटर्निंग विधि से वापसी।
12 11एन स्थिरांक/4 वीए, #+बी A: गंतव्य रजिस्टर (4 बिट्स)
B: हस्ताक्षरित int (4 बिट्स)		 दिए गए शाब्दिक मान (साइन-32 बिट्स तक विस्तारित) को निर्दिष्ट रजिस्टर में ले जाएं।
13 21s स्थिरांक/16 वीएए, #+बीबीबीबी A: गंतव्य रजिस्टर (8 बिट्स)
B: हस्ताक्षरित पूर्णांक (16 बिट्स)		 दिए गए शाब्दिक मान (साइन-32 बिट्स तक विस्तारित) को निर्दिष्ट रजिस्टर में ले जाएं।
14 31i स्थिरांक वीएए, #+बीबीबीबीबीबीबी A: गंतव्य रजिस्टर (8 बिट्स)
B: मनमाना 32-बिट स्थिरांक		 दिए गए शाब्दिक मान को निर्दिष्ट रजिस्टर में ले जाएँ।
15 21 घंटे स्थिरांक/उच्च16 वीएए, #+बीबीबीबी0000 A: गंतव्य रजिस्टर (8 बिट्स)
B: हस्ताक्षरित पूर्णांक (16 बिट्स)		 दिए गए शाब्दिक मान (दाएँ-शून्य-32 बिट्स तक विस्तारित) को निर्दिष्ट रजिस्टर में ले जाएँ।
16 21 एस कॉन्स्ट-वाइड/16 वीएए, #+बीबीबीबी A: गंतव्य रजिस्टर (8 बिट्स)
B: हस्ताक्षरित पूर्णांक (16 बिट्स)		 दिए गए शाब्दिक मान (साइन-64 बिट्स तक विस्तारित) को निर्दिष्ट रजिस्टर-जोड़ी में ले जाएं।
17 31i कॉन्स्ट-वाइड/32 वीएए, #+बीबीबीबीबीबीबी A: गंतव्य रजिस्टर (8 बिट्स)
B: हस्ताक्षरित int (32 बिट्स)		 दिए गए शाब्दिक मान (साइन-64 बिट्स तक विस्तारित) को निर्दिष्ट रजिस्टर-जोड़ी में ले जाएं।
18 51ली कॉन्स्ट-वाइड वीएए, #+बीबीबीबीबीबीबीबीबीबीबीबी A: गंतव्य रजिस्टर (8 बिट्स)
B: मनमानी दोगुनी-चौड़ाई (64-बिट) स्थिरांक		 दिए गए शाब्दिक मान को निर्दिष्ट रजिस्टर-जोड़ी में ले जाएँ।
19 21 घंटे कॉन्स्ट-वाइड/हाई16 वीएए, #+बीबीबीबी00000000000 A: गंतव्य रजिस्टर (8 बिट्स)
B: हस्ताक्षरित पूर्णांक (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() , जबकि अभी भी उचित मॉनिटर स्वच्छता का प्रबंधन कर रहा हूं।

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

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

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

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

21 12x सरणी-लंबाई वीए, वीबी A: गंतव्य रजिस्टर (4 बिट्स)
B: सरणी संदर्भ-असर रजिस्टर (4 बिट्स)		 दिए गए गंतव्य में स्टोर करें, प्रविष्टियों में संकेतित सरणी की लंबाई दर्ज करें
22 21सी नया-उदाहरण वीएए, टाइप@बीबीबीबी A: गंतव्य रजिस्टर (8 बिट्स)
B: इंडेक्स टाइप करें		 गंतव्य में इसका संदर्भ संग्रहीत करते हुए, संकेतित प्रकार का एक नया उदाहरण बनाएं। प्रकार को एक गैर-सरणी वर्ग का संदर्भ देना चाहिए।
23 22सी नई सारणी vA, vB, type@CCCC 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 भरण-सरणी-डेटा वीएए, +बीबीबीबीबीबीबी (" fill-array-data-payload प्रारूप" में नीचे निर्दिष्ट पूरक डेटा के साथ) A: सरणी संदर्भ (8 बिट्स)
B: हस्ताक्षरित "शाखा" तालिका डेटा छद्म निर्देश से ऑफसेट (32 बिट्स)		 दिए गए एरे को संकेतित डेटा से भरें। संदर्भ आदिमों की एक सरणी का होना चाहिए, और डेटा तालिका को इसके प्रकार से मेल खाना चाहिए और इसमें सरणी में फिट होने से अधिक तत्व नहीं होने चाहिए। अर्थात्, सारणी तालिका से बड़ी हो सकती है, और यदि ऐसा है, तो सारणी के केवल प्रारंभिक तत्व ही सेट किए जाते हैं, शेष को अकेला छोड़ दिया जाता है।
27 11x वीएए फेंको A: अपवाद-असर रजिस्टर (8 बिट्स)
 संकेतित अपवाद फेंकें.
28 10t गोटो +एए 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डी: सीएमपीएल-फ्लोट (एलटी बायस)
2ई: सीएमपीजी-फ्लोट (जीटी पूर्वाग्रह)
2एफ: सीएमपीएल-डबल (एलटी बायस)
30: सीएमपीजी-डबल (जीटी पूर्वाग्रह)
31: सीएमपी-लंबा		 A: गंतव्य रजिस्टर (8 बिट्स)
B: पहला स्रोत रजिस्टर या जोड़ी
C: दूसरा स्रोत रजिस्टर या जोड़ी		 संकेतित फ़्लोटिंग पॉइंट या long तुलना करें, यदि b == c तो a को 0 , यदि b > c तो 1 , या यदि b < c तो -1 सेट करें। फ़्लोटिंग पॉइंट ऑपरेशंस के लिए सूचीबद्ध "पूर्वाग्रह" इंगित करता है कि NaN तुलनाओं का इलाज कैसे किया जाता है: NaN तुलनाओं के लिए "gt पूर्वाग्रह" निर्देश 1 लौटाते हैं, और "lt पूर्वाग्रह" निर्देश -1 लौटाते हैं।

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

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

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

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

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

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

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

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

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

6ई..72 35सी आह्वान- प्रकार {vC, vD, vE, vF, vG}, meth@BBBB
6e: आह्वान-आभासी
6एफ: इनवोक-सुपर
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 विधि को लागू करने के लिए किया जाता है, अर्थात, किसी ऐसे ऑब्जेक्ट पर जिसका ठोस वर्ग ज्ञात नहीं है, एक interface को संदर्भित करने वाले method_id का उपयोग किया जाता है।

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

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 (अप्रयुक्त) (अप्रयुक्त)
7बी..8एफ 12x अनोप वीए, वीबी
7बी: नकारात्मक-इंट
7सी: नॉट-इंट
7डी: नकारात्मक-लंबा
7ई: ज्यादा देर तक नहीं
7एफ: नेग-फ्लोट
80: नकारात्मक-डबल
81: इंट-टू-लॉन्ग
82: इंट-टू-फ्लोट
83: इंट-टू-डबल
84: लॉन्ग-टू-इंट
85: लंबे समय तक तैरने वाला
86: लम्बा-से-दोगुना
87: फ्लोट-टू-इंट
88: फ्लोट-टू-लॉन्ग
89: फ्लोट-टू-डबल
8ए: डबल-टू-इंट
8बी: डबल-टू-लॉन्ग
8सी: डबल-टू-फ्लोट
8डी: इंट-टू-बाइट
8ई: इंट-टू-चार
8एफ: इंट-टू-शॉर्ट		 A: गंतव्य रजिस्टर या जोड़ी (4 बिट्स)
B: स्रोत रजिस्टर या जोड़ी (4 बिट्स)		 स्रोत रजिस्टर पर पहचाने गए यूनरी ऑपरेशन को निष्पादित करें, परिणाम को गंतव्य रजिस्टर में संग्रहीत करें।
90..एएफ 23x बिनोप वीएए, वीबीबी, वीसीसी
90: ऐड-इंट
91: उप-अंत
92: मुल-इंट
93: डिव-इंट
94: रेम-इंट
95: और-इंट
96: या-int
97: एक्सओआर-इंट
98: एसएचएल-इंट
99: श्री-इंट
9ए: उश्र-इंट
9बी: ऐड-लॉन्ग
9सी: उप-लंबा
9डी: मुल-लंबा
9ई: डिव-लॉन्ग
9f: रेम-लॉन्ग
अ0: और-लंबा
a1: या-लंबा
a2: xor-लंबा
ए3: एसएचएल-लंबा
a4: श्री-लंबा
a5: उश्र-लंबा
a6: ऐड-फ्लोट
a7: सब-फ्लोट
ए8: मल-फ्लोट
ए9: डिव-फ्लोट
एए: रेम-फ्लोट
एबी: ऐड-डबल
एसी: सब-डबल
विज्ञापन: मल-डबल
एई: डिव-डबल
एएफ: रेम-डबल		 A: गंतव्य रजिस्टर या जोड़ी (8 बिट्स)
B: पहला स्रोत रजिस्टर या जोड़ी (8 बिट्स)
C: दूसरा स्रोत रजिस्टर या जोड़ी (8 बिट्स)		 दो स्रोत रजिस्टरों पर पहचाने गए बाइनरी ऑपरेशन को निष्पादित करें, परिणाम को गंतव्य रजिस्टर में संग्रहीत करें।

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

b0..cf 12x बिनोप /2एडीआर वीए, वीबी
b0: add-int/2addr
b1: उप-int/2addr
b2: mul-int/2addr
b3: div-int/2addr
b4: rem-int/2addr
b5: और-int/2addr
b6: या-int/2addr
b7: xor-int/2addr
b8: shl-int/2addr
b9: shr-int/2addr
बीए: ushr-int/2addr
बीबी: ऐड-लॉन्ग/2एडीआर
बीसी: सब-लॉन्ग/2एडीआर
बीडी: mul-long/2addr
होना: div-long/2addr
बीएफ: रेम-लॉन्ग/2एडीआर
c0: और-लंबा/2addr
c1: या-लंबा/2पता
c2: xor-long/2addr
c3: shl-long/2addr
c4: shr-long/2addr
c5: ushr-long/2addr
c6: ऐड-फ्लोट/2addr
c7: सब-फ़्लोट/2addr
c8: mul-float/2addr
c9: div-float/2addr
सीए: रेम-फ्लोट/2एडीआर
सीबी: ऐड-डबल/2एडीआर
सीसी: सब-डबल/2एडीआर
सीडी: mul-double/2addr
सीई: div-double/2addr
सीएफ: rem-double/2addr		 A: गंतव्य और प्रथम स्रोत रजिस्टर या जोड़ी (4 बिट्स)
B: दूसरा स्रोत रजिस्टर या जोड़ी (4 बिट्स)		 पहले स्रोत रजिस्टर में परिणाम संग्रहीत करते हुए, दो स्रोत रजिस्टरों पर पहचाने गए बाइनरी ऑपरेशन को निष्पादित करें।

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

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

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

d8..e2 22b बिनोप /लिट8 वीएए, वीबीबी, #+सीसी
d8: ऐड-इंट/लिट8
d9: rsub-int/lit8
दा: mul-int/lit8
डीबी: div-int/lit8
डीसी: रेम-इंट/लिट8
dd: and-int/lit8
डी: या-इंट/लिट8
डीएफ: 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सीसी आह्वान-बहुरूपी {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 के बाद से डेक्स फ़ाइलों में मौजूद है।
एफबी 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 छद्म ऑपकोड की पहचान करना
आकार उशॉर्ट तालिका में प्रविष्टियों की संख्या
पहली_कुंजी int यहाँ पहला (और सबसे निचला) स्विच केस मान
लक्ष्यों को int[] size सापेक्ष शाखा लक्ष्यों की सूची। लक्ष्य स्विच ऑपकोड के पते से संबंधित हैं, इस तालिका के नहीं।

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

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

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

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

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

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

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

गणितीय संक्रिया विवरण

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

ऑपकोड सी शब्दार्थ टिप्पणियाँ
नकारात्मक-int int32 ए;
int32 परिणाम = -ए;		 यूनरी ट्वोज़-पूरक।
नहीं-int int32 ए;
int32 परिणाम = ~ए;		 यूनरी वाले-पूरक।
नकारात्मक-लंबा int64 ए;
int64 परिणाम = -ए;		 यूनरी ट्वोज़-पूरक।
लंबे समय तक नहीं int64 ए;
int64 परिणाम = ~ए;		 यूनरी वाले-पूरक।
नकारात्मक-फ्लोट फ्लोट ए;
फ्लोट परिणाम = -ए;		 फ़्लोटिंग पॉइंट निषेध.
नकारात्मक-डबल डबल एक;
दोहरा परिणाम = -ए;		 फ़्लोटिंग पॉइंट निषेध.
int-to-long int32 ए;
int64 परिणाम = (int64) a;		 int32 का int64 में विस्तार पर हस्ताक्षर करें।
int-to-फ्लोट int32 ए;
फ्लोट परिणाम = (फ्लोट) ए;		 राउंड-टू-नेस्ट का उपयोग करके int32 को float में परिवर्तित करना। यह कुछ मूल्यों के लिए सटीकता खो देता है।
इंट-टू-डबल int32 a;
डबल परिणाम = (डबल) ए;		 int32 का रूपांतरण double के लिए।
लंबे समय तक int64 a;
int32 परिणाम = (int32) a;		 int32 में int64 का ट्रंकेशन।
लंबे समय तक int64 a;
फ्लोट परिणाम = (फ्लोट) ए;		 राउंड-टू-नोयरस्टेस्ट का उपयोग करके, float के लिए int64 का रूपांतरण। यह कुछ मूल्यों के लिए सटीकता खो देता है।
लंबे समय तक डबल int64 a;
डबल परिणाम = (डबल) ए;		 double -टू-नोयरस्टेस्ट का उपयोग करके int64 का रूपांतरण। यह कुछ मूल्यों के लिए सटीकता खो देता है।
लपेटना फ्लोट ए;
int32 परिणाम = (int32) a;		 राउंड-टावर्ड-शून्य का उपयोग करके, int32 में float का रूपांतरण। NaN और -0.0 (नकारात्मक शून्य) पूर्णांक 0 में परिवर्तित करें। बहुत बड़े के साथ infinities और मूल्यों का प्रतिनिधित्व करने के लिए एक परिमाण या तो 0x7fffffff या -0x80000000 में परिवर्तित हो जाता है।
लम्बी फ्लोट ए;
int64 परिणाम = (int64) a;		 राउंड-टावर्ड-शून्य का उपयोग करके, int64 में float का रूपांतरण। float-to-int के लिए एक ही विशेष केस नियम यहां लागू होते हैं, सिवाय इसके कि आउट-ऑफ-रेंज मान साइन के आधार पर 0x7fffffffffffffff या -0x8000000000000000 में परिवर्तित हो जाते हैं।
तैरना फ्लोट ए;
डबल परिणाम = (डबल) ए;		 float का रूपांतरण double करने के लिए, मूल्य को बिल्कुल संरक्षित करना।
दोहरा डबल एक;
int32 परिणाम = (int32) a;		 राउंड-टावर्ड-शून्य का उपयोग करते हुए, int32 में double में रूपांतरण। float-to-int के लिए एक ही विशेष केस नियम यहां लागू होते हैं।
लम्बा डबल एक;
int64 परिणाम = (int64) a;		 राउंड-टावर्ड-शून्य का उपयोग करके int64 में double में रूपांतरण। float-to-long के लिए एक ही विशेष मामले के नियम यहां लागू होते हैं।
डबल-टू-फ्लोट डबल एक;
फ्लोट परिणाम = (फ्लोट) ए;		 राउंड-टू-नोयरस्टेस्ट का उपयोग करके double टू float का रूपांतरण। यह कुछ मूल्यों के लिए सटीकता खो देता है।
इंट-टू-बाइट int32 a;
int32 परिणाम = (एक << 24) >> 24;		 int32 से int8 का ट्रंकेशन, परिणाम का विस्तार करें।
इंट-टू-चार int32 a;
int32 परिणाम = a & 0xffff;		 साइन एक्सटेंशन के बिना int32 से uint16 का ट्रंकेशन।
इंट-टू-शॉर्ट int32 a;
int32 परिणाम = (एक << 16) >> 16;		 int32 से int16 का ट्रंकेशन, परिणाम का विस्तार करें।
ऐड-इन-इन int32 a, b;
int32 परिणाम = a + b;		 Twos- पूरक जोड़।
उप-भाग int32 a, b;
int32 परिणाम = a - b;		 TWOS- पूरक घटाव।
rsub-int int32 a, b;
int32 परिणाम = b - a;		 TWOS-COMPLEMENT रिवर्स घटाव।
मल-इन int32 a, b;
int32 परिणाम = a * b;		 TWOS- पूरक गुणन।
डाइव-इन int32 a, b;
int32 परिणाम = ए / बी;		 Twos- पूरक विभाजन, शून्य की ओर गोल (यानी, पूर्णांक को काट दिया गया)। यदि b == 0 यदि यह ArithmeticException करता है।
रिम-इन int32 a, b;
int32 परिणाम = a % b;		 विभाजन के बाद ट्वोस-पूरक शेष। परिणाम का संकेत a के समान है, और यह अधिक सटीक रूप से result == a - (a / b) * b । यदि b == 0 यदि यह ArithmeticException करता है।
और int32 a, b;
int32 परिणाम = a & b;		 बिटवाइज़ और.
या int32 a, b;
int32 परिणाम = a | बी;		 बिटवाइज़ या.
XOR-INT int32 a, b;
int32 परिणाम = a ^ b;		 बिटवाइज़ XOR.
शिल्पी int32 a, b;
int32 परिणाम = a << (b & 0x1f);		 बिटवाइज शिफ्ट बाएं (नकाबपोश तर्क के साथ)।
शिरण int32 a, b;
int32 परिणाम = a >> (b & 0x1f);		 बिटवाइज़ ने शिफ्ट शिफ्ट (नकाबपोश तर्क के साथ) पर हस्ताक्षर किए।
उश्र-इंट UINT32 A, B;
int32 परिणाम = a >> (b & 0x1f);		 बिटवाइज़ अहस्ताक्षरित शिफ्ट राइट (नकाबपोश तर्क के साथ)।
लम्बा int64 ए, बी;
int64 परिणाम = a + b;		 Twos- पूरक जोड़।
लम्बी int64 ए, बी;
int64 परिणाम = a - b;		 TWOS- पूरक घटाव।
लम्बी लम्बी int64 ए, बी;
int64 परिणाम = a * b;		 TWOS- पूरक गुणन।
एक प्रकार का int64 ए, बी;
int64 परिणाम = ए / बी;		 Twos- पूरक विभाजन, शून्य की ओर गोल (यानी, पूर्णांक को काट दिया गया)। यदि b == 0 यदि यह ArithmeticException करता है।
लम्बा int64 ए, बी;
int64 परिणाम = a % b;		 विभाजन के बाद ट्वोस-पूरक शेष। परिणाम का संकेत a के समान है, और यह अधिक सटीक रूप से result == a - (a / b) * b । यदि b == 0 यदि यह ArithmeticException करता है।
और लंबा int64 ए, बी;
int64 परिणाम = a & b;		 बिटवाइज़ और.
लम्बी int64 ए, बी;
int64 परिणाम = a | बी;		 बिटवाइज़ या.
XOR-LONG int64 ए, बी;
int64 परिणाम = a ^ b;		 बिटवाइज़ XOR.
शिल्पी int64 a;
int32 b;
int64 परिणाम = a << (b & 0x3f);		 बिटवाइज शिफ्ट बाएं (नकाबपोश तर्क के साथ)।
सुस्त int64 a;
int32 b;
int64 परिणाम = a >> (b & 0x3f);		 बिटवाइज़ ने शिफ्ट शिफ्ट (नकाबपोश तर्क के साथ) पर हस्ताक्षर किए।
उश्र-लॉन्ग uint64 a;
int32 b;
int64 परिणाम = a >> (b & 0x3f);		 बिटवाइज़ अहस्ताक्षरित शिफ्ट राइट (नकाबपोश तर्क के साथ)।
ऐड-फ्लोट फ्लोट ए, बी;
फ्लोट परिणाम = ए + बी;		 फ़्लोटिंग पॉइंट जोड़.
उप-चौड़ी फ्लोट ए, बी;
फ्लोट परिणाम = ए - बी;		 फ़्लोटिंग पॉइंट घटाव।
मुलायम फ्लोट ए, बी;
फ्लोट परिणाम = ए * बी;		 फ़्लोटिंग पॉइंट गुणन।
डाइव-फ्लोट फ्लोट ए, बी;
फ्लोट परिणाम = ए / बी;		 फ़्लोटिंग पॉइंट डिवीजन.
रेम-फ्लोट फ्लोट ए, बी;
फ्लोट परिणाम = एक % बी;		 डिवीजन के बाद फ्लोटिंग पॉइंट शेष। यह फ़ंक्शन IEEE 754 शेष से अलग है और इसे result == a - roundTowardZero(a / b) * b ।
जोड़ें डबल ए, बी;
डबल परिणाम = ए + बी;		 फ़्लोटिंग पॉइंट जोड़.
उप-डबल डबल ए, बी;
डबल परिणाम = ए - बी;		 फ़्लोटिंग पॉइंट घटाव।
शराबी डबल ए, बी;
डबल परिणाम = ए * बी;		 फ़्लोटिंग पॉइंट गुणन।
डुबकी डबल ए, बी;
डबल परिणाम = ए / बी;		 फ़्लोटिंग पॉइंट डिवीजन.
रेम-डबल डबल ए, बी;
डबल परिणाम = एक % बी;		 डिवीजन के बाद फ्लोटिंग पॉइंट शेष। यह फ़ंक्शन IEEE 754 शेष से अलग है और इसे result == a - roundTowardZero(a / b) * b ।