uClibc/libpthread/nptl/sysdeps/unix/sysv/linux/i386/i486/pthread_cond_timedwait.S

   1 /* Copyright (C) 2002-2004,2006-2007,2009,2010 Free Software Foundation, Inc.
   2    This file is part of the GNU C Library.
   3    Contributed by Ulrich Drepper <drepper@redhat.com>, 2002.
   4
   5    The GNU C Library is free software; you can redistribute it and/or
   6    modify it under the terms of the GNU Lesser General Public
   7    License as published by the Free Software Foundation; either
   8    version 2.1 of the License, or (at your option) any later version.
   9
  10    The GNU C Library is distributed in the hope that it will be useful,
  11    but WITHOUT ANY WARRANTY; without even the implied warranty of
  12    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13    Lesser General Public License for more details.
  14
  15    You should have received a copy of the GNU Lesser General Public
  16    License along with the GNU C Library; if not, write to the Free
  17    Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
  18    02111-1307 USA.  */
  19
  20 #include <sysdep.h>
  21 #include <lowlevellock.h>
  22 #include <lowlevelcond.h>
  23 #include <pthread-errnos.h>
  24 #include <pthread-pi-defines.h>
  25 #include <bits/kernel-features.h>
  26
  27
  28         .text
  29
  30 /* int pthread_cond_timedwait (pthread_cond_t *cond, pthread_mutex_t *mutex,
  31                                const struct timespec *abstime)  */
  32         .globl  __pthread_cond_timedwait
  33         .type   __pthread_cond_timedwait, @function
  34         .protected      __pthread_cond_timedwait
  35         .align  16
  36 __pthread_cond_timedwait:
  37 .LSTARTCODE:
  38         cfi_startproc
  39 #ifdef SHARED
  40         cfi_personality(DW_EH_PE_pcrel | DW_EH_PE_sdata4 | DW_EH_PE_indirect,
  41                         DW.ref.__gcc_personality_v0)
  42         cfi_lsda(DW_EH_PE_pcrel | DW_EH_PE_sdata4, .LexceptSTART)
  43 #else
  44         cfi_personality(DW_EH_PE_udata4, __gcc_personality_v0)
  45         cfi_lsda(DW_EH_PE_udata4, .LexceptSTART)
  46 #endif
  47
  48         pushl   %ebp
  49         cfi_adjust_cfa_offset(4)
  50         cfi_rel_offset(%ebp, 0)
  51         pushl   %edi
  52         cfi_adjust_cfa_offset(4)
  53         cfi_rel_offset(%edi, 0)
  54         pushl   %esi
  55         cfi_adjust_cfa_offset(4)
  56         cfi_rel_offset(%esi, 0)
  57         pushl   %ebx
  58         cfi_adjust_cfa_offset(4)
  59         cfi_rel_offset(%ebx, 0)
  60
  61         movl    20(%esp), %ebx
  62         movl    28(%esp), %ebp
  63
  64         cmpl    $1000000000, 4(%ebp)
  65         movl    $EINVAL, %eax
  66         jae     18f
  67
  68         /* Get internal lock.  */
  69         movl    $1, %edx
  70         xorl    %eax, %eax
  71         LOCK
  72 #if cond_lock == 0
  73         cmpxchgl %edx, (%ebx)
  74 #else
  75         cmpxchgl %edx, cond_lock(%ebx)
  76 #endif
  77         jnz     1f
  78
  79         /* Store the reference to the mutex.  If there is already a
  80            different value in there this is a bad user bug.  */
  81 2:      cmpl    $-1, dep_mutex(%ebx)
  82         movl    24(%esp), %eax
  83         je      17f
  84         movl    %eax, dep_mutex(%ebx)
  85
  86         /* Unlock the mutex.  */
  87 17:     xorl    %edx, %edx
  88         call    __pthread_mutex_unlock_usercnt
  89
  90         testl   %eax, %eax
  91         jne     16f
  92
  93         addl    $1, total_seq(%ebx)
  94         adcl    $0, total_seq+4(%ebx)
  95         addl    $1, cond_futex(%ebx)
  96         addl    $(1 << nwaiters_shift), cond_nwaiters(%ebx)
  97
  98 #define FRAME_SIZE 32
  99         subl    $FRAME_SIZE, %esp
 100         cfi_adjust_cfa_offset(FRAME_SIZE)
 101         cfi_remember_state
 102
 103         /* Get and store current wakeup_seq value.  */
 104         movl    wakeup_seq(%ebx), %edi
 105         movl    wakeup_seq+4(%ebx), %edx
 106         movl    broadcast_seq(%ebx), %eax
 107         movl    %edi, 12(%esp)
 108         movl    %edx, 16(%esp)
 109         movl    %eax, 20(%esp)
 110
 111         /* Reset the pi-requeued flag.  */
 112 8:      movl    $0, 24(%esp)
 113         /* Get the current time.  */
 114         movl    %ebx, %edx
 115 #ifdef __NR_clock_gettime
 116         /* Get the clock number.  */
 117         movl    cond_nwaiters(%ebx), %ebx
 118         andl    $((1 << nwaiters_shift) - 1), %ebx
 119         /* Only clocks 0 and 1 are allowed so far.  Both are handled in the
 120            kernel.  */
 121         leal    4(%esp), %ecx
 122         movl    $__NR_clock_gettime, %eax
 123         ENTER_KERNEL
 124 # ifndef __ASSUME_POSIX_TIMERS
 125         cmpl    $-ENOSYS, %eax
 126         je      19f
 127 # endif
 128         movl    %edx, %ebx
 129
 130         /* Compute relative timeout.  */
 131         movl    (%ebp), %ecx
 132         movl    4(%ebp), %edx
 133         subl    4(%esp), %ecx
 134         subl    8(%esp), %edx
 135 #else
 136         /* Get the current time.  */
 137         leal    4(%esp), %ebx
 138         xorl    %ecx, %ecx
 139         movl    $__NR_gettimeofday, %eax
 140         ENTER_KERNEL
 141         movl    %edx, %ebx
 142
 143         /* Compute relative timeout.  */
 144         movl    8(%esp), %eax
 145         movl    $1000, %edx
 146         mul     %edx            /* Milli seconds to nano seconds.  */
 147         movl    (%ebp), %ecx
 148         movl    4(%ebp), %edx
 149         subl    4(%esp), %ecx
 150         subl    %eax, %edx
 151 #endif
 152         jns     12f
 153         addl    $1000000000, %edx
 154         subl    $1, %ecx
 155 12:     testl   %ecx, %ecx
 156         movl    $-ETIMEDOUT, %esi
 157         js      6f
 158
 159         /* Store relative timeout.  */
 160 21:     movl    %ecx, 4(%esp)
 161         movl    %edx, 8(%esp)
 162
 163         movl    cond_futex(%ebx), %edi
 164         movl    %edi, 28(%esp)
 165
 166         /* Unlock.  */
 167         LOCK
 168 #if cond_lock == 0
 169         subl    $1, (%ebx)
 170 #else
 171         subl    $1, cond_lock(%ebx)
 172 #endif
 173         jne     3f
 174
 175 .LcleanupSTART:
 176 4:      call    __pthread_enable_asynccancel
 177         movl    %eax, (%esp)
 178
 179 #if FUTEX_PRIVATE_FLAG > 255
 180         xorl    %ecx, %ecx
 181 #endif
 182         cmpl    $-1, dep_mutex(%ebx)
 183         sete    %cl
 184         je      40f
 185
 186         movl    dep_mutex(%ebx), %edi
 187         /* Requeue to a non-robust PI mutex if the PI bit is set and
 188            the robust bit is not set.  */
 189         movl    MUTEX_KIND(%edi), %eax
 190         andl    $(ROBUST_BIT|PI_BIT), %eax
 191         cmpl    $PI_BIT, %eax
 192         jne     40f
 193
 194         movl    $(FUTEX_WAIT_REQUEUE_PI|FUTEX_PRIVATE_FLAG), %ecx
 195         /* The following only works like this because we only support
 196            two clocks, represented using a single bit.  */
 197         testl   $1, cond_nwaiters(%ebx)
 198         /* XXX Need to implement using sete instead of a jump.  */
 199         jne     42f
 200         orl     $FUTEX_CLOCK_REALTIME, %ecx
 201
 202         /* Requeue-PI uses absolute timeout */
 203 42:     leal    (%ebp), %esi
 204         movl    28(%esp), %edx
 205         addl    $cond_futex, %ebx
 206         movl    $SYS_futex, %eax
 207         ENTER_KERNEL
 208         subl    $cond_futex, %ebx
 209         movl    %eax, %esi
 210         /* Set the pi-requeued flag only if the kernel has returned 0. The
 211            kernel does not hold the mutex on ETIMEDOUT or any other error.  */
 212         cmpl    $0, %eax
 213         sete    24(%esp)
 214         je      41f
 215
 216         /* Normal and PI futexes dont mix. Use normal futex functions only
 217            if the kernel does not support the PI futex functions.  */
 218         cmpl    $-ENOSYS, %eax
 219         jne     41f
 220         xorl    %ecx, %ecx
 221
 222 40:     subl    $1, %ecx
 223 #ifdef __ASSUME_PRIVATE_FUTEX
 224         andl    $FUTEX_PRIVATE_FLAG, %ecx
 225 #else
 226         andl    %gs:PRIVATE_FUTEX, %ecx
 227 #endif
 228 #if FUTEX_WAIT != 0
 229         addl    $FUTEX_WAIT, %ecx
 230 #endif
 231         leal    4(%esp), %esi
 232         movl    28(%esp), %edx
 233         addl    $cond_futex, %ebx
 234 .Ladd_cond_futex:
 235         movl    $SYS_futex, %eax
 236         ENTER_KERNEL
 237         subl    $cond_futex, %ebx
 238 .Lsub_cond_futex:
 239         movl    %eax, %esi
 240
 241 41:     movl    (%esp), %eax
 242         call    __pthread_disable_asynccancel
 243 .LcleanupEND:
 244
 245         /* Lock.  */
 246         movl    $1, %edx
 247         xorl    %eax, %eax
 248         LOCK
 249 #if cond_lock == 0
 250         cmpxchgl %edx, (%ebx)
 251 #else
 252         cmpxchgl %edx, cond_lock(%ebx)
 253 #endif
 254         jnz     5f
 255
 256 6:      movl    broadcast_seq(%ebx), %eax
 257         cmpl    20(%esp), %eax
 258         jne     23f
 259
 260         movl    woken_seq(%ebx), %eax
 261         movl    woken_seq+4(%ebx), %ecx
 262
 263         movl    wakeup_seq(%ebx), %edi
 264         movl    wakeup_seq+4(%ebx), %edx
 265
 266         cmpl    16(%esp), %edx
 267         jne     7f
 268         cmpl    12(%esp), %edi
 269         je      15f
 270
 271 7:      cmpl    %ecx, %edx
 272         jne     9f
 273         cmp     %eax, %edi
 274         jne     9f
 275
 276 15:     cmpl    $-ETIMEDOUT, %esi
 277         jne     8b
 278
 279         addl    $1, wakeup_seq(%ebx)
 280         adcl    $0, wakeup_seq+4(%ebx)
 281         addl    $1, cond_futex(%ebx)
 282         movl    $ETIMEDOUT, %esi
 283         jmp     14f
 284
 285 23:     xorl    %esi, %esi
 286         jmp     24f
 287
 288 9:      xorl    %esi, %esi
 289 14:     addl    $1, woken_seq(%ebx)
 290         adcl    $0, woken_seq+4(%ebx)
 291
 292 24:     subl    $(1 << nwaiters_shift), cond_nwaiters(%ebx)
 293
 294         /* Wake up a thread which wants to destroy the condvar object.  */
 295         movl    total_seq(%ebx), %eax
 296         andl    total_seq+4(%ebx), %eax
 297         cmpl    $0xffffffff, %eax
 298         jne     25f
 299         movl    cond_nwaiters(%ebx), %eax
 300         andl    $~((1 << nwaiters_shift) - 1), %eax
 301         jne     25f
 302
 303         addl    $cond_nwaiters, %ebx
 304         movl    $SYS_futex, %eax
 305 #if FUTEX_PRIVATE_FLAG > 255
 306         xorl    %ecx, %ecx
 307 #endif
 308         cmpl    $-1, dep_mutex-cond_nwaiters(%ebx)
 309         sete    %cl
 310         subl    $1, %ecx
 311 #ifdef __ASSUME_PRIVATE_FUTEX
 312         andl    $FUTEX_PRIVATE_FLAG, %ecx
 313 #else
 314         andl    %gs:PRIVATE_FUTEX, %ecx
 315 #endif
 316         addl    $FUTEX_WAKE, %ecx
 317         movl    $1, %edx
 318         ENTER_KERNEL
 319         subl    $cond_nwaiters, %ebx
 320
 321 25:     LOCK
 322 #if cond_lock == 0
 323         subl    $1, (%ebx)
 324 #else
 325         subl    $1, cond_lock(%ebx)
 326 #endif
 327         jne     10f
 328
 329 11:     movl    24+FRAME_SIZE(%esp), %eax
 330         /* With requeue_pi, the mutex lock is held in the kernel.  */
 331         movl    24(%esp), %ecx
 332         testl   %ecx, %ecx
 333         jnz     27f
 334
 335         call    __pthread_mutex_cond_lock
 336 26:     addl    $FRAME_SIZE, %esp
 337         cfi_adjust_cfa_offset(-FRAME_SIZE);
 338
 339         /* We return the result of the mutex_lock operation if it failed.  */
 340         testl   %eax, %eax
 341 #ifdef HAVE_CMOV
 342         cmovel  %esi, %eax
 343 #else
 344         jne     22f
 345         movl    %esi, %eax
 346 22:
 347 #endif
 348
 349 18:     popl    %ebx
 350         cfi_adjust_cfa_offset(-4)
 351         cfi_restore(%ebx)
 352         popl    %esi
 353         cfi_adjust_cfa_offset(-4)
 354         cfi_restore(%esi)
 355         popl    %edi
 356         cfi_adjust_cfa_offset(-4)
 357         cfi_restore(%edi)
 358         popl    %ebp
 359         cfi_adjust_cfa_offset(-4)
 360         cfi_restore(%ebp)
 361
 362         ret
 363
 364         cfi_restore_state
 365
 366 27:     call    __pthread_mutex_cond_lock_adjust
 367         xorl    %eax, %eax
 368         jmp     26b
 369
 370         cfi_adjust_cfa_offset(-FRAME_SIZE);
 371         /* Initial locking failed.  */
 372 1:
 373 #if cond_lock == 0
 374         movl    %ebx, %edx
 375 #else
 376         leal    cond_lock(%ebx), %edx
 377 #endif
 378 #if (LLL_SHARED-LLL_PRIVATE) > 255
 379         xorl    %ecx, %ecx
 380 #endif
 381         cmpl    $-1, dep_mutex(%ebx)
 382         setne   %cl
 383         subl    $1, %ecx
 384         andl    $(LLL_SHARED-LLL_PRIVATE), %ecx
 385 #if LLL_PRIVATE != 0
 386         addl    $LLL_PRIVATE, %ecx
 387 #endif
 388         call    __lll_lock_wait
 389         jmp     2b
 390
 391         /* The initial unlocking of the mutex failed.  */
 392 16:
 393         LOCK
 394 #if cond_lock == 0
 395         subl    $1, (%ebx)
 396 #else
 397         subl    $1, cond_lock(%ebx)
 398 #endif
 399         jne     18b
 400
 401         movl    %eax, %esi
 402 #if cond_lock == 0
 403         movl    %ebx, %eax
 404 #else
 405         leal    cond_lock(%ebx), %eax
 406 #endif
 407 #if (LLL_SHARED-LLL_PRIVATE) > 255
 408         xorl    %ecx, %ecx
 409 #endif
 410         cmpl    $-1, dep_mutex(%ebx)
 411         setne   %cl
 412         subl    $1, %ecx
 413         andl    $(LLL_SHARED-LLL_PRIVATE), %ecx
 414 #if LLL_PRIVATE != 0
 415         addl    $LLL_PRIVATE, %ecx
 416 #endif
 417         call    __lll_unlock_wake
 418
 419         movl    %esi, %eax
 420         jmp     18b
 421
 422         cfi_adjust_cfa_offset(FRAME_SIZE)
 423
 424         /* Unlock in loop requires wakeup.  */
 425 3:
 426 #if cond_lock == 0
 427         movl    %ebx, %eax
 428 #else
 429         leal    cond_lock(%ebx), %eax
 430 #endif
 431 #if (LLL_SHARED-LLL_PRIVATE) > 255
 432         xorl    %ecx, %ecx
 433 #endif
 434         cmpl    $-1, dep_mutex(%ebx)
 435         setne   %cl
 436         subl    $1, %ecx
 437         andl    $(LLL_SHARED-LLL_PRIVATE), %ecx
 438 #if LLL_PRIVATE != 0
 439         addl    $LLL_PRIVATE, %ecx
 440 #endif
 441         call    __lll_unlock_wake
 442         jmp     4b
 443
 444         /* Locking in loop failed.  */
 445 5:
 446 #if cond_lock == 0
 447         movl    %ebx, %edx
 448 #else
 449         leal    cond_lock(%ebx), %edx
 450 #endif
 451 #if (LLL_SHARED-LLL_PRIVATE) > 255
 452         xorl    %ecx, %ecx
 453 #endif
 454         cmpl    $-1, dep_mutex(%ebx)
 455         setne   %cl
 456         subl    $1, %ecx
 457         andl    $(LLL_SHARED-LLL_PRIVATE), %ecx
 458 #if LLL_PRIVATE != 0
 459         addl    $LLL_PRIVATE, %ecx
 460 #endif
 461         call    __lll_lock_wait
 462         jmp     6b
 463
 464         /* Unlock after loop requires wakeup.  */
 465 10:
 466 #if cond_lock == 0
 467         movl    %ebx, %eax
 468 #else
 469         leal    cond_lock(%ebx), %eax
 470 #endif
 471 #if (LLL_SHARED-LLL_PRIVATE) > 255
 472         xorl    %ecx, %ecx
 473 #endif
 474         cmpl    $-1, dep_mutex(%ebx)
 475         setne   %cl
 476         subl    $1, %ecx
 477         andl    $(LLL_SHARED-LLL_PRIVATE), %ecx
 478 #if LLL_PRIVATE != 0
 479         addl    $LLL_PRIVATE, %ecx
 480 #endif
 481         call    __lll_unlock_wake
 482         jmp     11b
 483
 484 #if defined __NR_clock_gettime && !defined __ASSUME_POSIX_TIMERS
 485         /* clock_gettime not available.  */
 486 19:     leal    4(%esp), %ebx
 487         xorl    %ecx, %ecx
 488         movl    $__NR_gettimeofday, %eax
 489         ENTER_KERNEL
 490         movl    %edx, %ebx
 491
 492         /* Compute relative timeout.  */
 493         movl    8(%esp), %eax
 494         movl    $1000, %edx
 495         mul     %edx            /* Milli seconds to nano seconds.  */
 496         movl    (%ebp), %ecx
 497         movl    4(%ebp), %edx
 498         subl    4(%esp), %ecx
 499         subl    %eax, %edx
 500         jns     20f
 501         addl    $1000000000, %edx
 502         subl    $1, %ecx
 503 20:     testl   %ecx, %ecx
 504         movl    $-ETIMEDOUT, %esi
 505         js      6b
 506         jmp     21b
 507 #endif
 508         .size   __pthread_cond_timedwait, .-__pthread_cond_timedwait
 509 weak_alias(__pthread_cond_timedwait, pthread_cond_timedwait)
 510
 511
 512         .type   __condvar_tw_cleanup2, @function
 513 __condvar_tw_cleanup2:
 514         subl    $cond_futex, %ebx
 515         .size   __condvar_tw_cleanup2, .-__condvar_tw_cleanup2
 516         .type   __condvar_tw_cleanup, @function
 517 __condvar_tw_cleanup:
 518         movl    %eax, %esi
 519
 520         /* Get internal lock.  */
 521         movl    $1, %edx
 522         xorl    %eax, %eax
 523         LOCK
 524 #if cond_lock == 0
 525         cmpxchgl %edx, (%ebx)
 526 #else
 527         cmpxchgl %edx, cond_lock(%ebx)
 528 #endif
 529         jz      1f
 530
 531 #if cond_lock == 0
 532         movl    %ebx, %edx
 533 #else
 534         leal    cond_lock(%ebx), %edx
 535 #endif
 536 #if (LLL_SHARED-LLL_PRIVATE) > 255
 537         xorl    %ecx, %ecx
 538 #endif
 539         cmpl    $-1, dep_mutex(%ebx)
 540         setne   %cl
 541         subl    $1, %ecx
 542         andl    $(LLL_SHARED-LLL_PRIVATE), %ecx
 543 #if LLL_PRIVATE != 0
 544         addl    $LLL_PRIVATE, %ecx
 545 #endif
 546         call    __lll_lock_wait
 547
 548 1:      movl    broadcast_seq(%ebx), %eax
 549         cmpl    20(%esp), %eax
 550         jne     3f
 551
 552         /* We increment the wakeup_seq counter only if it is lower than
 553            total_seq.  If this is not the case the thread was woken and
 554            then canceled.  In this case we ignore the signal.  */
 555         movl    total_seq(%ebx), %eax
 556         movl    total_seq+4(%ebx), %edi
 557         cmpl    wakeup_seq+4(%ebx), %edi
 558         jb      6f
 559         ja      7f
 560         cmpl    wakeup_seq(%ebx), %eax
 561         jbe     7f
 562
 563 6:      addl    $1, wakeup_seq(%ebx)
 564         adcl    $0, wakeup_seq+4(%ebx)
 565         addl    $1, cond_futex(%ebx)
 566
 567 7:      addl    $1, woken_seq(%ebx)
 568         adcl    $0, woken_seq+4(%ebx)
 569
 570 3:      subl    $(1 << nwaiters_shift), cond_nwaiters(%ebx)
 571
 572         /* Wake up a thread which wants to destroy the condvar object.  */
 573         xorl    %edi, %edi
 574         movl    total_seq(%ebx), %eax
 575         andl    total_seq+4(%ebx), %eax
 576         cmpl    $0xffffffff, %eax
 577         jne     4f
 578         movl    cond_nwaiters(%ebx), %eax
 579         andl    $~((1 << nwaiters_shift) - 1), %eax
 580         jne     4f
 581
 582         addl    $cond_nwaiters, %ebx
 583         movl    $SYS_futex, %eax
 584 #if FUTEX_PRIVATE_FLAG > 255
 585         xorl    %ecx, %ecx
 586 #endif
 587         cmpl    $-1, dep_mutex-cond_nwaiters(%ebx)
 588         sete    %cl
 589         subl    $1, %ecx
 590 #ifdef __ASSUME_PRIVATE_FUTEX
 591         andl    $FUTEX_PRIVATE_FLAG, %ecx
 592 #else
 593         andl    %gs:PRIVATE_FUTEX, %ecx
 594 #endif
 595         addl    $FUTEX_WAKE, %ecx
 596         movl    $1, %edx
 597         ENTER_KERNEL
 598         subl    $cond_nwaiters, %ebx
 599         movl    $1, %edi
 600
 601 4:      LOCK
 602 #if cond_lock == 0
 603         subl    $1, (%ebx)
 604 #else
 605         subl    $1, cond_lock(%ebx)
 606 #endif
 607         je      2f
 608
 609 #if cond_lock == 0
 610         movl    %ebx, %eax
 611 #else
 612         leal    cond_lock(%ebx), %eax
 613 #endif
 614 #if (LLL_SHARED-LLL_PRIVATE) > 255
 615         xorl    %ecx, %ecx
 616 #endif
 617         cmpl    $-1, dep_mutex(%ebx)
 618         setne   %cl
 619         subl    $1, %ecx
 620         andl    $(LLL_SHARED-LLL_PRIVATE), %ecx
 621 #if LLL_PRIVATE != 0
 622         addl    $LLL_PRIVATE, %ecx
 623 #endif
 624         call    __lll_unlock_wake
 625
 626         /* Wake up all waiters to make sure no signal gets lost.  */
 627 2:      testl   %edi, %edi
 628         jnz     5f
 629         addl    $cond_futex, %ebx
 630 #if FUTEX_PRIVATE_FLAG > 255
 631         xorl    %ecx, %ecx
 632 #endif
 633         cmpl    $-1, dep_mutex-cond_futex(%ebx)
 634         sete    %cl
 635         subl    $1, %ecx
 636 #ifdef __ASSUME_PRIVATE_FUTEX
 637         andl    $FUTEX_PRIVATE_FLAG, %ecx
 638 #else
 639         andl    %gs:PRIVATE_FUTEX, %ecx
 640 #endif
 641         addl    $FUTEX_WAKE, %ecx
 642         movl    $SYS_futex, %eax
 643         movl    $0x7fffffff, %edx
 644         ENTER_KERNEL
 645
 646 5:      movl    24+FRAME_SIZE(%esp), %eax
 647         call    __pthread_mutex_cond_lock
 648
 649         movl    %esi, (%esp)
 650 .LcallUR:
 651 #ifdef __PIC__
 652         call    __i686.get_pc_thunk.bx
 653         addl    $_GLOBAL_OFFSET_TABLE_, %ebx
 654 #endif
 655         call    _Unwind_Resume@PLT
 656         hlt
 657 .LENDCODE:
 658         cfi_endproc
 659         .size   __condvar_tw_cleanup, .-__condvar_tw_cleanup
 660
 661
 662         .section .gcc_except_table,"a",@progbits
 663 .LexceptSTART:
 664         .byte   DW_EH_PE_omit                   # @LPStart format (omit)
 665         .byte   DW_EH_PE_omit                   # @TType format (omit)
 666         .byte   DW_EH_PE_sdata4                 # call-site format
 667                                                 # DW_EH_PE_sdata4
 668         .uleb128 .Lcstend-.Lcstbegin
 669 .Lcstbegin:
 670         .long   .LcleanupSTART-.LSTARTCODE
 671         .long   .Ladd_cond_futex-.LcleanupSTART
 672         .long   __condvar_tw_cleanup-.LSTARTCODE
 673         .uleb128  0
 674         .long   .Ladd_cond_futex-.LSTARTCODE
 675         .long   .Lsub_cond_futex-.Ladd_cond_futex
 676         .long   __condvar_tw_cleanup2-.LSTARTCODE
 677         .uleb128  0
 678         .long   .Lsub_cond_futex-.LSTARTCODE
 679         .long   .LcleanupEND-.Lsub_cond_futex
 680         .long   __condvar_tw_cleanup-.LSTARTCODE
 681         .uleb128  0
 682         .long   .LcallUR-.LSTARTCODE
 683         .long   .LENDCODE-.LcallUR
 684         .long   0
 685         .uleb128  0
 686 .Lcstend:
 687
 688
 689 #ifdef SHARED
 690         .hidden DW.ref.__gcc_personality_v0
 691         .weak   DW.ref.__gcc_personality_v0
 692         .section .gnu.linkonce.d.DW.ref.__gcc_personality_v0,"aw",@progbits
 693         .align  4
 694         .type   DW.ref.__gcc_personality_v0, @object
 695         .size   DW.ref.__gcc_personality_v0, 4
 696 DW.ref.__gcc_personality_v0:
 697         .long   __gcc_personality_v0
 698 #endif