Subversion Repositories Kolibri OS

Rev

Rev 3761 | Rev 4421 | Go to most recent revision | Blame | Compare with Previous | Last modification | View Log | Download | RSS feed

  1. ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
  2. ;;                                                              ;;
  3. ;; Copyright (C) KolibriOS team 2004-2012. All rights reserved. ;;
  4. ;; Distributed under terms of the GNU General Public License    ;;
  5. ;;                                                              ;;
  6. ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
  7.  
  8. $Revision: 4418 $
  9.  
  10. include 'export.inc'
  11.  
  12. align 4
  13.  
  14. proc load_PE stdcall, file_name:dword
  15.            locals
  16.              image  dd ?
  17.              entry  dd ?
  18.              base   dd ?
  19.            endl
  20.  
  21.         stdcall load_file, [file_name]
  22.         test    eax, eax
  23.         jz      .fail
  24.  
  25.         mov     [image], eax
  26.  
  27.         mov     edx, [eax+60]
  28.  
  29.         stdcall kernel_alloc, [eax+80+edx]
  30.         test    eax, eax
  31.         jz      .cleanup
  32.  
  33.         mov     [base], eax
  34.  
  35.         stdcall map_PE, eax, [image]
  36.  
  37.         mov     [entry], eax
  38.         test    eax, eax
  39.         jnz     .cleanup
  40.  
  41.         stdcall kernel_free, [base]
  42. .cleanup:
  43.         stdcall kernel_free, [image]
  44.         mov     eax, [entry]
  45.         ret
  46. .fail:
  47.         xor     eax, eax
  48.         ret
  49. endp
  50.  
  51. DWORD equ dword
  52. PTR   equ
  53.  
  54. align 4
  55. map_PE:                    ;stdcall base:dword, image:dword
  56.         cld
  57.         push    ebp
  58.         push    edi
  59.         push    esi
  60.         push    ebx
  61.         sub     esp, 60
  62.         mov     ebx, DWORD PTR [esp+84]
  63.         mov     ebp, DWORD PTR [esp+80]
  64.         mov     edx, ebx
  65.         mov     esi, ebx
  66.         add     edx, DWORD PTR [ebx+60]
  67.         mov     edi, ebp
  68.         mov     DWORD PTR [esp+32], edx
  69.         mov     ecx, DWORD PTR [edx+84]
  70.  
  71.         shr     ecx, 2
  72.         rep movsd
  73.  
  74.         movzx   eax, WORD PTR [edx+6]
  75.         mov     DWORD PTR [esp+36], 0
  76.         mov     DWORD PTR [esp+16], eax
  77.         jmp     L2
  78. L3:
  79.         mov     eax, DWORD PTR [edx+264]
  80.         test    eax, eax
  81.         je      L4
  82.         mov     esi, ebx
  83.         mov     edi, ebp
  84.         add     esi, DWORD PTR [edx+268]
  85.         mov     ecx, eax
  86.         add     edi, DWORD PTR [edx+260]
  87.  
  88.         add     ecx, 3
  89.         shr     ecx, 2
  90.         rep movsd
  91.  
  92. L4:
  93.         mov     ecx, DWORD PTR [edx+256]
  94.         cmp     ecx, eax
  95.         jbe     L6
  96.         sub     ecx, eax
  97.         add     eax, DWORD PTR [edx+260]
  98.         lea     edi, [eax+ebp]
  99.  
  100.         xor     eax, eax
  101.         rep stosb
  102.  
  103. L6:
  104.         inc     DWORD PTR [esp+36]
  105.         add     edx, 40
  106. L2:
  107.         mov     esi, DWORD PTR [esp+16]
  108.         cmp     DWORD PTR [esp+36], esi
  109.         jne     L3
  110.         mov     edi, DWORD PTR [esp+32]
  111.         cmp     DWORD PTR [edi+164], 0
  112.         je      L9
  113.         mov     esi, ebp
  114.         mov     ecx, ebp
  115.         sub     esi, DWORD PTR [edi+52]
  116.         add     ecx, DWORD PTR [edi+160]
  117.         mov     eax, esi
  118.         shr     eax, 16
  119.         mov     DWORD PTR [esp+12], eax
  120.         jmp     L11
  121. L12:
  122.         lea     ebx, [eax-8]
  123.         xor     edi, edi
  124.         shr     ebx, 1
  125.         jmp     L13
  126. L14:
  127.         movzx   eax, WORD PTR [ecx+8+edi*2]
  128.         mov     edx, eax
  129.         shr     eax, 12
  130.         and     edx, 4095
  131.         add     edx, DWORD PTR [ecx]
  132.         cmp     ax, 2
  133.         je      L17
  134.         cmp     ax, 3
  135.         je      L18
  136.         dec     ax
  137.         jne     L15
  138.         mov     eax, DWORD PTR [esp+12]
  139.         add     WORD PTR [edx+ebp], ax
  140. L17:
  141.         add     WORD PTR [edx+ebp], si
  142. L18:
  143.         add     DWORD PTR [edx+ebp], esi
  144. L15:
  145.         inc     edi
  146. L13:
  147.         cmp     edi, ebx
  148.         jne     L14
  149.         add     ecx, DWORD PTR [ecx+4]
  150. L11:
  151.         mov     eax, DWORD PTR [ecx+4]
  152.         test    eax, eax
  153.         jne     L12
  154. L9:
  155.         mov     edx, DWORD PTR [esp+32]
  156.         cmp     DWORD PTR [edx+132], 0
  157.         je      L20
  158.         mov     eax, ebp
  159.         add     eax, DWORD PTR [edx+128]
  160.         mov     DWORD PTR [esp+40], 0
  161.         add     eax, 20
  162.         mov     DWORD PTR [esp+56], eax
  163. L22:
  164.         mov     ecx, DWORD PTR [esp+56]
  165.         cmp     DWORD PTR [ecx-16], 0
  166.         jne     L23
  167.         cmp     DWORD PTR [ecx-8], 0
  168.         je      L25
  169. L23:
  170.         mov     edi, DWORD PTR [__exports+32]
  171.         mov     esi, DWORD PTR [__exports+28]
  172.         mov     eax, DWORD PTR [esp+56]
  173.         mov     DWORD PTR [esp+20], edi
  174.         add     edi, OS_BASE
  175.         add     esi, OS_BASE
  176.         mov     DWORD PTR [esp+44], esi
  177.         mov     ecx, DWORD PTR [eax-4]
  178.         mov     DWORD PTR [esp+48], edi
  179.         mov     edx, DWORD PTR [eax-20]
  180.         test    edx, edx
  181.         jnz     @f
  182.         mov     edx, ecx
  183. @@:
  184.         mov     DWORD PTR [esp+52], 0
  185.         add     ecx, ebp
  186.         add     edx, ebp
  187.         mov     DWORD PTR [esp+24], edx
  188.         mov     DWORD PTR [esp+28], ecx
  189. L26:
  190.         mov     esi, DWORD PTR [esp+52]
  191.         mov     edi, DWORD PTR [esp+24]
  192.         mov     eax, DWORD PTR [edi+esi*4]
  193.         test    eax, eax
  194.         je      L27
  195.         test    eax, eax
  196.         js      L27
  197.         lea     edi, [ebp+eax]
  198.         mov     eax, DWORD PTR [esp+28]
  199.         mov     DWORD PTR [eax+esi*4], 0
  200.         lea     esi, [edi+2]
  201.         push    eax
  202.         push    32
  203.         movzx   eax, WORD PTR [edi]
  204.         mov     edx, DWORD PTR [esp+56]
  205.         mov     eax, DWORD PTR [edx+eax*4]
  206.         add     eax, OS_BASE
  207.         push    eax
  208.         push    esi
  209.         call    strncmp
  210.         pop     ebx
  211.         xor     ebx, ebx
  212.         test    eax, eax
  213.         jne     L32
  214.         jmp     L30
  215. L33:
  216.         push    ecx
  217.         push    32
  218.         mov     ecx, DWORD PTR [esp+28]
  219.         mov     eax, DWORD PTR [ecx+OS_BASE+ebx*4]
  220.         add     eax, OS_BASE
  221.         push    eax
  222.         push    esi
  223.         call    strncmp
  224.         pop     edx
  225.         test    eax, eax
  226.         jne     L34
  227.         mov     esi, DWORD PTR [esp+44]
  228.         mov     edx, DWORD PTR [esp+52]
  229.         mov     ecx, DWORD PTR [esp+28]
  230.         mov     eax, DWORD PTR [esi+ebx*4]
  231.         add     eax, OS_BASE
  232.         mov     DWORD PTR [ecx+edx*4], eax
  233.         jmp     L36
  234. L34:
  235.         inc     ebx
  236. L32:
  237.         cmp     ebx, DWORD PTR [__exports+24]
  238.         jb      L33
  239. L36:
  240.         cmp     ebx, DWORD PTR [__exports+24]
  241.         jne     L37
  242.  
  243.         mov     esi, msg_unresolved
  244.         call    sys_msg_board_str
  245.         lea     esi, [edi+2]
  246.         call    sys_msg_board_str
  247.         mov     esi, msg_CR
  248.         call    sys_msg_board_str
  249.  
  250.         mov     DWORD PTR [esp+40], 1
  251.         jmp     L37
  252. L30:
  253.         movzx   eax, WORD PTR [edi]
  254.         mov     esi, DWORD PTR [esp+44]
  255.         mov     edi, DWORD PTR [esp+52]
  256.         mov     edx, DWORD PTR [esp+28]
  257.         mov     eax, DWORD PTR [esi+eax*4]
  258.         add     eax, OS_BASE
  259.         mov     DWORD PTR [edx+edi*4], eax
  260. L37:
  261.         inc     DWORD PTR [esp+52]
  262.         jmp     L26
  263. L27:
  264.         add     DWORD PTR [esp+56], 20
  265.         jmp     L22
  266. L25:
  267.         xor     eax, eax
  268.         cmp     DWORD PTR [esp+40], 0
  269.         jne     L40
  270. L20:
  271.         mov     ecx, DWORD PTR [esp+32]
  272.         mov     eax, ebp
  273.         add     eax, DWORD PTR [ecx+40]
  274. L40:
  275.         add     esp, 60
  276.         pop     ebx
  277.         pop     esi
  278.         pop     edi
  279.         pop     ebp
  280.         ret     8
  281.