Subversion Repositories Kolibri OS

Rev

Rev 9406 | Go to most recent revision | Show entire file | Ignore whitespace | Details | Blame | Last modification | View Log | RSS feed

Rev 9406 Rev 9715
Line 1... Line 1...
1 
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 1 
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
2 
;;                                                              ;;
 2 
;;                                                              ;;
3 
;; Copyright (C) KolibriOS team 2004-2015. All rights reserved. ;;
 3 
;; Copyright (C) KolibriOS team 2004-2022. All rights reserved. ;;
4 
;; Distributed under terms of the GNU General Public License    ;;
 4 
;; Distributed under terms of the GNU General Public License    ;;
5 
;;                                                              ;;
 5 
;;                                                              ;;
6 
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 6 
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
Line 7... Line 7...
7 
 
 7 
 
Line 8... Line 8...
8 
$Revision: 9406 $
 8 
$Revision: 9715 $
Line 9... Line 9...
9 
 
 9 
 
Line 25... Line 25...
25 
        test    eax, eax
 25 
        test    eax, eax
26 
        jz      .fail
 26 
        jz      .fail
Line 27... Line 27...
27 
 
 27 
 
Line 28... Line 28...
28 
        mov     [image], eax
 28 
        mov     [image], eax
29 
 
 29 
 
30 
        mov     edx, [eax+STRIPPED_PE_HEADER.SizeOfImage]
 30 
        mov     edx, [eax + STRIPPED_PE_HEADER.SizeOfImage]
31 
;        mov     cl, [eax+STRIPPED_PE_HEADER.Subsystem]
 31 
;        mov     cl, [eax + STRIPPED_PE_HEADER.Subsystem]
Line 32... Line 32...
32 
        cmp     word [eax], STRIPPED_PE_SIGNATURE
 32 
        cmp     word [eax], STRIPPED_PE_SIGNATURE
33 
        jz      @f
 33 
        jz      @f
34 
 
 34 
 
Line 35... Line 35...
35 
        mov     edx, [eax+60]
 35 
        mov     edx, [eax + 60]
36 
;        mov     cl, [eax+5Ch+edx]
 36 
;        mov     cl, [eax + 5Ch + edx]
37 
        mov     edx, [eax+80+edx]
 37 
        mov     edx, [eax + 80 + edx]
38 
 
 38 
 
Line 89... Line 89...
89 
end virtual
 89 
end virtual
90 
        cmp     word [ebx], STRIPPED_PE_SIGNATURE
 90 
        cmp     word [ebx], STRIPPED_PE_SIGNATURE
91 
        jz      .stripped
 91 
        jz      .stripped
Line 92... Line 92...
92 
 
 92 
 
93 
        mov     edx, ebx
 93 
        mov     edx, ebx
94 
        add     edx, [ebx+60]
 94 
        add     edx, [ebx + 60]
95 
        movzx   eax, word [edx+6]
 95 
        movzx   eax, word [edx + 6]
96 
        mov     [.numsections], eax
 96 
        mov     [.numsections], eax
97 
        mov     eax, [edx+40]
 97 
        mov     eax, [edx + 40]
98 
        mov     [.AddressOfEntryPoint], eax
 98 
        mov     [.AddressOfEntryPoint], eax
99 
        mov     eax, [edx+52]
 99 
        mov     eax, [edx + 52]
100 
        mov     [.ImageBase], eax
 100 
        mov     [.ImageBase], eax
101 
        mov     ecx, [edx+84]
 101 
        mov     ecx, [edx + 84]
102 
        mov     [.section_header_size], 40
 102 
        mov     [.section_header_size], 40
103 
        mov     eax, [edx+128]
 103 
        mov     eax, [edx + 128]
104 
        mov     [.import_descr], eax
 104 
        mov     [.import_descr], eax
105 
        mov     eax, [edx+160]
 105 
        mov     eax, [edx + 160]
106 
        mov     [.relocs_rva], eax
 106 
        mov     [.relocs_rva], eax
107 
        mov     eax, [edx+164]
 107 
        mov     eax, [edx + 164]
108 
        mov     [.relocs_size], eax
 108 
        mov     [.relocs_size], eax
Line 109... Line 109...
109 
        add     edx, 256
 109 
        add     edx, 256
110 
 
 110 
 
111 
        jmp     .common
 111 
        jmp     .common
112 
.stripped:
 112 
.stripped:
113 
        mov     eax, [ebx+STRIPPED_PE_HEADER.AddressOfEntryPoint]
 113 
        mov     eax, [ebx + STRIPPED_PE_HEADER.AddressOfEntryPoint]
114 
        mov     [.AddressOfEntryPoint], eax
 114 
        mov     [.AddressOfEntryPoint], eax
115 
        mov     eax, [ebx+STRIPPED_PE_HEADER.ImageBase]
 115 
        mov     eax, [ebx + STRIPPED_PE_HEADER.ImageBase]
116 
        mov     [.ImageBase], eax
 116 
        mov     [.ImageBase], eax
117 
        movzx   eax, [ebx+STRIPPED_PE_HEADER.NumberOfSections]
 117 
        movzx   eax, [ebx + STRIPPED_PE_HEADER.NumberOfSections]
118 
        mov     [.numsections], eax
 118 
        mov     [.numsections], eax
119 
        movzx   ecx, [ebx+STRIPPED_PE_HEADER.NumberOfRvaAndSizes]
 119 
        movzx   ecx, [ebx + STRIPPED_PE_HEADER.NumberOfRvaAndSizes]
120 
        xor     eax, eax
 120 
        xor     eax, eax
121 
        mov     [.relocs_rva], eax
 121 
        mov     [.relocs_rva], eax
122 
        mov     [.relocs_size], eax
 122 
        mov     [.relocs_size], eax
123 
        test    ecx, ecx
 123 
        test    ecx, ecx
124 
        jz      @f
 124 
        jz      @f
125 
        mov     eax, [ebx+sizeof.STRIPPED_PE_HEADER+SPE_DIRECTORY_IMPORT*8]
 125 
        mov     eax, [ebx + sizeof.STRIPPED_PE_HEADER + SPE_DIRECTORY_IMPORT*8]
126 
@@:
 126 
@@:
127 
        mov     [.import_descr], eax
 127 
        mov     [.import_descr], eax
128 
        cmp     ecx, SPE_DIRECTORY_BASERELOC
 128 
        cmp     ecx, SPE_DIRECTORY_BASERELOC
129 
        jbe     @f
 129 
        jbe     @f
130 
        mov     eax, [ebx+sizeof.STRIPPED_PE_HEADER+SPE_DIRECTORY_BASERELOC*8]
 130 
        mov     eax, [ebx + sizeof.STRIPPED_PE_HEADER + SPE_DIRECTORY_BASERELOC*8]
131 
        mov     [.relocs_rva], eax
 131 
        mov     [.relocs_rva], eax
132 
        mov     eax, [ebx+sizeof.STRIPPED_PE_HEADER+SPE_DIRECTORY_BASERELOC*8+4]
 132 
        mov     eax, [ebx + sizeof.STRIPPED_PE_HEADER + SPE_DIRECTORY_BASERELOC*8+4]
133 
        mov     [.relocs_size], eax
 133 
        mov     [.relocs_size], eax
134 
@@:
 134 
@@:
135 
        mov     [.section_header_size], 28
 135 
        mov     [.section_header_size], 28
Line 136... Line 136...
136 
        lea     edx, [ebx+ecx*8+sizeof.STRIPPED_PE_HEADER+8]
 136 
        lea     edx, [ebx + ecx*8 + sizeof.STRIPPED_PE_HEADER + 8]
137 
        mov     ecx, [ebx+STRIPPED_PE_HEADER.SizeOfHeaders]
 137 
        mov     ecx, [ebx + STRIPPED_PE_HEADER.SizeOfHeaders]
138 
 
 138 
 
139 
.common:
 139 
.common:
140 
        mov     esi, ebx
 140 
        mov     esi, ebx
Line 141... Line 141...
141 
        mov     edi, ebp
 141 
        mov     edi, ebp
142 
        shr     ecx, 2
 142 
        shr     ecx, 2
143 
        rep movsd
 143 
        rep movsd
144 
 
 144 
 
145 
        cmp     [.numsections], 0
 145 
        cmp     [.numsections], 0
146 
        jz      .nosections
 146 
        jz      .nosections
147 
.copy_sections:
 147 
.copy_sections:
148 
        mov     eax, [edx+8]
 148 
        mov     eax, [edx + 8]
149 
        test    eax, eax
 149 
        test    eax, eax
150 
        je      .no_section_data
 150 
        je      .no_section_data
151 
        mov     esi, ebx
 151 
        mov     esi, ebx
Line 152... Line 152...
152 
        mov     edi, ebp
 152 
        mov     edi, ebp
153 
        add     esi, [edx+12]
 153 
        add     esi, [edx + 12]
154 
        mov     ecx, eax
 154 
        mov     ecx, eax
Line 155... Line 155...
155 
        add     edi, [edx+4]
 155 
        add     edi, [edx + 4]
156 
 
 156 
 
157 
        add     ecx, 3
 157 
        add     ecx, 3
158 
        shr     ecx, 2
 158 
        shr     ecx, 2
159 
        rep movsd
 159 
        rep movsd
160 
 
 160 
 
161 
.no_section_data:
 161 
.no_section_data:
Line 162... Line 162...
162 
        mov     ecx, [edx]
 162 
        mov     ecx, [edx]
163 
        cmp     ecx, eax
 163 
        cmp     ecx, eax
Line 181... Line 181...
181 
        sub     esi, [.ImageBase]
 181 
        sub     esi, [.ImageBase]
182 
        add     ecx, [.relocs_rva]
 182 
        add     ecx, [.relocs_rva]
183 
.relocs_block:
 183 
.relocs_block:
184 
        mov     edi, [ecx]
 184 
        mov     edi, [ecx]
185 
        add     edi, ebp
 185 
        add     edi, ebp
186 
        mov     ebx, [ecx+4]
 186 
        mov     ebx, [ecx + 4]
187 
        add     ecx, 8
 187 
        add     ecx, 8
188 
        sub     [.relocs_size], ebx
 188 
        sub     [.relocs_size], ebx
189 
        sub     ebx, 8
 189 
        sub     ebx, 8
190 
        shr     ebx, 1
 190 
        shr     ebx, 1
191 
        jz      .relocs_next_block
 191 
        jz      .relocs_next_block
Line 209... Line 209...
209 
        je      .no_imports
 209 
        je      .no_imports
210 
        add     [.import_descr], ebp
 210 
        add     [.import_descr], ebp
211 
        mov     [.bad_import], 0
 211 
        mov     [.bad_import], 0
212 
.import_block:
 212 
.import_block:
213 
        mov     ecx, [.import_descr]
 213 
        mov     ecx, [.import_descr]
214 
        cmp     dword [ecx+4], 0
 214 
        cmp     dword [ecx + 4], 0
215 
        jne     @f
 215 
        jne     @f
216 
        cmp     dword [ecx+12], 0
 216 
        cmp     dword [ecx + 12], 0
217 
        je      .done_imports
 217 
        je      .done_imports
218 
@@:
 218 
@@:
219 
        mov     edx, dword [ecx]
 219 
        mov     edx, dword [ecx]
220 
        mov     ecx, dword [ecx+16]
 220 
        mov     ecx, dword [ecx + 16]
221 
        test    edx, edx
 221 
        test    edx, edx
222 
        jnz     @f
 222 
        jnz     @f
223 
        mov     edx, ecx
 223 
        mov     edx, ecx
224 
@@:
 224 
@@:
225 
        mov     [.import_idx], 0
 225 
        mov     [.import_idx], 0
Line 228... Line 228...
228 
        mov     [.import_names], edx
 228 
        mov     [.import_names], edx
229 
        mov     [.import_targets], ecx
 229 
        mov     [.import_targets], ecx
230 
.import_func:
 230 
.import_func:
231 
        mov     esi, [.import_idx]
 231 
        mov     esi, [.import_idx]
232 
        mov     edi, [.import_names]
 232 
        mov     edi, [.import_names]
233 
        mov     eax, [edi+esi*4]
 233 
        mov     eax, [edi + esi*4]
234 
        test    eax, eax
 234 
        test    eax, eax
235 
        je      .next_import_block
 235 
        je      .next_import_block
236 
        js      .next_import_block
 236 
        js      .next_import_block
237 
        lea     edi, [ebp+eax]
 237 
        lea     edi, [ebp + eax]
238 
        mov     eax, [.import_targets]
 238 
        mov     eax, [.import_targets]
239 
        mov     dword [eax+esi*4], 0
 239 
        mov     dword [eax + esi*4], 0
240 
        lea     esi, [edi+2]
 240 
        lea     esi, [edi + 2]
241 
        movzx   ebx, word [edi]
 241 
        movzx   ebx, word [edi]
242 
        push    32
 242 
        push    32
243 
        mov     ecx, [__exports+32]
 243 
        mov     ecx, [__exports + 32]
244 
        mov     eax, [ecx+OS_BASE+ebx*4]
 244 
        mov     eax, [ecx + OS_BASE + ebx*4]
245 
        add     eax, OS_BASE
 245 
        add     eax, OS_BASE
246 
        push    eax
 246 
        push    eax
247 
        push    esi
 247 
        push    esi
248 
        call    strncmp
 248 
        call    strncmp
249 
        test    eax, eax
 249 
        test    eax, eax
250 
        jz      .import_func_found
 250 
        jz      .import_func_found
251 
        xor     ebx, ebx
 251 
        xor     ebx, ebx
252 
.import_func_candidate:
 252 
.import_func_candidate:
253 
        push    32
 253 
        push    32
254 
        mov     ecx, [__exports+32]
 254 
        mov     ecx, [__exports + 32]
255 
        mov     eax, [ecx+OS_BASE+ebx*4]
 255 
        mov     eax, [ecx + OS_BASE + ebx*4]
256 
        add     eax, OS_BASE
 256 
        add     eax, OS_BASE
257 
        push    eax
 257 
        push    eax
258 
        push    esi
 258 
        push    esi
259 
        call    strncmp
 259 
        call    strncmp
260 
        test    eax, eax
 260 
        test    eax, eax
261 
        je      .import_func_found
 261 
        je      .import_func_found
262 
        inc     ebx
 262 
        inc     ebx
263 
        cmp     ebx, [__exports+24]
 263 
        cmp     ebx, [__exports + 24]
264 
        jb      .import_func_candidate
 264 
        jb      .import_func_candidate
Line 265... Line 265...
265 
 
 265 
 
266 
        mov     esi, msg_unresolved
 266 
        mov     esi, msg_unresolved
267 
        call    sys_msg_board_str
 267 
        call    sys_msg_board_str
268 
        lea     esi, [edi+2]
 268 
        lea     esi, [edi + 2]
269 
        call    sys_msg_board_str
 269 
        call    sys_msg_board_str
270 
        mov     esi, msg_CR
 270 
        mov     esi, msg_CR
Line 271... Line 271...
271 
        call    sys_msg_board_str
 271 
        call    sys_msg_board_str
272 
 
 272 
 
273 
        mov     [.bad_import], 1
 273 
        mov     [.bad_import], 1
274 
        jmp     .next_import_func
 274 
        jmp     .next_import_func
275 
.import_func_found:
 275 
.import_func_found:
276 
        mov     esi, [__exports+28]
 276 
        mov     esi, [__exports + 28]
277 
        mov     edx, [.import_idx]
 277 
        mov     edx, [.import_idx]
278 
        mov     ecx, [.import_targets]
 278 
        mov     ecx, [.import_targets]
279 
        mov     eax, [esi+OS_BASE+ebx*4]
 279 
        mov     eax, [esi + OS_BASE + ebx*4]
280 
        add     eax, OS_BASE
 280 
        add     eax, OS_BASE
281 
        mov     [ecx+edx*4], eax
 281 
        mov     [ecx + edx*4], eax
282 
.next_import_func:
 282 
.next_import_func:
283 
        inc     [.import_idx]
 283 
        inc     [.import_idx]
284 
        jmp     .import_func
 284 
        jmp     .import_func