WebSVN – HelenOS-historic – Diff – /kernel/trunk/arch/ia32/src/asm.S


#
# Copyright (C) 2001-2004 Jakub Jermar
# All rights reserved.
#
# Redistribution and use in source and binary forms, with or without
# modification, are permitted provided that the following conditions
# are met:
#
# - Redistributions of source code must retain the above copyright
#   notice, this list of conditions and the following disclaimer.
# - Redistributions in binary form must reproduce the above copyright
#   notice, this list of conditions and the following disclaimer in the
#   documentation and/or other materials provided with the distribution.
# - The name of the author may not be used to endorse or promote products
#   derived from this software without specific prior written permission.
#
# THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
# IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
# OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
# IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
# INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
# NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
# DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
# THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
# THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
#
 
## very low and hardware-level functions
 
#  Mask for interrupts 0 - 31 (bits 0 - 31) where 0 means that int has no error word
# and 1 means interrupt with error word
#define ERROR_WORD_INTERRUPT_LIST 0x00027D00
 
.text
 
.global paging_on
.global enable_l_apic_in_msr
.global interrupt_handlers
.global inb
.global inw
.global inl
.global outb
.global outw
.global outl
.global memcopy
.global memsetb
.global memsetw
.global memcmp
 
 
## Turn paging on
#
# Enable paging and write-back caching in CR0.
#
paging_on:
	pushl %eax
	movl %cr0,%eax
	orl $(1<<31),%eax		# paging on
	andl $~((1<<30)|(1<<29)),%eax	# clear Cache Disable and not Write Though
	movl %eax,%cr0
	jmp 0f
0:
	popl %eax
	ret
 
 
## Enable local APIC
#
# Enable local APIC in MSR.
#
enable_l_apic_in_msr:
	pusha
	
	movl $0x1b, %ecx
	rdmsr
	orl $(1<<11),%eax
	orl $(0xfee00000),%eax
	wrmsr
	
	popa
	ret
 
 
## Declare interrupt handlers
#
# Declare interrupt handlers for n interrupt
# vectors starting at vector i.
#
# The handlers setup data segment registers
# and call trap_dispatcher().
#
.macro handler i n
	push %ebp
	movl %esp,%ebp
	pusha
 
	push %ds
	push %es
 
	# we must fill the data segment registers
	movw $16,%ax
	movw %ax,%ds
	movw %ax,%es
 
	movl $(\i),%edi
	pushl %ebp
	addl $4,(%esp)
	pushl %edi
	call trap_dispatcher
	addl $8,%esp
 
	pop %es
	pop %ds
 
 
# CLNT
  pushfl;
	pop %eax;
	and $0xFFFFBFFF,%eax;
	push %eax;
	popfl;
	
 
 
# Test if this is interrupt with error word or not
	mov $\i,%cl;
	movl $1,%eax;
	test $0xe0,%cl;
	jnz 0f;
	and $0x1f,%cl;
	shl %cl,%eax;
	and $ERROR_WORD_INTERRUPT_LIST,%eax;
	jz 0f;
 
 
# Return with error word
	popa;
	pop %ebp;
	add $4,%esp;    # Skip error word
	iret;
 
0:
# Return with no error word
	popa
	pop %ebp
	iret
 
	.if (\n-\i)-1
	handler "(\i+1)",\n
	.endif
.endm
 
# keep in sync with pm.h !!!
IDT_ITEMS=64
interrupt_handlers:
h_start:
	handler 0 64
#	handler 64 128	
#	handler 128 192
#	handler 192 256
h_end:
 
 
## I/O input (byte)
#
# Get a byte from I/O port and store it AL.
#
inb:
	push %edx
	xorl %eax,%eax
	movl 8(%esp),%edx
	inb %dx,%al
	pop %edx
	ret
 
 
## I/O input (word)
#
# Get a word from I/O port and store it AX.
#
inw:
	push %edx
	xorl %eax,%eax
	movl 8(%esp),%edx
	inw %dx,%ax
	pop %edx
	ret
 
 
## I/O input (dword)
#
# Get a dword from I/O port and store it EAX.
#
inl:
	push %edx
	xorl %eax,%eax
	movl 8(%esp),%edx
	inl %dx,%eax
	pop %edx
	ret
 
 
## I/O output (byte)
#
# Send a byte to I/O port.
#
outb:
	push %ebp
	movl %esp,%ebp
	pusha
 
	movl 8(%ebp),%edx
	movl 12(%ebp),%eax
	outb %al,%dx
 
	popa
	pop %ebp
	ret
 
 
## I/O output (word)
#
# Send a word to I/O port.
#
outw:
	push %ebp
	movl %esp,%ebp
	pusha
 
	movl 8(%ebp),%edx
	movl 12(%ebp),%eax
	outw %ax,%dx
 
	popa
	pop %ebp
	ret
 
 
## I/O output (dword)
#
# Send a dword to I/O port.
#
outl:
	push %ebp
	movl %esp,%ebp
	pusha
 
	movl 8(%ebp),%edx
	movl 12(%ebp),%eax
	outl %eax,%dx
 
	popa
	pop %ebp
	ret
 
 
## Copy memory
#
# Copy a given number of bytes (3rd argument)
# from the memory location defined by 2nd argument
# to the memory location defined by 1st argument.
# The memory areas cannot overlap.
#
SRC=12
DST=8
CNT=16
memcopy:
	push %ebp
	movl %esp,%ebp
	pusha
 
	cld
	movl CNT(%ebp),%ecx
	movl DST(%ebp),%edi
	movl SRC(%ebp),%esi
 
	rep movsb %ds:(%esi),%es:(%edi)
 
	popa
	pop %ebp
	ret
 
 
## Fill memory with bytes
#
# Fill a given number of bytes (2nd argument)
# at memory defined by 1st argument with the
# byte value defined by 3rd argument.
#
DST=8
CNT=12
X=16
memsetb:
	push %ebp
	movl %esp,%ebp
	pusha
 
	cld
	movl CNT(%ebp),%ecx
	movl DST(%ebp),%edi
	movl X(%ebp),%eax
 
	rep stosb %al,%es:(%edi)
 
	popa
	pop %ebp
	ret
 
 
## Fill memory with words
#
# Fill a given number of words (2nd argument)
# at memory defined by 1st argument with the
# word value defined by 3rd argument.
#
DST=8
CNT=12
X=16
memsetw:
	push %ebp
	movl %esp,%ebp
	pusha
 
	cld
	movl CNT(%ebp),%ecx
	movl DST(%ebp),%edi
	movl X(%ebp),%eax
 
	rep stosw %ax,%es:(%edi)
 
	popa
	pop %ebp
	ret
 
 
## Compare memory regions for equality
#
# Compare a given number of bytes (3rd argument)
# at memory locations defined by 1st and 2nd argument
# for equality. If the bytes are equal, EAX contains
# 0.
#
SRC=12
DST=16
CNT=20
memcmp:
	push %ebp
	subl $4,%esp	
	movl %esp,%ebp
 
	pusha
 
	cld
	movl CNT(%ebp),%ecx
	movl DST(%ebp),%edi
	movl SRC(%ebp),%esi
 
	repe cmpsb %es:(%edi),%ds:(%esi)
	movl %ecx,(%ebp)
 
	popa
	
	movl (%ebp),%eax	# return value => %eax (zero on success)
	addl $4,%esp
	pop %ebp
	
	ret
 
 
# THIS IS USERSPACE CODE
.global utext
utext:
	xor %ax,%ax;
	mov %ax,%ds;
	mov %ax,%es;
	mov %ax,%fs;
	mov %ax,%gs;
0:
	int $48
	jmp 0b
	# not reached
utext_end:
 
.data
.global utext_size
utext_size:
	.long utext_end - utext 
 
 
#.section K_DATA_START
.global interrupt_handler_size
 
interrupt_handler_size: .long (h_end-h_start)/IDT_ITEMS
 

Rev 196	Rev 198
1	#	1	#
2	# Copyright (C) 2001-2004 Jakub Jermar	2	# Copyright (C) 2001-2004 Jakub Jermar
3	# All rights reserved.	3	# All rights reserved.
4	#	4	#
5	# Redistribution and use in source and binary forms, with or without	5	# Redistribution and use in source and binary forms, with or without
6	# modification, are permitted provided that the following conditions	6	# modification, are permitted provided that the following conditions
7	# are met:	7	# are met:
8	#	8	#
9	# - Redistributions of source code must retain the above copyright	9	# - Redistributions of source code must retain the above copyright
10	# notice, this list of conditions and the following disclaimer.	10	# notice, this list of conditions and the following disclaimer.
11	# - Redistributions in binary form must reproduce the above copyright	11	# - Redistributions in binary form must reproduce the above copyright
12	# notice, this list of conditions and the following disclaimer in the	12	# notice, this list of conditions and the following disclaimer in the
13	# documentation and/or other materials provided with the distribution.	13	# documentation and/or other materials provided with the distribution.
14	# - The name of the author may not be used to endorse or promote products	14	# - The name of the author may not be used to endorse or promote products
15	# derived from this software without specific prior written permission.	15	# derived from this software without specific prior written permission.
16	#	16	#
17	# THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR	17	# THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
18	# IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES	18	# IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
19	# OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.	19	# OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
20	# IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,	20	# IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
21	# INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT	21	# INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
22	# NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,	22	# NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
23	# DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY	23	# DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
24	# THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT	24	# THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
25	# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF	25	# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
26	# THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.	26	# THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
27	#	27	#
28		28
29	## very low and hardware-level functions	29	## very low and hardware-level functions
30		30
31	# Mask for interrupts 0 - 31 (bits 0 - 31) where 0 means that int has no error word	31	# Mask for interrupts 0 - 31 (bits 0 - 31) where 0 means that int has no error word
32	# and 1 means interrupt with error word	32	# and 1 means interrupt with error word
33	#define ERROR_WORD_INTERRUPT_LIST 0x00027D00	33	#define ERROR_WORD_INTERRUPT_LIST 0x00027D00
34		34
35	.text	35	.text
36		36
37	.global paging_on	37	.global paging_on
38	.global enable_l_apic_in_msr	38	.global enable_l_apic_in_msr
39	.global interrupt_handlers	39	.global interrupt_handlers
40	.global inb	40	.global inb
41	.global inw	41	.global inw
42	.global inl	42	.global inl
43	.global outb	43	.global outb
44	.global outw	44	.global outw
45	.global outl	45	.global outl
46	.global memcopy	46	.global memcopy
47	.global memsetb	47	.global memsetb
48	.global memsetw	48	.global memsetw
49	.global memcmp	49	.global memcmp
50		50
51		51
52	## Turn paging on	52	## Turn paging on
53	#	53	#
54	# Enable paging and write-back caching in CR0.	54	# Enable paging and write-back caching in CR0.
55	#	55	#
56	paging_on:	56	paging_on:
57	pushl %eax	57	pushl %eax
58	movl %cr0,%eax	58	movl %cr0,%eax
59	orl $(1<<31),%eax # paging on	59	orl $(1<<31),%eax # paging on
60	andl $~((1<<30)\|(1<<29)),%eax # clear Cache Disable and not Write Though	60	andl $~((1<<30)\|(1<<29)),%eax # clear Cache Disable and not Write Though
61	movl %eax,%cr0	61	movl %eax,%cr0
62	jmp 0f	62	jmp 0f
63	0:	63	0:
64	popl %eax	64	popl %eax
65	ret	65	ret
66		66
67		67
68	## Enable local APIC	68	## Enable local APIC
69	#	69	#
70	# Enable local APIC in MSR.	70	# Enable local APIC in MSR.
71	#	71	#
72	enable_l_apic_in_msr:	72	enable_l_apic_in_msr:
73	pusha	73	pusha
74		74
75	movl $0x1b, %ecx	75	movl $0x1b, %ecx
76	rdmsr	76	rdmsr
77	orl $(1<<11),%eax	77	orl $(1<<11),%eax
78	orl $(0xfee00000),%eax	78	orl $(0xfee00000),%eax
79	wrmsr	79	wrmsr
80		80
81	popa	81	popa
82	ret	82	ret
83		83
84		84
85	## Declare interrupt handlers	85	## Declare interrupt handlers
86	#	86	#
87	# Declare interrupt handlers for n interrupt	87	# Declare interrupt handlers for n interrupt
88	# vectors starting at vector i.	88	# vectors starting at vector i.
89	#	89	#
90	# The handlers setup data segment registers	90	# The handlers setup data segment registers
91	# and call trap_dispatcher().	91	# and call trap_dispatcher().
92	#	92	#
93	.macro handler i n	93	.macro handler i n
94	push %ebp	94	push %ebp
95	movl %esp,%ebp	95	movl %esp,%ebp
96	pusha	96	pusha
97		97
98	push %ds	98	push %ds
99	push %es	99	push %es
100		100
101	# we must fill the data segment registers	101	# we must fill the data segment registers
102	movw $16,%ax	102	movw $16,%ax
103	movw %ax,%ds	103	movw %ax,%ds
104	movw %ax,%es	104	movw %ax,%es
105		105
106	movl $(\i),%edi	106	movl $(\i),%edi
107	pushl %ebp	107	pushl %ebp
108	addl $4,(%esp)	108	addl $4,(%esp)
109	pushl %edi	109	pushl %edi
110	call trap_dispatcher	110	call trap_dispatcher
111	addl $8,%esp	111	addl $8,%esp
112		112
113	pop %es	113	pop %es
114	pop %ds	114	pop %ds
115		115
116		116
117	# CLNT	117	# CLNT
118	pushfl;	118	pushfl;
119	pop %eax;	119	pop %eax;
120	and $0xFFFFBFFF,%eax;	120	and $0xFFFFBFFF,%eax;
121	push %eax;	121	push %eax;
122	popfl;	122	popfl;
123		123
124		124
125		125
126	# Test if this is interrupt with error word or not	126	# Test if this is interrupt with error word or not
127	mov $\i,%cl;	127	mov $\i,%cl;
128	movl $1,%eax;	128	movl $1,%eax;
129	test $0xe0,%cl;	129	test $0xe0,%cl;
130	jnz 0f;	130	jnz 0f;
131	and $0x1f,%cl;	131	and $0x1f,%cl;
132	shl %cl,%eax;	132	shl %cl,%eax;
133	and $ERROR_WORD_INTERRUPT_LIST,%eax;	133	and $ERROR_WORD_INTERRUPT_LIST,%eax;
134	jz 0f;	134	jz 0f;
135		135
136		136
137	# Return with error word	137	# Return with error word
138	popa;	138	popa;
139	pop %ebp;	139	pop %ebp;
140	add $4,%esp; # Skip error word	140	add $4,%esp; # Skip error word
141	iret;	141	iret;
142		142
143	0:	143	0:
144	# Return with no error word	144	# Return with no error word
145	popa	145	popa
146	pop %ebp	146	pop %ebp
147	iret	147	iret
148		148
149	.if (\n-\i)-1	149	.if (\n-\i)-1
150	handler "(\i+1)",\n	150	handler "(\i+1)",\n
151	.endif	151	.endif
152	.endm	152	.endm
153		153
154	# keep in sync with pm.h !!!	154	# keep in sync with pm.h !!!
155	IDT_ITEMS=64	155	IDT_ITEMS=64
156	interrupt_handlers:	156	interrupt_handlers:
157	h_start:	157	h_start:
158	handler 0 64	158	handler 0 64
159	# handler 64 128	159	# handler 64 128
160	# handler 128 192	160	# handler 128 192
161	# handler 192 256	161	# handler 192 256
162	h_end:	162	h_end:
163		163
164		164
165	## I/O input (byte)	165	## I/O input (byte)
166	#	166	#
167	# Get a byte from I/O port and store it AL.	167	# Get a byte from I/O port and store it AL.
168	#	168	#
169	inb:	169	inb:
170	push %edx	170	push %edx
171	xorl %eax,%eax	171	xorl %eax,%eax
172	movl 8(%esp),%edx	172	movl 8(%esp),%edx
173	inb %dx,%al	173	inb %dx,%al
174	pop %edx	174	pop %edx
175	ret	175	ret
176		176
177		177
178	## I/O input (word)	178	## I/O input (word)
179	#	179	#
180	# Get a word from I/O port and store it AX.	180	# Get a word from I/O port and store it AX.
181	#	181	#
182	inw:	182	inw:
183	push %edx	183	push %edx
184	xorl %eax,%eax	184	xorl %eax,%eax
185	movl 8(%esp),%edx	185	movl 8(%esp),%edx
186	inw %dx,%ax	186	inw %dx,%ax
187	pop %edx	187	pop %edx
188	ret	188	ret
189		189
190		190
191	## I/O input (dword)	191	## I/O input (dword)
192	#	192	#
193	# Get a dword from I/O port and store it EAX.	193	# Get a dword from I/O port and store it EAX.
194	#	194	#
195	inl:	195	inl:
196	push %edx	196	push %edx
197	xorl %eax,%eax	197	xorl %eax,%eax
198	movl 8(%esp),%edx	198	movl 8(%esp),%edx
199	inl %dx,%eax	199	inl %dx,%eax
200	pop %edx	200	pop %edx
201	ret	201	ret
202		202
203		203
204	## I/O output (byte)	204	## I/O output (byte)
205	#	205	#
206	# Send a byte to I/O port.	206	# Send a byte to I/O port.
207	#	207	#
208	outb:	208	outb:
209	push %ebp	209	push %ebp
210	movl %esp,%ebp	210	movl %esp,%ebp
211	pusha	211	pusha
212		212
213	movl 8(%ebp),%edx	213	movl 8(%ebp),%edx
214	movl 12(%ebp),%eax	214	movl 12(%ebp),%eax
215	outb %al,%dx	215	outb %al,%dx
216		216
217	popa	217	popa
218	pop %ebp	218	pop %ebp
219	ret	219	ret
220		220
221		221
222	## I/O output (word)	222	## I/O output (word)
223	#	223	#
224	# Send a word to I/O port.	224	# Send a word to I/O port.
225	#	225	#
226	outw:	226	outw:
227	push %ebp	227	push %ebp
228	movl %esp,%ebp	228	movl %esp,%ebp
229	pusha	229	pusha
230		230
231	movl 8(%ebp),%edx	231	movl 8(%ebp),%edx
232	movl 12(%ebp),%eax	232	movl 12(%ebp),%eax
233	outw %ax,%dx	233	outw %ax,%dx
234		234
235	popa	235	popa
236	pop %ebp	236	pop %ebp
237	ret	237	ret
238		238
239		239
240	## I/O output (dword)	240	## I/O output (dword)
241	#	241	#
242	# Send a dword to I/O port.	242	# Send a dword to I/O port.
243	#	243	#
244	outl:	244	outl:
245	push %ebp	245	push %ebp
246	movl %esp,%ebp	246	movl %esp,%ebp
247	pusha	247	pusha
248		248
249	movl 8(%ebp),%edx	249	movl 8(%ebp),%edx
250	movl 12(%ebp),%eax	250	movl 12(%ebp),%eax
251	outl %eax,%dx	251	outl %eax,%dx
252		252
253	popa	253	popa
254	pop %ebp	254	pop %ebp
255	ret	255	ret
256		256
257		257
258	## Copy memory	258	## Copy memory
259	#	259	#
260	# Copy a given number of bytes (3rd argument)	260	# Copy a given number of bytes (3rd argument)
261	# from the memory location defined by 1st argument	261	# from the memory location defined by 2nd argument
262	# to the memory location defined by 2nd argument.	262	# to the memory location defined by 1st argument.
263	# The memory areas cannot overlap.	263	# The memory areas cannot overlap.
264	#	264	#
265	SRC=12	265	SRC=12
266	DST=8	266	DST=8
267	CNT=16	267	CNT=16
268	memcopy:	268	memcopy:
269	push %ebp	269	push %ebp
270	movl %esp,%ebp	270	movl %esp,%ebp
271	pusha	271	pusha
272		272
273	cld	273	cld
274	movl CNT(%ebp),%ecx	274	movl CNT(%ebp),%ecx
275	movl DST(%ebp),%edi	275	movl DST(%ebp),%edi
276	movl SRC(%ebp),%esi	276	movl SRC(%ebp),%esi
277		277
278	rep movsb %ds:(%esi),%es:(%edi)	278	rep movsb %ds:(%esi),%es:(%edi)
279		279
280	popa	280	popa
281	pop %ebp	281	pop %ebp
282	ret	282	ret
283		283
284		284
285	## Fill memory with bytes	285	## Fill memory with bytes
286	#	286	#
287	# Fill a given number of bytes (2nd argument)	287	# Fill a given number of bytes (2nd argument)
288	# at memory defined by 1st argument with the	288	# at memory defined by 1st argument with the
289	# byte value defined by 3rd argument.	289	# byte value defined by 3rd argument.
290	#	290	#
291	DST=8	291	DST=8
292	CNT=12	292	CNT=12
293	X=16	293	X=16
294	memsetb:	294	memsetb:
295	push %ebp	295	push %ebp
296	movl %esp,%ebp	296	movl %esp,%ebp
297	pusha	297	pusha
298		298
299	cld	299	cld
300	movl CNT(%ebp),%ecx	300	movl CNT(%ebp),%ecx
301	movl DST(%ebp),%edi	301	movl DST(%ebp),%edi
302	movl X(%ebp),%eax	302	movl X(%ebp),%eax
303		303
304	rep stosb %al,%es:(%edi)	304	rep stosb %al,%es:(%edi)
305		305
306	popa	306	popa
307	pop %ebp	307	pop %ebp
308	ret	308	ret
309		309
310		310
311	## Fill memory with words	311	## Fill memory with words
312	#	312	#
313	# Fill a given number of words (2nd argument)	313	# Fill a given number of words (2nd argument)
314	# at memory defined by 1st argument with the	314	# at memory defined by 1st argument with the
315	# word value defined by 3rd argument.	315	# word value defined by 3rd argument.
316	#	316	#
317	DST=8	317	DST=8
318	CNT=12	318	CNT=12
319	X=16	319	X=16
320	memsetw:	320	memsetw:
321	push %ebp	321	push %ebp
322	movl %esp,%ebp	322	movl %esp,%ebp
323	pusha	323	pusha
324		324
325	cld	325	cld
326	movl CNT(%ebp),%ecx	326	movl CNT(%ebp),%ecx
327	movl DST(%ebp),%edi	327	movl DST(%ebp),%edi
328	movl X(%ebp),%eax	328	movl X(%ebp),%eax
329		329
330	rep stosw %ax,%es:(%edi)	330	rep stosw %ax,%es:(%edi)
331		331
332	popa	332	popa
333	pop %ebp	333	pop %ebp
334	ret	334	ret
335		335
336		336
337	## Compare memory regions for equality	337	## Compare memory regions for equality
338	#	338	#
339	# Compare a given number of bytes (3rd argument)	339	# Compare a given number of bytes (3rd argument)
340	# at memory locations defined by 1st and 2nd argument	340	# at memory locations defined by 1st and 2nd argument
341	# for equality. If the bytes are equal, EAX contains	341	# for equality. If the bytes are equal, EAX contains
342	# 0.	342	# 0.
343	#	343	#
344	SRC=12	344	SRC=12
345	DST=16	345	DST=16
346	CNT=20	346	CNT=20
347	memcmp:	347	memcmp:
348	push %ebp	348	push %ebp
349	subl $4,%esp	349	subl $4,%esp
350	movl %esp,%ebp	350	movl %esp,%ebp
351		351
352	pusha	352	pusha
353		353
354	cld	354	cld
355	movl CNT(%ebp),%ecx	355	movl CNT(%ebp),%ecx
356	movl DST(%ebp),%edi	356	movl DST(%ebp),%edi
357	movl SRC(%ebp),%esi	357	movl SRC(%ebp),%esi
358		358
359	repe cmpsb %es:(%edi),%ds:(%esi)	359	repe cmpsb %es:(%edi),%ds:(%esi)
360	movl %ecx,(%ebp)	360	movl %ecx,(%ebp)
361		361
362	popa	362	popa
363		363
364	movl (%ebp),%eax # return value => %eax (zero on success)	364	movl (%ebp),%eax # return value => %eax (zero on success)
365	addl $4,%esp	365	addl $4,%esp
366	pop %ebp	366	pop %ebp
367		367
368	ret	368	ret
369		369
370		370
371	# THIS IS USERSPACE CODE	371	# THIS IS USERSPACE CODE
372	.global utext	372	.global utext
373	utext:	373	utext:
374	xor %ax,%ax;	374	xor %ax,%ax;
375	mov %ax,%ds;	375	mov %ax,%ds;
376	mov %ax,%es;	376	mov %ax,%es;
377	mov %ax,%fs;	377	mov %ax,%fs;
378	mov %ax,%gs;	378	mov %ax,%gs;
379	0:	379	0:
380	int $48	380	int $48
381	jmp 0b	381	jmp 0b
382	# not reached	382	# not reached
383	utext_end:	383	utext_end:
384		384
385	.data	385	.data
386	.global utext_size	386	.global utext_size
387	utext_size:	387	utext_size:
388	.long utext_end - utext	388	.long utext_end - utext
389		389
390		390
391	#.section K_DATA_START	391	#.section K_DATA_START
392	.global interrupt_handler_size	392	.global interrupt_handler_size
393		393
394	interrupt_handler_size: .long (h_end-h_start)/IDT_ITEMS	394	interrupt_handler_size: .long (h_end-h_start)/IDT_ITEMS
395		395

Subversion Repositories HelenOS-historic

(root)/kernel/trunk/arch/ia32/src/asm.S @ 952 – Rev 196 → 198