Mercurial > hg > graal-compiler
annotate src/os_cpu/linux_x86/vm/linux_x86_64.s @ 7858:4958cbdbf360
Fixed minor bugs in NodeFactory generation.
author | Christian Humer <christian.humer@gmail.com> |
---|---|
date | Mon, 25 Feb 2013 14:22:18 +0100 |
parents | c18cbe5936b8 |
children | 980532a806a5 |
rev | line source |
---|---|
0 | 1 # |
1552
c18cbe5936b8
6941466: Oracle rebranding changes for Hotspot repositories
trims
parents:
0
diff
changeset
|
2 # Copyright (c) 2004, 2007, Oracle and/or its affiliates. All rights reserved. |
0 | 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 # | |
1552
c18cbe5936b8
6941466: Oracle rebranding changes for Hotspot repositories
trims
parents:
0
diff
changeset
|
19 # Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA |
c18cbe5936b8
6941466: Oracle rebranding changes for Hotspot repositories
trims
parents:
0
diff
changeset
|
20 # or visit www.oracle.com if you need additional information or have any |
c18cbe5936b8
6941466: Oracle rebranding changes for Hotspot repositories
trims
parents:
0
diff
changeset
|
21 # questions. |
0 | 22 # |
23 | |
24 | |
25 # NOTE WELL! The _Copy functions are called directly | |
26 # from server-compiler-generated code via CallLeafNoFP, | |
27 # which means that they *must* either not use floating | |
28 # point or use it in the same manner as does the server | |
29 # compiler. | |
30 | |
31 .globl _Copy_arrayof_conjoint_bytes | |
32 .globl _Copy_arrayof_conjoint_jshorts | |
33 .globl _Copy_conjoint_jshorts_atomic | |
34 .globl _Copy_arrayof_conjoint_jints | |
35 .globl _Copy_conjoint_jints_atomic | |
36 .globl _Copy_arrayof_conjoint_jlongs | |
37 .globl _Copy_conjoint_jlongs_atomic | |
38 | |
39 .text | |
40 | |
41 .globl SafeFetch32, Fetch32PFI, Fetch32Resume | |
42 .align 16 | |
43 .type SafeFetch32,@function | |
44 // Prototype: int SafeFetch32 (int * Adr, int ErrValue) | |
45 SafeFetch32: | |
46 movl %esi, %eax | |
47 Fetch32PFI: | |
48 movl (%rdi), %eax | |
49 Fetch32Resume: | |
50 ret | |
51 | |
52 .globl SafeFetchN, FetchNPFI, FetchNResume | |
53 .align 16 | |
54 .type SafeFetchN,@function | |
55 // Prototype: intptr_t SafeFetchN (intptr_t * Adr, intptr_t ErrValue) | |
56 SafeFetchN: | |
57 movq %rsi, %rax | |
58 FetchNPFI: | |
59 movq (%rdi), %rax | |
60 FetchNResume: | |
61 ret | |
62 | |
63 .globl SpinPause | |
64 .align 16 | |
65 .type SpinPause,@function | |
66 SpinPause: | |
67 rep | |
68 nop | |
69 movq $1, %rax | |
70 ret | |
71 | |
72 # Support for void Copy::arrayof_conjoint_bytes(void* from, | |
73 # void* to, | |
74 # size_t count) | |
75 # rdi - from | |
76 # rsi - to | |
77 # rdx - count, treated as ssize_t | |
78 # | |
79 .p2align 4,,15 | |
80 .type _Copy_arrayof_conjoint_bytes,@function | |
81 _Copy_arrayof_conjoint_bytes: | |
82 movq %rdx,%r8 # byte count | |
83 shrq $3,%rdx # qword count | |
84 cmpq %rdi,%rsi | |
85 leaq -1(%rdi,%r8,1),%rax # from + bcount*1 - 1 | |
86 jbe acb_CopyRight | |
87 cmpq %rax,%rsi | |
88 jbe acb_CopyLeft | |
89 acb_CopyRight: | |
90 leaq -8(%rdi,%rdx,8),%rax # from + qcount*8 - 8 | |
91 leaq -8(%rsi,%rdx,8),%rcx # to + qcount*8 - 8 | |
92 negq %rdx | |
93 jmp 7f | |
94 .p2align 4,,15 | |
95 1: movq 8(%rax,%rdx,8),%rsi | |
96 movq %rsi,8(%rcx,%rdx,8) | |
97 addq $1,%rdx | |
98 jnz 1b | |
99 2: testq $4,%r8 # check for trailing dword | |
100 jz 3f | |
101 movl 8(%rax),%esi # copy trailing dword | |
102 movl %esi,8(%rcx) | |
103 addq $4,%rax | |
104 addq $4,%rcx # original %rsi is trashed, so we | |
105 # can't use it as a base register | |
106 3: testq $2,%r8 # check for trailing word | |
107 jz 4f | |
108 movw 8(%rax),%si # copy trailing word | |
109 movw %si,8(%rcx) | |
110 addq $2,%rcx | |
111 4: testq $1,%r8 # check for trailing byte | |
112 jz 5f | |
113 movb -1(%rdi,%r8,1),%al # copy trailing byte | |
114 movb %al,8(%rcx) | |
115 5: ret | |
116 .p2align 4,,15 | |
117 6: movq -24(%rax,%rdx,8),%rsi | |
118 movq %rsi,-24(%rcx,%rdx,8) | |
119 movq -16(%rax,%rdx,8),%rsi | |
120 movq %rsi,-16(%rcx,%rdx,8) | |
121 movq -8(%rax,%rdx,8),%rsi | |
122 movq %rsi,-8(%rcx,%rdx,8) | |
123 movq (%rax,%rdx,8),%rsi | |
124 movq %rsi,(%rcx,%rdx,8) | |
125 7: addq $4,%rdx | |
126 jle 6b | |
127 subq $4,%rdx | |
128 jl 1b | |
129 jmp 2b | |
130 acb_CopyLeft: | |
131 testq $1,%r8 # check for trailing byte | |
132 jz 1f | |
133 movb -1(%rdi,%r8,1),%cl # copy trailing byte | |
134 movb %cl,-1(%rsi,%r8,1) | |
135 subq $1,%r8 # adjust for possible trailing word | |
136 1: testq $2,%r8 # check for trailing word | |
137 jz 2f | |
138 movw -2(%rdi,%r8,1),%cx # copy trailing word | |
139 movw %cx,-2(%rsi,%r8,1) | |
140 2: testq $4,%r8 # check for trailing dword | |
141 jz 5f | |
142 movl (%rdi,%rdx,8),%ecx # copy trailing dword | |
143 movl %ecx,(%rsi,%rdx,8) | |
144 jmp 5f | |
145 .p2align 4,,15 | |
146 3: movq -8(%rdi,%rdx,8),%rcx | |
147 movq %rcx,-8(%rsi,%rdx,8) | |
148 subq $1,%rdx | |
149 jnz 3b | |
150 ret | |
151 .p2align 4,,15 | |
152 4: movq 24(%rdi,%rdx,8),%rcx | |
153 movq %rcx,24(%rsi,%rdx,8) | |
154 movq 16(%rdi,%rdx,8),%rcx | |
155 movq %rcx,16(%rsi,%rdx,8) | |
156 movq 8(%rdi,%rdx,8),%rcx | |
157 movq %rcx,8(%rsi,%rdx,8) | |
158 movq (%rdi,%rdx,8),%rcx | |
159 movq %rcx,(%rsi,%rdx,8) | |
160 5: subq $4,%rdx | |
161 jge 4b | |
162 addq $4,%rdx | |
163 jg 3b | |
164 ret | |
165 | |
166 # Support for void Copy::arrayof_conjoint_jshorts(void* from, | |
167 # void* to, | |
168 # size_t count) | |
169 # Equivalent to | |
170 # conjoint_jshorts_atomic | |
171 # | |
172 # If 'from' and/or 'to' are aligned on 4- or 2-byte boundaries, we | |
173 # let the hardware handle it. The tow or four words within dwords | |
174 # or qwords that span cache line boundaries will still be loaded | |
175 # and stored atomically. | |
176 # | |
177 # rdi - from | |
178 # rsi - to | |
179 # rdx - count, treated as ssize_t | |
180 # | |
181 .p2align 4,,15 | |
182 .type _Copy_arrayof_conjoint_jshorts,@function | |
183 .type _Copy_conjoint_jshorts_atomic,@function | |
184 _Copy_arrayof_conjoint_jshorts: | |
185 _Copy_conjoint_jshorts_atomic: | |
186 movq %rdx,%r8 # word count | |
187 shrq $2,%rdx # qword count | |
188 cmpq %rdi,%rsi | |
189 leaq -2(%rdi,%r8,2),%rax # from + wcount*2 - 2 | |
190 jbe acs_CopyRight | |
191 cmpq %rax,%rsi | |
192 jbe acs_CopyLeft | |
193 acs_CopyRight: | |
194 leaq -8(%rdi,%rdx,8),%rax # from + qcount*8 - 8 | |
195 leaq -8(%rsi,%rdx,8),%rcx # to + qcount*8 - 8 | |
196 negq %rdx | |
197 jmp 6f | |
198 1: movq 8(%rax,%rdx,8),%rsi | |
199 movq %rsi,8(%rcx,%rdx,8) | |
200 addq $1,%rdx | |
201 jnz 1b | |
202 2: testq $2,%r8 # check for trailing dword | |
203 jz 3f | |
204 movl 8(%rax),%esi # copy trailing dword | |
205 movl %esi,8(%rcx) | |
206 addq $4,%rcx # original %rsi is trashed, so we | |
207 # can't use it as a base register | |
208 3: testq $1,%r8 # check for trailing word | |
209 jz 4f | |
210 movw -2(%rdi,%r8,2),%si # copy trailing word | |
211 movw %si,8(%rcx) | |
212 4: ret | |
213 .p2align 4,,15 | |
214 5: movq -24(%rax,%rdx,8),%rsi | |
215 movq %rsi,-24(%rcx,%rdx,8) | |
216 movq -16(%rax,%rdx,8),%rsi | |
217 movq %rsi,-16(%rcx,%rdx,8) | |
218 movq -8(%rax,%rdx,8),%rsi | |
219 movq %rsi,-8(%rcx,%rdx,8) | |
220 movq (%rax,%rdx,8),%rsi | |
221 movq %rsi,(%rcx,%rdx,8) | |
222 6: addq $4,%rdx | |
223 jle 5b | |
224 subq $4,%rdx | |
225 jl 1b | |
226 jmp 2b | |
227 acs_CopyLeft: | |
228 testq $1,%r8 # check for trailing word | |
229 jz 1f | |
230 movw -2(%rdi,%r8,2),%cx # copy trailing word | |
231 movw %cx,-2(%rsi,%r8,2) | |
232 1: testq $2,%r8 # check for trailing dword | |
233 jz 4f | |
234 movl (%rdi,%rdx,8),%ecx # copy trailing dword | |
235 movl %ecx,(%rsi,%rdx,8) | |
236 jmp 4f | |
237 2: movq -8(%rdi,%rdx,8),%rcx | |
238 movq %rcx,-8(%rsi,%rdx,8) | |
239 subq $1,%rdx | |
240 jnz 2b | |
241 ret | |
242 .p2align 4,,15 | |
243 3: movq 24(%rdi,%rdx,8),%rcx | |
244 movq %rcx,24(%rsi,%rdx,8) | |
245 movq 16(%rdi,%rdx,8),%rcx | |
246 movq %rcx,16(%rsi,%rdx,8) | |
247 movq 8(%rdi,%rdx,8),%rcx | |
248 movq %rcx,8(%rsi,%rdx,8) | |
249 movq (%rdi,%rdx,8),%rcx | |
250 movq %rcx,(%rsi,%rdx,8) | |
251 4: subq $4,%rdx | |
252 jge 3b | |
253 addq $4,%rdx | |
254 jg 2b | |
255 ret | |
256 | |
257 # Support for void Copy::arrayof_conjoint_jints(jint* from, | |
258 # jint* to, | |
259 # size_t count) | |
260 # Equivalent to | |
261 # conjoint_jints_atomic | |
262 # | |
263 # If 'from' and/or 'to' are aligned on 4-byte boundaries, we let | |
264 # the hardware handle it. The two dwords within qwords that span | |
265 # cache line boundaries will still be loaded and stored atomically. | |
266 # | |
267 # rdi - from | |
268 # rsi - to | |
269 # rdx - count, treated as ssize_t | |
270 # | |
271 .p2align 4,,15 | |
272 .type _Copy_arrayof_conjoint_jints,@function | |
273 .type _Copy_conjoint_jints_atomic,@function | |
274 _Copy_arrayof_conjoint_jints: | |
275 _Copy_conjoint_jints_atomic: | |
276 movq %rdx,%r8 # dword count | |
277 shrq %rdx # qword count | |
278 cmpq %rdi,%rsi | |
279 leaq -4(%rdi,%r8,4),%rax # from + dcount*4 - 4 | |
280 jbe aci_CopyRight | |
281 cmpq %rax,%rsi | |
282 jbe aci_CopyLeft | |
283 aci_CopyRight: | |
284 leaq -8(%rdi,%rdx,8),%rax # from + qcount*8 - 8 | |
285 leaq -8(%rsi,%rdx,8),%rcx # to + qcount*8 - 8 | |
286 negq %rdx | |
287 jmp 5f | |
288 .p2align 4,,15 | |
289 1: movq 8(%rax,%rdx,8),%rsi | |
290 movq %rsi,8(%rcx,%rdx,8) | |
291 addq $1,%rdx | |
292 jnz 1b | |
293 2: testq $1,%r8 # check for trailing dword | |
294 jz 3f | |
295 movl 8(%rax),%esi # copy trailing dword | |
296 movl %esi,8(%rcx) | |
297 3: ret | |
298 .p2align 4,,15 | |
299 4: movq -24(%rax,%rdx,8),%rsi | |
300 movq %rsi,-24(%rcx,%rdx,8) | |
301 movq -16(%rax,%rdx,8),%rsi | |
302 movq %rsi,-16(%rcx,%rdx,8) | |
303 movq -8(%rax,%rdx,8),%rsi | |
304 movq %rsi,-8(%rcx,%rdx,8) | |
305 movq (%rax,%rdx,8),%rsi | |
306 movq %rsi,(%rcx,%rdx,8) | |
307 5: addq $4,%rdx | |
308 jle 4b | |
309 subq $4,%rdx | |
310 jl 1b | |
311 jmp 2b | |
312 aci_CopyLeft: | |
313 testq $1,%r8 # check for trailing dword | |
314 jz 3f | |
315 movl -4(%rdi,%r8,4),%ecx # copy trailing dword | |
316 movl %ecx,-4(%rsi,%r8,4) | |
317 jmp 3f | |
318 1: movq -8(%rdi,%rdx,8),%rcx | |
319 movq %rcx,-8(%rsi,%rdx,8) | |
320 subq $1,%rdx | |
321 jnz 1b | |
322 ret | |
323 .p2align 4,,15 | |
324 2: movq 24(%rdi,%rdx,8),%rcx | |
325 movq %rcx,24(%rsi,%rdx,8) | |
326 movq 16(%rdi,%rdx,8),%rcx | |
327 movq %rcx,16(%rsi,%rdx,8) | |
328 movq 8(%rdi,%rdx,8),%rcx | |
329 movq %rcx,8(%rsi,%rdx,8) | |
330 movq (%rdi,%rdx,8),%rcx | |
331 movq %rcx,(%rsi,%rdx,8) | |
332 3: subq $4,%rdx | |
333 jge 2b | |
334 addq $4,%rdx | |
335 jg 1b | |
336 ret | |
337 | |
338 # Support for void Copy::arrayof_conjoint_jlongs(jlong* from, | |
339 # jlong* to, | |
340 # size_t count) | |
341 # Equivalent to | |
342 # conjoint_jlongs_atomic | |
343 # arrayof_conjoint_oops | |
344 # conjoint_oops_atomic | |
345 # | |
346 # rdi - from | |
347 # rsi - to | |
348 # rdx - count, treated as ssize_t | |
349 # | |
350 .p2align 4,,15 | |
351 .type _Copy_arrayof_conjoint_jlongs,@function | |
352 .type _Copy_conjoint_jlongs_atomic,@function | |
353 _Copy_arrayof_conjoint_jlongs: | |
354 _Copy_conjoint_jlongs_atomic: | |
355 cmpq %rdi,%rsi | |
356 leaq -8(%rdi,%rdx,8),%rax # from + count*8 - 8 | |
357 jbe acl_CopyRight | |
358 cmpq %rax,%rsi | |
359 jbe acl_CopyLeft | |
360 acl_CopyRight: | |
361 leaq -8(%rsi,%rdx,8),%rcx # to + count*8 - 8 | |
362 negq %rdx | |
363 jmp 3f | |
364 1: movq 8(%rax,%rdx,8),%rsi | |
365 movq %rsi,8(%rcx,%rdx,8) | |
366 addq $1,%rdx | |
367 jnz 1b | |
368 ret | |
369 .p2align 4,,15 | |
370 2: movq -24(%rax,%rdx,8),%rsi | |
371 movq %rsi,-24(%rcx,%rdx,8) | |
372 movq -16(%rax,%rdx,8),%rsi | |
373 movq %rsi,-16(%rcx,%rdx,8) | |
374 movq -8(%rax,%rdx,8),%rsi | |
375 movq %rsi,-8(%rcx,%rdx,8) | |
376 movq (%rax,%rdx,8),%rsi | |
377 movq %rsi,(%rcx,%rdx,8) | |
378 3: addq $4,%rdx | |
379 jle 2b | |
380 subq $4,%rdx | |
381 jl 1b | |
382 ret | |
383 4: movq -8(%rdi,%rdx,8),%rcx | |
384 movq %rcx,-8(%rsi,%rdx,8) | |
385 subq $1,%rdx | |
386 jnz 4b | |
387 ret | |
388 .p2align 4,,15 | |
389 5: movq 24(%rdi,%rdx,8),%rcx | |
390 movq %rcx,24(%rsi,%rdx,8) | |
391 movq 16(%rdi,%rdx,8),%rcx | |
392 movq %rcx,16(%rsi,%rdx,8) | |
393 movq 8(%rdi,%rdx,8),%rcx | |
394 movq %rcx,8(%rsi,%rdx,8) | |
395 movq (%rdi,%rdx,8),%rcx | |
396 movq %rcx,(%rsi,%rdx,8) | |
397 acl_CopyLeft: | |
398 subq $4,%rdx | |
399 jge 5b | |
400 addq $4,%rdx | |
401 jg 4b | |
402 ret |