घर
Top.Mail.Ru Yandeks.Metrika
मंच: "अन्य";
वर्तमान संग्रह: 2017.08.27;
डाउनलोड करें: [xml.tar.bz2];

नीचे

पासिंग फंक्शन पैरामीटर इसी तरह की शाखाएँ खोजें


SergP ©   (2016-05-30 14:38) [0]

मान लीजिए कि मेरा तीन मापदंडों वाला एक कार्य है:
फ़ंक्शन खोज (गणना: पूर्णांक; कीवर्ड: इंटैक्सएनएक्सएक्स; var स्रोत): पूर्णांक;

पहला पैरामीटर, जैसा कि मैं इसे समझता हूं, EAX के माध्यम से प्रसारित किया जाता है
परिणाम, भी, EAX के माध्यम से प्रेषित किया जा रहा है।
तीसरा EDX के माध्यम से लगता है
दूसरे के बारे में क्या?
मैं कोडांतरक में अच्छा नहीं हूं, लेकिन कोड द्वारा इसे देखते हुए इसे स्टैक के माध्यम से पारित किया जाता है। यदि हां, तो यह वास्तव में स्टैक पर कहाँ है?
जैसा कि मैं इसे समझता हूं, रिटर्न पता (4 बाइट्स) स्टैक के शीर्ष पर है, और यह पैरामीटर होने के बाद, इसकी निचली बाइट्स शीर्ष के करीब हैं। है न?

यानी ऐसे काम करेगा क्या?
(फ़ील्ड फ़ील्ड द्वारा सरणी में खोजें। यदि पर - सरणी तत्व की संख्या लौटाता है, यदि नहीं मिला है, तो -XNUMI वापस कर दिया गया है)

... TWork = पैक रिकॉर्ड टाइप करें फ़ील्ड: int64; MSet: TMset; जांच: विस्तारित; अंत; ... workarr: TWork की पैक सरणी; ... फ़ंक्शन खोज (गणना: पूर्णांक; कीवर्ड: इंटैक्सएनएक्सएक्स; var स्रोत): पूर्णांक; लेबल lbloop, lbcont, lbbreak; स्थिरांक step = sizeof (TWork); एएसएम धक्का देना edx; एक्स्टॉक्स धक्का; धक्का देना ebx; मूव एक्क्स, [esp + $ 64]; Mov ईबेक्स, [esp + $ 10]; डीईसी ईएक्सएक्स; lbloop: cmp ebx, [edx + $ 14]; jnz lbcont; cmp ecx, [edx]; jz lbbreak; lbcont: edx, चरण जोड़ें; डीईसी ईएक्सएक्स; jns लब्लूप; lbbreak: पॉप ईबेक्स; पॉप ईएक्सएक्स; पॉप edx; अंत;



SergP ©   (2016-05-30 14:50) [1]

मैंने संकलित कोड को देखा।
यह शुरू में वहाँ जोड़ा गया:
धक्का देना; // मैंने जो मांगा वह क्यों नहीं किया?
मूव एबप, एस्प;
धक्का देना ebx;

और अंत में:

मूव एंक्स, ईबेक्स; // यह मेरा परिणाम क्यों खराब करता है?
पॉप ईबेक्स;
पॉप ईबीपी;
$ 0008 को रिटायर करें; // क्या पैरामीटर?
lea eax, [eax + $ 00]; // और यह किस तरह का चमत्कार है? या यह सिर्फ संरेखण से संबंधित बकवास है?



SergP ©   (2016-05-30 14:53) [2]


> $ $ 0008; // क्या पैरामीटर?


यद्यपि ऐसा लगता है कि मुझे समझ में आया कि यह क्या है, अगर मैं सही ढंग से समझ गया, तो यह वह संख्या है जिसके द्वारा लौटने के बाद ईएसपी अतिरिक्त रूप से बढ़ जाता है, पैरामीटर स्टैक पर पारित होने के कारण ...
लेकिन बाकी का क्या?



Rouse_ ©   (2016-05-30 15:14) [3]

इसलिए लिखें:

फ़ंक्शन Search2 (गणना: पूर्णांक; कीवर्ड: int64; var स्रोत): पूर्णांक; स्थिरांक step = sizeof (TWork); एएसएम धक्का देना mov ecx, eax Mov edx, [edx] @compare: Mov eax, [esp + 12] cmp [edx], ईएक्सएक्स jne @next Mov eax, [esp + 16] सीएमपी [edx + 4], ईएक्सएक्स जे @ डोन @next: edx चरण जोड़ें decx jnz @compare मूव एक्क्स, [esp] inc Ecx @done: पॉप ईएक्स सब ईएक्स, ईएक्सएक्स अंत;



SergP ©   (2016-05-30 15:23) [4]


> मूव ऐक्स, [एस्प + एक्सएनयूएमएक्स]
> cmp [edx], eax
> jne @next
> मूव ऐक्स, [एस्प + एक्सएनयूएमएक्स]
> cmp [edx + 4], ईएक्सएक्स
> जे @ डोन


ठीक है, इसलिए संकलक खुद को एक समान तरीके से करता है ...
मैं इसे और तेज करना चाहता था ... यानी। रजिस्टरों में दूसरे पैरामीटर को स्टोर करने के लिए, ताकि इसे लगातार मेमोरी से खींचना न हो।

lbloop: cmp eax, [edx + $ 04]; jnz lbcont; cmp ecx, [edx]; jz lbbreak;

ऐसा लगता है कि यह काम किया ...:

फ़ंक्शन खोज (गणना: पूर्णांक; कीवर्ड: इंटैक्सएनएक्सएक्स; var स्रोत): पूर्णांक; लेबल lbloop, lbcont, lbbreak; स्थिरांक step = sizeof (TWork); एएसएम धक्का देना edx; एक्स्टॉक्स धक्का; Mov ईबेक्स, ईएएनएक्स; मूव एक्क्स, [ईबेपी + $ एक्सएनयूएमएक्स]; मूव एनेक्स, [ईबेपी + $ एक्सएनयूएमएक्ससी]; डिक ईबेक्स; lbloop: cmp eax, [edx + $ 64]; jnz lbcont; cmp ecx, [edx]; jz lbbreak; lbcont: edx, चरण जोड़ें; डिक ईबेक्स; jns लब्लूप; lbbreak: पॉप ईएक्सएक्स; पॉप edx; अंत;

हालांकि अभी भी कुछ विषमताएं हैं ... लेकिन शायद वे कोड के अन्य भागों से संबंधित हैं।



SergP ©   (2016-05-30 15:25) [5]


> हालांकि अभी भी कुछ विषमताएं हैं ... लेकिन शायद वे
> कोड के अन्य भागों से जुड़ा हुआ है।


उ। ठीक है, हाँ। मिल गया। मैं सरणी ऊपर जा रहा हूं, और काउंटर नीचे गिना जा रहा है ... :)))



Rouse_ ©   (2016-05-30 15:28) [6]

रजिस्टर में खैर फिर इस तरह:

फ़ंक्शन Search2 (गणना: पूर्णांक; कीवर्ड: int64; var स्रोत): पूर्णांक; स्थिरांक step = sizeof (TWork); एएसएम धक्का देना esi धक्का Mov esi, [esp + 16] एडी को धक्का देना Mov edi, [esp + 24] mov ecx, eax Mov edx, [edx] @compare: cmp [edx], esi jne @next cmp [edx + 4], edi जे @ डोन @next: edx चरण जोड़ें decx jnz @compare मूव एक्क्स, [esp + 8] inc Ecx @done: पॉप ईडी पॉप एसईआई पॉप ईएक्स सब ईएक्स, ईएक्सएक्स अंत;



Rouse_ ©   (2016-05-30 15:30) [7]

खैर, एक उदाहरण कॉल:

वर workarr: TWork की पैक सरणी; शुरू करना कोशिश सेटल्रॉन्ग (वर्कचेयर, एक्सएनयूएमएक्स); workarr [10] .field: = 0; workarr [456] .field: = $ CDB7F81CDB21FXNNX; Writeln (Search81 (20, $ CDB2F10CDB81F21, workarr)); // परिणाम 81 होना चाहिए



SergP ©   (2016-05-30 16:13) [8]


> ईएक्सएक्स
> jnz @compare


और एक अन्य प्रश्न: ऐसा लगता है कि आप लूप कमांड का उपयोग ऐसी चीजों के लिए कर सकते हैं यदि यह एक एक्सएनएक्सएक्स-बिट रजिस्टर के साथ काम करता है।

लेकिन इंटरनेट पर मौजूद जानकारी के अनुसार मैं यह नहीं समझ सकता: लूप कमांड किस तरह के रजिस्टर का उपयोग करता है: CX या ECX?

उदाहरण के लिए, इसे कैसे समझा जाए:

> एलओओपी कमांड बिना किसी बदलाव के काउंटर रजिस्टर को घटाता है
> या तो झंडे से। फिर शर्तों के लिए विशिष्ट
> LOOP कमांड का विशिष्ट रूप उपयोग किया जाता है। अगर स्थितियां
> संतुष्ट है, तो लेबल के लिए एक छोटा संक्रमण है,
> एलओओपी कमांड के संचालन द्वारा निर्दिष्ट।
>
> यदि पता आकार की विशेषता 16 बिट्स है, तो के रूप में
> काउंटर सीएक्स रजिस्टर का उपयोग करता है, अन्यथा - ईसीएक्स।


पता आकार विशेषता का क्या अर्थ है?



Rouse_ ©   (2016-05-30 16:21) [9]


> और एक और सवाल: ऐसा लगता है कि आप इस तरह की चीजों के लिए कमांड का उपयोग कर सकते हैं
> लूप यदि यह 32-बिट रजिस्टर के साथ काम करता है।

एक नियम के रूप में, वे इसका उपयोग नहीं करते हैं, यह उपायों पर थोड़ा खो देता है।


> पता आकार विशेषता का क्या मतलब है?

एक उपसर्ग जो पता रजिस्टर के आकार को दर्शाता है, जिसके साथ हम काम कर रहे हैं।

इस तरह लूप 65538 बार जाएगा
मूव एक्एक्सएक्स, एक्सएनयूएमएक्स @loop: लूप @ लूप

और इसलिए, केवल दो बार (क्योंकि सीएक्स रजिस्टर में यह दो के बराबर होगा):

मूव एक्एक्सएक्स, एक्सएनयूएमएक्स @loop: db $ 65538 // एड्रेस-साइज ओवरराइड प्रीफिक्स लूप @ लूप



SergP ©   (2016-05-30 17:08) [10]

JZ से JE और JNE से JE टीमों के बीच अंतर क्या है?



SergP ©   (2016-05-30 17:19) [11]


> edx जोड़ें, चरण


और अधिक: LEA edx, [edx + step] इस मामले में तेज होगा?



Rouse_ ©   (2016-05-30 17:21) [12]

शायद पठनीयता के अलावा कुछ नहीं।
बुलियन संचालन के लिए, वे आमतौर पर E (परीक्षण / cmp के बाद), गणितीय के लिए (जोड़ / उप / inc / dec) Z पर प्रयास करते हैं। इस मामले में, इकाई को घटाया जाता है, और हम परिणाम शून्य होने की उम्मीद करते हैं, इसलिए JNZ (इन निर्देशों के opcodes समान हैं)



Rouse_ ©   (2016-05-30 17:22) [13]


> और दूसरा: LEA edx, [edx + step] इस मामले में तेज होगा?

नहीं, वे उपायों में समान होंगे।



SergP ©   (2016-05-31 14:59) [14]

क्यों, विषय कोड के मामले में (भले ही यह पूरी तरह से सही न हो), संकलक ने कहा:

शुरुआत में:
धक्का देना; मूव एबप, एस्प; धक्का देना ebx;
और अंत में:
मूव ईएक्सएक्स, ईबेक्स; पॉप ईबेक्स; पॉप ईबीपी; $ 0008 को फिर से बेचना;

और केवल [6] के मामले में

शीघ्र
धक्कामुक्की; मूव एबप, एस्प;

और अंत में:

पॉप ईबीपी; $ 0008 को फिर से बेचना;

यानी इस शौकिया संकलक गतिविधि के कारण क्या हुआ:
... धक्का देना ebx; ... मूव ईएक्सएक्स, ईबेक्स; पॉप ईबेक्स; ...
?
और भविष्य में कंपाइलर की ऐसी साज़िश का पूर्वानुमान कैसे लगाया जाए?



dmk ©   (2016-05-31 15:39) [15]

> यानी। इस शौकिया संकलक गतिविधि के कारण क्या हुआ:
डिबगिंग। डीबग कर्नेल के लिए आपको आवश्यक है। ब्रेकप्वाइंट, आदि।



dmk ©   (2016-05-31 15:40) [16]

आप ईबीपी का उपयोग किए बिना बाहरी ओब्ज को खींच सकते हैं, लेकिन ब्रेकप्वाइंट वहां काम नहीं करेंगे।



SergP ©   (2016-05-31 16:00) [17]


> dmk © (31.05.16 15: 40) [16]
>
> आप ईबीपी का उपयोग किए बिना बाहरी ओब्ज को खींच सकते हैं, लेकिन वहां
> ब्रेकप्वाइंट काम नहीं करेगा।


मैं ईबीपी (इस तथ्य के बारे में बात नहीं कर रहा हूं कि कंपाइलर हमेशा आवेषण डरावना नहीं है), लेकिन इस तथ्य के बारे में कि यह आवेषण अस्पष्ट है जब ... कभी-कभी यह सम्मिलित करता है, और कभी-कभी नहीं।
यहाँ यह है:

... धक्का देना ebx; ... मूव ईएक्सएक्स, ईबेक्स; पॉप ईबेक्स; ...



dmk ©   (2016-05-31 16:31) [18]

यह कहना मुश्किल है मेरे पास डेल्फी XE6 है और कोई नहीं है। केवल बीपी, ईबीपी, आरबीपी।
यह पसंद नहीं है - पुराने ढंग से ओब्ज "ऑब्जेक्ट डालें। संकलन मेस्म या कुछ और।
फिर जैसा लिखा होगा वैसा ही होगा।
ट्रुबो पास्कल और डेल्फी एक्सएनयूएमएक्स के दिनों में, मैंने किया। ओबीजे डाला।

वैसे, आप डिबग को अक्षम करके अभी भी देख सकते हैं।
बिना डिबगिंग के Shitf + Ctrl + F9 चलाएं।



Rouse_ ©   (2016-05-31 16:57) [19]


> विषय कोड के मामले में क्यों (भले ही यह काफी नहीं है
> सच), संकलक जोड़ा गया:
>

क्योंकि, बिंदुओं पर:

1.
शुरुआत में धक्का देना; मूव एबप, एस्प; और अंत में: पॉप ईबीपी; $ 0008 को फिर से बेचना;

यह एक स्टैक फ्रेम है, यह स्वचालित रूप से जोड़ा जाता है जब प्रक्रिया स्वयं स्टैक का उपयोग करती है (इनपुट मापदंडों के लिए स्थानीय चर के लिए)।

2.
$ 0008 को पुनःप्राप्त करें
FASTCALL समझौते के कारण स्टैक साफ हो गया है (विशेष रूप से, स्टैक के माध्यम से दूसरे पैरामीटर का स्थानांतरण समतल किया गया है)

3.
धक्का देना ebx; और अंत में: मूव एंक्स, ईबेक्स; पॉप ईबेक्स;
EBX ऑब्जेक्ट रजिस्टर जिसे सहेजने की आवश्यकता है, यह देखते हुए कि आप इसका उपयोग करते हैं, कंपाइलर आपको इंश्योर करता है



dmk ©   (2016-05-31 17:01) [20]

> यह देखते हुए कि आप इसका इस्तेमाल करते हैं, कंपाइलर आपको इंश्योर करता है

हम्म ... मैं एक नहीं है। सहेजा नहीं गया है, एवी या लटका हुआ है।
सेटिंग्स में कहीं?



SergP ©   (2016-05-31 17:03) [21]


>
> EBX ऑब्जेक्ट रजिस्टर को बचाया जा सकता है, यह देखते हुए
> आप इसका इस्तेमाल करते हैं, कंपाइलर आपको इंश्योर करता है


हां, मैंने इसका इस्तेमाल किया, लेकिन मैंने खुद ही इसे बचा लिया।
ठीक है, यहां तक ​​कि उसे मुझे इस तरह से बीमा करते हैं,
लेकिन मुझे उस फ़ंक्शन को खराब क्यों करना चाहिए जो फ़ंक्शन के अंत में मूव एक्सएक्सएक्स, ईबेक्स कमांड के साथ था?



Rouse_ ©   (2016-05-31 17:05) [22]


> dmk © (31.05.16 17: 01) [20]
quoted1 >> यह देखते हुए कि आप इसका उपयोग करते हैं, संकलक आपका बीमा करता है
>
> हम्म ... मेरे पास एक नहीं है। सहेजा नहीं गया है, एवी या लटका हुआ है।
>
> कहीं सेटिंग्स में?

HE10 पर Hmm, भी उत्पन्न नहीं हुआ था, लेकिन कल घर पर (HE4) एक ऐसा कोड था



Rouse_ ©   (2016-05-31 17:07) [23]


> सर्गप © (31.05.16 17: 03) [21]

जानबूझकर डाले गए निर्देश के लिए कोड जनरेशन एरर (जाहिरा तौर पर) से कई विकल्प हैं (आपको डॉक देखने की जरूरत है)



SergP ©   (2016-05-31 17:23) [24]


> Rouse_ © (31.05.16 17: 07) [23]
>
>
>> सर्ग © (31.05.16 17: 03) [21]
>
> कोड पीढ़ी की त्रुटियों (जाहिरा तौर पर) से कई विकल्प हैं
> जानबूझकर डाले गए निर्देशों (डॉक्स को देखा जाना चाहिए)


लेकिन आपके कोड [6] में यह सम्मिलित नहीं है ...

यह पता चला है कि जब मैंने एक्मे पर कुछ लिखा था, तो मुझे ब्रेकर को लगाने की आवश्यकता है, और सीपीयू-व्यू विंडो में हमेशा जांच लें कि कंपाइलर ने वहां घुमा दिया है, और अगर उसने मुझे ऐसा कोई उपहार दिया है, तो कोड को अलग तरीके से लिखें और फिर से जांच करें, और इसी तरह से जब तक इसके अतिरिक्त मेरे कोड के तर्क का विरोध नहीं करेंगे?



Rouse_ ©   (2016-05-31 17:24) [25]

यह संभावना है कि यह वास्तव में एक गलती है, अब मैंने अपने स्रोत कोड संशोधित किए हैं, मेरे पास वहां सभी प्रकार की सुरक्षा नेट योजनाएं हैं:

फ़ंक्शन GetSPAddrFromPEB (var लेन: पूर्णांक): सूचक; एएसएम {$ IFDEF WIN32} Mov edx, FS: [$ 30] Movzx ecx, शब्द ptr [edx + $ 1F0] मूव [ईईएन], ईएक्सएक्स Mov eax, [edx + $ 1F4] {$ ELSE} // Mov rdx, GS: [$ 60] // पुराने संस्करणों में कोड जेनरेशन सेगमेंट के साथ काम करने पर तैरता है // इसलिए हम सीधे opcodes लिखेंगे DB $ 65, $ 48, $ 8B, $ 14, $ 25, $ 60, $ 00, $ 00, 00 Movzx rax, शब्द ptr [rdx + $ 2E8] mov शब्द ptr [rcx], कुल्हाड़ी mov rax, [rdx + $ 2F0] {$ ENDIF} अंत;



Rouse_ ©   (2016-05-31 17:24) [26]


> सर्गप © (31.05.16 17: 23) [24]
> यह पता चला है कि जब मैंने एक्मे पर कुछ लिखा, उसके बाद मुझे करने की आवश्यकता है
> ब्रेक लगाएं, और सीपीयू-व्यू विंडो में हमेशा देखें कि क्या है
> संकलक ने मूर्ख बनाया, और अगर उसने मुझे ऐसा उपहार दिया,
> कोड को अलग से फिर से लिखें और दोबारा जांचें, और इसी तरह,
> जब तक इसके अतिरिक्त विरोधाभासी तर्क समाप्त नहीं हो जाते
> मेरा कोड काम?

बेशक, आपको हमेशा जांचने की आवश्यकता है - लेकिन और कैसे?



Rouse_ ©   (2016-05-31 17:27) [27]

एक और विकल्प है।
प्रक्रियाओं के रूप में अपने सभी एएसएम ब्लॉक को डिज़ाइन करें - फिर आपको क्लीन कोड मिलेगा - एक प्रस्तावना और उपसंहार के बिना - यह खुद को इस तरह के कार्यों की कॉल को नियंत्रित करने के लिए थकाऊ है।



Rouse_ ©   (2016-05-31 18:44) [28]


> dmk © (31.05.16 17: 01) [20]
quoted1 >> यह देखते हुए कि आप इसका उपयोग करते हैं, संकलक आपका बीमा करता है
>
> हम्म ... मेरे पास एक नहीं है। सहेजा नहीं गया है, एवी या लटका हुआ है।
>


हां, मैंने N4 के तहत डबल-चेक किया

// пролог
005B1FD4: 55                                         PUSH EBP
005B1FD5: 8B EC                                      MOV EBP, ESP
005B1FD7: 53                                         PUSH EBX

// тело функции
005B1FD8: 52                                         PUSH EDX
005B1FD9: 51                                         PUSH ECX
005B1FDA: 53                                         PUSH EBX
005B1FDB: 8B 4C 24 10                                MOV ECX, [ESP+0x10]
005B1FDF: 8B 5C 24 14                                MOV EBX, [ESP+0x14]
005B1FE3: 48                                         DEC EAX
005B1FE4: 3B 5A 04                                   CMP EBX, [EDX+0x4]
005B1FE7: 75 04                                      JNZ 0x5B1FED
005B1FE9: 3B 0A                                      CMP ECX, [EDX]
005B1FEB: 74 06                                      JZ 0x5B1FF3
005B1FED: 83 C2 16                                   ADD EDX, 0x16
005B1FF0: 48                                         DEC EAX
005B1FF1: 79 F1                                      JNS 0x5B1FE4
005B1FF3: 5B                                         POP EBX
005B1FF4: 59                                         POP ECX
005B1FF5: 5A                                         POP EDX

// эпилог
005B1FF6: 8B C3                                      MOV EAX, EBX << оть это весьма странно, видимо инициализация результата
005B1FF8: 5B                                         POP EBX
005B1FF9: 5D                                         POP EBP
005B1FFA: C2 08 00                                   RET 0x8


स्पष्ट रूप से एक कोड पीढ़ी वक्र है



Rouse_ ©   (2016-05-31 18:46) [29]

इस तथ्य को देखते हुए कि यह HE10 में नहीं देखा गया है, इसका मतलब है कि कोडकंट्रल पर एक बग रिपोर्ट थी और यह तय हो गई थी।



Pavia ©   (2016-05-31 23:20) [30]

1) पढ़ने में मदद करने वाले पैरामीटर।
पहले 3 पैरामीटर EAX, EDX और ECX के माध्यम से पारित किए जाते हैं, बाकी स्टैक के माध्यम से।

2)

> ईबीपी धक्का; // मैंने जो मांगा वह क्यों नहीं किया?

यह डीबगर के लिए है। ज़बरदस्ती ऐसे ही धक्के लगाता है
प्रक्रिया फू (); रजिस्टरों; इकट्ठा एएसएम अंत; रजिस्टरों के माध्यम से पैरामीटर पारित करना और शुरू करना हटा दें।


> मूव ईएक्सएक्स, ईबेक्स; // यह मेरा परिणाम क्यों खराब करता है?

यह आपको खराब नहीं करता है, लेकिन बाज।
परिणाम स्टैक पर एक स्थानीय चर है।
एक कंपाइलर विकसित करते समय, यह करना आसान होता है।


> और एक और सवाल: ऐसा लगता है कि आप इस तरह की चीजों के लिए कमांड का उपयोग कर सकते हैं
> लूप यदि यह 32-बिट रजिस्टर के साथ काम करता है।
>
> लेकिन इंटरनेट पर मौजूद जानकारी के अनुसार मैं नहीं समझ सकता: कौन सा
> रजिस्टर लूप कमांड का उपयोग करता है: CX या ECX?


निर्देश, उर्फ ​​लूप लूप, के कई कोड हैं। डिफ़ॉल्ट रूप से, डेल्फी में संकलक सेटिंग के आधार पर 32 बिट या 64 बिट है।
पुराने पास्कल में 16 बिट था।

16 के लिए - CX, 32, ECX के लिए

कोड को उपसर्ग को स्विच करने के लिए मजबूर किया जा सकता है।
आमतौर पर db 66h, लेकिन लूप db 67h के लिए

> पता आकार विशेषता का क्या मतलब है?

मुख्य दो उपसर्ग change_size_data और उपसर्ग change_size_address के कई उपसर्ग हैं
db 66h और db 67h


> JZ से JE और JNE से JE टीमों के बीच अंतर क्या है?

कुछ भी नहीं। लूप के बारे में याद रखें, यहां विपरीत मामला अलग है, कोड समान है।


> और दूसरा: LEA edx, [edx + step] इस मामले में तेज होगा?

यह वही है।


>?
> और भविष्य में कंपाइलर की ऐसी साज़िश का पूर्वानुमान कैसे लगाया जाए?

स्टैक फ्रेम बनाने के लिए एल्गोरिथ्म काफी जटिल है।

यह RTL पास्कल 7 से है जो 13 डिस्केट पर था।


*******************************************************
; *       *
; * MACROS      *
; *       *
; *******************************************************

LOCALS @@

; Public variable definition macro

VAR MACRO Symbol,SType,Count
 PUBLIC Symbol
 Symbol LABEL SType
 IF Count
   DB SType * Count DUP(?)
 ENDIF
ENDM

; Parameter definition macro

ARG MACRO Symbol,SType,Count
 LOCAL Offset
 @AP = @AP + SType * Count
 Offset = @AP
 Symbol EQU (SType PTR [BP+@AF-Offset])
ENDM

@AP = 0
@AF = 0

; Local variables definition macro

LOC MACRO Symbol,SType,Count
 LOCAL Offset
 @LP = @LP + SType * Count
 Offset = @LP
 Symbol EQU (SType PTR [BP+@LF-Offset])
ENDM

@LP = 0
@LF = 0

; Stack frame modifiers

sfFar  EQU 01H  ;FAR frame
sfMarkBP EQU 02H  ;Make saved BP odd
sfSaveDS EQU 04H  ;Save DS at [BP-2]
sfInitDS EQU 08H  ;Init DS using SS

; Default stack frame type

sfDefault = 0

; Stack frame types

   IF WindowsVersion
WINFAR  EQU sfFar+sfMarkBP+sfSaveDS
   ELSE
WINFAR  EQU sfFar
   ENDIF

; Entry code generation macro

ENTRY MACRO FrameType
 IFB <FrameType>
   @SF = sfDefault
 ELSE
   IFIDNI <FrameType>,<NEAR>
     @SF = 0
   ELSE
     IFIDNI <FrameType>,<FAR>
       @SF = sfFar
     ELSE
       @SF = FrameType
     ENDIF
   ENDIF
 ENDIF
 IF @SF AND sfMarkBP
   INC BP
 ENDIF
 PUSH BP
 MOV BP,SP
 IF @SF AND sfFar
   @AF = @AP + 6
 ELSE
   @AF = @AP + 4
 ENDIF
 IF @SF AND sfSaveDS
   PUSH DS
   @LF = -2
 ELSE
   @LF = 0
 ENDIF
 IF @LP
   SUB SP,@LP
 ENDIF
 IF @SF AND sfInitDS
   PUSH DS
   PUSH SS
   POP DS
 ENDIF
ENDM

; Exit code generation macro

EXIT MACRO ArgSize
 IF @SF AND sfInitDS
   POP DS
 ENDIF
 IF @LF - @LP
   MOV SP,BP
 ENDIF
 POP BP
 IF @SF AND sfMarkBP
   DEC BP
 ENDIF
 IFNB <ArgSize>
   @AP = ArgSize
 ENDIF
 IF @SF AND sfFar
   RETF @AP
 ELSE
   RETN @AP
 ENDIF
 @AP = 0
 @LP = 0
ENDM



Rouse_ ©   (2016-05-31 23:46) [31]

उम्म्म्म…
पाविया, क्या आप जानते हैं कि सिद्धांत अभ्यास से कैसे भिन्न होता है? :)

पुनश्च: और इसलिए सिद्धांत रूप में ... ठीक है, आपने कोशिश की :)



Pavia ©   (2016-06-01 08:53) [32]


> पाविया, क्या आप जानते हैं कि सिद्धांत अभ्यास से कैसे भिन्न होता है? :)

मुझे पता है

कल ही मुझे याद नहीं आया कि आवश्यक सिद्धांत कहाँ है। आज मुझे याद आया।
पूर्ण सिद्धांत कागज उपयोगकर्ता मैनुअल में निहित है, मदद में नहीं।


> हां, मैंने इसका इस्तेमाल किया, लेकिन मैंने खुद ही इसे बचा लिया।
>
> ठीक है, यहां तक ​​कि मुझे इस तरह से उसका बीमा करने दें,
> लेकिन मुझे फ़ंक्शन के अंत में परिणाम क्यों खराब करना चाहिए, जो
> eax में था, कमांड mov eax, ebx?

हां यह कंपाइलर का एक जांबाज है। लेकिन प्रोग्रामर कोई कम दोषी नहीं है।

विधानसभा प्रक्रियाओं और कार्यों


> जब तक कोई फ़ंक्शन स्ट्रिंग, वैरिएंट या इंटरफ़ेस नहीं देता है
> संदर्भ, संकलक एक फ़ंक्शन परिणाम आवंटित नहीं करता है
> चर; @Result प्रतीक का एक संदर्भ एक त्रुटि है।
> तार, विकल्प और इंटरफेस के लिए, कॉलर हमेशा
> एक @ संकेत सूचक आवंटित करता है।
>


जब तक आप टेक्स्ट में @Result नहीं लिखते, तब तक कंपाइलर को लगता है कि यह नहीं है।
सिद्धांत रूप में, उसे मूव एंक्स, एबक्स को फेंकना चाहिए था। लेकिन उसने इसे दूर नहीं फेंका।

इसलिए Mov @ Result, eax लिखें और सब कुछ टॉप टाइप होगा।



Pavia ©   (2016-06-01 09:03) [33]

अब मैं अपना कोड जनरेटर कर रहा हूं। तो कोई सिद्धांत नहीं है! यह स्पष्ट नहीं है कि इसकी सटीकता की गारंटी कैसे दी जाए।
अब तक मैंने निम्नलिखित पर ध्यान केंद्रित किया है कि मैं एक विशेष मामला लिख ​​रहा हूं, फिर मैं सामान्य लोगों के लिए सामान्यीकरण करूंगा। और परीक्षण के बाद। लेकिन जैसा कि आप जानते हैं, परीक्षण यह गारंटी नहीं देता है कि कोई त्रुटि नहीं होगी। विशेष रूप से एक अज्ञात आउटपुट फ़ंक्शन के साथ यहां।



Rouse_ ©   (2016-06-01 10:36) [34]

फिर भी, आपके पास गलत निष्कर्ष है, लगभग सब कुछ।
मुझे नहीं पता कि आप इस तरह के दस्तावेज़ कहाँ पढ़ते हैं


> पहले 3 मापदंडों को EAX, EDX और ECX के माध्यम से पारित किया जाता है, बाकी
> ढेर के माध्यम से।

यह सच नहीं है यदि पैरामीटर रजिस्टर में फिट नहीं होता है तो यह स्टैक के माध्यम से जबरन चला जाता है


> डिबगर के लिए यह आवश्यक है।

सच नहीं है। यह डिबगर के लिए पूरी तरह से वायलेट है, और प्रोग्राम डिबगर के बिना सही ढंग से काम करता है। यह स्थानीय चर और मापदंडों के लिए आवश्यक है।


> जबरन बंद कर दिया जाए
> प्रक्रिया फू (); रजिस्टरों;
> इकट्ठा
> अस्म
> अंत;


सच नहीं है।

प्रक्रिया फू (); रजिस्टर; कोडांतरक; वर Tst: DWORD; एएसएम मूव एक्सएक्सएक्स, एक्सएनयूएमएक्स मूव टीएसटी, ईएक्सएक्स अंत;

यह निम्नलिखित कोड का उत्पादन करेगा:
004184AC: 55 PUSH EBP 004184AD: 8B EC MOV EBP, ESP 004184AF: 51 PUSH ECX 004184B0: B8 0A 00 00 00 MOV EAX, 0xA 004184B5: 89 45 FC MOV [EBP-0x4], EAX 004184B8: 59 POP ECX 004184B9: 5D POP EBP 004184BA: C3 RET


> यह आपको खराब नहीं करता है, लेकिन बाज।
> परिणाम स्टैक पर एक स्थानीय चर है।

सच नहीं है, इस मामले में परिणाम बिल्कुल EAX है, और स्टैक पर किसी प्रकार का चर नहीं है (स्टैक का क्या करना है)


> उपसर्ग को स्विच करने के लिए कोड को मजबूर किया जा सकता है।
> आमतौर पर db 66h, लेकिन लूप db 67h के लिए


सच नहीं है, उपसर्ग 0х66 तथाकथित OperandSizeOverride का उपयोग निर्देश को संशोधित करने के लिए किया जाता है (insw-> insd / iret-> iretd, आदि) और रजिस्टरों को संशोधित करने के लिए उपसर्ग AddressSizeOverride = $ 67 का उपयोग किया जाता है

यहाँ उपसर्गों की पूरी सूची दी गई है:

// सेवा उपसर्ग // "2.2। संस्मरण के सारांश देखें" // ==================================================== ============================= टाइप TPrefixData = रिकॉर्ड मूल्य: पूर्णांक; विवरण: स्ट्रिंग; अंत; स्थिरांक // लॉक और दोहराएं उपसर्ग: pfxLock = $ F0; // LOCK उपसर्ग केवल निम्नलिखित निर्देशों के लिए और केवल उन्हीं रूपों के लिए लगाया जा सकता है // उन निर्देशों का जहां गंतव्य ऑपरेंड एक मेमोरी ऑपरैंड है: ADD, ADC, और, // BTC, BTR, BTS, CMPXCHG, CMPXCH8B, DEC, INC, NEG, NOT, OR, SBB, SUB, XOR // XADD, और XCHG pfxRepn = $ F2; pfxRep = $ F3; // सेगमेंट ओवरराइड उपसर्ग: pfxCSSegmentOverride = $ 2E; pfxSSSegmentOverride = $ 36; pfxDSSegmentOverride = $ 3E; pfxESSegmentOverride = $ 26; pfxFSSegmentOverride = $ 64; pfxGSSegmentOverride = $ 65; // ऑपरेंड-आकार ओवरराइड उपसर्ग // (जब भागने के साथ प्रयोग किया जाता है opcode 0FH, यह // कुछ SIMD निर्देशों के लिए एक अनिवार्य उपसर्ग के रूप में माना जाता है) pfxOperandSizeOverride = $ 66; pfxEscapeOpcode = $ 0F; // पता-आकार उपसर्ग ओवरराइड करें pfxAddressSizeOverride = $ 67; pfxFPU_BFHTRange = $ BF; pfxFPUOpcodeRange = [$ D8 .. $ DF]; उपसर्ग: सरणी [] TPrefixData = [0..8] ( (मान: pfxLock; विवरण: "लॉक"), (मान: pfxRepn; विवरण: "repn"), (मान: pfxRep; विवरण: "प्रतिनिधि"), (मान: pfxCSSegmentOverride; विवरण: "सीएस:"), (मान: pfxSSSegmentOverride; विवरण: "ss:"), (मान: pfxDSSegmentOverride; विवरण: "ds:"), (मान: pfxESSegmentOverride; विवरण: "es:"), (मान: pfxFSSegmentOverride; विवरण: "fs:"), (मान: pfxGSSegmentOverride; विवरण: "gs:") );


> स्टैक फ्रेम बनाने के लिए एल्गोरिथ्म काफी जटिल है।

सच नहीं है - स्टैक फ्रेम का आकार उपयोग किए गए स्थानीय चर के कुल आकार के बराबर है और पैरामीटर स्टैक से गुजरता है। इस बारे में कुछ भी रहस्य या जटिल नहीं है।


> तो Mov @ Result, eax लिखें और सब कुछ टॉप टाइप हो जाएगा।

और आपको एक अद्भुत लेकिन संवेदनहीन आउटपुट मिलता है
MOV EAX, EAX

कुछ इस तरह संक्षेप में।



Игорь Шевченко ©   (2016-06-01 12:05) [35]

http://www.lib.ru/LITRA/CHEHOW/r_letter.txt



SergP ©   (2016-06-01 15:01) [36]


> निर्देश, उर्फ ​​लूप लूप, कई कोड हैं।
> डिफ़ॉल्ट रूप से, डेल्फी में 32 बिट या 64 बिट निर्भर करता है
> संकलक सेटिंग से।
> पुराने पास्कल में 16 बिट था।
>
> 16 के लिए - CX, 32, ECX के लिए
>
> उपसर्ग को स्विच करने के लिए कोड को मजबूर किया जा सकता है।
> आमतौर पर db 66h, लेकिन लूप db 67h के लिए


तो क्या यह उपसर्ग केवल अगले लूप कमांड पर कार्य करता है या यह विश्व स्तर पर स्विच करता है?
और db के माध्यम से क्यों? क्या वह एक अलग mnemonics के साथ आना भूल गई?



Rouse_ ©   (2016-06-01 15:27) [37]


>
> तो यह उपसर्ग केवल अगले आदेश पर कार्य करता है
> लूप या स्विच विश्व स्तर पर?

हां, यह निर्देश का पालन करने के लिए एक उपसर्ग है, इसके डिफ़ॉल्ट व्यवहार को संशोधित करता है


> और क्यों db के माध्यम से? क्या वह एक अलग mnemonics के साथ आना भूल गई?

शायद वहाँ है, लेकिन मुझे पता नहीं है। (शायद कुछ धागे "लघु लूप" या कुछ और)



Pavia ©   (2016-06-01 16:18) [38]


> तो यह उपसर्ग केवल अगले आदेश पर कार्य करता है
> लूप या स्विच विश्व स्तर पर?
> और क्यों db के माध्यम से? क्या वह एक अलग mnemonics के साथ आना भूल गई?
>

हाँ, केवल अगले एक। सांत्वना के लिए, उन्होंने एक अलग से नहीं शुरू किया। पीटीआर या प्रत्यय डी आमतौर पर उपयोग किया जाता है, लेकिन लूप एक अपवाद है। इंटेल ने वास्तव में वर्णन नहीं किया। अब वे बोर्डेलियन शैली का पालन करने लगते हैं। लेकिन प्रत्येक कंपाइलर के लिए अलग से पता लगाना आवश्यक है।


> 80386 प्रोसेसर के लिए लूप निर्देश या तो कर सकते हैं
> गिनती के रूप में सीएक्स या ईसीएक्स का उपयोग करें
> रजिस्टर करें। मानक LOOP, LOOPE, LOOPZ, LOOPNE, और LOOPNZ
> मांसाहार
> इंटेल से कि क्या के आधार पर गिनती रजिस्टर का चयन करें
> वर्तमान कोड सेगमेंट एक 32-bit सेगमेंट है (उपयोग करते समय
> ECX) या 16- बिट सेगमेंट (जब CX का उपयोग कर रहे हों)।
> टर्बो असेंबलर के विशेष निर्देश हैं जो वृद्धि करते हैं
> LOOP का लचीलापन
> सुविधा। LOOPW, LOOPWE, LOOPWZ, LOOPWNE, और LOOPWNZ
> निर्देश
> आकार की परवाह किए बिना, गिनती रजिस्टर के रूप में सीएक्स का उपयोग करें
> वर्तमान खंड का। इसी तरह, LOOPD, LOOPDE, LOOPDZ,
> LOOPDNE, और LOOPDNZ निर्देश गिनती के रूप में ECX का उपयोग करते हैं
> रजिस्टर करें



Pavia ©   (2016-06-01 16:41) [39]


Quott1 >> डीबगर के लिए यह आवश्यक है।
>
> सच नहीं है। यह डिबगर और प्रोग्राम के लिए विशुद्ध रूप से वायलेट है
> यह डिबगर के बिना सही तरीके से कैसे काम करता है। यह स्थानीय के लिए आवश्यक है
> चर और पैरामीटर।

डीबगर की परवाह करता है! स्क्रीनशॉट देखें। XE5 सेटिंग्स मानक हैं।
http://s33.postimg.org/p7tfcr7jj/image.png



Rouse_ ©   (2016-06-01 16:59) [40]


> पाविया © (01.06.16 16: 41) [39]

खैर, ये संकलक सेटिंग्स हैं, डिबगर नहीं :)



Pavia ©   (2016-06-01 16:59) [41]


Quoted1 >> कोड को उपसर्ग को स्विच करने के लिए मजबूर किया जा सकता है।
>> आमतौर पर db 66h, लेकिन लूप db 67h के लिए
>
>
> सच नहीं है, उपसर्ग 0х66 तथाकथित OperandSizeOverride का उपयोग किया जाता है
> निर्देश को संशोधित करने के लिए (insw-> insd / iret-> iretd, आदि।
>) और रजिस्टरों को संशोधित करने के लिए, AddressSizeOverride उपसर्ग का उपयोग किया जाता है
> = $ 67

यहाँ आप गलत हैं। मन को देखो। लूप स्ट्रिंग निर्देशों के समूह के अंतर्गत आता है। इसलिए, उसके लिए, अन्य निर्देशों की तरह नहीं।
देखें मन:
https://docviewer.yandex.ru/?url=ya-disk-public%3A%2F%2Fks8F6OS9JWdJWsURii23TBL%2F3QETut6hh5lPpMKMQfE%3D&name=253666.pdf&page=644&c=574ee91d863a

IF (AddressSize = 32) जब गणना ईसीएक्स है; Else if (AddressSize = 64) गणना RCX है; ELSE काउंट CX है; FI;



Rouse_ ©   (2016-06-01 17:08) [42]


> इसलिए, उसके लिए, अन्य निर्देशों की तरह नहीं।

मुझे कुछ समझ में नहीं आया, आप कहना चाहते हैं कि अन्य निर्देशों के लिए 0x67 उपसर्ग का उपयोग नहीं किया गया है, केवल LOOP के लिए? :)



Pavia ©   (2016-06-01 17:15) [43]


> मुझे कुछ समझ में नहीं आया, आप अन्य निर्देशों के लिए कहना चाहते हैं
> 0x67 उपसर्ग का उपयोग नहीं किया जाता है, केवल LOOP के लिए? :)

मैं कहना चाहता हूं कि लूप में "ईसीएक्स एक रजिस्टर नहीं है, लेकिन एक पता है!
इसलिए, db 66h के बजाय, आपको db 67h का उपयोग करना चाहिए।

सामान्य निर्देश:
"पॉप cx"
"popd ecx" = "db 66h पॉप cx"

आवर्धक पर
"लूप cx"
"लूप्ड इक्सेक्स" = "डीबी एक्सएनयूएमएक्सएच लूप सीएक्स"



Rouse_ ©   (2016-06-01 17:30) [44]


>
> मैं कहना चाहता हूं कि लूप "और ईसीएक्स एक रजिस्टर नहीं है, बल्कि एक पता है!
>

नहीं, वहां सब कुछ थोड़ा अलग तरीके से काम करता है, एक्सएनयूएमएक्स इंगित करता है कि आपको सीएक्स रजिस्टर के साथ जांच करने की आवश्यकता है, और एक्सएनयूएमएक्स इंगित करता है कि संक्रमण गणना किए गए पते के निचले हिस्से में जाएगा, उदाहरण के लिए:

66E2E5 लूप $ 005b1fe4

यहां छलांग पता 005b1fe4 पर नहीं बल्कि पता 0000 से होगी1fe4



SergP ©   (2016-06-02 13:07) [45]


> क्योंकि, अंकों से:
>
> 1।
>
> शुरुआत में
> ईबीपी धक्का;
> मूव एबप, एस्प;
>
> और अंत में:
>
> पॉप ईबीपी;
> $ $ 0008;
>
>
> यह एक स्टैक फ्रेम है, इसका उपयोग करते समय स्वचालित रूप से जोड़ा जाता है
> स्वयं स्टैक की प्रक्रिया (स्थानीय चर के लिए, इनपुट के लिए)
> पैरामीटर)।
>
> 2।
>
> $ 0008 को पुनःप्राप्त करें
>
> FASTCALL समझौते के कारण स्टैक को साफ किया जा रहा है (विशेष रूप से, इसे समतल किया गया है
> स्टैक के माध्यम से दूसरा पैरामीटर पास करना)
>
> 3।
>
> धक्कामुक्की;
> और अंत में:
> मूव ईएक्सएक्स, ईबेक्स;
> पॉप ईबेक्स;
>
> EBX ऑब्जेक्ट रजिस्टर को बचाया जा सकता है, यह देखते हुए
> आप इसका इस्तेमाल करते हैं, कंपाइलर आपको इंश्योर करता है
>


फिर, कंपाइलर मुझे इंश्योरेंस क्यों नहीं कराना चाहता है, और कोई पहल नहीं करता है?

प्रक्रिया बड़बड़ाना; एएसएम मूव एबप एक्क्स मूव एबक्स, एडक्स अंत;

यह बकवास संकलित है:
मूव एबप एक्क्स मूव एबक्स, एडक्स गीला करना
और कुछ नहीं।



Rouse_ ©   (2016-06-02 13:19) [46]

खैर, ऐसे संकलक :)



DayGaykin ©   (2016-06-02 13:26) [47]

और क्या आप संक्षेप में कह सकते हैं कि जब से यह विषय सामने आया है, तब आपको किन अन्य रजिस्टरों को रखने की आवश्यकता है? और 64 बिट्स में।



Rouse_ ©   (2016-06-02 15:44) [48]


> DayGaykin © (02.06.16 13: 26) [47]
> और आप संक्षेप में कह सकते हैं, जब से विषय आया है, अन्य रजिस्टरों की क्या आवश्यकता है
> बचाओ? और 64 बिट्स में।

32: EBX, EPB, ESP, EDI, ESI
64: RBX, RBP, RSP, RDI, RSI, R12-RXBUMX



SergP ©   (2016-06-02 16:15) [49]

मज़े के लिए, मैंने इस तरह के एक समारोह को लिखने की कोशिश की:

फ़ंक्शन बीटीसी (var संख्या: int64): बाइट; एएसएम धक्का देना मूव एक्क्स, [ईईएक्स] mov al, -2 कॉल करें @ कॉन्टिन्यू पॉप mov ecx, [ecx + 4] @continue: lea edx, [ecx-1] inc al या ecx, edx jnz @continue अंत;

कंपाइलर ने इस बार कुछ नहीं जोड़ा।
स्टैक पर कुछ भी पारित नहीं किया जाता है। इसलिए, अंत में, कंपाइलर सिर्फ रिट डालता है

लेकिन किसी कारण से यह बात लटक गई। और डिबगर के तहत भी कॉल @ कॉन्टिन्यू पर लटका हुआ है
क्यों?



SergP ©   (2016-06-02 16:28) [50]

हम्म। पहले से ही जहां मैं बेवकूफ पाया



dmk ©   (2016-06-02 20:10) [51]

jmp @@ जारी रखें

@@ जारी रखें:



SergP ©   (2016-06-02 21:08) [52]


> dmk © (02.06.16 20: 10) [51]
>
> jmp @@ जारी रखें
>
> @@ जारी रखें:


मत करो। कॉल @ कॉन्टिन्यू - यह तो कल्पना की गई थी।
यह बस एक अंतहीन लूप पर चला गया, और डिबगर जाहिरा तौर पर कदम से कदम कॉल के ठीक पहले कमांड निष्पादन के परिणाम दिखाता है। और कॉल के साथ, ऐसा लगता है जैसे वह पूरे सबरूटिन को एक कदम के रूप में गिना जाता है जब तक कि रिट नहीं हो जाता

मैंने इसे फिर से लिखा है:
// 64-बिट संख्या में इकाई बिट्स की संख्या की गणना, मामलों के लिए // जब उनकी औसत संख्या कम होती है। फ़ंक्शन बीटीसी (var संख्या: int64): बाइट; एएसएम धक्का देना मूव एक्क्स, [ईईएक्स] xor eax, eax @cnt32 पर कॉल करें पॉप mov ecx, [ecx + 4] @cnt32: या ecx, ecx jz @exit @continue: inc eax lea edx, [ecx-1] और ecx, edx jnz @continue @exit: अंत;

अब यह काम करता है।



dmk ©   (2016-06-02 23:12) [53]

हम्म, क्या ऐसा सोचना आसान नहीं है?
आपको ऐसे चक्र की आवश्यकता क्यों है?

फ़ंक्शन न्यूबिट्स (v: int64): int64;
एएसएम
popcnt रक्स, वी
अंत;

प्रक्रिया TForm3.ButtonClick (प्रेषक: TObject);
था
v: int64;
bc: int64;

शुरू करना
v: = 48756000; // बिट्स की संख्या
bc: = NumBits (v);
ShowMessage ("संख्या में बिट्स की संख्या" + IntToStr (v) + "=" + IntToStr (bc));
अंत;



SergP ©   (2016-06-03 03:52) [54]


> dmk © (02.06.16 23: 12) [53]
>
> आपको ऐसे चक्र की आवश्यकता क्यों है?
>


1। [52] में सिर्फ यह दिलचस्प था कि कंपाइलर अपनी पूंछ की कार्यप्रणाली के कार्य पर कैसे प्रतिक्रिया देगा। यद्यपि आप इसके बिना (और भी तेज हो सकते हैं) कर सकते हैं।
2। [52] विधि सबसे अच्छे से दूर है, लेकिन यह उन मामलों में बहुत बुरा नहीं है जब आपको बड़ी मात्रा में डेटा संसाधित करना पड़ता है, जहां यह पहले से ज्ञात है कि संख्या में यूनिट बिट्स की औसत संख्या बड़ी नहीं है। उदाहरण के लिए 5-8।
3.

> हम्म, लेकिन ऐसा सोचना आसान नहीं है?
> फ़ंक्शन न्यूबिट्स (v: int64): int64;
> अस्म
> पॉपकान रक्स, वी
> अंत;


और अगर अचानक प्रोसेसर SSE4 का समर्थन नहीं करता है तो ऐसा फ़ंक्शन कैसे काम करेगा?



dmk ©   (2016-06-03 12:47) [55]

अधिभार लेबल वाले फ़ंक्शन चर लिखें। प्रारंभिक करते समय, समर्थन की जांच करें और वांछित चर लोड करें। आपका पुराना या SSE4.2

टाइप करें TNumBits = function (v: uint64): बाइट;

था
NumBits: TNumBits;

// Bit20 1 का एक मान बताता है कि प्रोसेसर SSE4.2 का समर्थन करता है
फ़ंक्शन CPU_SupportSSE42: बूलियन;
एएसएम
Mov रक्स, $ 01
सीपीयूआईडी
xor rax, rax // परिणाम: = गलत
एक्स्टेक्स, 00100000h // 20 बिट का परीक्षण करें
jz @NOSSE42
inc rax // परिणाम: = सत्य
@NOSSE42:
अंत;

SSE42 लंबे समय से है। अधिकांश आधुनिक प्रोसेसर इस सेट का समर्थन करते हैं। Core2DUO, Core2QUAD से शुरू होने वाली इंटेल; AMD केवल Buldozer FX के साथ शुरू होता है।



Rouse_ ©   (2016-06-03 13:06) [56]


> dmk © (03.06.16 12: 47) [55]

तो यह है:
फ़ंक्शन CPU_SupportSSE42: बूलियन; एएसएम मूव एक्सएक्सएक्स, एक्सएनयूएमएक्स सीपीयूआईडी एक्जाम, 1h का परीक्षण करें सेटेन अल अंत;



dmk ©   (2016-06-03 13:44) [57]

यह इस तरह निकला:

फ़ंक्शन NumBitsX86 (v: uint64): बाइट; एएसएम मूव्ड आरएक्सएक्स, वी bswap rdx Mov rxx, 64 xor रैक्स, रैक्स @@ एनबी: xor r8b, r8b shld r8, rdx, 1 shl rdx, 1 अल जोड़ें, r8b dec rcx jnz @@ एनबी अंत; फ़ंक्शन NumBitsSSE42 (v: uint64): बाइट; एएसएम popcnt रक्स, वी अंत; प्रारंभ यदि CPU_SupportSSE42 है NumBits: = NumBitsSSE42 और NumBits: = NumBitsX86;



dmk ©   (2016-06-03 13:44) [58]

Rouse_ © (03.06.16 13: 06) [56]

धन्यवाद! हम जानेंगे;)



SergP ©   (2016-06-03 13:49) [59]

वैसे, डेल्फी के किस संस्करण में इनलाइन असेंबलर SSE4.2 mnemonics का समर्थन करता है?



dmk ©   (2016-06-03 13:53) [60]

> सर्गप © (03.06.16 13: 49) [59]
डेल्फी 2010 और XE SSE4.2 अनुदेश सेट का समर्थन करते हैं



dmk ©   (2016-06-03 13:59) [61]

Rouse_ © (03.06.16 13: 06) [56]
SintaxHighlighter का उपयोग कैसे करें? मैं किसी भी तरह से समझ में नहीं आता)



NoUser ©   (2016-06-03 15:08) [62]

> dmk © (03.06.16 13: 59) [61]
बटन "डी"))

Rouse_, चूंकि ऐसी बू आ रही थी, हमें CALL से पहले स्टैक के संरेखण के बारे में बताएं -
यह कैसे सही है, यह आवश्यक है / आवश्यक नहीं है, रजिस्टर मापदंडों के लिए आरक्षित करने के लिए कितना महत्वपूर्ण है, तुरंत 20h या?
धन्यवाद.



Rouse_ ©   (2016-06-03 15:23) [63]


> NoUser © (03.06.16 15: 08) [62]

64 बिट्स में, स्टैक को 16 बाइट सीमा के साथ संरेखित किया जाना चाहिए, स्टैक को अतिरिक्त 4 64-बिट मापदंडों के लिए आरक्षित होना चाहिए (भले ही यह आवश्यक न हो - यह प्रलेखन में लिखा गया है)


> कॉलिंग फ़ंक्शन के लिए स्थान आवंटित करने के लिए जिम्मेदार है
> कहा समारोह के मापदंडों और हमेशा पर्याप्त प्रकाश डाला जाना चाहिए
> 4 मापदंडों के लिए स्थान, भले ही कहा जाता है
> इतने सारे पैरामीटर नहीं हैं। यह सरल बनाने में मदद करता है
> प्रोटोटाइप के बिना कार्यों के लिए समर्थन और एक चर के साथ कार्य करता है
> तर्कों की संख्या (vararg) C / C ++। एक चर के साथ कार्यों के लिए
> प्रोटोटाइप के बिना कोई तर्क या कार्य
> फ़्लोट मान संगत में डुप्लिकेट होना चाहिए
> सामान्य प्रयोजन रजिस्टर। निम्नलिखित किसी भी पैरामीटर
> पहले 4, कॉल को बैकअप पर स्टैक पर संग्रहीत किया जाना चाहिए
> पहले चार के लिए भंडारण। चर के साथ समारोह विवरण
> तर्कों की संख्या कार्य अनुभाग में प्रस्तुत की गई है
> तर्क (चर) की चर संख्या। के बारे में जानकारी
> प्रोटोटाइप के बिना फ़ंक्शन बिना अनुभाग कार्य में प्रस्तुत किए जाते हैं
> प्रोटोटाइप।
> संरेखण
>
> अधिकांश संरचनाएं प्राकृतिक संरेखण द्वारा संरेखित की जाती हैं।
> मुख्य अपवाद स्टैक पॉइंटर्स और फ़ंक्शंस हैं
> मॉलोक या एलोका मेमोरी आवंटन जो संरेखित हैं
> प्रदर्शन को बनाए रखने के लिए 16 बाइट्स पर। संरेखण
> ऊपर 16 बाइट्स को मैन्युअल रूप से निष्पादित किया जाना चाहिए, लेकिन 16 के साथ शुरू करना
> बाइट्स सामान्य आकार संरेखण संचालन के लिए किया जाता है
> एक्सएमएम, जो अधिकांश कोड के लिए पर्याप्त होना चाहिए। अतिरिक्त
> संरचना और संरेखण जानकारी के लिए, प्रकार देखें और
> भंडारण। स्टैक के बारे में अधिक जानकारी के लिए, देखें
> स्टैक का उपयोग करना।



SergP ©   (2016-06-03 16:08) [64]

खैर, फिर कुछ और सवाल:
यदि, उदाहरण के लिए, मैं पूरी तरह से कोडांतरक में प्रक्रिया / कार्य को फिर से लिखना चाहता हूं:
1। वैश्विक चर के साथ कैसे काम करें?
2। यदि किसी परिणाम के लिए यह एक रिकॉर्ड है, तो किसी फ़ंक्शन को कैसे लौटना चाहिए?
3। अगर मुझे स्थानीय चर के लिए मेमोरी की आवश्यकता है: कैसे करना सबसे अच्छा है:
सेकंड सेकंड में चर का वर्णन न करें, लेकिन वांछित मान से स्टैक पॉइंटर को कम करें, मेमोरी के इस टुकड़े का उपयोग करें, और बाहर निकलने से पहले स्टैक पॉइंटर को अपनी मूल स्थिति में लौटाएं? या कुछ और?
4। अगर मेरे पास WinXP है, तो मैं 64-बिट RON (rax, rbx ....) का उपयोग नहीं कर सकता हूं?



dmk ©   (2016-06-03 16:36) [65]

1। mov rax, GlobalVar
2.
TSomeType = रिकॉर्ड निजी सार्वजनिक समारोह InRangeX (x: पूर्णांक): बूलियन; अंत;

3। इसे पसंद करें।
4। आप कर सकते हैं, केवल आपको अपने मापदंडों को स्थानांतरित करने की आवश्यकता है। उदाहरण के लिए, एक सूचक के माध्यम से।



Rouse_ ©   (2016-06-03 16:40) [66]


> वैश्विक चर के साथ कैसे काम करें?

हमेशा की तरह। इसके बजाय:
MyGlobalVar: = 123
लिखना
lea eax, MyGlobalVar mov [eax], 123


> यदि परिणाम उदाहरण के लिए है, तो किसी फ़ंक्शन को कैसे लौटना चाहिए
> रिकॉर्ड?

संरचनाओं को संदर्भ द्वारा वापस किया जाता है


> 3। अगर मुझे स्थानीय चर के लिए मेमोरी की आवश्यकता है:

बेहतर उन्हें वर्जन सेक्शन में घोषित करें, कंपाइलर मेमोरी एलोकेशन के लिए कोड जोड़ेगा


> 4। अगर मेरे पास WinXP है, तो 64-bit RON (rax) का उपयोग करें,
> आरबीएक्स ....) मैं नहीं कर सकता?

RAX रजिस्टर आदि। आप केवल 64 बिट कोड में, क्रमशः, केवल 64 बिट OS के तहत उपयोग कर सकते हैं



dmk ©   (2016-06-03 18:26) [67]

> RAX रजिस्टर आदि। आप क्रमशः 64 बिट कोड में ही उपयोग कर सकते हैं
> केवल 64 बिट OS के अंतर्गत

अजीब बात है, mmx यह 64 बिट्स पर लागू नहीं होता है? D7 में, पहले बाइट कोड थे। 32 बिट कोड में उपयोग किया जाता है।



Rouse_ ©   (2016-06-03 19:41) [68]

ये अलग चीजें हैं।



SergP ©   (2016-06-04 09:56) [69]


उदाहरण के लिए, फ़ंक्शन को परिणाम कैसे लौटाया जाना चाहिए?
> यह
>> रिकॉर्ड?
>
> संरचनाओं को संदर्भ द्वारा लौटाया जाता है


और इस व्यवसाय के लिए मेमोरी कहाँ आवंटित की गई है? और कौन उसे बाहर खड़ा करता है?
फ़ंक्शन या कॉलिंग प्रक्रिया / फ़ंक्शन को कहा जाता है?
यानी यह लिंक किसके पास है?



Игорь Шевченко ©   (2016-06-04 10:35) [70]

SergP © (03.06.16 16: 08) [64]


> अच्छा, फिर कुछ और सवाल:


आपके लिए उनसे पूछना जल्दबाजी होगी। मैटरियल को मंचों पर पढ़ाया जाना चाहिए न कि।



Inovet ©   (2016-06-04 12:10) [71]

> [64] सर्ग © (03.06.16 16: 08)

एएसएम पर एक प्रयोग करें और मुख्य मॉड्यूल पर क्लिक करें - इससे प्रश्न कम हो जाएंगे।



Inovet ©   (2016-06-04 12:12) [72]

यह सही है। इसे स्वयं करें।



SergP ©   (2016-06-04 13:25) [73]


> इनोवेट © (04.06.16 12: 12) [72]
>
> यह सही है। इसे स्वयं करें।


किन हितों के साथ मैं पहले ही समझ गया था।

लेकिन आपको बस सीपीयू-व्यू विंडो में कोड को समझना होगा, और वहां पठनीयता कम है, नेविगेशन असहज है, और सबसे बड़ी समस्या यह है कि आप यह सब एक पाठ फ़ाइल में डंप नहीं कर सकते हैं।

खैर, और इसके अलावा फ्रैंक प्रलाप से भरा है। बेशक, जब आप संकलक के दृष्टिकोण से सोचने की कोशिश करते हैं, तो यह स्पष्ट प्रतीत होता है कि उसने ऐसा क्यों किया। लेकिन आदमी के दृष्टिकोण से, यह बकवास है ...

उदाहरण के लिए, संकलक के मोती में से एक है:
... यदि (संख्या और 1) <> 0 तो मूव ऐक्स, [एबप + $ एक्सएनयूएमएक्स] Mov edx, [ebp + $ 08c] और ईएक्सएक्स, $ एक्सएनयूएमएक्स xor edx, edx cmp edx, $ 0 jnz + $ 00000001 cmp eax, $ 00 jz + $ 03



Inovet ©   (2016-06-04 18:59) [74]

> [73] सर्ग © (04.06.16 13: 25)
> और सबसे बड़ी समस्या यह है कि इसे रीसेट करना असंभव है
> एक पाठ फ़ाइल के लिए।

ऐसा करने के लिए, असंतुष्टों की तरह रिवर्स इंजीनियरिंग टुकड़े हैं।



Inovet ©   (2016-06-04 19:15) [75]

> [73] सर्ग © (04.06.16 13: 25)
> यहाँ, उदाहरण के लिए, संकलक के मोती:

खैर, क्या यह डिबग असेंबली में हो सकता है?



Inovet ©   (2016-06-04 19:18) [76]

> [74] इनवेट © (04.06.16 18: 59)
> रिवर्स इंजीनियरिंग

हां, बस मामले में, सी में एक संकलक विकल्प है, जब आप इसे चालू करते हैं, तो संकलक पहले पाठ एएफएम में उत्पन्न होता है, फिर एम्स पहले से ही संकलन करता है।



Inovet ©   (2016-06-05 00:28) [77]

Rozych, क्या आप वास्तव में "कूद" शब्द से संक्रमित हैं? खैर, यह रूसी अफवाह के लिए बुरा लगता है। एक सामान्य शब्द है "संक्रमण"। लीप, मिलन। शायद मैं संबंधित विषयगत मंचों पर नहीं जाता, लेकिन मैं निंदा करता हूं। क्या उछाल है।

मैं आपकी ग्रामर नाजी की सदस्यता लूंगा। चलो इतने गूंगे अनुरेखण कागज का उपयोग नहीं करते हैं।



Германн ©   (2016-06-05 01:37) [78]


> इगोर शेवचेंको © (04.06.16 10: 35) [70]
>
> सर्गप © (03.06.16 16: 08) [64]
>
>
Quoted1 >> खैर, फिर कुछ और सवाल:
>
>
> आपके लिए उनसे पूछना जल्दबाजी होगी। मैटरियल को मंचों पर पढ़ाया जाना चाहिए न कि।
>

इस पोस्ट का क्या मतलब है?



Crysis ©   (2016-06-05 08:21) [79]

> पहला पैरामीटर, जैसा कि मैं समझता हूं, इसे EAX के माध्यम से प्रेषित किया जाता है
> परिणाम, भी, EAX के माध्यम से प्रेषित किया जा रहा है।
> तीसरा EDX के जरिए लगता है
> और दूसरे के बारे में क्या?


Int64 को स्टैक के माध्यम से पारित किया जाता है

> ईबीपी धक्का; // मैंने जो मांगा वह क्यों नहीं किया?
> मूव एबप, एस्प;
> धक्कामुक्की;
> पॉप ईबीपी;
> $ $ 0008; // क्या पैरामीटर?


यह डेल्फी कंपाइलर की एक विशेषता है। अगर किसी फंक्शन या सेक्शन वर्जन में स्टैक वेरिएबल्स हैं - डेल्फी प्रीफिक्स / पोस्टफिक्स और ईबे के जरिए वैरिएबल एक्सेस करते हैं। यदि आप var के माध्यम से कीवर्ड घोषित करते हैं, तो इसके लिए सूचक EDX से होकर गुजरेगा, और तीसरा पैरामीटर ECX होगा।



Игорь Шевченко ©   (2016-06-05 10:28) [80]


> खैर, और इसके अलावा फ्रैंक प्रलाप से भरा है। बेशक जब
> संकलक के दृष्टिकोण से सोचने की कोशिश कर रहा है, यह स्पष्ट लगता है
> उसने ऐसा क्यों किया। लेकिन मानवीय दृष्टिकोण से, यह बकवास है।
> ..


अशिक्षित व्यक्ति की दृष्टि से।



Pavia ©   (2016-06-05 11:56) [81]


> Rozych, क्या आप वास्तव में "कूद" शब्द से संक्रमित हैं? अच्छा बुरा
> यह रूसी अफवाह है। एक सामान्य शब्द है
> "संक्रमण"। लीप, मिलन। मैं शायद प्रासंगिक पर
> विषयगत फोरम नहीं होते हैं, लेकिन निंदा करते हैं। क्या ... कूद।
>
>
> सदस्यता लें-आपका व्याकरण नाजी चलो उपयोग नहीं करते हैं
> तो गूंगा अनुरेखण कागजात।

कूदो, कूदो ध्वनि खराब है, केवल इस तथ्य से कि वे शायद ही कभी उपयोग किए जाते हैं। अधिक बार जाते थे, जाते थे। दुकान पर जाओ।

लेकिन अर्थ एक छलांग है। संक्रमण नहीं। संक्रमण समय के साथ खिंची जाने वाली एक प्रक्रिया है। और वह एक त्वरित छलांग है। और इस मामले में, मैं कूदता हूं।

शब्दों की पसंद के बारे में। पाठ लिखते समय, आपको यह समझने की आवश्यकता है कि इसे किसके लिए डिज़ाइन किया गया है: पेशेवरों के लिए एक धूसर द्रव्यमान। लोकप्रियता के लिए, आपको ग्रे द्रव्यमान के स्तर तक नीचे जाना चाहिए। लेकिन पेशेवरों के लिए अधिक सही शब्दों का उपयोग करना बेहतर है।

पुनश्च। पाविया, रोटी के लिए गई।



Rouse_ ©   (2016-06-05 13:24) [82]


> और इस व्यवसाय के लिए स्मृति कहाँ आवंटित की गई है? और कौन उसे बाहर खड़ा करता है?

कौन स्टोर करता है, कहां से और आवंटित करता है।

उदाहरण के लिए:

वर पी: टीपोट; शुरू करना P: = पॉइंट (10, 10);

स्थानीय P के लिए मेमोरी को स्टैक पर कॉल किए गए फ़ंक्शन द्वारा आवंटित किया जाता है।


> इनोवेट © (05.06.16 00: 28) [77]
> Rozych, क्या आप वास्तव में "कूद" शब्द से संक्रमित हैं? अच्छा बुरा
> यह रूसी अफवाह है।

सामान्य लगता है, संक्रमण ज़ेबरा पर ट्रैफिक लाइट के बगल में है :)



Inovet ©   (2016-06-05 13:40) [83]

> [81] Pavia © (05.06.16 11: 56)
> लेकिन अर्थ एक छलांग है। संक्रमण नहीं। संक्रमण एक प्रक्रिया है
> समय के साथ बढ़ाया। और वह एक त्वरित छलांग है। और इसी में
> केस मैं कूदता हूं।


> [82] Rouse_ © (05.06.16 13: 24)
> आम तौर पर यह लगता है, संक्रमण ज़ेबरा पर ट्रैफिक लाइट के बगल में है
> :)

मैं यहां ग्रे मास और भाषा विज्ञान के बारे में चर्चा नहीं करूंगा, क्योंकि मैं इस मामले में कुछ भी नहीं समझता हूं। उन्होंने अपनी राय व्यक्त की।

यहां तक ​​कि ग्रे द्रव्यमान की खोज में भी। जब एक कोरियाई कंपनी नूडल्स का उत्पादन करती है, तो दोशीरक रूसी बाजार में प्रवेश करती है, तो यह सिफारिश की गई थी कि वह अपना नाम मूल दोशीराक से दोशीरक में बदल ले, अन्यथा रूसी-भाषी वातावरण में इस तरह के नाम के साथ आगे बढ़ना मुश्किल होगा। यह वहां से "कूद" है, केवल प्रोग्रामिंग के संदर्भ में। एक अन्य संदर्भ में, शब्दों के प्राकृतिक वातावरण में, यह सामान्य लगता है।



Inovet ©   (2016-06-05 13:45) [84]

या भौतिकी से एक और उदाहरण, निश्चित रूप से एक छलांग है, प्रकृति इतनी व्यवस्थित है - क्वांटम कूद। लेकिन मैंने कभी भी रूसी पाठ में एक क्वांटम संक्रमण के अलावा दूसरा शब्द नहीं देखा। बेशक, मैं थोड़ा भौतिक साहित्य पढ़ता हूं, लेकिन फिर भी भौतिक विज्ञानी, इस विज्ञान की सभी जटिलताओं के साथ, शैली की भावना रखते हैं।



Inovet ©   (2016-06-05 14:00) [85]

"लेबल पर कूदना" कहना बेहतर है - यह प्रोग्रामर और स्लैंग है, और यह स्पष्ट और स्वादिष्ट है।



Inovet ©   (2016-06-05 14:00) [86]

> [85] इनवेट © (05.06.16 14: 00)
> कठबोली

असभ्य



Rouse_ ©   (2016-06-05 15:25) [87]

क्या फर्क पड़ता है? JUMP उनके साथ रहेगा (PS: मैंने श्रृंखला देखी - एक क्वांटम छलांग? :)



Inovet ©   (2016-06-05 15:30) [88]

> [87] Rouse_ © (05.06.16 15: 25)
> पुनश्च: मैंने श्रृंखला देखी - एक क्वांटम छलांग?

नहीं। :) यह ग्रे द्रव्यमान के लिए है? :)



Inovet ©   (2016-06-05 15:35) [89]

विकी पर पाया गया
न्यू मैक्सिको (यूएसए) के रेगिस्तान में बेस में डॉ। सैमुअल बेकेट ने द क्वांटम लीप नामक एक शीर्ष-गुप्त परियोजना का नेतृत्व किया।

न्यू मैक्सिको - जो इस पर संदेह करेगा। और "कूद", हालांकि - जो भी बेहतर नहीं है। :)



Inovet ©   (2016-06-05 15:44) [90]

> [89] इनवेट © (05.06.16 15: 35)
> "कूदो",

उह, हाँ, आप इस रूसी भाषा को जानते हैं, हाँ।
कूद।



Юрий Зотов ©   (2016-06-05 17:23) [91]

> "जंप टू लेबल" - यह प्रोग्रामर है

यदि प्रोग्रामर के तरीके से, तो "लेबल" नहीं, बल्कि "लेबल"।



Inovet ©   (2016-06-05 20:08) [92]

> [91] यूरी जोतोव © (05.06.16 17: 23)
> लेयबक

सोचा, समझ लिया, लेकिन वास्तव में अर्थ का स्वाद नहीं लिया। चरखी का प्रकार?



SergP ©   (2016-06-05 22:07) [93]


>
> जो स्टोर करता है, से और आवंटित करता है।
>
> उदाहरण के लिए:
>
> वर
> पी: TPoint;
> शुरू करो
> P: = पॉइंट (10, 10);
>
>
> स्थानीय पी के तहत मेमोरी को ऑन पर कॉल किया जाता है
> ढेर।


खैर, वास्तव में, मैंने शुरुआत में सोचा था कि यह उन मामलों में होना चाहिए जब संरचना मूल्य से नहीं लौटती है।
लेकिन मैंने पूछा क्योंकि मुझे नहीं पता था कि यह सभी मामलों में कैसे काम करना चाहिए, विशेष रूप से जब फ़ंक्शन को इस तरह कहा जाता है:

> शुरू करो
> बिंदु (10, 10);

[72] के बाद, उन्होंने बस एक नज़र लेने का फैसला किया और देखा कि भले ही हमें परिणाम की आवश्यकता नहीं है और चर का वर्णन नहीं किया गया है, वैसे भी कॉलिंग प्रक्रिया / फ़ंक्शन इसके लिए स्टैक पर एक जगह आवंटित करती है।


> एक सामान्य शब्द है "संक्रमण"। लीप, मिलन। मैं शायद
> मैं प्रासंगिक विषयगत मंचों पर नहीं हूं, लेकिन
> निंदा करना। क्या उछाल है।


क्यों? यह दोनों शब्द लगता है, जब अपने आप में: संक्रमण और कूद दोनों - सामान्य रूप से माना जाता है।
हालांकि "सशर्त कूद" और "सशर्त कूद" जैसे वाक्यांशों में मैं पूर्व को पसंद करूंगा।



SergP ©   (2016-06-05 23:18) [94]


> इनोवेट © (04.06.16 19: 15) [75]
>
>> [73] सर्ग © (04.06.16 13: 25)
उद्धरण 1 >> यहाँ, उदाहरण के लिए, संकलक के मोती:
>
> खैर, यह इस के डिबग विधानसभा में हो सकता है?


मत करो। यह डिबग से संबंधित नहीं है। केवल int64 प्रकार की संख्या
... यदि (संख्या और 1) <> 0 तो मूव ऐक्स, [एबप + $ एक्सएनयूएमएक्स] Mov edx, [ebp + $ 08c] और ईएक्सएक्स, $ एक्सएनयूएमएक्स xor edx, edx cmp edx, $ 0 jnz + $ 00000001 cmp eax, $ 00 jz + $ 03

लेकिन इसके बजाय यदि (संख्या और 1) <> 0, यह लिखें कि क्या विषम (संख्या), सभी बकवास गायब हो जाती है और कोड सभ्य हो जाता है:
... यदि विषम (संख्या) तो मूव ऐक्स, [एबप + $ एक्सएनयूएमएक्स] परीक्षण अल, $ 08 jz + $ 01



Германн ©   (2016-06-06 01:38) [95]


> बस टाइप करें int64

यह मुझे कुछ याद दिलाता है। :)
लेकिन Rozych फिर से कहेगा कि यह सब ठीक है।



dmk ©   (2016-06-06 08:24) [96]

SergP © (05.06.16 23: 18) [94]
कंपाइलर डेवलपर्स आपको बताएंगे: अपना खुद का लिखें - सही :)

सामान्य तौर पर, अगर 32 थोड़ा मोड है, तो सब कुछ तार्किक है। 64 बिट्स पर जाएं। कोड में सब कुछ बहुत अधिक संक्षिप्त और सरल है (यहां तक ​​कि कोडांतरक में भी), और 32-बिट में 64 रजिस्टरों में 2 बिट्स को विकृत और तोड़ना है।



पन्ने: 1 2 3 पूरी शाखा

मंच: "अन्य";
वर्तमान संग्रह: 2017.08.27;
डाउनलोड करें: [xml.tar.bz2];

ऊपर





मेमोरी: 1.06 एमबी
समय: 0.084 c
4-1283282748
सैम बेल्लामी
2010-08-31 23:25
2017.08.27
अनुप्रयोग सक्रियण, SDI


1-1352975235
yurikon
2012-11-15 14:27
2017.08.27
कुंजी द्वारा सरणी तक पहुंच


3-1314713126
tomkat
2011-08-30 18:05
2017.08.27
फायरबर्ड में% बच


4-1283494887
worldmen
2010-09-03 10:21
2017.08.27
एक खिड़की के अस्तित्व का निर्धारण


2-1427276393
Ega23
2015-03-25 12:39
2017.08.27
फ़ंक्शन के लिए विकल्पों की एक सरणी पास करना





अफ्रीकी अल्बानियन अरबी भाषा अर्मेनियाई आज़रबाइजानी बस्क बेलारूसी बल्गेरियाई कैटलन सरलीकृत चीनी) चीनी पारंपरिक) क्रोएशियाई चेक डेनिश डच अंग्रेज़ी एस्तोनियावासी फिलिपिनो फिनिश फ्रेंच
गैलिशियन् जॉर्जियाई जर्मन यूनानी हाईटियन यहूदी हिंदी हंगरी आइसलैंड का इन्डोनेशियाई आयरिश इतालवी जापानी कोरियाई लात्वीयावासी लिथुआनियाई मेसीडोनियन मलायी मोलतिज़ नार्वेजियन
फ़ारसी पोलिश पुर्तगाली रोमानियाई रूसी सर्बियाई स्लोवाक स्लोवेनियाई स्पेनिश स्वाहिली स्वीडिश थाई तुर्की यूक्रेनी उर्दू वियतनामी वेल्श यहूदी बंगाली बोस्नियाई
सिबुआनो एस्पेरांतो गुजराती हौसा हमोंग ईग्बो जावानीस कन्नड़ खमेर लाओ लैटिन माओरी मराठी मंगोलियन नेपाली पंजाबी सोमाली तामिल तेलुगु योरूबा
ज़ुलु
Английский Французский Немецкий Итальянский Португальский Русский Испанский