1 #
   2 # Copyright (c) 2004, 2017, Oracle and/or its affiliates. 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 Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
  20 # or visit www.oracle.com if you need additional information or have any
  21 # questions.
  22 #
  23 
  24 
  25 #ifdef __APPLE__
  26 # Darwin uses _ prefixed global symbols
  27 #define SYMBOL(s) _ ## s
  28 #define ELF_TYPE(name, description)
  29 #else
  30 #define SYMBOL(s) s
  31 #define ELF_TYPE(name, description) .type name,description
  32 #endif
  33 
  34         .globl SYMBOL(fixcw)
  35 
  36         # NOTE WELL!  The _Copy functions are called directly
  37         # from server-compiler-generated code via CallLeafNoFP,
  38         # which means that they *must* either not use floating
  39         # point or use it in the same manner as does the server
  40         # compiler.
  41 
  42         .globl SYMBOL(_Copy_conjoint_bytes)
  43         .globl SYMBOL(_Copy_arrayof_conjoint_bytes)
  44         .globl SYMBOL(_Copy_conjoint_jshorts_atomic)
  45         .globl SYMBOL(_Copy_arrayof_conjoint_jshorts)
  46         .globl SYMBOL(_Copy_conjoint_jints_atomic)
  47         .globl SYMBOL(_Copy_arrayof_conjoint_jints)
  48         .globl SYMBOL(_Copy_conjoint_jlongs_atomic)
  49         .globl SYMBOL(_mmx_Copy_arrayof_conjoint_jshorts)
  50 
  51         .globl SYMBOL(_Atomic_cmpxchg_long)
  52         .globl SYMBOL(_Atomic_move_long)
  53 
  54         .text
  55 
  56 # Support for void os::Solaris::init_thread_fpu_state() in os_solaris_i486.cpp
  57 # Set fpu to 53 bit precision.  This happens too early to use a stub.
  58 # ported from solaris_x86_32.s
  59         .p2align 4,,15
  60 SYMBOL(fixcw):
  61         pushl    $0x27f
  62         fldcw    0(%esp)
  63         popl     %eax
  64         ret
  65 
  66         .globl  SYMBOL(SpinPause)
  67         ELF_TYPE(SpinPause,@function)
  68         .p2align 4,,15
  69 SYMBOL(SpinPause):
  70         rep
  71         nop
  72         movl    $1, %eax
  73         ret
  74 
  75         # Support for void Copy::conjoint_bytes(void* from,
  76         #                                       void* to,
  77         #                                       size_t count)
  78         .p2align 4,,15
  79         ELF_TYPE(_Copy_conjoint_bytes,@function)
  80 SYMBOL(_Copy_conjoint_bytes):
  81         pushl    %esi
  82         movl     4+12(%esp),%ecx      # count
  83         pushl    %edi
  84         movl     8+ 4(%esp),%esi      # from
  85         movl     8+ 8(%esp),%edi      # to
  86         cmpl     %esi,%edi
  87         leal     -1(%esi,%ecx),%eax   # from + count - 1
  88         jbe      cb_CopyRight
  89         cmpl     %eax,%edi
  90         jbe      cb_CopyLeft
  91         # copy from low to high
  92 cb_CopyRight:
  93         cmpl     $3,%ecx
  94         jbe      5f                   # <= 3 bytes
  95         # align source address at dword address boundary
  96         movl     %ecx,%eax            # original count
  97         movl     $4,%ecx
  98         subl     %esi,%ecx
  99         andl     $3,%ecx              # prefix byte count
 100         jz       1f                   # no prefix
 101         subl     %ecx,%eax            # byte count less prefix
 102         # copy prefix
 103         subl     %esi,%edi
 104 0:      movb     (%esi),%dl
 105         movb     %dl,(%edi,%esi,1)
 106         addl     $1,%esi
 107         subl     $1,%ecx
 108         jnz      0b
 109         addl     %esi,%edi
 110 1:      movl     %eax,%ecx            # byte count less prefix
 111         shrl     $2,%ecx              # dword count
 112         jz       4f                   # no dwords to move
 113         cmpl     $32,%ecx
 114         jbe      2f                   # <= 32 dwords
 115         # copy aligned dwords
 116         rep;     smovl
 117         jmp      4f
 118         # copy aligned dwords
 119 2:      subl     %esi,%edi
 120         .p2align 4,,15
 121 3:      movl     (%esi),%edx
 122         movl     %edx,(%edi,%esi,1)
 123         addl     $4,%esi
 124         subl     $1,%ecx
 125         jnz      3b
 126         addl     %esi,%edi
 127 4:      movl     %eax,%ecx            # byte count less prefix
 128 5:      andl     $3,%ecx              # suffix byte count
 129         jz       7f                   # no suffix
 130         # copy suffix
 131         xorl     %eax,%eax
 132 6:      movb     (%esi,%eax,1),%dl
 133         movb     %dl,(%edi,%eax,1)
 134         addl     $1,%eax
 135         subl     $1,%ecx
 136         jnz      6b
 137 7:      popl     %edi
 138         popl     %esi
 139         ret
 140         # copy from high to low
 141 cb_CopyLeft:
 142         std
 143         leal     -4(%edi,%ecx),%edi   # to + count - 4
 144         movl     %eax,%esi            # from + count - 1
 145         movl     %ecx,%eax
 146         subl     $3,%esi              # from + count - 4
 147         cmpl     $3,%ecx
 148         jbe      5f                   # <= 3 bytes
 149 1:      shrl     $2,%ecx              # dword count
 150         jz       4f                   # no dwords to move
 151         cmpl     $32,%ecx
 152         ja       3f                   # > 32 dwords
 153         # copy dwords, aligned or not
 154         subl     %esi,%edi
 155         .p2align 4,,15
 156 2:      movl     (%esi),%edx
 157         movl     %edx,(%edi,%esi,1)
 158         subl     $4,%esi
 159         subl     $1,%ecx
 160         jnz      2b
 161         addl     %esi,%edi
 162         jmp      4f
 163         # copy dwords, aligned or not
 164 3:      rep;     smovl
 165 4:      movl     %eax,%ecx            # byte count
 166 5:      andl     $3,%ecx              # suffix byte count
 167         jz       7f                   # no suffix
 168         # copy suffix
 169         subl     %esi,%edi
 170         addl     $3,%esi
 171 6:      movb     (%esi),%dl
 172         movb     %dl,(%edi,%esi,1)
 173         subl     $1,%esi
 174         subl     $1,%ecx
 175         jnz      6b
 176 7:      cld
 177         popl     %edi
 178         popl     %esi
 179         ret
 180 
 181         # Support for void Copy::arrayof_conjoint_bytes(void* from,
 182         #                                               void* to,
 183         #                                               size_t count)
 184         #
 185         # Same as _Copy_conjoint_bytes, except no source alignment check.
 186         .p2align 4,,15
 187         ELF_TYPE(_Copy_arrayof_conjoint_bytes,@function)
 188 SYMBOL(_Copy_arrayof_conjoint_bytes):
 189         pushl    %esi
 190         movl     4+12(%esp),%ecx      # count
 191         pushl    %edi
 192         movl     8+ 4(%esp),%esi      # from
 193         movl     8+ 8(%esp),%edi      # to
 194         cmpl     %esi,%edi
 195         leal     -1(%esi,%ecx),%eax   # from + count - 1
 196         jbe      acb_CopyRight
 197         cmpl     %eax,%edi
 198         jbe      acb_CopyLeft
 199         # copy from low to high
 200 acb_CopyRight:
 201         cmpl     $3,%ecx
 202         jbe      5f
 203 1:      movl     %ecx,%eax
 204         shrl     $2,%ecx
 205         jz       4f
 206         cmpl     $32,%ecx
 207         ja       3f
 208         # copy aligned dwords
 209         subl     %esi,%edi
 210         .p2align 4,,15
 211 2:      movl     (%esi),%edx
 212         movl     %edx,(%edi,%esi,1)
 213         addl     $4,%esi
 214         subl     $1,%ecx
 215         jnz      2b
 216         addl     %esi,%edi
 217         jmp      4f
 218         # copy aligned dwords
 219 3:      rep;     smovl
 220 4:      movl     %eax,%ecx
 221 5:      andl     $3,%ecx
 222         jz       7f
 223         # copy suffix
 224         xorl     %eax,%eax
 225 6:      movb     (%esi,%eax,1),%dl
 226         movb     %dl,(%edi,%eax,1)
 227         addl     $1,%eax
 228         subl     $1,%ecx
 229         jnz      6b
 230 7:      popl     %edi
 231         popl     %esi
 232         ret
 233 acb_CopyLeft:
 234         std
 235         leal     -4(%edi,%ecx),%edi   # to + count - 4
 236         movl     %eax,%esi            # from + count - 1
 237         movl     %ecx,%eax
 238         subl     $3,%esi              # from + count - 4
 239         cmpl     $3,%ecx
 240         jbe      5f
 241 1:      shrl     $2,%ecx
 242         jz       4f
 243         cmpl     $32,%ecx
 244         jbe      2f                   # <= 32 dwords
 245         rep;     smovl
 246         jmp      4f
 247         .space 8
 248 2:      subl     %esi,%edi
 249         .p2align 4,,15
 250 3:      movl     (%esi),%edx
 251         movl     %edx,(%edi,%esi,1)
 252         subl     $4,%esi
 253         subl     $1,%ecx
 254         jnz      3b
 255         addl     %esi,%edi
 256 4:      movl     %eax,%ecx
 257 5:      andl     $3,%ecx
 258         jz       7f
 259         subl     %esi,%edi
 260         addl     $3,%esi
 261 6:      movb     (%esi),%dl
 262         movb     %dl,(%edi,%esi,1)
 263         subl     $1,%esi
 264         subl     $1,%ecx
 265         jnz      6b
 266 7:      cld
 267         popl     %edi
 268         popl     %esi
 269         ret
 270 
 271         # Support for void Copy::conjoint_jshorts_atomic(void* from,
 272         #                                                void* to,
 273         #                                                size_t count)
 274         .p2align 4,,15
 275         ELF_TYPE(_Copy_conjoint_jshorts_atomic,@function)
 276 SYMBOL(_Copy_conjoint_jshorts_atomic):
 277         pushl    %esi
 278         movl     4+12(%esp),%ecx      # count
 279         pushl    %edi
 280         movl     8+ 4(%esp),%esi      # from
 281         movl     8+ 8(%esp),%edi      # to
 282         cmpl     %esi,%edi
 283         leal     -2(%esi,%ecx,2),%eax # from + count*2 - 2
 284         jbe      cs_CopyRight
 285         cmpl     %eax,%edi
 286         jbe      cs_CopyLeft
 287         # copy from low to high
 288 cs_CopyRight:
 289         # align source address at dword address boundary
 290         movl     %esi,%eax            # original from
 291         andl     $3,%eax              # either 0 or 2
 292         jz       1f                   # no prefix
 293         # copy prefix
 294         subl     $1,%ecx
 295         jl       5f                   # zero count
 296         movw     (%esi),%dx
 297         movw     %dx,(%edi)
 298         addl     %eax,%esi            # %eax == 2
 299         addl     %eax,%edi
 300 1:      movl     %ecx,%eax            # word count less prefix
 301         sarl     %ecx                 # dword count
 302         jz       4f                   # no dwords to move
 303         cmpl     $32,%ecx
 304         jbe      2f                   # <= 32 dwords
 305         # copy aligned dwords
 306         rep;     smovl
 307         jmp      4f
 308         # copy aligned dwords
 309 2:      subl     %esi,%edi
 310         .p2align 4,,15
 311 3:      movl     (%esi),%edx
 312         movl     %edx,(%edi,%esi,1)
 313         addl     $4,%esi
 314         subl     $1,%ecx
 315         jnz      3b
 316         addl     %esi,%edi
 317 4:      andl     $1,%eax              # suffix count
 318         jz       5f                   # no suffix
 319         # copy suffix
 320         movw     (%esi),%dx
 321         movw     %dx,(%edi)
 322 5:      popl     %edi
 323         popl     %esi
 324         ret
 325         # copy from high to low
 326 cs_CopyLeft:
 327         std
 328         leal     -4(%edi,%ecx,2),%edi # to + count*2 - 4
 329         movl     %eax,%esi            # from + count*2 - 2
 330         movl     %ecx,%eax
 331         subl     $2,%esi              # from + count*2 - 4
 332 1:      sarl     %ecx                 # dword count
 333         jz       4f                   # no dwords to move
 334         cmpl     $32,%ecx
 335         ja       3f                   # > 32 dwords
 336         subl     %esi,%edi
 337         .p2align 4,,15
 338 2:      movl     (%esi),%edx
 339         movl     %edx,(%edi,%esi,1)
 340         subl     $4,%esi
 341         subl     $1,%ecx
 342         jnz      2b
 343         addl     %esi,%edi
 344         jmp      4f
 345 3:      rep;     smovl
 346 4:      andl     $1,%eax              # suffix count
 347         jz       5f                   # no suffix
 348         # copy suffix
 349         addl     $2,%esi
 350         addl     $2,%edi
 351         movw     (%esi),%dx
 352         movw     %dx,(%edi)
 353 5:      cld
 354         popl     %edi
 355         popl     %esi
 356         ret
 357 
 358         # Support for void Copy::arrayof_conjoint_jshorts(void* from,
 359         #                                                 void* to,
 360         #                                                 size_t count)
 361         .p2align 4,,15
 362         ELF_TYPE(_Copy_arrayof_conjoint_jshorts,@function)
 363 SYMBOL(_Copy_arrayof_conjoint_jshorts):
 364         pushl    %esi
 365         movl     4+12(%esp),%ecx      # count
 366         pushl    %edi
 367         movl     8+ 4(%esp),%esi      # from
 368         movl     8+ 8(%esp),%edi      # to
 369         cmpl     %esi,%edi
 370         leal     -2(%esi,%ecx,2),%eax # from + count*2 - 2
 371         jbe      acs_CopyRight
 372         cmpl     %eax,%edi
 373         jbe      acs_CopyLeft
 374 acs_CopyRight:
 375         movl     %ecx,%eax            # word count
 376         sarl     %ecx                 # dword count
 377         jz       4f                   # no dwords to move
 378         cmpl     $32,%ecx
 379         jbe      2f                   # <= 32 dwords
 380         # copy aligned dwords
 381         rep;     smovl
 382         jmp      4f
 383         # copy aligned dwords
 384         .space 5
 385 2:      subl     %esi,%edi
 386         .p2align 4,,15
 387 3:      movl     (%esi),%edx
 388         movl     %edx,(%edi,%esi,1)
 389         addl     $4,%esi
 390         subl     $1,%ecx
 391         jnz      3b
 392         addl     %esi,%edi
 393 4:      andl     $1,%eax              # suffix count
 394         jz       5f                   # no suffix
 395         # copy suffix
 396         movw     (%esi),%dx
 397         movw     %dx,(%edi)
 398 5:      popl     %edi
 399         popl     %esi
 400         ret
 401 acs_CopyLeft:
 402         std
 403         leal     -4(%edi,%ecx,2),%edi # to + count*2 - 4
 404         movl     %eax,%esi            # from + count*2 - 2
 405         movl     %ecx,%eax
 406         subl     $2,%esi              # from + count*2 - 4
 407         sarl     %ecx                 # dword count
 408         jz       4f                   # no dwords to move
 409         cmpl     $32,%ecx
 410         ja       3f                   # > 32 dwords
 411         subl     %esi,%edi
 412         .p2align 4,,15
 413 2:      movl     (%esi),%edx
 414         movl     %edx,(%edi,%esi,1)
 415         subl     $4,%esi
 416         subl     $1,%ecx
 417         jnz      2b
 418         addl     %esi,%edi
 419         jmp      4f
 420 3:      rep;     smovl
 421 4:      andl     $1,%eax              # suffix count
 422         jz       5f                   # no suffix
 423         # copy suffix
 424         addl     $2,%esi
 425         addl     $2,%edi
 426         movw     (%esi),%dx
 427         movw     %dx,(%edi)
 428 5:      cld
 429         popl     %edi
 430         popl     %esi
 431         ret
 432 
 433         # Support for void Copy::conjoint_jints_atomic(void* from,
 434         #                                              void* to,
 435         #                                              size_t count)
 436         # Equivalent to
 437         #   arrayof_conjoint_jints
 438         .p2align 4,,15
 439         ELF_TYPE(_Copy_conjoint_jints_atomic,@function)
 440         ELF_TYPE(_Copy_arrayof_conjoint_jints,@function)
 441 SYMBOL(_Copy_conjoint_jints_atomic):
 442 SYMBOL(_Copy_arrayof_conjoint_jints):
 443         pushl    %esi
 444         movl     4+12(%esp),%ecx      # count
 445         pushl    %edi
 446         movl     8+ 4(%esp),%esi      # from
 447         movl     8+ 8(%esp),%edi      # to
 448         cmpl     %esi,%edi
 449         leal     -4(%esi,%ecx,4),%eax # from + count*4 - 4
 450         jbe      ci_CopyRight
 451         cmpl     %eax,%edi
 452         jbe      ci_CopyLeft
 453 ci_CopyRight:
 454         cmpl     $32,%ecx
 455         jbe      2f                   # <= 32 dwords
 456         rep;     smovl
 457         popl     %edi
 458         popl     %esi
 459         ret
 460         .space 10
 461 2:      subl     %esi,%edi
 462         jmp      4f
 463         .p2align 4,,15
 464 3:      movl     (%esi),%edx
 465         movl     %edx,(%edi,%esi,1)
 466         addl     $4,%esi
 467 4:      subl     $1,%ecx
 468         jge      3b
 469         popl     %edi
 470         popl     %esi
 471         ret
 472 ci_CopyLeft:
 473         std
 474         leal     -4(%edi,%ecx,4),%edi # to + count*4 - 4
 475         cmpl     $32,%ecx
 476         ja       4f                   # > 32 dwords
 477         subl     %eax,%edi            # eax == from + count*4 - 4
 478         jmp      3f
 479         .p2align 4,,15
 480 2:      movl     (%eax),%edx
 481         movl     %edx,(%edi,%eax,1)
 482         subl     $4,%eax
 483 3:      subl     $1,%ecx
 484         jge      2b
 485         cld
 486         popl     %edi
 487         popl     %esi
 488         ret
 489 4:      movl     %eax,%esi            # from + count*4 - 4
 490         rep;     smovl
 491         cld
 492         popl     %edi
 493         popl     %esi
 494         ret
 495 
 496         # Support for void Copy::conjoint_jlongs_atomic(jlong* from,
 497         #                                               jlong* to,
 498         #                                               size_t count)
 499         #
 500         # 32-bit
 501         #
 502         # count treated as signed
 503         #
 504         # // if (from > to) {
 505         #   while (--count >= 0) {
 506         #     *to++ = *from++;
 507         #   }
 508         # } else {
 509         #   while (--count >= 0) {
 510         #     to[count] = from[count];
 511         #   }
 512         # }
 513         .p2align 4,,15
 514         ELF_TYPE(_Copy_conjoint_jlongs_atomic,@function)
 515 SYMBOL(_Copy_conjoint_jlongs_atomic):
 516         movl     4+8(%esp),%ecx       # count
 517         movl     4+0(%esp),%eax       # from
 518         movl     4+4(%esp),%edx       # to
 519         cmpl     %eax,%edx
 520         jae      cla_CopyLeft
 521 cla_CopyRight:
 522         subl     %eax,%edx
 523         jmp      2f
 524         .p2align 4,,15
 525 1:      fildll   (%eax)
 526         fistpll  (%edx,%eax,1)
 527         addl     $8,%eax
 528 2:      subl     $1,%ecx
 529         jge      1b
 530         ret
 531         .p2align 4,,15
 532 3:      fildll   (%eax,%ecx,8)
 533         fistpll  (%edx,%ecx,8)
 534 cla_CopyLeft:
 535         subl     $1,%ecx
 536         jge      3b
 537         ret
 538 
 539         # Support for void Copy::arrayof_conjoint_jshorts(void* from,
 540         #                                                 void* to,
 541         #                                                 size_t count)
 542         .p2align 4,,15
 543         ELF_TYPE(_mmx_Copy_arrayof_conjoint_jshorts,@function)
 544 SYMBOL(_mmx_Copy_arrayof_conjoint_jshorts):
 545         pushl    %esi
 546         movl     4+12(%esp),%ecx
 547         pushl    %edi
 548         movl     8+ 4(%esp),%esi
 549         movl     8+ 8(%esp),%edi
 550         cmpl     %esi,%edi
 551         leal     -2(%esi,%ecx,2),%eax
 552         jbe      mmx_acs_CopyRight
 553         cmpl     %eax,%edi
 554         jbe      mmx_acs_CopyLeft
 555 mmx_acs_CopyRight:
 556         movl     %ecx,%eax
 557         sarl     %ecx
 558         je       5f
 559         cmpl     $33,%ecx
 560         jae      3f
 561 1:      subl     %esi,%edi
 562         .p2align 4,,15
 563 2:      movl     (%esi),%edx
 564         movl     %edx,(%edi,%esi,1)
 565         addl     $4,%esi
 566         subl     $1,%ecx
 567         jnz      2b
 568         addl     %esi,%edi
 569         jmp      5f
 570 3:      smovl # align to 8 bytes, we know we are 4 byte aligned to start
 571         subl     $1,%ecx
 572 4:      .p2align 4,,15
 573         movq     0(%esi),%mm0
 574         addl     $64,%edi
 575         movq     8(%esi),%mm1
 576         subl     $16,%ecx
 577         movq     16(%esi),%mm2
 578         movq     %mm0,-64(%edi)
 579         movq     24(%esi),%mm0
 580         movq     %mm1,-56(%edi)
 581         movq     32(%esi),%mm1
 582         movq     %mm2,-48(%edi)
 583         movq     40(%esi),%mm2
 584         movq     %mm0,-40(%edi)
 585         movq     48(%esi),%mm0
 586         movq     %mm1,-32(%edi)
 587         movq     56(%esi),%mm1
 588         movq     %mm2,-24(%edi)
 589         movq     %mm0,-16(%edi)
 590         addl     $64,%esi
 591         movq     %mm1,-8(%edi)
 592         cmpl     $16,%ecx
 593         jge      4b
 594         emms
 595         testl    %ecx,%ecx
 596         ja       1b
 597 5:      andl     $1,%eax
 598         je       7f
 599 6:      movw     (%esi),%dx
 600         movw     %dx,(%edi)
 601 7:      popl     %edi
 602         popl     %esi
 603         ret
 604 mmx_acs_CopyLeft:
 605         std
 606         leal     -4(%edi,%ecx,2),%edi
 607         movl     %eax,%esi
 608         movl     %ecx,%eax
 609         subl     $2,%esi
 610         sarl     %ecx
 611         je       4f
 612         cmpl     $32,%ecx
 613         ja       3f
 614         subl     %esi,%edi
 615         .p2align 4,,15
 616 2:      movl     (%esi),%edx
 617         movl     %edx,(%edi,%esi,1)
 618         subl     $4,%esi
 619         subl     $1,%ecx
 620         jnz      2b
 621         addl     %esi,%edi
 622         jmp      4f
 623 3:      rep;     smovl
 624 4:      andl     $1,%eax
 625         je       6f
 626         addl     $2,%esi
 627         addl     $2,%edi
 628 5:      movw     (%esi),%dx
 629         movw     %dx,(%edi)
 630 6:      cld
 631         popl     %edi
 632         popl     %esi
 633         ret
 634 
 635 
 636         # Support for int64_t Atomic::cmpxchg(int64_t exchange_value,
 637         #                                     volatile int64_t* dest,
 638         #                                     int64_t compare_value)
 639         #
 640         .p2align 4,,15
 641         ELF_TYPE(_Atomic_cmpxchg_long,@function)
 642 SYMBOL(_Atomic_cmpxchg_long):
 643                                    #  8(%esp) : return PC
 644         pushl    %ebx              #  4(%esp) : old %ebx
 645         pushl    %edi              #  0(%esp) : old %edi
 646         movl     12(%esp), %ebx    # 12(%esp) : exchange_value (low)
 647         movl     16(%esp), %ecx    # 16(%esp) : exchange_value (high)
 648         movl     24(%esp), %eax    # 24(%esp) : compare_value (low)
 649         movl     28(%esp), %edx    # 28(%esp) : compare_value (high)
 650         movl     20(%esp), %edi    # 20(%esp) : dest
 651         lock
 652         cmpxchg8b (%edi)
 653         popl     %edi
 654         popl     %ebx
 655         ret
 656 
 657 
 658         # Support for int64_t Atomic::load and Atomic::store.
 659         # void _Atomic_move_long(const volatile int64_t* src, volatile int64_t* dst)
 660         .p2align 4,,15
 661         ELF_TYPE(_Atomic_move_long,@function)
 662 SYMBOL(_Atomic_move_long):
 663         movl     4(%esp), %eax   # src
 664         fildll    (%eax)
 665         movl     8(%esp), %eax   # dest
 666         fistpll   (%eax)
 667         ret
 668 
--- EOF ---