WebSVN – HelenOS – Diff – /SPARTAN/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 cpu_halt
.global cpu_sleep
.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;
	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 1st argument
# to the memory location defined by 2nd argument.
# The memory areas cannot overlap.
#
SRC=8
DST=12
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:
#	movl $0xdeadbeaf, %eax
  int $48
	cli;
	sti;
	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 137	Rev 141
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 cpu_halt	37	.global cpu_halt
38	.global cpu_sleep	38	.global cpu_sleep
39	.global paging_on	39	.global paging_on
40	.global enable_l_apic_in_msr	40	.global enable_l_apic_in_msr
41	.global interrupt_handlers	41	.global interrupt_handlers
42	.global inb	42	.global inb
43	.global inw	43	.global inw
44	.global inl	44	.global inl
45	.global outb	45	.global outb
46	.global outw	46	.global outw
47	.global outl	47	.global outl
48	.global memcopy	48	.global memcopy
49	.global memsetb	49	.global memsetb
50	.global memsetw	50	.global memsetw
51	.global memcmp	51	.global memcmp
52		52
53		53
54	## Turn paging on	54	## Turn paging on
55	#	55	#
56	# Enable paging and write-back caching in CR0.	56	# Enable paging and write-back caching in CR0.
57	#	57	#
58	paging_on:	58	paging_on:
59	pushl %eax	59	pushl %eax
60	movl %cr0,%eax	60	movl %cr0,%eax
61	orl $(1<<31),%eax # paging on	61	orl $(1<<31),%eax # paging on
62	andl $~((1<<30)\|(1<<29)),%eax # clear Cache Disable and not Write Though	62	andl $~((1<<30)\|(1<<29)),%eax # clear Cache Disable and not Write Though
63	movl %eax,%cr0	63	movl %eax,%cr0
64	jmp 0f	64	jmp 0f
65	0:	65	0:
66	popl %eax	66	popl %eax
67	ret	67	ret
68		68
69		69
70	## Enable local APIC	70	## Enable local APIC
71	#	71	#
72	# Enable local APIC in MSR.	72	# Enable local APIC in MSR.
73	#	73	#
74	enable_l_apic_in_msr:	74	enable_l_apic_in_msr:
75	pusha	75	pusha
76		76
77	movl $0x1b, %ecx	77	movl $0x1b, %ecx
78	rdmsr	78	rdmsr
79	orl $(1<<11),%eax	79	orl $(1<<11),%eax
80	orl $(0xfee00000),%eax	80	orl $(0xfee00000),%eax
81	wrmsr	81	wrmsr
82		82
83	popa	83	popa
84	ret	84	ret
85		85
86		86
87	## Declare interrupt handlers	87	## Declare interrupt handlers
88	#	88	#
89	# Declare interrupt handlers for n interrupt	89	# Declare interrupt handlers for n interrupt
90	# vectors starting at vector i.	90	# vectors starting at vector i.
91	#	91	#
92	# The handlers setup data segment registers	92	# The handlers setup data segment registers
93	# and call trap_dispatcher().	93	# and call trap_dispatcher().
94	#	94	#
95	.macro handler i n	95	.macro handler i n
96	push %ebp	96	push %ebp
97	movl %esp,%ebp	97	movl %esp,%ebp
98	pusha	98	pusha
99		99
100	push %ds	100	push %ds
101	push %es	101	push %es
102		102
103	# we must fill the data segment registers	103	# we must fill the data segment registers
104	movw $16,%ax	104	movw $16,%ax
105	movw %ax,%ds	105	movw %ax,%ds
106	movw %ax,%es	106	movw %ax,%es
107		107
108	movl $(\i),%edi	108	movl $(\i),%edi
109	pushl %ebp	109	pushl %ebp
110	addl $4,(%esp)	110	addl $4,(%esp)
111	pushl %edi	111	pushl %edi
112	call trap_dispatcher	112	call trap_dispatcher
113	addl $8,%esp	113	addl $8,%esp
114		114
115	pop %es	115	pop %es
116	pop %ds	116	pop %ds
117		117
118		118
-		119	# CLNT
-		120	pushfl;
-		121	pop %eax;
-		122	and $0xFFFFBFFF;
-		123	push %eax;
-		124	popfl;
-		125
-		126
-		127
119	# Test if this is interrupt with error word or not	128	# Test if this is interrupt with error word or not
120	mov $\i,%cl;	129	mov $\i,%cl;
121	movl $1,%eax;	130	movl $1,%eax;
122	test $0xe0,%cl;	131	test $0xe0,%cl;
123	jnz 0f;	132	jnz 0f;
124	and $0x1f,%cl;	133	and $0x1f,%cl;
125	shl %cl,%eax;	134	shl %cl,%eax;
126	and $ERROR_WORD_INTERRUPT_LIST,%eax;	135	and $ERROR_WORD_INTERRUPT_LIST,%eax;
127	jz 0f;	136	jz 0f;
128		137
129		138
130	# Return with error word	139	# Return with error word
131	popa;	140	popa;
132	pop %ebp;	141	pop %ebp;
133	add $4,%esp; # Skip error word	142	add $4,%esp; # Skip error word
134	iret;	143	iret;
135		144
136	0:	145	0:
137	# Return with no error word	146	# Return with no error word
138	popa	147	popa
139	pop %ebp	148	pop %ebp
140	iret	149	iret
141		150
142	.if (\n-\i)-1	151	.if (\n-\i)-1
143	handler "(\i+1)",\n	152	handler "(\i+1)",\n
144	.endif	153	.endif
145	.endm	154	.endm
146		155
147	# keep in sync with pm.h !!!	156	# keep in sync with pm.h !!!
148	IDT_ITEMS=64	157	IDT_ITEMS=64
149	interrupt_handlers:	158	interrupt_handlers:
150	h_start:	159	h_start:
151	handler 0 64	160	handler 0 64
152	# handler 64 128	161	# handler 64 128
153	# handler 128 192	162	# handler 128 192
154	# handler 192 256	163	# handler 192 256
155	h_end:	164	h_end:
156		165
157		166
158	## I/O input (byte)	167	## I/O input (byte)
159	#	168	#
160	# Get a byte from I/O port and store it AL.	169	# Get a byte from I/O port and store it AL.
161	#	170	#
162	inb:	171	inb:
163	push %edx	172	push %edx
164	xorl %eax,%eax	173	xorl %eax,%eax
165	movl 8(%esp),%edx	174	movl 8(%esp),%edx
166	inb %dx,%al	175	inb %dx,%al
167	pop %edx	176	pop %edx
168	ret	177	ret
169		178
170		179
171	## I/O input (word)	180	## I/O input (word)
172	#	181	#
173	# Get a word from I/O port and store it AX.	182	# Get a word from I/O port and store it AX.
174	#	183	#
175	inw:	184	inw:
176	push %edx	185	push %edx
177	xorl %eax,%eax	186	xorl %eax,%eax
178	movl 8(%esp),%edx	187	movl 8(%esp),%edx
179	inw %dx,%ax	188	inw %dx,%ax
180	pop %edx	189	pop %edx
181	ret	190	ret
182		191
183		192
184	## I/O input (dword)	193	## I/O input (dword)
185	#	194	#
186	# Get a dword from I/O port and store it EAX.	195	# Get a dword from I/O port and store it EAX.
187	#	196	#
188	inl:	197	inl:
189	push %edx	198	push %edx
190	xorl %eax,%eax	199	xorl %eax,%eax
191	movl 8(%esp),%edx	200	movl 8(%esp),%edx
192	inl %dx,%eax	201	inl %dx,%eax
193	pop %edx	202	pop %edx
194	ret	203	ret
195		204
196		205
197	## I/O output (byte)	206	## I/O output (byte)
198	#	207	#
199	# Send a byte to I/O port.	208	# Send a byte to I/O port.
200	#	209	#
201	outb:	210	outb:
202	push %ebp	211	push %ebp
203	movl %esp,%ebp	212	movl %esp,%ebp
204	pusha	213	pusha
205		214
206	movl 8(%ebp),%edx	215	movl 8(%ebp),%edx
207	movl 12(%ebp),%eax	216	movl 12(%ebp),%eax
208	outb %al,%dx	217	outb %al,%dx
209		218
210	popa	219	popa
211	pop %ebp	220	pop %ebp
212	ret	221	ret
213		222
214		223
215	## I/O output (word)	224	## I/O output (word)
216	#	225	#
217	# Send a word to I/O port.	226	# Send a word to I/O port.
218	#	227	#
219	outw:	228	outw:
220	push %ebp	229	push %ebp
221	movl %esp,%ebp	230	movl %esp,%ebp
222	pusha	231	pusha
223		232
224	movl 8(%ebp),%edx	233	movl 8(%ebp),%edx
225	movl 12(%ebp),%eax	234	movl 12(%ebp),%eax
226	outw %ax,%dx	235	outw %ax,%dx
227		236
228	popa	237	popa
229	pop %ebp	238	pop %ebp
230	ret	239	ret
231		240
232		241
233	## I/O output (dword)	242	## I/O output (dword)
234	#	243	#
235	# Send a dword to I/O port.	244	# Send a dword to I/O port.
236	#	245	#
237	outl:	246	outl:
238	push %ebp	247	push %ebp
239	movl %esp,%ebp	248	movl %esp,%ebp
240	pusha	249	pusha
241		250
242	movl 8(%ebp),%edx	251	movl 8(%ebp),%edx
243	movl 12(%ebp),%eax	252	movl 12(%ebp),%eax
244	outl %eax,%dx	253	outl %eax,%dx
245		254
246	popa	255	popa
247	pop %ebp	256	pop %ebp
248	ret	257	ret
249		258
250		259
251	## Copy memory	260	## Copy memory
252	#	261	#
253	# Copy a given number of bytes (3rd argument)	262	# Copy a given number of bytes (3rd argument)
254	# from the memory location defined by 1st argument	263	# from the memory location defined by 1st argument
255	# to the memory location defined by 2nd argument.	264	# to the memory location defined by 2nd argument.
256	# The memory areas cannot overlap.	265	# The memory areas cannot overlap.
257	#	266	#
258	SRC=8	267	SRC=8
259	DST=12	268	DST=12
260	CNT=16	269	CNT=16
261	memcopy:	270	memcopy:
262	push %ebp	271	push %ebp
263	movl %esp,%ebp	272	movl %esp,%ebp
264	pusha	273	pusha
265		274
266	cld	275	cld
267	movl CNT(%ebp),%ecx	276	movl CNT(%ebp),%ecx
268	movl DST(%ebp),%edi	277	movl DST(%ebp),%edi
269	movl SRC(%ebp),%esi	278	movl SRC(%ebp),%esi
270		279
271	rep movsb %ds:(%esi),%es:(%edi)	280	rep movsb %ds:(%esi),%es:(%edi)
272		281
273	popa	282	popa
274	pop %ebp	283	pop %ebp
275	ret	284	ret
276		285
277		286
278	## Fill memory with bytes	287	## Fill memory with bytes
279	#	288	#
280	# Fill a given number of bytes (2nd argument)	289	# Fill a given number of bytes (2nd argument)
281	# at memory defined by 1st argument with the	290	# at memory defined by 1st argument with the
282	# byte value defined by 3rd argument.	291	# byte value defined by 3rd argument.
283	#	292	#
284	DST=8	293	DST=8
285	CNT=12	294	CNT=12
286	X=16	295	X=16
287	memsetb:	296	memsetb:
288	push %ebp	297	push %ebp
289	movl %esp,%ebp	298	movl %esp,%ebp
290	pusha	299	pusha
291		300
292	cld	301	cld
293	movl CNT(%ebp),%ecx	302	movl CNT(%ebp),%ecx
294	movl DST(%ebp),%edi	303	movl DST(%ebp),%edi
295	movl X(%ebp),%eax	304	movl X(%ebp),%eax
296		305
297	rep stosb %al,%es:(%edi)	306	rep stosb %al,%es:(%edi)
298		307
299	popa	308	popa
300	pop %ebp	309	pop %ebp
301	ret	310	ret
302		311
303		312
304	## Fill memory with words	313	## Fill memory with words
305	#	314	#
306	# Fill a given number of words (2nd argument)	315	# Fill a given number of words (2nd argument)
307	# at memory defined by 1st argument with the	316	# at memory defined by 1st argument with the
308	# word value defined by 3rd argument.	317	# word value defined by 3rd argument.
309	#	318	#
310	DST=8	319	DST=8
311	CNT=12	320	CNT=12
312	X=16	321	X=16
313	memsetw:	322	memsetw:
314	push %ebp	323	push %ebp
315	movl %esp,%ebp	324	movl %esp,%ebp
316	pusha	325	pusha
317		326
318	cld	327	cld
319	movl CNT(%ebp),%ecx	328	movl CNT(%ebp),%ecx
320	movl DST(%ebp),%edi	329	movl DST(%ebp),%edi
321	movl X(%ebp),%eax	330	movl X(%ebp),%eax
322		331
323	rep stosw %ax,%es:(%edi)	332	rep stosw %ax,%es:(%edi)
324		333
325	popa	334	popa
326	pop %ebp	335	pop %ebp
327	ret	336	ret
328		337
329		338
330	## Compare memory regions for equality	339	## Compare memory regions for equality
331	#	340	#
332	# Compare a given number of bytes (3rd argument)	341	# Compare a given number of bytes (3rd argument)
333	# at memory locations defined by 1st and 2nd argument	342	# at memory locations defined by 1st and 2nd argument
334	# for equality. If the bytes are equal, EAX contains	343	# for equality. If the bytes are equal, EAX contains
335	# 0.	344	# 0.
336	#	345	#
337	SRC=12	346	SRC=12
338	DST=16	347	DST=16
339	CNT=20	348	CNT=20
340	memcmp:	349	memcmp:
341	push %ebp	350	push %ebp
342	subl $4,%esp	351	subl $4,%esp
343	movl %esp,%ebp	352	movl %esp,%ebp
344		353
345	pusha	354	pusha
346		355
347	cld	356	cld
348	movl CNT(%ebp),%ecx	357	movl CNT(%ebp),%ecx
349	movl DST(%ebp),%edi	358	movl DST(%ebp),%edi
350	movl SRC(%ebp),%esi	359	movl SRC(%ebp),%esi
351		360
352	repe cmpsb %es:(%edi),%ds:(%esi)	361	repe cmpsb %es:(%edi),%ds:(%esi)
353	movl %ecx,(%ebp)	362	movl %ecx,(%ebp)
354		363
355	popa	364	popa
356		365
357	movl (%ebp),%eax # return value => %eax (zero on success)	366	movl (%ebp),%eax # return value => %eax (zero on success)
358	addl $4,%esp	367	addl $4,%esp
359	pop %ebp	368	pop %ebp
360		369
361	ret	370	ret
362		371
363		372
364	# THIS IS USERSPACE CODE	373	# THIS IS USERSPACE CODE
365	.global utext	374	.global utext
366	utext:	375	utext:
367	xor %ax,%ax;	376	xor %ax,%ax;
368	mov %ax,%ds;	377	mov %ax,%ds;
369	mov %ax,%es;	378	mov %ax,%es;
370	mov %ax,%fs;	379	mov %ax,%fs;
371	mov %ax,%gs;	380	mov %ax,%gs;
372	0:	381	0:
373	# movl $0xdeadbeaf, %eax	382	# movl $0xdeadbeaf, %eax
374	int $48	383	int $48
375	cli;	384	cli;
376	sti;	385	sti;
377	jmp 0b	386	jmp 0b
378	# not reached	387	# not reached
379	utext_end:	388	utext_end:
380		389
381	.data	390	.data
382	.global utext_size	391	.global utext_size
383	utext_size:	392	utext_size:
384	.long utext_end - utext	393	.long utext_end - utext
385		394
386		395
387	#.section K_DATA_START	396	#.section K_DATA_START
388	.global interrupt_handler_size	397	.global interrupt_handler_size
389		398
390	interrupt_handler_size: .long (h_end-h_start)/IDT_ITEMS	399	interrupt_handler_size: .long (h_end-h_start)/IDT_ITEMS
391		400

Subversion Repositories HelenOS

(root)/SPARTAN/trunk/arch/ia32/src/asm.S – Rev 137 → 141