Mercurial > hg > graal-compiler

comparison src/os_cpu/solaris_x86/vm/solaris_x86_64.s @ 0:a61af66fc99e jdk7-b24

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
Initial load
author duke
date Sat, 01 Dec 2007 00:00:00 +0000
parents
children c18cbe5936b8
comparison
equal deleted inserted replaced
-1:000000000000 0:a61af66fc99e
1 /
2 / Copyright 2004-2005 Sun Microsystems, Inc. All Rights Reserved.
3 / DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4 /
5 / This code is free software; you can redistribute it and/or modify it
6 / under the terms of the GNU General Public License version 2 only, as
7 / published by the Free Software Foundation.
8 /
9 / This code is distributed in the hope that it will be useful, but WITHOUT
10 / ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
11 / FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
12 / version 2 for more details (a copy is included in the LICENSE file that
13 / accompanied this code).
14 /
15 / You should have received a copy of the GNU General Public License version
16 / 2 along with this work; if not, write to the Free Software Foundation,
17 / Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
18 /
19 / Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
20 / CA 95054 USA or visit www.sun.com if you need additional information or
21 / have any questions.
22 /
23
24 .globl fs_load
25 .globl fs_thread
26
27 // NOTE WELL! The _Copy functions are called directly
28 // from server-compiler-generated code via CallLeafNoFP,
29 // which means that they *must* either not use floating
30 // point or use it in the same manner as does the server
31 // compiler.
32
33 .globl _Copy_arrayof_conjoint_bytes
34 .globl _Copy_conjoint_jshorts_atomic
35 .globl _Copy_arrayof_conjoint_jshorts
36 .globl _Copy_conjoint_jints_atomic
37 .globl _Copy_arrayof_conjoint_jints
38 .globl _Copy_conjoint_jlongs_atomic
39 .globl _Copy_arrayof_conjoint_jlongs
40
41 .section .text,"ax"
42
43 / Fast thread accessors, used by threadLS_solaris_amd64.cpp
44 .align 16
45 fs_load:
46 movq %fs:(%rdi),%rax
47 ret
48
49 .align 16
50 fs_thread:
51 movq %fs:0x0,%rax
52 ret
53
54 .globl SafeFetch32, Fetch32PFI, Fetch32Resume
55 .align 16
56 // Prototype: int SafeFetch32 (int * Adr, int ErrValue)
57 SafeFetch32:
58 movl %esi, %eax
59 Fetch32PFI:
60 movl (%rdi), %eax
61 Fetch32Resume:
62 ret
63
64 .globl SafeFetchN, FetchNPFI, FetchNResume
65 .align 16
66 // Prototype: intptr_t SafeFetchN (intptr_t * Adr, intptr_t ErrValue)
67 SafeFetchN:
68 movq %rsi, %rax
69 FetchNPFI:
70 movq (%rdi), %rax
71 FetchNResume:
72 ret
73
74 .globl SpinPause
75 .align 16
76 SpinPause:
77 rep
78 nop
79 movq $1, %rax
80 ret
81
82
83 / Support for void Copy::arrayof_conjoint_bytes(void* from,
84 / void* to,
85 / size_t count)
86 / rdi - from
87 / rsi - to
88 / rdx - count, treated as ssize_t
89 /
90 .align 16
91 _Copy_arrayof_conjoint_bytes:
92 movq %rdx,%r8 / byte count
93 shrq $3,%rdx / qword count
94 cmpq %rdi,%rsi
95 leaq -1(%rdi,%r8,1),%rax / from + bcount*1 - 1
96 jbe acb_CopyRight
97 cmpq %rax,%rsi
98 jbe acb_CopyLeft
99 acb_CopyRight:
100 leaq -8(%rdi,%rdx,8),%rax / from + qcount*8 - 8
101 leaq -8(%rsi,%rdx,8),%rcx / to + qcount*8 - 8
102 negq %rdx
103 jmp 7f
104 .align 16
105 1: movq 8(%rax,%rdx,8),%rsi
106 movq %rsi,8(%rcx,%rdx,8)
107 addq $1,%rdx
108 jnz 1b
109 2: testq $4,%r8 / check for trailing dword
110 jz 3f
111 movl 8(%rax),%esi / copy trailing dword
112 movl %esi,8(%rcx)
113 addq $4,%rax
114 addq $4,%rcx / original %rsi is trashed, so we
115 / can't use it as a base register
116 3: testq $2,%r8 / check for trailing word
117 jz 4f
118 movw 8(%rax),%si / copy trailing word
119 movw %si,8(%rcx)
120 addq $2,%rcx
121 4: testq $1,%r8 / check for trailing byte
122 jz 5f
123 movb -1(%rdi,%r8,1),%al / copy trailing byte
124 movb %al,8(%rcx)
125 5: ret
126 .align 16
127 6: movq -24(%rax,%rdx,8),%rsi
128 movq %rsi,-24(%rcx,%rdx,8)
129 movq -16(%rax,%rdx,8),%rsi
130 movq %rsi,-16(%rcx,%rdx,8)
131 movq -8(%rax,%rdx,8),%rsi
132 movq %rsi,-8(%rcx,%rdx,8)
133 movq (%rax,%rdx,8),%rsi
134 movq %rsi,(%rcx,%rdx,8)
135 7: addq $4,%rdx
136 jle 6b
137 subq $4,%rdx
138 jl 1b
139 jmp 2b
140 acb_CopyLeft:
141 testq $1,%r8 / check for trailing byte
142 jz 1f
143 movb -1(%rdi,%r8,1),%cl / copy trailing byte
144 movb %cl,-1(%rsi,%r8,1)
145 subq $1,%r8 / adjust for possible trailing word
146 1: testq $2,%r8 / check for trailing word
147 jz 2f
148 movw -2(%rdi,%r8,1),%cx / copy trailing word
149 movw %cx,-2(%rsi,%r8,1)
150 2: testq $4,%r8 / check for trailing dword
151 jz 5f
152 movl (%rdi,%rdx,8),%ecx / copy trailing dword
153 movl %ecx,(%rsi,%rdx,8)
154 jmp 5f
155 .align 16
156 3: movq -8(%rdi,%rdx,8),%rcx
157 movq %rcx,-8(%rsi,%rdx,8)
158 subq $1,%rdx
159 jnz 3b
160 ret
161 .align 16
162 4: movq 24(%rdi,%rdx,8),%rcx
163 movq %rcx,24(%rsi,%rdx,8)
164 movq 16(%rdi,%rdx,8),%rcx
165 movq %rcx,16(%rsi,%rdx,8)
166 movq 8(%rdi,%rdx,8),%rcx
167 movq %rcx,8(%rsi,%rdx,8)
168 movq (%rdi,%rdx,8),%rcx
169 movq %rcx,(%rsi,%rdx,8)
170 5: subq $4,%rdx
171 jge 4b
172 addq $4,%rdx
173 jg 3b
174 ret
175
176 / Support for void Copy::arrayof_conjoint_jshorts(void* from,
177 / void* to,
178 / size_t count)
179 / Equivalent to
180 / conjoint_jshorts_atomic
181 /
182 / If 'from' and/or 'to' are aligned on 4- or 2-byte boundaries, we
183 / let the hardware handle it. The tow or four words within dwords
184 / or qwords that span cache line boundaries will still be loaded
185 / and stored atomically.
186 /
187 / rdi - from
188 / rsi - to
189 / rdx - count, treated as ssize_t
190 /
191 .align 16
192 _Copy_arrayof_conjoint_jshorts:
193 _Copy_conjoint_jshorts_atomic:
194 movq %rdx,%r8 / word count
195 shrq $2,%rdx / qword count
196 cmpq %rdi,%rsi
197 leaq -2(%rdi,%r8,2),%rax / from + wcount*2 - 2
198 jbe acs_CopyRight
199 cmpq %rax,%rsi
200 jbe acs_CopyLeft
201 acs_CopyRight:
202 leaq -8(%rdi,%rdx,8),%rax / from + qcount*8 - 8
203 leaq -8(%rsi,%rdx,8),%rcx / to + qcount*8 - 8
204 negq %rdx
205 jmp 6f
206 1: movq 8(%rax,%rdx,8),%rsi
207 movq %rsi,8(%rcx,%rdx,8)
208 addq $1,%rdx
209 jnz 1b
210 2: testq $2,%r8 / check for trailing dword
211 jz 3f
212 movl 8(%rax),%esi / copy trailing dword
213 movl %esi,8(%rcx)
214 addq $4,%rcx / original %rsi is trashed, so we
215 / can't use it as a base register
216 3: testq $1,%r8 / check for trailing word
217 jz 4f
218 movw -2(%rdi,%r8,2),%si / copy trailing word
219 movw %si,8(%rcx)
220 4: ret
221 .align 16
222 5: movq -24(%rax,%rdx,8),%rsi
223 movq %rsi,-24(%rcx,%rdx,8)
224 movq -16(%rax,%rdx,8),%rsi
225 movq %rsi,-16(%rcx,%rdx,8)
226 movq -8(%rax,%rdx,8),%rsi
227 movq %rsi,-8(%rcx,%rdx,8)
228 movq (%rax,%rdx,8),%rsi
229 movq %rsi,(%rcx,%rdx,8)
230 6: addq $4,%rdx
231 jle 5b
232 subq $4,%rdx
233 jl 1b
234 jmp 2b
235 acs_CopyLeft:
236 testq $1,%r8 / check for trailing word
237 jz 1f
238 movw -2(%rdi,%r8,2),%cx / copy trailing word
239 movw %cx,-2(%rsi,%r8,2)
240 1: testq $2,%r8 / check for trailing dword
241 jz 4f
242 movl (%rdi,%rdx,8),%ecx / copy trailing dword
243 movl %ecx,(%rsi,%rdx,8)
244 jmp 4f
245 2: movq -8(%rdi,%rdx,8),%rcx
246 movq %rcx,-8(%rsi,%rdx,8)
247 subq $1,%rdx
248 jnz 2b
249 ret
250 .align 16
251 3: movq 24(%rdi,%rdx,8),%rcx
252 movq %rcx,24(%rsi,%rdx,8)
253 movq 16(%rdi,%rdx,8),%rcx
254 movq %rcx,16(%rsi,%rdx,8)
255 movq 8(%rdi,%rdx,8),%rcx
256 movq %rcx,8(%rsi,%rdx,8)
257 movq (%rdi,%rdx,8),%rcx
258 movq %rcx,(%rsi,%rdx,8)
259 4: subq $4,%rdx
260 jge 3b
261 addq $4,%rdx
262 jg 2b
263 ret
264
265 / Support for void Copy::arrayof_conjoint_jints(jint* from,
266 / jint* to,
267 / size_t count)
268 / Equivalent to
269 / conjoint_jints_atomic
270 /
271 / If 'from' and/or 'to' are aligned on 4-byte boundaries, we let
272 / the hardware handle it. The two dwords within qwords that span
273 / cache line boundaries will still be loaded and stored atomically.
274 /
275 / rdi - from
276 / rsi - to
277 / rdx - count, treated as ssize_t
278 /
279 .align 16
280 _Copy_arrayof_conjoint_jints:
281 _Copy_conjoint_jints_atomic:
282 movq %rdx,%r8 / dword count
283 shrq %rdx / qword count
284 cmpq %rdi,%rsi
285 leaq -4(%rdi,%r8,4),%rax / from + dcount*4 - 4
286 jbe aci_CopyRight
287 cmpq %rax,%rsi
288 jbe aci_CopyLeft
289 aci_CopyRight:
290 leaq -8(%rdi,%rdx,8),%rax / from + qcount*8 - 8
291 leaq -8(%rsi,%rdx,8),%rcx / to + qcount*8 - 8
292 negq %rdx
293 jmp 5f
294 .align 16
295 1: movq 8(%rax,%rdx,8),%rsi
296 movq %rsi,8(%rcx,%rdx,8)
297 addq $1,%rdx
298 jnz 1b
299 2: testq $1,%r8 / check for trailing dword
300 jz 3f
301 movl 8(%rax),%esi / copy trailing dword
302 movl %esi,8(%rcx)
303 3: ret
304 .align 16
305 4: movq -24(%rax,%rdx,8),%rsi
306 movq %rsi,-24(%rcx,%rdx,8)
307 movq -16(%rax,%rdx,8),%rsi
308 movq %rsi,-16(%rcx,%rdx,8)
309 movq -8(%rax,%rdx,8),%rsi
310 movq %rsi,-8(%rcx,%rdx,8)
311 movq (%rax,%rdx,8),%rsi
312 movq %rsi,(%rcx,%rdx,8)
313 5: addq $4,%rdx
314 jle 4b
315 subq $4,%rdx
316 jl 1b
317 jmp 2b
318 aci_CopyLeft:
319 testq $1,%r8 / check for trailing dword
320 jz 3f
321 movl -4(%rdi,%r8,4),%ecx / copy trailing dword
322 movl %ecx,-4(%rsi,%r8,4)
323 jmp 3f
324 1: movq -8(%rdi,%rdx,8),%rcx
325 movq %rcx,-8(%rsi,%rdx,8)
326 subq $1,%rdx
327 jnz 1b
328 ret
329 .align 16
330 2: movq 24(%rdi,%rdx,8),%rcx
331 movq %rcx,24(%rsi,%rdx,8)
332 movq 16(%rdi,%rdx,8),%rcx
333 movq %rcx,16(%rsi,%rdx,8)
334 movq 8(%rdi,%rdx,8),%rcx
335 movq %rcx,8(%rsi,%rdx,8)
336 movq (%rdi,%rdx,8),%rcx
337 movq %rcx,(%rsi,%rdx,8)
338 3: subq $4,%rdx
339 jge 2b
340 addq $4,%rdx
341 jg 1b
342 ret
343
344 / Support for void Copy::arrayof_conjoint_jlongs(jlong* from,
345 / jlong* to,
346 / size_t count)
347 / Equivalent to
348 / conjoint_jlongs_atomic
349 / arrayof_conjoint_oops
350 / conjoint_oops_atomic
351 /
352 / rdi - from
353 / rsi - to
354 / rdx - count, treated as ssize_t
355 /
356 .align 16
357 _Copy_arrayof_conjoint_jlongs:
358 _Copy_conjoint_jlongs_atomic:
359 cmpq %rdi,%rsi
360 leaq -8(%rdi,%rdx,8),%rax / from + count*8 - 8
361 jbe acl_CopyRight
362 cmpq %rax,%rsi
363 jbe acl_CopyLeft
364 acl_CopyRight:
365 leaq -8(%rsi,%rdx,8),%rcx / to + count*8 - 8
366 negq %rdx
367 jmp 3f
368 1: movq 8(%rax,%rdx,8),%rsi
369 movq %rsi,8(%rcx,%rdx,8)
370 addq $1,%rdx
371 jnz 1b
372 ret
373 .align 16
374 2: movq -24(%rax,%rdx,8),%rsi
375 movq %rsi,-24(%rcx,%rdx,8)
376 movq -16(%rax,%rdx,8),%rsi
377 movq %rsi,-16(%rcx,%rdx,8)
378 movq -8(%rax,%rdx,8),%rsi
379 movq %rsi,-8(%rcx,%rdx,8)
380 movq (%rax,%rdx,8),%rsi
381 movq %rsi,(%rcx,%rdx,8)
382 3: addq $4,%rdx
383 jle 2b
384 subq $4,%rdx
385 jl 1b
386 ret
387 4: movq -8(%rdi,%rdx,8),%rcx
388 movq %rcx,-8(%rsi,%rdx,8)
389 subq $1,%rdx
390 jnz 4b
391 ret
392 .align 16
393 5: movq 24(%rdi,%rdx,8),%rcx
394 movq %rcx,24(%rsi,%rdx,8)
395 movq 16(%rdi,%rdx,8),%rcx
396 movq %rcx,16(%rsi,%rdx,8)
397 movq 8(%rdi,%rdx,8),%rcx
398 movq %rcx,8(%rsi,%rdx,8)
399 movq (%rdi,%rdx,8),%rcx
400 movq %rcx,(%rsi,%rdx,8)
401 acl_CopyLeft:
402 subq $4,%rdx
403 jge 5b
404 addq $4,%rdx
405 jg 4b
406 ret