WebSVN – Kolibri OS – Diff – /kernel/branches/Kolibri-acpi/core/peload.inc


;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;                                                              ;;
;; Copyright (C) KolibriOS team 2004-2012. All rights reserved. ;;
;; Distributed under terms of the GNU General Public License    ;;
;;                                                              ;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
$Revision: 2465 $
 
include 'export.inc'
 
align 4
 
proc load_PE stdcall, file_name:dword
           locals
             image  dd ?
             entry  dd ?
             base   dd ?
           endl
 
        stdcall load_file, [file_name]
        test    eax, eax
        jz      .fail
 
        mov     [image], eax
 
        mov     edx, [eax+60]
 
        stdcall kernel_alloc, [eax+80+edx]
        test    eax, eax
        jz      .cleanup
 
        mov     [base], eax
 
        stdcall map_PE, eax, [image]
 
        mov     [entry], eax
        test    eax, eax
        jnz     .cleanup
 
        stdcall kernel_free, [base]
.cleanup:
        stdcall kernel_free, [image]
        mov     eax, [entry]
        ret
.fail:
        xor     eax, eax
        ret
endp
 
DWORD equ dword
PTR   equ
 
align 4
map_PE:                    ;stdcall base:dword, image:dword
        cld
        push    ebp
        push    edi
        push    esi
        push    ebx
        sub     esp, 60
        mov     ebx, DWORD PTR [esp+84]
        mov     ebp, DWORD PTR [esp+80]
        mov     edx, ebx
        mov     esi, ebx
        add     edx, DWORD PTR [ebx+60]
        mov     edi, ebp
        mov     DWORD PTR [esp+32], edx
        mov     ecx, DWORD PTR [edx+84]
 
        shr     ecx, 2
        rep movsd
 
        movzx   eax, WORD PTR [edx+6]
        mov     DWORD PTR [esp+36], 0
        mov     DWORD PTR [esp+16], eax
        jmp     L2
L3:
        mov     eax, DWORD PTR [edx+264]
        test    eax, eax
        je      L4
        mov     esi, ebx
        mov     edi, ebp
        add     esi, DWORD PTR [edx+268]
        mov     ecx, eax
        add     edi, DWORD PTR [edx+260]
 
        shr     ecx, 2
        rep movsd
 
L4:
        mov     ecx, DWORD PTR [edx+256]
        add     ecx, 4095
        and     ecx, -4096
        cmp     ecx, eax
        jbe     L6
        sub     ecx, eax
        add     eax, DWORD PTR [edx+260]
        lea     edi, [eax+ebp]
 
        xor     eax, eax
        rep stosb
 
L6:
        inc     DWORD PTR [esp+36]
        add     edx, 40
L2:
        mov     esi, DWORD PTR [esp+16]
        cmp     DWORD PTR [esp+36], esi
        jne     L3
        mov     edi, DWORD PTR [esp+32]
        cmp     DWORD PTR [edi+164], 0
        je      L9
        mov     esi, ebp
        mov     ecx, ebp
        sub     esi, DWORD PTR [edi+52]
        add     ecx, DWORD PTR [edi+160]
        mov     eax, esi
        shr     eax, 16
        mov     DWORD PTR [esp+12], eax
        jmp     L11
L12:
        lea     ebx, [eax-8]
        xor     edi, edi
        shr     ebx, 1
        jmp     L13
L14:
        movzx   eax, WORD PTR [ecx+8+edi*2]
        mov     edx, eax
        shr     eax, 12
        and     edx, 4095
        add     edx, DWORD PTR [ecx]
        cmp     ax, 2
        je      L17
        cmp     ax, 3
        je      L18
        dec     ax
        jne     L15
        mov     eax, DWORD PTR [esp+12]
        add     WORD PTR [edx+ebp], ax
L17:
        add     WORD PTR [edx+ebp], si
L18:
        add     DWORD PTR [edx+ebp], esi
L15:
        inc     edi
L13:
        cmp     edi, ebx
        jne     L14
        add     ecx, DWORD PTR [ecx+4]
L11:
        mov     eax, DWORD PTR [ecx+4]
        test    eax, eax
        jne     L12
L9:
        mov     edx, DWORD PTR [esp+32]
        cmp     DWORD PTR [edx+132], 0
        je      L20
        mov     eax, ebp
        add     eax, DWORD PTR [edx+128]
        mov     DWORD PTR [esp+40], 0
        add     eax, 20
        mov     DWORD PTR [esp+56], eax
L22:
        mov     ecx, DWORD PTR [esp+56]
        cmp     DWORD PTR [ecx-16], 0
        jne     L23
        cmp     DWORD PTR [ecx-8], 0
        je      L25
L23:
        mov     edi, DWORD PTR [__exports+32]
        mov     esi, DWORD PTR [__exports+28]
        mov     eax, DWORD PTR [esp+56]
        mov     DWORD PTR [esp+20], edi
        add     edi, OS_BASE
        add     esi, OS_BASE
        mov     DWORD PTR [esp+44], esi
        mov     ecx, DWORD PTR [eax-4]
        mov     DWORD PTR [esp+48], edi
        mov     edx, DWORD PTR [eax-20]
        mov     DWORD PTR [esp+52], 0
        add     ecx, ebp
        add     edx, ebp
        mov     DWORD PTR [esp+24], edx
        mov     DWORD PTR [esp+28], ecx
L26:
        mov     esi, DWORD PTR [esp+52]
        mov     edi, DWORD PTR [esp+24]
        mov     eax, DWORD PTR [edi+esi*4]
        test    eax, eax
        je      L27
        test    eax, eax
        js      L27
        lea     edi, [ebp+eax]
        mov     eax, DWORD PTR [esp+28]
        mov     DWORD PTR [eax+esi*4], 0
        lea     esi, [edi+2]
        push    eax
        push    32
        movzx   eax, WORD PTR [edi]
        mov     edx, DWORD PTR [esp+56]
        mov     eax, DWORD PTR [edx+eax*4]
        add     eax, OS_BASE
        push    eax
        push    esi
        call    strncmp
        pop     ebx
        xor     ebx, ebx
        test    eax, eax
        jne     L32
        jmp     L30
L33:
        push    ecx
        push    32
        mov     ecx, DWORD PTR [esp+28]
        mov     eax, DWORD PTR [ecx+OS_BASE+ebx*4]
        add     eax, OS_BASE
        push    eax
        push    esi
        call    strncmp
        pop     edx
        test    eax, eax
        jne     L34
        mov     esi, DWORD PTR [esp+44]
        mov     edx, DWORD PTR [esp+52]
        mov     ecx, DWORD PTR [esp+28]
        mov     eax, DWORD PTR [esi+ebx*4]
        add     eax, OS_BASE
        mov     DWORD PTR [ecx+edx*4], eax
        jmp     L36
L34:
        inc     ebx
L32:
        cmp     ebx, DWORD PTR [__exports+24]
        jb      L33
L36:
        cmp     ebx, DWORD PTR [__exports+24]
        jne     L37
 
        mov     esi, msg_unresolved
        call    sys_msg_board_str
        lea     esi, [edi+2]
        call    sys_msg_board_str
        mov     esi, msg_CR
        call    sys_msg_board_str
 
        mov     DWORD PTR [esp+40], 1
        jmp     L37
L30:
        movzx   eax, WORD PTR [edi]
        mov     esi, DWORD PTR [esp+44]
        mov     edi, DWORD PTR [esp+52]
        mov     edx, DWORD PTR [esp+28]
        mov     eax, DWORD PTR [esi+eax*4]
        add     eax, OS_BASE
        mov     DWORD PTR [edx+edi*4], eax
L37:
        inc     DWORD PTR [esp+52]
        jmp     L26
L27:
        add     DWORD PTR [esp+56], 20
        jmp     L22
L25:
        xor     eax, eax
        cmp     DWORD PTR [esp+40], 0
        jne     L40
L20:
        mov     ecx, DWORD PTR [esp+32]
        mov     eax, ebp
        add     eax, DWORD PTR [ecx+40]
L40:
        add     esp, 60
        pop     ebx
        pop     esi
        pop     edi
        pop     ebp
        ret     8
 
 align 16
__exports:
          export 'KERNEL',   \
          alloc_kernel_space,    'AllocKernelSpace',   \      ; stdcall
          alloc_page,            'AllocPage',          \      ; gcc ABI
          alloc_pages,           'AllocPages',         \      ; stdcall
          commit_pages,          'CommitPages',        \      ; eax, ebx, ecx
\
          create_event,          'CreateEvent',        \      ; ecx, esi
          destroy_event,         'DestroyEvent',       \      ;
          raise_event,           'RaiseEvent',         \      ; eax, ebx, edx, esi
          wait_event,            'WaitEvent',          \      ; eax, ebx
          get_event_ex,          'GetEvent',           \      ; edi
\
          create_kernel_object,  'CreateObject',       \
          create_ring_buffer,    'CreateRingBuffer',   \      ; stdcall
          destroy_kernel_object, 'DestroyObject',      \
          free_kernel_space,     'FreeKernelSpace',    \      ; stdcall
          free_page,             'FreePage',           \      ; eax
          kernel_alloc,          'KernelAlloc',        \      ; stdcall
          kernel_free,           'KernelFree',         \      ; stdcall
          malloc,                'Kmalloc',            \
          free,                  'Kfree',              \
          map_io_mem,            'MapIoMem',           \      ; stdcall
          get_pg_addr,           'GetPgAddr',          \      ; eax
\
          mutex_init,            'MutexInit',          \      ; gcc fastcall
          mutex_lock,            'MutexLock',          \      ; gcc fastcall
          mutex_unlock,          'MutexUnlock',        \      ; gcc fastcall
\
          get_display,           'GetDisplay',         \
          set_screen,            'SetScreen',          \
          window._.get_rect,     'GetWindowRect',      \      ; gcc fastcall
          pci_api_drv,           'PciApi',             \
          pci_read8,             'PciRead8',           \      ; stdcall
          pci_read16,            'PciRead16',          \      ; stdcall
          pci_read32,            'PciRead32',          \      ; stdcall
          pci_write8,            'PciWrite8',          \      ; stdcall
          pci_write16,           'PciWrite16',         \      ; stdcall
          pci_write32,           'PciWrite32',         \      ; stdcall
\
          get_pid,               'GetPid',             \
          get_service,           'GetService',         \      ;
          reg_service,           'RegService',         \      ; stdcall
          attach_int_handler,    'AttachIntHandler',   \      ; stdcall
          user_alloc,            'UserAlloc',          \      ; stdcall
          user_free,             'UserFree',           \      ; stdcall
          unmap_pages,           'UnmapPages',         \      ; eax, ecx
          sys_msg_board_str,     'SysMsgBoardStr',     \
          get_timer_ticks,       'GetTimerTicks',      \
          get_stack_base,        'GetStackBase',       \
          delay_hs,              'Delay',              \      ; ebx
          set_mouse_data,        'SetMouseData',       \      ;
          set_keyboard_data,     'SetKeyboardData',    \      ; gcc fastcall
          timer_hs,              'TimerHs'                   ; stdcall

Rev 2434	Rev 2465
1	;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;	1	;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
2	;; ;;	2	;; ;;
3	;; Copyright (C) KolibriOS team 2004-2007. All rights reserved. ;;	3	;; Copyright (C) KolibriOS team 2004-2012. 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	;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
7		7
8	$Revision: 2434 $	8	$Revision: 2465 $
9		9
10	include 'export.inc'	10	include 'export.inc'
11		11
12	align 4	12	align 4
13		13
14	proc load_PE stdcall, file_name:dword	14	proc load_PE stdcall, file_name:dword
15	locals	15	locals
16	image dd ?	16	image dd ?
17	entry dd ?	17	entry dd ?
18	base dd ?	18	base dd ?
19	endl	19	endl
20		20
21	stdcall load_file, [file_name]	21	stdcall load_file, [file_name]
22	test eax, eax	22	test eax, eax
23	jz .fail	23	jz .fail
24		24
25	mov [image], eax	25	mov [image], eax
26		26
27	mov edx, [eax+60]	27	mov edx, [eax+60]
28		28
29	stdcall kernel_alloc, [eax+80+edx]	29	stdcall kernel_alloc, [eax+80+edx]
30	test eax, eax	30	test eax, eax
31	jz .cleanup	31	jz .cleanup
32		32
33	mov [base], eax	33	mov [base], eax
34		34
35	stdcall map_PE, eax, [image]	35	stdcall map_PE, eax, [image]
36		36
37	mov [entry], eax	37	mov [entry], eax
38	test eax, eax	38	test eax, eax
39	jnz .cleanup	39	jnz .cleanup
40		40
41	stdcall kernel_free, [base]	41	stdcall kernel_free, [base]
42	.cleanup:	42	.cleanup:
43	stdcall kernel_free, [image]	43	stdcall kernel_free, [image]
44	mov eax, [entry]	44	mov eax, [entry]
45	ret	45	ret
46	.fail:	46	.fail:
47	xor eax, eax	47	xor eax, eax
48	ret	48	ret
49	endp	49	endp
50		50
51	DWORD equ dword	51	DWORD equ dword
52	PTR equ	52	PTR equ
53		53
54	align 4	54	align 4
55	map_PE: ;stdcall base:dword, image:dword	55	map_PE: ;stdcall base:dword, image:dword
56	cld	56	cld
57	push ebp	57	push ebp
58	push edi	58	push edi
59	push esi	59	push esi
60	push ebx	60	push ebx
61	sub esp, 60	61	sub esp, 60
62	mov ebx, DWORD PTR [esp+84]	62	mov ebx, DWORD PTR [esp+84]
63	mov ebp, DWORD PTR [esp+80]	63	mov ebp, DWORD PTR [esp+80]
64	mov edx, ebx	64	mov edx, ebx
65	mov esi, ebx	65	mov esi, ebx
66	add edx, DWORD PTR [ebx+60]	66	add edx, DWORD PTR [ebx+60]
67	mov edi, ebp	67	mov edi, ebp
68	mov DWORD PTR [esp+32], edx	68	mov DWORD PTR [esp+32], edx
69	mov ecx, DWORD PTR [edx+84]	69	mov ecx, DWORD PTR [edx+84]
70		70
71	shr ecx, 2	71	shr ecx, 2
72	rep movsd	72	rep movsd
73		73
74	movzx eax, WORD PTR [edx+6]	74	movzx eax, WORD PTR [edx+6]
75	mov DWORD PTR [esp+36], 0	75	mov DWORD PTR [esp+36], 0
76	mov DWORD PTR [esp+16], eax	76	mov DWORD PTR [esp+16], eax
77	jmp L2	77	jmp L2
78	L3:	78	L3:
79	mov eax, DWORD PTR [edx+264]	79	mov eax, DWORD PTR [edx+264]
80	test eax, eax	80	test eax, eax
81	je L4	81	je L4
82	mov esi, ebx	82	mov esi, ebx
83	mov edi, ebp	83	mov edi, ebp
84	add esi, DWORD PTR [edx+268]	84	add esi, DWORD PTR [edx+268]
85	mov ecx, eax	85	mov ecx, eax
86	add edi, DWORD PTR [edx+260]	86	add edi, DWORD PTR [edx+260]
87		87
88	shr ecx, 2	88	shr ecx, 2
89	rep movsd	89	rep movsd
90		90
91	L4:	91	L4:
92	mov ecx, DWORD PTR [edx+256]	92	mov ecx, DWORD PTR [edx+256]
93	add ecx, 4095	93	add ecx, 4095
94	and ecx, -4096	94	and ecx, -4096
95	cmp ecx, eax	95	cmp ecx, eax
96	jbe L6	96	jbe L6
97	sub ecx, eax	97	sub ecx, eax
98	add eax, DWORD PTR [edx+260]	98	add eax, DWORD PTR [edx+260]
99	lea edi, [eax+ebp]	99	lea edi, [eax+ebp]
100		100
101	xor eax, eax	101	xor eax, eax
102	rep stosb	102	rep stosb
103		103
104	L6:	104	L6:
105	inc DWORD PTR [esp+36]	105	inc DWORD PTR [esp+36]
106	add edx, 40	106	add edx, 40
107	L2:	107	L2:
108	mov esi, DWORD PTR [esp+16]	108	mov esi, DWORD PTR [esp+16]
109	cmp DWORD PTR [esp+36], esi	109	cmp DWORD PTR [esp+36], esi
110	jne L3	110	jne L3
111	mov edi, DWORD PTR [esp+32]	111	mov edi, DWORD PTR [esp+32]
112	cmp DWORD PTR [edi+164], 0	112	cmp DWORD PTR [edi+164], 0
113	je L9	113	je L9
114	mov esi, ebp	114	mov esi, ebp
115	mov ecx, ebp	115	mov ecx, ebp
116	sub esi, DWORD PTR [edi+52]	116	sub esi, DWORD PTR [edi+52]
117	add ecx, DWORD PTR [edi+160]	117	add ecx, DWORD PTR [edi+160]
118	mov eax, esi	118	mov eax, esi
119	shr eax, 16	119	shr eax, 16
120	mov DWORD PTR [esp+12], eax	120	mov DWORD PTR [esp+12], eax
121	jmp L11	121	jmp L11
122	L12:	122	L12:
123	lea ebx, [eax-8]	123	lea ebx, [eax-8]
124	xor edi, edi	124	xor edi, edi
125	shr ebx, 1	125	shr ebx, 1
126	jmp L13	126	jmp L13
127	L14:	127	L14:
128	movzx eax, WORD PTR [ecx+8+edi*2]	128	movzx eax, WORD PTR [ecx+8+edi*2]
129	mov edx, eax	129	mov edx, eax
130	shr eax, 12	130	shr eax, 12
131	and edx, 4095	131	and edx, 4095
132	add edx, DWORD PTR [ecx]	132	add edx, DWORD PTR [ecx]
133	cmp ax, 2	133	cmp ax, 2
134	je L17	134	je L17
135	cmp ax, 3	135	cmp ax, 3
136	je L18	136	je L18
137	dec ax	137	dec ax
138	jne L15	138	jne L15
139	mov eax, DWORD PTR [esp+12]	139	mov eax, DWORD PTR [esp+12]
140	add WORD PTR [edx+ebp], ax	140	add WORD PTR [edx+ebp], ax
141	L17:	141	L17:
142	add WORD PTR [edx+ebp], si	142	add WORD PTR [edx+ebp], si
143	L18:	143	L18:
144	add DWORD PTR [edx+ebp], esi	144	add DWORD PTR [edx+ebp], esi
145	L15:	145	L15:
146	inc edi	146	inc edi
147	L13:	147	L13:
148	cmp edi, ebx	148	cmp edi, ebx
149	jne L14	149	jne L14
150	add ecx, DWORD PTR [ecx+4]	150	add ecx, DWORD PTR [ecx+4]
151	L11:	151	L11:
152	mov eax, DWORD PTR [ecx+4]	152	mov eax, DWORD PTR [ecx+4]
153	test eax, eax	153	test eax, eax
154	jne L12	154	jne L12
155	L9:	155	L9:
156	mov edx, DWORD PTR [esp+32]	156	mov edx, DWORD PTR [esp+32]
157	cmp DWORD PTR [edx+132], 0	157	cmp DWORD PTR [edx+132], 0
158	je L20	158	je L20
159	mov eax, ebp	159	mov eax, ebp
160	add eax, DWORD PTR [edx+128]	160	add eax, DWORD PTR [edx+128]
161	mov DWORD PTR [esp+40], 0	161	mov DWORD PTR [esp+40], 0
162	add eax, 20	162	add eax, 20
163	mov DWORD PTR [esp+56], eax	163	mov DWORD PTR [esp+56], eax
164	L22:	164	L22:
165	mov ecx, DWORD PTR [esp+56]	165	mov ecx, DWORD PTR [esp+56]
166	cmp DWORD PTR [ecx-16], 0	166	cmp DWORD PTR [ecx-16], 0
167	jne L23	167	jne L23
168	cmp DWORD PTR [ecx-8], 0	168	cmp DWORD PTR [ecx-8], 0
169	je L25	169	je L25
170	L23:	170	L23:
171	mov edi, DWORD PTR [__exports+32]	171	mov edi, DWORD PTR [__exports+32]
172	mov esi, DWORD PTR [__exports+28]	172	mov esi, DWORD PTR [__exports+28]
173	mov eax, DWORD PTR [esp+56]	173	mov eax, DWORD PTR [esp+56]
174	mov DWORD PTR [esp+20], edi	174	mov DWORD PTR [esp+20], edi
175	add edi, OS_BASE	175	add edi, OS_BASE
176	add esi, OS_BASE	176	add esi, OS_BASE
177	mov DWORD PTR [esp+44], esi	177	mov DWORD PTR [esp+44], esi
178	mov ecx, DWORD PTR [eax-4]	178	mov ecx, DWORD PTR [eax-4]
179	mov DWORD PTR [esp+48], edi	179	mov DWORD PTR [esp+48], edi
180	mov edx, DWORD PTR [eax-20]	180	mov edx, DWORD PTR [eax-20]
181	mov DWORD PTR [esp+52], 0	181	mov DWORD PTR [esp+52], 0
182	add ecx, ebp	182	add ecx, ebp
183	add edx, ebp	183	add edx, ebp
184	mov DWORD PTR [esp+24], edx	184	mov DWORD PTR [esp+24], edx
185	mov DWORD PTR [esp+28], ecx	185	mov DWORD PTR [esp+28], ecx
186	L26:	186	L26:
187	mov esi, DWORD PTR [esp+52]	187	mov esi, DWORD PTR [esp+52]
188	mov edi, DWORD PTR [esp+24]	188	mov edi, DWORD PTR [esp+24]
189	mov eax, DWORD PTR [edi+esi*4]	189	mov eax, DWORD PTR [edi+esi*4]
190	test eax, eax	190	test eax, eax
191	je L27	191	je L27
192	test eax, eax	192	test eax, eax
193	js L27	193	js L27
194	lea edi, [ebp+eax]	194	lea edi, [ebp+eax]
195	mov eax, DWORD PTR [esp+28]	195	mov eax, DWORD PTR [esp+28]
196	mov DWORD PTR [eax+esi*4], 0	196	mov DWORD PTR [eax+esi*4], 0
197	lea esi, [edi+2]	197	lea esi, [edi+2]
198	push eax	198	push eax
199	push 32	199	push 32
200	movzx eax, WORD PTR [edi]	200	movzx eax, WORD PTR [edi]
201	mov edx, DWORD PTR [esp+56]	201	mov edx, DWORD PTR [esp+56]
202	mov eax, DWORD PTR [edx+eax*4]	202	mov eax, DWORD PTR [edx+eax*4]
203	add eax, OS_BASE	203	add eax, OS_BASE
204	push eax	204	push eax
205	push esi	205	push esi
206	call strncmp	206	call strncmp
207	pop ebx	207	pop ebx
208	xor ebx, ebx	208	xor ebx, ebx
209	test eax, eax	209	test eax, eax
210	jne L32	210	jne L32
211	jmp L30	211	jmp L30
212	L33:	212	L33:
213	push ecx	213	push ecx
214	push 32	214	push 32
215	mov ecx, DWORD PTR [esp+28]	215	mov ecx, DWORD PTR [esp+28]
216	mov eax, DWORD PTR [ecx+OS_BASE+ebx*4]	216	mov eax, DWORD PTR [ecx+OS_BASE+ebx*4]
217	add eax, OS_BASE	217	add eax, OS_BASE
218	push eax	218	push eax
219	push esi	219	push esi
220	call strncmp	220	call strncmp
221	pop edx	221	pop edx
222	test eax, eax	222	test eax, eax
223	jne L34	223	jne L34
224	mov esi, DWORD PTR [esp+44]	224	mov esi, DWORD PTR [esp+44]
225	mov edx, DWORD PTR [esp+52]	225	mov edx, DWORD PTR [esp+52]
226	mov ecx, DWORD PTR [esp+28]	226	mov ecx, DWORD PTR [esp+28]
227	mov eax, DWORD PTR [esi+ebx*4]	227	mov eax, DWORD PTR [esi+ebx*4]
228	add eax, OS_BASE	228	add eax, OS_BASE
229	mov DWORD PTR [ecx+edx*4], eax	229	mov DWORD PTR [ecx+edx*4], eax
230	jmp L36	230	jmp L36
231	L34:	231	L34:
232	inc ebx	232	inc ebx
233	L32:	233	L32:
234	cmp ebx, DWORD PTR [__exports+24]	234	cmp ebx, DWORD PTR [__exports+24]
235	jb L33	235	jb L33
236	L36:	236	L36:
237	cmp ebx, DWORD PTR [__exports+24]	237	cmp ebx, DWORD PTR [__exports+24]
238	jne L37	238	jne L37
239		239
240	mov esi, msg_unresolved	240	mov esi, msg_unresolved
241	call sys_msg_board_str	241	call sys_msg_board_str
242	lea esi, [edi+2]	242	lea esi, [edi+2]
243	call sys_msg_board_str	243	call sys_msg_board_str
244	mov esi, msg_CR	244	mov esi, msg_CR
245	call sys_msg_board_str	245	call sys_msg_board_str
246		246
247	mov DWORD PTR [esp+40], 1	247	mov DWORD PTR [esp+40], 1
248	jmp L37	248	jmp L37
249	L30:	249	L30:
250	movzx eax, WORD PTR [edi]	250	movzx eax, WORD PTR [edi]
251	mov esi, DWORD PTR [esp+44]	251	mov esi, DWORD PTR [esp+44]
252	mov edi, DWORD PTR [esp+52]	252	mov edi, DWORD PTR [esp+52]
253	mov edx, DWORD PTR [esp+28]	253	mov edx, DWORD PTR [esp+28]
254	mov eax, DWORD PTR [esi+eax*4]	254	mov eax, DWORD PTR [esi+eax*4]
255	add eax, OS_BASE	255	add eax, OS_BASE
256	mov DWORD PTR [edx+edi*4], eax	256	mov DWORD PTR [edx+edi*4], eax
257	L37:	257	L37:
258	inc DWORD PTR [esp+52]	258	inc DWORD PTR [esp+52]
259	jmp L26	259	jmp L26
260	L27:	260	L27:
261	add DWORD PTR [esp+56], 20	261	add DWORD PTR [esp+56], 20
262	jmp L22	262	jmp L22
263	L25:	263	L25:
264	xor eax, eax	264	xor eax, eax
265	cmp DWORD PTR [esp+40], 0	265	cmp DWORD PTR [esp+40], 0
266	jne L40	266	jne L40
267	L20:	267	L20:
268	mov ecx, DWORD PTR [esp+32]	268	mov ecx, DWORD PTR [esp+32]
269	mov eax, ebp	269	mov eax, ebp
270	add eax, DWORD PTR [ecx+40]	270	add eax, DWORD PTR [ecx+40]
271	L40:	271	L40:
272	add esp, 60	272	add esp, 60
273	pop ebx	273	pop ebx
274	pop esi	274	pop esi
275	pop edi	275	pop edi
276	pop ebp	276	pop ebp
277	ret 8	277	ret 8
278		278
279	align 16	279	align 16
280	__exports:	280	__exports:
281	export 'KERNEL', \	281	export 'KERNEL', \
282	alloc_kernel_space, 'AllocKernelSpace', \ ; stdcall	282	alloc_kernel_space, 'AllocKernelSpace', \ ; stdcall
283	alloc_page, 'AllocPage', \ ; gcc ABI	283	alloc_page, 'AllocPage', \ ; gcc ABI
284	alloc_pages, 'AllocPages', \ ; stdcall	284	alloc_pages, 'AllocPages', \ ; stdcall
285	commit_pages, 'CommitPages', \ ; eax, ebx, ecx	285	commit_pages, 'CommitPages', \ ; eax, ebx, ecx
286	\	286	\
287	create_event, 'CreateEvent', \ ; ecx, esi	287	create_event, 'CreateEvent', \ ; ecx, esi
288	destroy_event, 'DestroyEvent', \ ;	288	destroy_event, 'DestroyEvent', \ ;
289	raise_event, 'RaiseEvent', \ ; eax, ebx, edx, esi	289	raise_event, 'RaiseEvent', \ ; eax, ebx, edx, esi
290	wait_event, 'WaitEvent', \ ; eax, ebx	290	wait_event, 'WaitEvent', \ ; eax, ebx
291	get_event_ex, 'GetEvent', \ ; edi	291	get_event_ex, 'GetEvent', \ ; edi
292	\	292	\
293	create_kernel_object, 'CreateObject', \	293	create_kernel_object, 'CreateObject', \
294	create_ring_buffer, 'CreateRingBuffer', \ ; stdcall	294	create_ring_buffer, 'CreateRingBuffer', \ ; stdcall
295	destroy_kernel_object, 'DestroyObject', \	295	destroy_kernel_object, 'DestroyObject', \
296	free_kernel_space, 'FreeKernelSpace', \ ; stdcall	296	free_kernel_space, 'FreeKernelSpace', \ ; stdcall
297	free_page, 'FreePage', \ ; eax	297	free_page, 'FreePage', \ ; eax
298	kernel_alloc, 'KernelAlloc', \ ; stdcall	298	kernel_alloc, 'KernelAlloc', \ ; stdcall
299	kernel_free, 'KernelFree', \ ; stdcall	299	kernel_free, 'KernelFree', \ ; stdcall
300	malloc, 'Kmalloc', \	300	malloc, 'Kmalloc', \
301	free, 'Kfree', \	301	free, 'Kfree', \
302	map_io_mem, 'MapIoMem', \ ; stdcall	302	map_io_mem, 'MapIoMem', \ ; stdcall
303	get_pg_addr, 'GetPgAddr', \ ; eax	303	get_pg_addr, 'GetPgAddr', \ ; eax
304	\	304	\
305	mutex_init, 'MutexInit', \ ; gcc fastcall	305	mutex_init, 'MutexInit', \ ; gcc fastcall
306	mutex_lock, 'MutexLock', \ ; gcc fastcall	306	mutex_lock, 'MutexLock', \ ; gcc fastcall
307	mutex_unlock, 'MutexUnlock', \ ; gcc fastcall	307	mutex_unlock, 'MutexUnlock', \ ; gcc fastcall
308	\	308	\
309	get_display, 'GetDisplay', \	309	get_display, 'GetDisplay', \
310	set_screen, 'SetScreen', \	310	set_screen, 'SetScreen', \
311	window._.get_rect, 'GetWindowRect', \ ; gcc fastcall	311	window._.get_rect, 'GetWindowRect', \ ; gcc fastcall
312	pci_api_drv, 'PciApi', \	312	pci_api_drv, 'PciApi', \
313	pci_read8, 'PciRead8', \ ; stdcall	313	pci_read8, 'PciRead8', \ ; stdcall
314	pci_read16, 'PciRead16', \ ; stdcall	314	pci_read16, 'PciRead16', \ ; stdcall
315	pci_read32, 'PciRead32', \ ; stdcall	315	pci_read32, 'PciRead32', \ ; stdcall
316	pci_write8, 'PciWrite8', \ ; stdcall	316	pci_write8, 'PciWrite8', \ ; stdcall
317	pci_write16, 'PciWrite16', \ ; stdcall	317	pci_write16, 'PciWrite16', \ ; stdcall
318	pci_write32, 'PciWrite32', \ ; stdcall	318	pci_write32, 'PciWrite32', \ ; stdcall
319	\	319	\
320	get_pid, 'GetPid', \	320	get_pid, 'GetPid', \
321	get_service, 'GetService', \ ;	321	get_service, 'GetService', \ ;
322	reg_service, 'RegService', \ ; stdcall	322	reg_service, 'RegService', \ ; stdcall
323	attach_int_handler, 'AttachIntHandler', \ ; stdcall	323	attach_int_handler, 'AttachIntHandler', \ ; stdcall
324	user_alloc, 'UserAlloc', \ ; stdcall	324	user_alloc, 'UserAlloc', \ ; stdcall
325	user_free, 'UserFree', \ ; stdcall	325	user_free, 'UserFree', \ ; stdcall
326	unmap_pages, 'UnmapPages', \ ; eax, ecx	326	unmap_pages, 'UnmapPages', \ ; eax, ecx
327	sys_msg_board_str, 'SysMsgBoardStr', \	327	sys_msg_board_str, 'SysMsgBoardStr', \
328	get_timer_ticks, 'GetTimerTicks', \	328	get_timer_ticks, 'GetTimerTicks', \
329	get_stack_base, 'GetStackBase', \	329	get_stack_base, 'GetStackBase', \
330	delay_hs, 'Delay', \ ; ebx	330	delay_hs, 'Delay', \ ; ebx
331	set_mouse_data, 'SetMouseData', \ ;	331	set_mouse_data, 'SetMouseData', \ ;
332	set_keyboard_data, 'SetKeyboardData', \ ; gcc fastcall	332	set_keyboard_data, 'SetKeyboardData', \ ; gcc fastcall
333	timer_hs, 'TimerHs' ; stdcall	333	timer_hs, 'TimerHs' ; stdcall

Subversion Repositories Kolibri OS

(root)/kernel/branches/Kolibri-acpi/core/peload.inc – Rev 2434 → 2465