x86 32-बिट मशीन कोड (32-बिट पूर्णांक): 17 बाइट्स।
(32-बिट या 64-बिट के लिए 16 बाइट्स सहित, डीएफ = 1 कॉलिंग कन्वेंशन सहित, नीचे अन्य संस्करण भी देखें।)
कॉलर रजिस्टरों में आर्ग पास करता है, जिसमें एक आउटपुट बफर के अंत में एक सूचक भी शामिल है (जैसे मेरा सी उत्तर ; इसे एल्गोरिदम के औचित्य और स्पष्टीकरण के लिए देखें।) glibc का आंतरिक _itoaकरता है। , इसलिए यह कोड-गोल्फ के लिए ही नहीं है। आर्ग-पासिंग रजिस्टर x86-64 सिस्टम V के करीब हैं, सिवाय इसके कि हमारे पास EDX के बजाय EAX में एक arg है।
वापसी पर, ईडीआई आउटपुट बफर में 0-टर्मिनेटेड सी स्ट्रिंग के पहले बाइट की ओर इशारा करता है। सामान्य रिटर्न-वैल्यू रजिस्टर EAX / RAX है, लेकिन असेंबली भाषा में आप एक फ़ंक्शन के लिए जो भी कॉलिंग कन्वेंशन सुविधाजनक है, उसका उपयोग कर सकते हैं। ( xchg eax,ediअंत में 1 बाइट जोड़ेगा)।
कॉल करने वाला स्पष्ट लंबाई की गणना कर सकता है यदि वह चाहता है, से buffer_end - edi। लेकिन मुझे नहीं लगता कि हम टर्मिनेटर को छोड़ने का औचित्य साबित कर सकते हैं जब तक कि फ़ंक्शन वास्तव में प्रारंभ + अंत बिंदु या सूचक + लंबाई दोनों को वापस नहीं करता है। इस संस्करण में 3 बाइट्स बचेंगे, लेकिन मुझे नहीं लगता कि यह उचित है।
- EAX = n = डिकोड करने की संख्या। (
idivअन्य अर्गों के निहितार्थ नहीं हैं।)
- EDI = आउटपुट बफर का अंत (64-बिट संस्करण अभी भी उपयोग करता है
dec edi, इसलिए निम्न 4GiB में होना चाहिए)
- ईएसआई / आरएसआई = लुकअप टेबल, उर्फ लुट। लबादा नहीं।
- ECX = तालिका की लंबाई = आधार। लबादा नहीं।
nasm -felf32 ascii-compress-base.asm -l /dev/stdout | cut -b -30,$((30+10))- (टिप्पणी संपादित करने के लिए संपादित हाथ, लाइन नंबरिंग अजीब है।)
32-bit: 17 bytes ; 64-bit: 18 bytes
; same source assembles as 32 or 64-bit
3 %ifidn __OUTPUT_FORMAT__, elf32
5 %define rdi edi
6 address %define rsi esi
11 machine %endif
14 code %define DEF(funcname) funcname: global funcname
16 bytes
22 ;;; returns: pointer in RDI to the start of a 0-terminated string
24 ;;; clobbers:; EDX (tmp remainder)
25 DEF(ascii_compress_nostring)
27 00000000 C60700 mov BYTE [rdi], 0
28 .loop: ; do{
29 00000003 99 cdq ; 1 byte shorter than xor edx,edx / div
30 00000004 F7F9 idiv ecx ; edx=n%B eax=n/B
31
32 00000006 8A1416 mov dl, [rsi + rdx] ; dl = LUT[n%B]
33 00000009 4F dec edi ; --output ; 2B in x86-64
34 0000000A 8817 mov [rdi], dl ; *output = dl
35
36 0000000C 85C0 test eax,eax ; div/idiv don't write flags in practice, and the manual says they're undefined.
37 0000000E 75F3 jnz .loop ; }while(n);
38
39 00000010 C3 ret
0x11 bytes = 17
40 00000011 11 .size: db $ - .start
यह आश्चर्य की बात है मूल रूप से कोई गति / आकार तालमेल के साथ सबसे सरल संस्करण में सबसे छोटी है कि है, लेकिन std/ cldउपयोग करने के लिए लागत 2 बाइट्स stosbअवरोही क्रम में जाने के लिए और अभी भी आम DF = 0 का पालन करें सम्मेलन बुला। (और स्टोरेज के बाद एसटीओएस घटता है , पॉइंटर को लूप एग्जिट पर एक बाइट बहुत कम इंगित करता है, जिससे हमें काम करने के लिए अतिरिक्त बाइट की लागत आती है।)
संस्करण:
मैं 4 महत्वपूर्ण भिन्न कार्यान्वयन ट्रिक्स (सरल movलोड / स्टोर (ऊपर) का उपयोग करके, lea/ / movsb(साफ-सुथरा लेकिन इष्टतम नहीं), xchg/ xlatb/ stosb/ का उपयोग करके आया था xchg, और एक जो ओवरलैपिंग-निर्देश हैक के साथ लूप में प्रवेश करता है। नीचे कोड देखें)। । आखिरी 0में आउटपुट स्ट्रिंग टर्मिनेटर के रूप में कॉपी करने के लिए लुकअप टेबल में एक अनुगामी की आवश्यकता होती है, इसलिए मैं +1 बाइट के रूप में गिन रहा हूं। 32/64-बिट (1-बाइट incया नहीं) पर निर्भर करता है , और क्या हम मान सकते हैं कि कॉलर सेट DF = 1 ( stosbअवरोही) या जो भी हो, अलग-अलग संस्करण सबसे कम (बंधे) हैं।
DF = 1 अवरोही क्रम में स्टोर करने के लिए इसे xchg / stosb / xchg की जीत बनाता है, लेकिन कॉलर अक्सर ऐसा नहीं चाहेगा; ऐसा लगता है कि कॉल करने वाले को हार्ड-टू-जस्ट तरीके से ऑफ़लोड करने का काम। (कस्टम एर्ग-पासिंग और रिटर्न-वैल्यू रजिस्टरों के विपरीत, जो आमतौर पर एएसएम कॉलर को किसी भी अतिरिक्त काम की लागत नहीं देते हैं।) लेकिन 64-बिट कोड में, cld/ scasbकाम करता है inc rdi, आउटपुट पॉइंटर को 32-बिट तक रौंदने से बचता है, इसलिए यह कभी-कभी होता है। 64-बिट-क्लीन कार्यों में DF = 1 को संरक्षित करने के लिए असुविधाजनक। । (स्थिर कोड / डेटा के पॉइंट्स लिनक्स पर x86-64 नॉन-पीआईई निष्पादनयोग्य में 32-बिट और हमेशा लिनक्स एक्स 32 एबीआई में होते हैं, इसलिए 32-बिट पॉइंटर्स का उपयोग करने वाला x86-64 संस्करण कुछ मामलों में उपयोग करने योग्य है। वैसे भी) यह सहभागिता आवश्यकताओं के विभिन्न संयोजनों को देखना दिलचस्प बनाती है।
- IA32 एक DF = 0 के साथ प्रवेश / निकास कॉलिंग कन्वेंशन पर: 17B (
nostring) ।
- IA32: 16B (एक DF = 1 सम्मेलन के साथ:
stosb_edx_argया skew) ; या आने वाले DF = NOTcare के साथ, इसे सेट करते हुए: 16 + 1Bstosb_decode_overlap या 17Bstosb_edx_arg
- 64-बिट पॉइंटर्स के साथ x86-64, और एंट्री / एग्जिट कॉलिंग कन्वेंशन पर एक DF = 0: 17 + 1 बाइट्स (
stosb_decode_overlap) , 18B ( stosb_edx_argया skew)
64-बिट पॉइंटर्स के साथ x86-64, अन्य DF हैंडलिंग: 16B (DF = 1 skew) , 17B ( nostringDF = 1 के साथ, scasbइसके बजाय का उपयोग करके dec)। 18B ( stosb_edx_arg3-बाइट के साथ DF = 1 का संरक्षण inc rdi)।
या अगर हम स्ट्रिंग से पहले 1 बाइट को पॉइंटर वापस करने की अनुमति देते हैं, तो 15 बी ( अंत में stosb_edx_argबिना inc)। सभी ने फिर से कॉल करने के लिए और अलग बेस / टेबल के साथ बफर में एक और स्ट्रिंग का विस्तार करने के लिए सेट किया ... लेकिन अगर हम एक टर्मिनेटिंग स्टोर नहीं करते हैं 0, तो यह अधिक समझ में आता है , और आप फ़ंक्शन बॉडी को लूप के अंदर रख सकते हैं ताकि वास्तव में एक अलग समस्या।
32-बिट आउटपुट पॉइंटर के साथ x86-64, DF = 0 कॉलिंग कन्वेंशन: 64-बिट आउटपुट पॉइंटर पर कोई सुधार नहीं, लेकिन 18B ( nostring) अब टाई।
- 32-बिट आउटपुट पॉइंटर के साथ x86-64: सर्वश्रेष्ठ 64-बिट पॉइंटर संस्करणों पर कोई सुधार नहीं, इसलिए 16 बी (डीएफ = 1
skew)। या DF = 1 सेट करने के लिए और इसे छोड़ दें, लेकिन इसके skewसाथ 17B । या के बजाय अंत के साथ 17 + 1 बी / के लिए ।stdcldstosb_decode_overlapinc edicldscasb
DF = 1 कॉलिंग कन्वेंशन के साथ: 16 बाइट्स (IA32 या x86-64)
इनपुट पर DF = 1 की आवश्यकता है, इसे सेट करता है। बमुश्किल प्रशंसनीय , कम से कम प्रति-कार्य के आधार पर। उपरोक्त संस्करण के समान ही काम करता है, लेकिन XLATB के बाद / AL से पहले / बाहर शेष पाने के लिए xchg के साथ (बेस के रूप में R / EBX के साथ टेबल लुकअप) और STOSB ( *output-- = al)।
एक सामान्य DF = 0 प्रवेश / बाहर निकलें सम्मेलन में रहते हुए, / / संस्करण 32 और 64-बिट कोड के लिए 18 बाइट्स की है, और 64-बिट साफ है (64-बिट उत्पादन सूचक के साथ काम करता है)।stdcldscasb
ध्यान दें कि इनपुट आर्गन्स विभिन्न रजिस्टरों में हैं, जिसमें तालिका के लिए RBX भी शामिल है (के लिए xlatb)। यह भी ध्यान दें कि यह लूप AL को संचय करके शुरू होता है, और अंतिम चार के साथ समाप्त होता है जो अभी तक संग्रहीत नहीं है (इसलिए movअंत में)। तो लूप दूसरों के सापेक्ष "तिरछा" है, इसलिए नाम।
;DF=1 version. Uncomment std/cld for DF=0
;32-bit and 64-bit: 16B
157 DEF(ascii_compress_skew)
158 ;;; inputs
159 ;; O in RDI = end of output buffer
160 ;; I in RBX = lookup table for xlatb
161 ;; n in EDX = number to decode
162 ;; B in ECX = length of table = modulus
163 ;;; returns: pointer in RDI to the start of a 0-terminated string
164 ;;; clobbers:; EDX=0, EAX=last char
165 .start:
166 ; std
167 00000060 31C0 xor eax,eax
168 .loop: ; do{
169 00000062 AA stosb
170 00000063 92 xchg eax, edx
171
172 00000064 99 cdq ; 1 byte shorter than xor edx,edx / div
173 00000065 F7F9 idiv ecx ; edx=n%B eax=n/B
174
175 00000067 92 xchg eax, edx ; eax=n%B edx=n/B
176 00000068 D7 xlatb ; al = byte [rbx + al]
177
178 00000069 85D2 test edx,edx
179 0000006B 75F5 jnz .loop ; }while(n = n/B);
180
181 0000006D 8807 mov [rdi], al ; stosb would move RDI away
182 ; cld
183 0000006F C3 ret
184 00000070 10 .size: db $ - .start
एक समान गैर-तिरछा संस्करण EDI / RDI का निरीक्षण करता है और फिर इसे ठीक करता है।
; 32-bit DF=1: 16B 64-bit: 17B (or 18B for DF=0)
70 DEF(ascii_compress_stosb_edx_arg) ; x86-64 SysV arg passing, but returns in RDI
71 ;; O in RDI = end of output buffer
72 ;; I in RBX = lookup table for xlatb
73 ;; n in EDX = number to decode
74 ;; B in ECX = length of table
75 ;;; clobbers EAX,EDX, preserves DF
76 ; 32-bit mode: a DF=1 convention would save 2B (use inc edi instead of cld/scasb)
77 ; 32-bit mode: call-clobbered DF would save 1B (still need STD, but INC EDI saves 1)
79 .start:
80 00000040 31C0 xor eax,eax
81 ; std
82 00000042 AA stosb
83 .loop:
84 00000043 92 xchg eax, edx
85 00000044 99 cdq
86 00000045 F7F9 idiv ecx ; edx=n%B eax=n/B
87
88 00000047 92 xchg eax, edx ; eax=n%B edx=n/B
89 00000048 D7 xlatb ; al = byte [rbx + al]
90 00000049 AA stosb ; *output-- = al
91
92 0000004A 85D2 test edx,edx
93 0000004C 75F5 jnz .loop
94
95 0000004E 47 inc edi
96 ;; cld
97 ;; scasb ; rdi++
98 0000004F C3 ret
99 00000050 10 .size: db $ - .start
16 bytes for the 32-bit DF=1 version
मैंने इसके साथ lea esi, [rbx+rdx]/ movsbआंतरिक लूप बॉडी के रूप में एक वैकल्पिक संस्करण की कोशिश की । (आरएसआई हर पुनरावृत्ति को रीसेट करता है, लेकिन आरडीआई घटता है)। लेकिन यह टर्मिनेटर के लिए xor-zero / stos का उपयोग नहीं कर सकता है, इसलिए यह 1 बाइट बड़ा है। (और यह LEA पर REX उपसर्ग के बिना लुकअप टेबल के लिए 64-बिट क्लीन नहीं है।)
स्पष्ट लंबाई और एक 0 टर्मिनेटर के साथ LUT : 16 + 1 बाइट्स (32-बिट)
यह संस्करण DF = 1 सेट करता है और इसे इस तरह से छोड़ देता है। मैं कुल बाइट गिनती के हिस्से के रूप में आवश्यक अतिरिक्त एलयू बाइट की गिनती कर रहा हूं।
यहाँ शांत चाल दो अलग-अलग तरीकों से एक ही बाइट्स को डिकोड कर रही है । हम शेष = आधार और भागफल = इनपुट संख्या के साथ लूप के मध्य में आते हैं, और 0 टर्मिनेटर को जगह में कॉपी करते हैं।
फ़ंक्शन के माध्यम से पहली बार, लूप के पहले 3 बाइट्स को LEA के लिए disp32 के उच्च बाइट्स के रूप में खपत किया जाता है। यह LEA EDX को आधार (मापांक) की प्रतिलिपि बनाता है, idivबाद के पुनरावृत्तियों के लिए शेष उत्पादन करता है।
2 बाइट idiv ebpहै FD, जो stdइस निर्देश के लिए opcode है कि इस फ़ंक्शन को काम करने की आवश्यकता है। (यह एक भाग्यशाली खोज थी। मैं इसे पहले से देख रहा था div, जो अपने आप को ModRM में बिट्स idivका उपयोग करने से अलग करता है /r।div epb रूप में cmc, जो हानिरहित है लेकिन सहायक नहीं है। लेकिन idiv ebpक्या हम वास्तव stdमें शीर्ष से निकाल सकते हैं । समारोह के।)
ध्यान दें कि इनपुट रजिस्टर एक बार फिर से भिन्न हैं: आधार के लिए ईबीपी।
103 DEF(ascii_compress_stosb_decode_overlap)
104 ;;; inputs
105 ;; n in EAX = number to decode
106 ;; O in RDI = end of output buffer
107 ;; I in RBX = lookup table, 0-terminated. (first iter copies LUT[base] as output terminator)
108 ;; B in EBP = base = length of table
109 ;;; returns: pointer in RDI to the start of a 0-terminated string
110 ;;; clobbers: EDX (=0), EAX, DF
111 ;; Or a DF=1 convention allows idiv ecx (STC). Or we could put xchg after stos and not run IDIV's modRM
112 .start:
117 ;2nd byte of div ebx = repz. edx=repnz.
118 ; div ebp = cmc. ecx=int1 = icebp (hardware-debug trap)
119 ;2nd byte of idiv ebp = std = 0xfd. ecx=stc
125
126 ;lea edx, [dword 0 + ebp]
127 00000040 8D9500 db 0x8d, 0x95, 0 ; opcode, modrm, 0 for lea edx, [rbp+disp32]. low byte = 0 so DL = BPL+0 = base
128 ; skips xchg, cdq, and idiv.
129 ; decode starts with the 2nd byte of idiv ebp, which decodes as the STD we need
130 .loop:
131 00000043 92 xchg eax, edx
132 00000044 99 cdq
133 00000045 F7FD idiv ebp ; edx=n%B eax=n/B;
134 ;; on loop entry, 2nd byte of idiv ebp runs as STD. n in EAX, like after idiv. base in edx (fake remainder)
135
136 00000047 92 xchg eax, edx ; eax=n%B edx=n/B
137 00000048 D7 xlatb ; al = byte [rbx + al]
138 .do_stos:
139 00000049 AA stosb ; *output-- = al
140
141 0000004A 85D2 test edx,edx
142 0000004C 75F5 jnz .loop
143
144 %ifidn __OUTPUT_FORMAT__, elf32
145 0000004E 47 inc edi ; saves a byte in 32-bit. Makes DF call-clobbered instead of normal DF=0
146 %else
147 cld
148 scasb ; rdi++
149 %endif
150
151 0000004F C3 ret
152 00000050 10 .size: db $ - .start
153 00000051 01 db 1 ; +1 because we require an extra LUT byte
# 16+1 bytes for a 32-bit version.
# 17+1 bytes for a 64-bit version that ends with DF=0
इस ओवरलैपिंग डिकोड ट्रिक का भी उपयोग किया जा सकता है cmp eax, imm32: यह केवल 4 बाइट्स को प्रभावी ढंग से कूदने के लिए 1 बाइट लेता है, केवल क्लोबरबर्स झंडे। (यह CPU पर प्रदर्शन के लिए भयानक है जो L1i कैश, BTW में निर्देश सीमाओं को चिह्नित करता है।)
लेकिन यहाँ, हम एक रजिस्टर की प्रतिलिपि बनाने और लूप में कूदने के लिए 3 बाइट्स का उपयोग कर रहे हैं। यह सामान्य रूप से 2 + 2 (mov + jmp) लेगा, और हमें XLATB से पहले STOS से ठीक पहले लूप में कूदने देगा। लेकिन फिर हमें एक अलग एसटीडी की आवश्यकता होगी, और यह बहुत दिलचस्प नहीं होगा।
इसे ऑनलाइन आज़माएं! (एक _startकॉलर के साथ जो उपयोग करता हैsys_write परिणाम पर )
डिबगिंग के लिए यह सबसे अच्छा है कि इसे नीचे चलाया जाए strace, या आउटपुट को हेक्सडंप किया जाए, ताकि आप देख सकें कि \0सही जगह पर टर्मिनेटर वगैरह है । लेकिन आप इसे वास्तव में काम कर सकते हैं, और AAAAAACHOOइनपुट के लिए उत्पादन कर सकते हैं
num equ 698911
table: db "CHAO"
%endif
tablen equ $ - table
db 0 ; "terminator" needed by ascii_compress_stosb_decode_overlap
(वास्तव में xxAAAAAACHOO\0x\0\0..., क्योंकि हम बफर में 2 बाइट्स से पहले एक निश्चित लंबाई तक डंप कर रहे हैं। इसलिए हम देख सकते हैं कि फ़ंक्शन ने बाइट्स को लिखा था और इसे किसी भी बाइट्स पर कदम नहीं रखना चाहिए था। स्टार्ट-पॉइंटर को फंक्शन में पास किया गया, दूसरा-अंतिम xकैरेक्टर था, जिसके बाद ज़ीरो था।)