RTEMS-6
Annotated Report
posix
Sun Feb 28 22:22:22 2021
40005560 <_POSIX_Condition_variables_Wait_support>:
int _POSIX_Condition_variables_Wait_support(
pthread_cond_t *cond,
pthread_mutex_t *mutex,
const struct timespec *abstime
)
{
40005560: 9d e3 bf 78 save %sp, -136, %sp
Thread_queue_Context queue_context;
int error;
Thread_Control *executing;
the_cond = _POSIX_Condition_variables_Get( cond );
POSIX_CONDITION_VARIABLES_VALIDATE_OBJECT( the_cond, flags );
40005564: 80 a6 20 00 cmp %i0, 0
40005568: 02 80 00 3e be 40005660 <_POSIX_Condition_variables_Wait_support+0x100>
4000556c: 05 06 37 ec sethi %hi(0x18dfb000), %g2
40005570: fa 06 00 00 ld [ %i0 ], %i5
40005574: 82 1e 00 1d xor %i0, %i5, %g1
40005578: 84 10 a1 fe or %g2, 0x1fe, %g2
4000557c: 82 18 40 02 xor %g1, %g2, %g1
40005580: 80 88 7f fe btst -2, %g1
40005584: 12 80 00 32 bne 4000564c <_POSIX_Condition_variables_Wait_support+0xec>
40005588: 80 a6 a0 00 cmp %i2, 0
_Thread_queue_Context_initialize( &queue_context );
if ( abstime != NULL ) {
4000558c: 02 80 00 37 be 40005668 <_POSIX_Condition_variables_Wait_support+0x108>
40005590: 80 8f 60 01 btst 1, %i5
RTEMS_INLINE_ROUTINE clockid_t _POSIX_Condition_variables_Get_clock(
unsigned long flags
)
{
if ( ( flags & POSIX_CONDITION_VARIABLES_CLOCK_MONOTONIC ) != 0 ) {
40005594: 12 80 00 39 bne 40005678 <_POSIX_Condition_variables_Wait_support+0x118> <== NEVER TAKEN
40005598: f4 27 bf e8 st %i2, [ %fp + -24 ]
queue_context->enqueue_callout = enqueue_callout;
4000559c: 03 10 00 15 sethi %hi(0x40005400), %g1
400055a0: 82 10 60 b8 or %g1, 0xb8, %g1 ! 400054b8 <_POSIX_Condition_variables_Enqueue_with_timeout_realtime>
400055a4: c2 27 bf e4 st %g1, [ %fp + -28 ]
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
400055a8: 91 d0 20 09 ta 9
400055ac: c2 27 bf dc st %g1, [ %fp + -36 ]
}
executing = _POSIX_Condition_variables_Acquire( the_cond, &queue_context );
if (
the_cond->mutex != POSIX_CONDITION_VARIABLES_NO_MUTEX
400055b0: c2 06 20 18 ld [ %i0 + 0x18 ], %g1
&& the_cond->mutex != mutex
400055b4: 80 a0 40 19 cmp %g1, %i1
400055b8: 02 80 00 0a be 400055e0 <_POSIX_Condition_variables_Wait_support+0x80>
400055bc: 84 10 00 06 mov %g6, %g2
400055c0: 80 a0 60 00 cmp %g1, 0
400055c4: 22 80 00 08 be,a 400055e4 <_POSIX_Condition_variables_Wait_support+0x84>
400055c8: fa 00 a0 20 ld [ %g2 + 0x20 ], %i5
register uint32_t _psr __asm__("g1") = psr; /* input to trap handler */
400055cc: c2 07 bf dc ld [ %fp + -36 ], %g1
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
400055d0: 91 d0 20 0a ta 0xa
400055d4: 01 00 00 00 nop
) {
_POSIX_Condition_variables_Release( the_cond, &queue_context );
return EINVAL;
400055d8: 81 c7 e0 08 ret
400055dc: 91 e8 20 16 restore %g0, 0x16, %o0
ISR_Level level;
Thread_Control *executing;
_Thread_queue_Context_ISR_disable( queue_context, level );
_Thread_queue_Context_set_ISR_level( queue_context, level );
executing = _Thread_Executing;
400055e0: fa 00 a0 20 ld [ %g2 + 0x20 ], %i5
}
the_cond->mutex = mutex;
400055e4: f2 26 20 18 st %i1, [ %i0 + 0x18 ]
queue_context->thread_state = thread_state;
400055e8: 82 10 20 20 mov 0x20, %g1
_Thread_queue_Context_set_thread_state(
&queue_context,
STATES_WAITING_FOR_CONDITION_VARIABLE
);
_Thread_queue_Enqueue(
400055ec: 90 06 20 0c add %i0, 0xc, %o0
400055f0: c2 27 bf e0 st %g1, [ %fp + -32 ]
400055f4: 96 07 bf dc add %fp, -36, %o3
400055f8: 94 10 00 1d mov %i5, %o2
400055fc: 13 10 00 4b sethi %hi(0x40012c00), %o1
40005600: 40 00 0a fb call 400081ec <_Thread_queue_Enqueue>
40005604: 92 12 62 88 or %o1, 0x288, %o1 ! 40012e88 <_Thread_queue_Operations_FIFO>
return _POSIX_Get_by_name_error_table[ error ];
}
RTEMS_INLINE_ROUTINE int _POSIX_Get_error( Status_Control status )
{
return STATUS_GET_POSIX( status );
40005608: c2 07 60 4c ld [ %i5 + 0x4c ], %g1
4000560c: b1 38 60 1f sra %g1, 0x1f, %i0
40005610: b0 0e 20 ff and %i0, 0xff, %i0
40005614: b0 06 00 01 add %i0, %g1, %i0
40005618: b1 3e 20 08 sra %i0, 8, %i0
* according to the POSIX standard. It means that pthread_cond_wait
* returns a success status, except for the fact that it was not
* woken up a pthread_cond_signal() or a pthread_cond_broadcast().
*/
if ( error == EINTR ) {
4000561c: 80 a6 20 04 cmp %i0, 4
40005620: 02 80 00 1c be 40005690 <_POSIX_Condition_variables_Wait_support+0x130> <== NEVER TAKEN
40005624: 80 a6 20 01 cmp %i0, 1
/*
* When we get here the dispatch disable level is 0.
*/
if ( error != EPERM ) {
40005628: 02 80 00 18 be 40005688 <_POSIX_Condition_variables_Wait_support+0x128>
4000562c: 01 00 00 00 nop
int mutex_error;
mutex_error = pthread_mutex_lock( mutex );
40005630: 40 00 00 86 call 40005848 <pthread_mutex_lock>
40005634: 90 10 00 19 mov %i1, %o0
if ( mutex_error != 0 ) {
40005638: 80 a2 20 00 cmp %o0, 0
4000563c: 12 80 00 09 bne 40005660 <_POSIX_Condition_variables_Wait_support+0x100>
40005640: 01 00 00 00 nop
error = EINVAL;
}
}
return error;
}
40005644: 81 c7 e0 08 ret
40005648: 81 e8 00 00 restore
POSIX_CONDITION_VARIABLES_VALIDATE_OBJECT( the_cond, flags );
4000564c: 7f ff ff 7f call 40005448 <_POSIX_Condition_variables_Auto_initialization>
40005650: 90 10 00 18 mov %i0, %o0
40005654: 80 a2 20 00 cmp %o0, 0
40005658: 12 bf ff cd bne 4000558c <_POSIX_Condition_variables_Wait_support+0x2c>
4000565c: 80 a6 a0 00 cmp %i2, 0
}
40005660: 81 c7 e0 08 ret
40005664: 91 e8 20 16 restore %g0, 0x16, %o0
queue_context->enqueue_callout = enqueue_callout;
40005668: 03 10 00 15 sethi %hi(0x40005400), %g1
4000566c: 82 10 60 f8 or %g1, 0xf8, %g1 ! 400054f8 <_POSIX_Condition_variables_Enqueue_no_timeout>
}
40005670: 10 bf ff ce b 400055a8 <_POSIX_Condition_variables_Wait_support+0x48>
40005674: c2 27 bf e4 st %g1, [ %fp + -28 ]
queue_context->enqueue_callout = enqueue_callout;
40005678: 03 10 00 15 sethi %hi(0x40005400), %g1 <== NOT EXECUTED
4000567c: 82 10 61 20 or %g1, 0x120, %g1 ! 40005520 <_POSIX_Condition_variables_Enqueue_with_timeout_monotonic><== NOT EXECUTED
}
40005680: 10 bf ff ca b 400055a8 <_POSIX_Condition_variables_Wait_support+0x48> <== NOT EXECUTED
40005684: c2 27 bf e4 st %g1, [ %fp + -28 ] <== NOT EXECUTED
40005688: 81 c7 e0 08 ret
4000568c: 81 e8 00 00 restore
error = 0;
40005690: 10 bf ff e8 b 40005630 <_POSIX_Condition_variables_Wait_support+0xd0> <== NOT EXECUTED
40005694: b0 10 20 00 clr %i0 <== NOT EXECUTED
40005698 <_POSIX_Message_queue_Receive_support>:
size_t msg_len,
unsigned int *msg_prio,
const struct timespec *abstime,
Thread_queue_Enqueue_callout enqueue_callout
)
{
40005698: 9d e3 bf 78 save %sp, -136, %sp
return (POSIX_Message_queue_Control *) _Objects_Get(
4000569c: 15 10 00 5d sethi %hi(0x40017400), %o2
400056a0: 92 07 bf dc add %fp, -36, %o1
400056a4: 94 12 a1 04 or %o2, 0x104, %o2
400056a8: 40 00 0b 4f call 400083e4 <_Objects_Get>
400056ac: 90 10 00 18 mov %i0, %o0
Thread_Control *executing;
Status_Control status;
the_mq = _POSIX_Message_queue_Get( mqdes, &queue_context );
if ( the_mq == NULL ) {
400056b0: 82 92 20 00 orcc %o0, 0, %g1
400056b4: 02 80 00 2b be 40005760 <_POSIX_Message_queue_Receive_support+0xc8>
400056b8: 01 00 00 00 nop
rtems_set_errno_and_return_minus_one( EBADF );
}
if ( ( the_mq->oflag & O_ACCMODE ) == O_WRONLY ) {
400056bc: d8 00 60 6c ld [ %g1 + 0x6c ], %o4
400056c0: 84 0b 20 03 and %o4, 3, %g2
400056c4: 80 a0 a0 01 cmp %g2, 1
400056c8: 02 80 00 23 be 40005754 <_POSIX_Message_queue_Receive_support+0xbc>
400056cc: 01 00 00 00 nop
_ISR_lock_ISR_enable( &queue_context.Lock_context.Lock_context );
rtems_set_errno_and_return_minus_one( EBADF );
}
if ( msg_len < the_mq->Message_queue.maximum_message_size ) {
400056d0: c4 00 60 28 ld [ %g1 + 0x28 ], %g2
400056d4: 80 a0 80 1a cmp %g2, %i2
400056d8: 18 80 00 28 bgu 40005778 <_POSIX_Message_queue_Receive_support+0xe0>
400056dc: 84 10 3f ff mov -1, %g2
queue_context->enqueue_callout = enqueue_callout;
400056e0: fa 27 bf e4 st %i5, [ %fp + -28 ]
* Now if something goes wrong, we return a "length" of -1
* to indicate an error.
*/
length_out = -1;
_CORE_message_queue_Acquire_critical(
400056e4: 90 00 60 10 add %g1, 0x10, %o0
queue_context->Timeout.arg = arg;
400056e8: f8 27 bf e8 st %i4, [ %fp + -24 ]
length_out = -1;
400056ec: c4 27 bf d8 st %g2, [ %fp + -40 ]
&the_mq->Message_queue,
&queue_context
);
if ( the_mq->open_count == 0 ) {
400056f0: c2 00 60 54 ld [ %g1 + 0x54 ], %g1
400056f4: 80 a0 60 00 cmp %g1, 0
400056f8: 02 80 00 17 be 40005754 <_POSIX_Message_queue_Receive_support+0xbc>
400056fc: 99 33 20 0e srl %o4, 0xe, %o4
}
/*
* Now perform the actual message receive
*/
executing = _Thread_Executing;
40005700: f8 01 a0 20 ld [ %g6 + 0x20 ], %i4
status = _CORE_message_queue_Seize(
40005704: 9a 07 bf dc add %fp, -36, %o5
40005708: 98 1b 20 01 xor %o4, 1, %o4
4000570c: 96 07 bf d8 add %fp, -40, %o3
40005710: 98 0b 20 01 and %o4, 1, %o4
40005714: 94 10 00 19 mov %i1, %o2
40005718: 40 00 07 62 call 400074a0 <_CORE_message_queue_Seize>
4000571c: 92 10 00 1c mov %i4, %o1
&length_out,
( the_mq->oflag & O_NONBLOCK ) == 0,
&queue_context
);
if ( status != STATUS_SUCCESSFUL ) {
40005720: ba 92 20 00 orcc %o0, 0, %i5
40005724: 12 80 00 1e bne 4000579c <_POSIX_Message_queue_Receive_support+0x104>
40005728: 80 a6 e0 00 cmp %i3, 0
rtems_set_errno_and_return_minus_one( _POSIX_Get_error( status ) );
}
if ( msg_prio != NULL ) {
4000572c: 22 80 00 08 be,a 4000574c <_POSIX_Message_queue_Receive_support+0xb4> <== NEVER TAKEN
40005730: f0 07 bf d8 ld [ %fp + -40 ], %i0 <== NOT EXECUTED
return (unsigned int) ((priority >= 0) ? priority : -priority);
40005734: c2 07 20 3c ld [ %i4 + 0x3c ], %g1
40005738: 85 38 60 1f sra %g1, 0x1f, %g2
4000573c: 82 18 80 01 xor %g2, %g1, %g1
40005740: 82 20 40 02 sub %g1, %g2, %g1
*msg_prio = _POSIX_Message_queue_Priority_from_core(
40005744: c2 26 c0 00 st %g1, [ %i3 ]
executing->Wait.count
);
}
return length_out;
40005748: f0 07 bf d8 ld [ %fp + -40 ], %i0
}
4000574c: 81 c7 e0 08 ret
40005750: 81 e8 00 00 restore
register uint32_t _psr __asm__("g1") = psr; /* input to trap handler */
40005754: c2 07 bf dc ld [ %fp + -36 ], %g1
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
40005758: 91 d0 20 0a ta 0xa
4000575c: 01 00 00 00 nop
rtems_set_errno_and_return_minus_one( EBADF );
40005760: 40 00 35 02 call 40012b68 <__errno>
40005764: b0 10 3f ff mov -1, %i0 ! ffffffff <RAM_END+0xbfbfffff>
40005768: 82 10 20 09 mov 9, %g1
4000576c: c2 22 00 00 st %g1, [ %o0 ]
40005770: 81 c7 e0 08 ret
40005774: 81 e8 00 00 restore
register uint32_t _psr __asm__("g1") = psr; /* input to trap handler */
40005778: c2 07 bf dc ld [ %fp + -36 ], %g1
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
4000577c: 91 d0 20 0a ta 0xa
40005780: 01 00 00 00 nop
rtems_set_errno_and_return_minus_one( EMSGSIZE );
40005784: 40 00 34 f9 call 40012b68 <__errno>
40005788: b0 10 3f ff mov -1, %i0 ! ffffffff <RAM_END+0xbfbfffff>
4000578c: 82 10 20 7a mov 0x7a, %g1
40005790: c2 22 00 00 st %g1, [ %o0 ]
40005794: 81 c7 e0 08 ret
40005798: 81 e8 00 00 restore
rtems_set_errno_and_return_minus_one( _POSIX_Get_error( status ) );
4000579c: 40 00 34 f3 call 40012b68 <__errno>
400057a0: b0 10 3f ff mov -1, %i0
return STATUS_GET_POSIX( status );
400057a4: 83 3f 60 1f sra %i5, 0x1f, %g1
400057a8: 82 08 60 ff and %g1, 0xff, %g1
400057ac: 82 00 40 1d add %g1, %i5, %g1
400057b0: 83 38 60 08 sra %g1, 8, %g1
400057b4: c2 22 00 00 st %g1, [ %o0 ]
400057b8: 81 c7 e0 08 ret
400057bc: 81 e8 00 00 restore
400057d8 <_POSIX_Message_queue_Send_support>:
size_t msg_len,
unsigned int msg_prio,
const struct timespec *abstime,
Thread_queue_Enqueue_callout enqueue_callout
)
{
400057d8: 9d e3 bf 70 save %sp, -144, %sp
/*
* Validate the priority.
* XXX - Do not validate msg_prio is not less than 0.
*/
if ( msg_prio > MQ_PRIO_MAX ) {
400057dc: 80 a6 e0 20 cmp %i3, 0x20
400057e0: 18 80 00 33 bgu 400058ac <_POSIX_Message_queue_Send_support+0xd4>
400057e4: 92 07 bf dc add %fp, -36, %o1
return (POSIX_Message_queue_Control *) _Objects_Get(
400057e8: 15 10 00 5d sethi %hi(0x40017400), %o2
400057ec: 90 10 00 18 mov %i0, %o0
400057f0: 40 00 0a fd call 400083e4 <_Objects_Get>
400057f4: 94 12 a1 04 or %o2, 0x104, %o2
rtems_set_errno_and_return_minus_one( EINVAL );
}
the_mq = _POSIX_Message_queue_Get( mqdes, &queue_context );
if ( the_mq == NULL ) {
400057f8: 82 92 20 00 orcc %o0, 0, %g1
400057fc: 02 80 00 32 be 400058c4 <_POSIX_Message_queue_Send_support+0xec> <== NEVER TAKEN
40005800: 01 00 00 00 nop
rtems_set_errno_and_return_minus_one( EBADF );
}
if ( ( the_mq->oflag & O_ACCMODE ) == O_RDONLY ) {
40005804: da 00 60 6c ld [ %g1 + 0x6c ], %o5
40005808: 80 8b 60 03 btst 3, %o5
4000580c: 02 80 00 1f be 40005888 <_POSIX_Message_queue_Send_support+0xb0>
40005810: 90 00 60 10 add %g1, 0x10, %o0
queue_context->enqueue_callout = enqueue_callout;
40005814: fa 27 bf e4 st %i5, [ %fp + -28 ]
queue_context->Timeout.arg = arg;
40005818: f8 27 bf e8 st %i4, [ %fp + -24 ]
_CORE_message_queue_Acquire_critical(
&the_mq->Message_queue,
&queue_context
);
if ( the_mq->open_count == 0 ) {
4000581c: c2 00 60 54 ld [ %g1 + 0x54 ], %g1
40005820: 80 a0 60 00 cmp %g1, 0
40005824: 02 80 00 19 be 40005888 <_POSIX_Message_queue_Send_support+0xb0>
40005828: 82 07 bf dc add %fp, -36, %g1
/*
* Now perform the actual message receive
*/
executing = _Thread_Executing;
status = _CORE_message_queue_Submit(
4000582c: c2 23 a0 5c st %g1, [ %sp + 0x5c ]
40005830: 9b 33 60 0e srl %o5, 0xe, %o5
40005834: d2 01 a0 20 ld [ %g6 + 0x20 ], %o1
40005838: 9a 1b 60 01 xor %o5, 1, %o5
4000583c: 98 20 00 1b neg %i3, %o4
40005840: 9a 0b 60 01 and %o5, 1, %o5
40005844: 96 10 00 1a mov %i2, %o3
40005848: 40 00 07 5f call 400075c4 <_CORE_message_queue_Submit>
4000584c: 94 10 00 19 mov %i1, %o2
RTEMS_INLINE_ROUTINE int _POSIX_Zero_or_minus_one_plus_errno(
Status_Control status
)
{
if ( status == STATUS_SUCCESSFUL ) {
40005850: b0 92 20 00 orcc %o0, 0, %i0
40005854: 12 80 00 04 bne 40005864 <_POSIX_Message_queue_Send_support+0x8c>
40005858: 01 00 00 00 nop
_POSIX_Message_queue_Priority_to_core( msg_prio ),
( the_mq->oflag & O_NONBLOCK ) == 0,
&queue_context
);
return _POSIX_Zero_or_minus_one_plus_errno( status );
}
4000585c: 81 c7 e0 08 ret
40005860: 81 e8 00 00 restore
return 0;
}
rtems_set_errno_and_return_minus_one( _POSIX_Get_error( status ) );
40005864: 40 00 34 c1 call 40012b68 <__errno>
40005868: 01 00 00 00 nop
return STATUS_GET_POSIX( status );
4000586c: 83 3e 20 1f sra %i0, 0x1f, %g1
40005870: 82 08 60 ff and %g1, 0xff, %g1
40005874: 82 00 40 18 add %g1, %i0, %g1
40005878: 83 38 60 08 sra %g1, 8, %g1
rtems_set_errno_and_return_minus_one( _POSIX_Get_error( status ) );
4000587c: c2 22 00 00 st %g1, [ %o0 ]
40005880: 81 c7 e0 08 ret
40005884: 91 e8 3f ff restore %g0, -1, %o0
register uint32_t _psr __asm__("g1") = psr; /* input to trap handler */
40005888: c2 07 bf dc ld [ %fp + -36 ], %g1
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
4000588c: 91 d0 20 0a ta 0xa
40005890: 01 00 00 00 nop
rtems_set_errno_and_return_minus_one( EBADF );
40005894: 40 00 34 b5 call 40012b68 <__errno>
40005898: b0 10 3f ff mov -1, %i0 ! ffffffff <RAM_END+0xbfbfffff>
4000589c: 82 10 20 09 mov 9, %g1
400058a0: c2 22 00 00 st %g1, [ %o0 ]
400058a4: 81 c7 e0 08 ret
400058a8: 81 e8 00 00 restore
rtems_set_errno_and_return_minus_one( EINVAL );
400058ac: 40 00 34 af call 40012b68 <__errno>
400058b0: b0 10 3f ff mov -1, %i0
400058b4: 82 10 20 16 mov 0x16, %g1
400058b8: c2 22 00 00 st %g1, [ %o0 ]
400058bc: 81 c7 e0 08 ret
400058c0: 81 e8 00 00 restore
rtems_set_errno_and_return_minus_one( EBADF );
400058c4: 40 00 34 a9 call 40012b68 <__errno> <== NOT EXECUTED
400058c8: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
400058cc: 82 10 20 09 mov 9, %g1 <== NOT EXECUTED
400058d0: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
400058d4: 81 c7 e0 08 ret <== NOT EXECUTED
400058d8: 81 e8 00 00 restore <== NOT EXECUTED
40007814 <_POSIX_Mutex_Lock_support>:
int _POSIX_Mutex_Lock_support(
pthread_mutex_t *mutex,
const struct timespec *abstime,
Thread_queue_Enqueue_callout enqueue_callout
)
{
40007814: 9d e3 bf 78 save %sp, -136, %sp
Thread_queue_Context queue_context;
Thread_Control *executing;
Status_Control status;
the_mutex = _POSIX_Mutex_Get( mutex );
POSIX_MUTEX_VALIDATE_OBJECT( the_mutex, flags );
40007818: ba 96 20 00 orcc %i0, 0, %i5
4000781c: 02 80 00 5a be 40007984 <_POSIX_Mutex_Lock_support+0x170>
40007820: 05 25 87 04 sethi %hi(0x961c1000), %g2
40007824: f8 07 40 00 ld [ %i5 ], %i4
40007828: 82 1f 40 1c xor %i5, %i4, %g1
4000782c: 84 10 a3 b8 or %g2, 0x3b8, %g2
40007830: 82 18 40 02 xor %g1, %g2, %g1
40007834: 80 88 7f f8 btst -8, %g1
40007838: 12 80 00 4e bne 40007970 <_POSIX_Mutex_Lock_support+0x15c>
4000783c: 01 00 00 00 nop
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
40007840: 91 d0 20 09 ta 9
)
{
#if defined( RTEMS_SMP )
context->Lock_context.isr_level = level;
#else
context->isr_level = level;
40007844: c2 27 bf dc st %g1, [ %fp + -36 ]
executing = _POSIX_Mutex_Acquire( the_mutex, &queue_context );
_Thread_queue_Context_set_enqueue_callout( &queue_context, enqueue_callout);
_Thread_queue_Context_set_timeout_argument( &queue_context, abstime );
switch ( _POSIX_Mutex_Get_protocol( flags ) ) {
40007848: 82 8f 20 03 andcc %i4, 3, %g1
queue_context->enqueue_callout = enqueue_callout;
4000784c: f4 27 bf e4 st %i2, [ %fp + -28 ]
queue_context->Timeout.arg = arg;
40007850: f2 27 bf e8 st %i1, [ %fp + -24 ]
40007854: 02 80 00 35 be 40007928 <_POSIX_Mutex_Lock_support+0x114>
40007858: f6 01 a0 20 ld [ %g6 + 0x20 ], %i3
4000785c: 80 a0 60 02 cmp %g1, 2
40007860: 02 80 00 1a be 400078c8 <_POSIX_Mutex_Lock_support+0xb4>
40007864: c2 07 60 10 ld [ %i5 + 0x10 ], %g1
{
Thread_Control *owner;
owner = _POSIX_Mutex_Get_owner( the_mutex );
if ( owner == NULL ) {
40007868: 80 a0 60 00 cmp %g1, 0
4000786c: 02 80 00 60 be 400079ec <_POSIX_Mutex_Lock_support+0x1d8>
40007870: 80 a6 c0 01 cmp %i3, %g1
_Thread_Resource_count_increment( executing );
_POSIX_Mutex_Release( the_mutex, queue_context );
return STATUS_SUCCESSFUL;
}
if ( owner == executing ) {
40007874: 02 80 00 33 be 40007940 <_POSIX_Mutex_Lock_support+0x12c>
40007878: 80 a6 60 01 cmp %i1, 1
if ( (uintptr_t) abstime != POSIX_MUTEX_ABSTIME_TRY_LOCK ) {
4000787c: 02 80 00 57 be 400079d8 <_POSIX_Mutex_Lock_support+0x1c4>
40007880: 82 10 20 01 mov 1, %g1
queue_context->thread_state = thread_state;
40007884: c2 27 bf e0 st %g1, [ %fp + -32 ]
queue_context->deadlock_callout = deadlock_callout;
40007888: 03 10 00 2a sethi %hi(0x4000a800), %g1
4000788c: 82 10 62 68 or %g1, 0x268, %g1 ! 4000aa68 <_Thread_queue_Deadlock_status>
_Thread_queue_Enqueue(
40007890: 96 07 bf dc add %fp, -36, %o3
40007894: c2 27 bf fc st %g1, [ %fp + -4 ]
40007898: 94 10 00 1b mov %i3, %o2
4000789c: 90 07 60 0c add %i5, 0xc, %o0
400078a0: 13 10 00 69 sethi %hi(0x4001a400), %o1
400078a4: 40 00 0c 79 call 4000aa88 <_Thread_queue_Enqueue>
400078a8: 92 12 63 48 or %o1, 0x348, %o1 ! 4001a748 <_Thread_queue_Operations_priority_inherit>
return _POSIX_Get_by_name_error_table[ error ];
}
RTEMS_INLINE_ROUTINE int _POSIX_Get_error( Status_Control status )
{
return STATUS_GET_POSIX( status );
400078ac: c2 06 e0 4c ld [ %i3 + 0x4c ], %g1
400078b0: b1 38 60 1f sra %g1, 0x1f, %i0
400078b4: b0 0e 20 ff and %i0, 0xff, %i0
400078b8: b0 06 00 01 add %i0, %g1, %i0
400078bc: b1 3e 20 08 sra %i0, 8, %i0
return _Thread_Wait_get_status( executing );
400078c0: 81 c7 e0 08 ret
400078c4: 81 e8 00 00 restore
{
Thread_Control *owner;
owner = _POSIX_Mutex_Get_owner( the_mutex );
if ( owner == NULL ) {
400078c8: 80 a0 60 00 cmp %g1, 0
400078cc: 02 80 00 4e be 40007a04 <_POSIX_Mutex_Lock_support+0x1f0>
400078d0: 80 a6 c0 01 cmp %i3, %g1
executing,
queue_context
);
}
if ( owner == executing ) {
400078d4: 02 80 00 1b be 40007940 <_POSIX_Mutex_Lock_support+0x12c> <== NEVER TAKEN
400078d8: 80 a6 60 01 cmp %i1, 1
if ( (uintptr_t) abstime != POSIX_MUTEX_ABSTIME_TRY_LOCK ) {
400078dc: 02 80 00 3f be 400079d8 <_POSIX_Mutex_Lock_support+0x1c4> <== NEVER TAKEN
400078e0: 82 10 20 01 mov 1, %g1
queue_context->thread_state = thread_state;
400078e4: c2 27 bf e0 st %g1, [ %fp + -32 ]
queue_context->deadlock_callout = deadlock_callout;
400078e8: 03 10 00 2a sethi %hi(0x4000a800), %g1
400078ec: 82 10 62 68 or %g1, 0x268, %g1 ! 4000aa68 <_Thread_queue_Deadlock_status>
_Thread_queue_Enqueue(
400078f0: 96 07 bf dc add %fp, -36, %o3
400078f4: c2 27 bf fc st %g1, [ %fp + -4 ]
400078f8: 94 10 00 1b mov %i3, %o2
400078fc: 90 07 60 0c add %i5, 0xc, %o0
40007900: 13 10 00 69 sethi %hi(0x4001a400), %o1
40007904: 40 00 0c 61 call 4000aa88 <_Thread_queue_Enqueue>
40007908: 92 12 63 5c or %o1, 0x35c, %o1 ! 4001a75c <_Thread_queue_Operations_priority>
4000790c: c2 06 e0 4c ld [ %i3 + 0x4c ], %g1
40007910: b1 38 60 1f sra %g1, 0x1f, %i0
40007914: b0 0e 20 ff and %i0, 0xff, %i0
40007918: b0 06 00 01 add %i0, %g1, %i0
4000791c: b1 3e 20 08 sra %i0, 8, %i0
return _Thread_Wait_get_status( executing );
40007920: 81 c7 e0 08 ret
40007924: 81 e8 00 00 restore
return the_mutex->Recursive.Mutex.Queue.Queue.owner;
40007928: c2 07 60 10 ld [ %i5 + 0x10 ], %g1
if ( owner == NULL ) {
4000792c: 80 a0 60 00 cmp %g1, 0
40007930: 02 80 00 2f be 400079ec <_POSIX_Mutex_Lock_support+0x1d8>
40007934: 80 a6 c0 01 cmp %i3, %g1
if ( owner == executing ) {
40007938: 12 80 00 15 bne 4000798c <_POSIX_Mutex_Lock_support+0x178>
4000793c: 80 a6 60 01 cmp %i1, 1
if ( _POSIX_Mutex_Is_recursive( flags ) ) {
40007940: 80 8f 20 04 btst 4, %i4
40007944: 02 80 00 06 be 4000795c <_POSIX_Mutex_Lock_support+0x148> <== ALWAYS TAKEN
40007948: b0 10 20 2d mov 0x2d, %i0
++the_mutex->Recursive.nest_level;
4000794c: c2 07 60 18 ld [ %i5 + 0x18 ], %g1 <== NOT EXECUTED
40007950: 82 00 60 01 inc %g1 <== NOT EXECUTED
40007954: c2 27 60 18 st %g1, [ %i5 + 0x18 ] <== NOT EXECUTED
return STATUS_SUCCESSFUL;
40007958: b0 10 20 00 clr %i0 <== NOT EXECUTED
register uint32_t _psr __asm__("g1") = psr; /* input to trap handler */
4000795c: c2 07 bf dc ld [ %fp + -36 ], %g1
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
40007960: 91 d0 20 0a ta 0xa
40007964: 01 00 00 00 nop
return status;
40007968: 81 c7 e0 08 ret
4000796c: 81 e8 00 00 restore
POSIX_MUTEX_VALIDATE_OBJECT( the_mutex, flags );
40007970: 40 00 00 9d call 40007be4 <_POSIX_Mutex_Auto_initialization>
40007974: 90 10 00 1d mov %i5, %o0
40007978: 80 a2 20 00 cmp %o0, 0
4000797c: 12 bf ff b1 bne 40007840 <_POSIX_Mutex_Lock_support+0x2c>
40007980: 01 00 00 00 nop
return STATUS_MUTEX_CEILING_VIOLATED;
40007984: 81 c7 e0 08 ret
40007988: 91 e8 20 16 restore %g0, 0x16, %o0
if ( (uintptr_t) abstime != POSIX_MUTEX_ABSTIME_TRY_LOCK ) {
4000798c: 02 80 00 13 be 400079d8 <_POSIX_Mutex_Lock_support+0x1c4> <== NEVER TAKEN
40007990: 82 10 20 01 mov 1, %g1
queue_context->thread_state = thread_state;
40007994: c2 27 bf e0 st %g1, [ %fp + -32 ]
queue_context->deadlock_callout = deadlock_callout;
40007998: 03 10 00 2a sethi %hi(0x4000a800), %g1
4000799c: 82 10 62 68 or %g1, 0x268, %g1 ! 4000aa68 <_Thread_queue_Deadlock_status>
_Thread_queue_Enqueue(
400079a0: 96 07 bf dc add %fp, -36, %o3
400079a4: c2 27 bf fc st %g1, [ %fp + -4 ]
400079a8: 94 10 00 1b mov %i3, %o2
400079ac: 90 07 60 0c add %i5, 0xc, %o0
400079b0: 13 10 00 69 sethi %hi(0x4001a400), %o1
400079b4: 40 00 0c 35 call 4000aa88 <_Thread_queue_Enqueue>
400079b8: 92 12 63 70 or %o1, 0x370, %o1 ! 4001a770 <_Thread_queue_Operations_FIFO>
400079bc: c2 06 e0 4c ld [ %i3 + 0x4c ], %g1
400079c0: b1 38 60 1f sra %g1, 0x1f, %i0
400079c4: b0 0e 20 ff and %i0, 0xff, %i0
400079c8: b0 06 00 01 add %i0, %g1, %i0
400079cc: b1 3e 20 08 sra %i0, 8, %i0
return _Thread_Wait_get_status( executing );
400079d0: 81 c7 e0 08 ret
400079d4: 81 e8 00 00 restore
register uint32_t _psr __asm__("g1") = psr; /* input to trap handler */
400079d8: c2 07 bf dc ld [ %fp + -36 ], %g1
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
400079dc: 91 d0 20 0a ta 0xa
400079e0: 01 00 00 00 nop
);
break;
}
return _POSIX_Get_error( status );
}
400079e4: 81 c7 e0 08 ret
400079e8: 91 e8 20 10 restore %g0, 0x10, %o0
the_mutex->Recursive.Mutex.Queue.Queue.owner = owner;
400079ec: f6 27 60 10 st %i3, [ %i5 + 0x10 ]
register uint32_t _psr __asm__("g1") = psr; /* input to trap handler */
400079f0: c2 07 bf dc ld [ %fp + -36 ], %g1
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
400079f4: 91 d0 20 0a ta 0xa
400079f8: 01 00 00 00 nop
400079fc: 81 c7 e0 08 ret
40007a00: 91 e8 20 00 restore %g0, 0, %o0
*/
RTEMS_INLINE_ROUTINE Priority_Control _Priority_Get_priority(
const Priority_Aggregation *aggregation
)
{
return aggregation->Node.priority;
40007a04: c2 06 e0 38 ld [ %i3 + 0x38 ], %g1
queue_context->Priority.update_count = 0;
40007a08: c0 27 bf f0 clr [ %fp + -16 ]
if (
40007a0c: c6 07 60 30 ld [ %i5 + 0x30 ], %g3
40007a10: c4 00 60 18 ld [ %g1 + 0x18 ], %g2
40007a14: 80 a0 c0 02 cmp %g3, %g2
40007a18: 18 80 00 1b bgu 40007a84 <_POSIX_Mutex_Lock_support+0x270> <== NEVER TAKEN
40007a1c: 01 00 00 00 nop
40007a20: 22 80 00 15 be,a 40007a74 <_POSIX_Mutex_Lock_support+0x260> <== ALWAYS TAKEN
40007a24: c4 07 60 34 ld [ %i5 + 0x34 ], %g2
the_mutex->Recursive.Mutex.Queue.Queue.owner = owner;
40007a28: f6 27 60 10 st %i3, [ %i5 + 0x10 ] <== NOT EXECUTED
_Thread_Priority_add(
40007a2c: 92 07 60 20 add %i5, 0x20, %o1
40007a30: 94 07 bf dc add %fp, -36, %o2
40007a34: 40 00 0a 16 call 4000a28c <_Thread_Priority_add>
40007a38: 90 10 00 1b mov %i3, %o0
const ISR_lock_Context *lock_context
)
{
uint32_t disable_level;
disable_level = cpu_self->thread_dispatch_disable_level;
40007a3c: c2 01 a0 18 ld [ %g6 + 0x18 ], %g1
_Profiling_Thread_dispatch_disable_critical(
cpu_self,
disable_level,
lock_context
);
cpu_self->thread_dispatch_disable_level = disable_level + 1;
40007a40: 82 00 60 01 inc %g1
*/
RTEMS_INLINE_ROUTINE Per_CPU_Control *_Thread_Dispatch_disable_critical(
const ISR_lock_Context *lock_context
)
{
return _Thread_Dispatch_disable_with_CPU( _Per_CPU_Get(), lock_context );
40007a44: ba 10 00 06 mov %g6, %i5
cpu_self->thread_dispatch_disable_level = disable_level + 1;
40007a48: c2 21 a0 18 st %g1, [ %g6 + 0x18 ]
register uint32_t _psr __asm__("g1") = psr; /* input to trap handler */
40007a4c: c2 07 bf dc ld [ %fp + -36 ], %g1
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
40007a50: 91 d0 20 0a ta 0xa
40007a54: 01 00 00 00 nop
_Thread_Priority_update( queue_context );
40007a58: 40 00 0a 72 call 4000a420 <_Thread_Priority_update>
40007a5c: 90 07 bf dc add %fp, -36, %o0
_Thread_Dispatch_enable( cpu_self );
40007a60: 90 10 00 1d mov %i5, %o0
40007a64: 40 00 0a ff call 4000a660 <_Thread_Dispatch_enable>
40007a68: b0 10 20 00 clr %i0
return STATUS_SUCCESSFUL;
40007a6c: 81 c7 e0 08 ret
40007a70: 81 e8 00 00 restore
if (
40007a74: c2 00 60 1c ld [ %g1 + 0x1c ], %g1
40007a78: 80 a0 80 01 cmp %g2, %g1
40007a7c: 28 bf ff ec bleu,a 40007a2c <_POSIX_Mutex_Lock_support+0x218>
40007a80: f6 27 60 10 st %i3, [ %i5 + 0x10 ]
register uint32_t _psr __asm__("g1") = psr; /* input to trap handler */
40007a84: c2 07 bf dc ld [ %fp + -36 ], %g1
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
40007a88: 91 d0 20 0a ta 0xa
40007a8c: 01 00 00 00 nop
40007a90: 30 bf ff bd b,a 40007984 <_POSIX_Mutex_Lock_support+0x170>
4000b584 <_POSIX_Priority_To_core>:
Priority_Control _POSIX_Priority_To_core(
const Scheduler_Control *scheduler,
int posix_priority,
bool *valid
)
{
4000b584: 9d e3 bf a0 save %sp, -96, %sp
Priority_Control core_posix_priority;
Priority_Control core_priority;
core_posix_priority = (Priority_Control) posix_priority;
core_priority = scheduler->maximum_priority - core_posix_priority;
4000b588: f8 1e 20 40 ldd [ %i0 + 0x40 ], %i4
core_posix_priority = (Priority_Control) posix_priority;
4000b58c: 83 3e 60 1f sra %i1, 0x1f, %g1
4000b590: 86 10 00 19 mov %i1, %g3
4000b594: 84 10 00 01 mov %g1, %g2
*valid = ( posix_priority >= POSIX_SCHEDULER_MINIMUM_PRIORITY
&& core_posix_priority < scheduler->maximum_priority );
4000b598: 80 a7 00 01 cmp %i4, %g1
4000b59c: 18 80 00 05 bgu 4000b5b0 <_POSIX_Priority_To_core+0x2c> <== NEVER TAKEN
4000b5a0: 88 10 20 01 mov 1, %g4
4000b5a4: 02 80 00 11 be 4000b5e8 <_POSIX_Priority_To_core+0x64>
4000b5a8: 80 a7 40 19 cmp %i5, %i1
4000b5ac: 88 10 20 00 clr %g4
4000b5b0: 82 20 40 19 sub %g1, %i1, %g1
4000b5b4: 83 30 60 1f srl %g1, 0x1f, %g1
4000b5b8: 82 08 40 04 and %g1, %g4, %g1
*valid = ( posix_priority >= POSIX_SCHEDULER_MINIMUM_PRIORITY
4000b5bc: c2 2e 80 00 stb %g1, [ %i2 ]
core_priority = scheduler->maximum_priority - core_posix_priority;
4000b5c0: b6 a7 40 03 subcc %i5, %g3, %i3
return ( *scheduler->Operations.map_priority )( scheduler, priority );
4000b5c4: c2 06 20 1c ld [ %i0 + 0x1c ], %g1
4000b5c8: b4 67 00 02 subx %i4, %g2, %i2
4000b5cc: 94 10 00 1b mov %i3, %o2
4000b5d0: 92 10 00 1a mov %i2, %o1
4000b5d4: 9f c0 40 00 call %g1
4000b5d8: 90 10 00 18 mov %i0, %o0
4000b5dc: b0 10 00 08 mov %o0, %i0
return _Scheduler_Map_priority( scheduler, core_priority );
}
4000b5e0: 81 c7 e0 08 ret
4000b5e4: 93 e8 00 09 restore %g0, %o1, %o1
&& core_posix_priority < scheduler->maximum_priority );
4000b5e8: 38 bf ff f3 bgu,a 4000b5b4 <_POSIX_Priority_To_core+0x30>
4000b5ec: 82 20 40 19 sub %g1, %i1, %g1
4000b5f0: 10 bf ff f0 b 4000b5b0 <_POSIX_Priority_To_core+0x2c>
4000b5f4: 88 10 20 00 clr %g4
40004d70 <_POSIX_Shm_Object_create_from_heap>:
int _POSIX_Shm_Object_create_from_heap(
POSIX_Shm_Object *shm_obj,
size_t size
)
{
40004d70: 9d e3 bf a0 save %sp, -96, %sp <== NOT EXECUTED
void *p = calloc( 1, size ); /* get zero'd memory */
40004d74: 90 10 20 01 mov 1, %o0 <== NOT EXECUTED
40004d78: 40 00 0f ae call 40008c30 <calloc> <== NOT EXECUTED
40004d7c: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED
if ( p != NULL ) {
40004d80: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
40004d84: 02 80 00 07 be 40004da0 <_POSIX_Shm_Object_create_from_heap+0x30> <== NOT EXECUTED
40004d88: 01 00 00 00 nop <== NOT EXECUTED
shm_obj->handle = p;
40004d8c: d0 26 00 00 st %o0, [ %i0 ] <== NOT EXECUTED
shm_obj->size = size;
40004d90: f2 26 20 04 st %i1, [ %i0 + 4 ] <== NOT EXECUTED
} else {
errno = EIO;
}
return 0;
}
40004d94: b0 10 20 00 clr %i0 <== NOT EXECUTED
40004d98: 81 c7 e0 08 ret <== NOT EXECUTED
40004d9c: 81 e8 00 00 restore <== NOT EXECUTED
errno = EIO;
40004da0: 40 00 2e 54 call 400106f0 <__errno> <== NOT EXECUTED
40004da4: b0 10 20 00 clr %i0 <== NOT EXECUTED
40004da8: 82 10 20 05 mov 5, %g1 <== NOT EXECUTED
40004dac: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
40004db0: 81 c7 e0 08 ret <== NOT EXECUTED
40004db4: 81 e8 00 00 restore <== NOT EXECUTED
40005e24 <_POSIX_Shm_Object_create_from_workspace>:
int _POSIX_Shm_Object_create_from_workspace(
POSIX_Shm_Object *shm_obj,
size_t size
)
{
40005e24: 9d e3 bf a0 save %sp, -96, %sp <== NOT EXECUTED
shm_obj->handle = _Workspace_Allocate( size );
40005e28: 40 00 0c 88 call 40009048 <_Workspace_Allocate> <== NOT EXECUTED
40005e2c: 90 10 00 19 mov %i1, %o0 <== NOT EXECUTED
if ( shm_obj->handle == NULL ) {
40005e30: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
40005e34: 02 80 00 08 be 40005e54 <_POSIX_Shm_Object_create_from_workspace+0x30> <== NOT EXECUTED
40005e38: d0 26 00 00 st %o0, [ %i0 ] <== NOT EXECUTED
return ENOMEM;
}
memset( shm_obj->handle, 0, size );
40005e3c: 94 10 00 19 mov %i1, %o2 <== NOT EXECUTED
40005e40: 40 00 2d 2b call 400112ec <memset> <== NOT EXECUTED
40005e44: 92 10 20 00 clr %o1 <== NOT EXECUTED
shm_obj->size = size;
40005e48: f2 26 20 04 st %i1, [ %i0 + 4 ] <== NOT EXECUTED
return 0;
40005e4c: 81 c7 e0 08 ret <== NOT EXECUTED
40005e50: 91 e8 20 00 restore %g0, 0, %o0 <== NOT EXECUTED
}
40005e54: 81 c7 e0 08 ret <== NOT EXECUTED
40005e58: 91 e8 20 0c restore %g0, 0xc, %o0 <== NOT EXECUTED
40004eb4 <_POSIX_Shm_Object_mmap_from_heap>:
size_t len,
int prot,
off_t off
)
{
if ( shm_obj == NULL || shm_obj->handle == NULL )
40004eb4: 80 a2 20 00 cmp %o0, 0
40004eb8: 02 80 00 11 be 40004efc <_POSIX_Shm_Object_mmap_from_heap+0x48> <== NEVER TAKEN
40004ebc: 86 10 00 0c mov %o4, %g3
40004ec0: c2 02 00 00 ld [ %o0 ], %g1
40004ec4: 80 a0 60 00 cmp %g1, 0
40004ec8: 02 80 00 09 be 40004eec <_POSIX_Shm_Object_mmap_from_heap+0x38> <== NEVER TAKEN
40004ecc: 9a 83 00 09 addcc %o4, %o1, %o5
return 0;
/* This is already checked by mmap. Maybe make it a debug assert? */
if ( shm_obj->size < len + off ) {
40004ed0: 98 42 e0 00 addx %o3, 0, %o4
40004ed4: 80 a3 20 00 cmp %o4, 0
40004ed8: 14 80 00 09 bg 40004efc <_POSIX_Shm_Object_mmap_from_heap+0x48> <== NEVER TAKEN
40004edc: c8 02 20 04 ld [ %o0 + 4 ], %g4
40004ee0: 02 80 00 05 be 40004ef4 <_POSIX_Shm_Object_mmap_from_heap+0x40> <== ALWAYS TAKEN
40004ee4: 80 a3 40 04 cmp %o5, %g4
return NULL;
}
return (char*)shm_obj->handle + off;
40004ee8: 82 00 40 03 add %g1, %g3, %g1 <== NOT EXECUTED
}
40004eec: 81 c3 e0 08 retl
40004ef0: 90 10 00 01 mov %g1, %o0
if ( shm_obj->size < len + off ) {
40004ef4: 08 bf ff fe bleu 40004eec <_POSIX_Shm_Object_mmap_from_heap+0x38> <== ALWAYS TAKEN
40004ef8: 82 00 40 03 add %g1, %g3, %g1
return 0;
40004efc: 82 10 20 00 clr %g1 <== NOT EXECUTED
}
40004f00: 81 c3 e0 08 retl <== NOT EXECUTED
40004f04: 90 10 00 01 mov %g1, %o0 <== NOT EXECUTED
40005f68 <_POSIX_Shm_Object_mmap_from_workspace>:
size_t len,
int prot,
off_t off
)
{
if ( shm_obj == NULL || shm_obj->handle == NULL )
40005f68: 80 a2 20 00 cmp %o0, 0
40005f6c: 02 80 00 11 be 40005fb0 <_POSIX_Shm_Object_mmap_from_workspace+0x48> <== NEVER TAKEN
40005f70: 86 10 00 0c mov %o4, %g3
40005f74: c2 02 00 00 ld [ %o0 ], %g1
40005f78: 80 a0 60 00 cmp %g1, 0
40005f7c: 02 80 00 09 be 40005fa0 <_POSIX_Shm_Object_mmap_from_workspace+0x38> <== NEVER TAKEN
40005f80: 9a 83 00 09 addcc %o4, %o1, %o5
return 0;
/* This is already checked by mmap. Maybe make it a debug assert? */
if ( shm_obj->size < len + off ) {
40005f84: 98 42 e0 00 addx %o3, 0, %o4
40005f88: 80 a3 20 00 cmp %o4, 0
40005f8c: 14 80 00 09 bg 40005fb0 <_POSIX_Shm_Object_mmap_from_workspace+0x48> <== NEVER TAKEN
40005f90: c8 02 20 04 ld [ %o0 + 4 ], %g4
40005f94: 02 80 00 05 be 40005fa8 <_POSIX_Shm_Object_mmap_from_workspace+0x40> <== ALWAYS TAKEN
40005f98: 80 a3 40 04 cmp %o5, %g4
return NULL;
}
return (char*)shm_obj->handle + off;
40005f9c: 82 00 40 03 add %g1, %g3, %g1 <== NOT EXECUTED
}
40005fa0: 81 c3 e0 08 retl
40005fa4: 90 10 00 01 mov %g1, %o0
if ( shm_obj->size < len + off ) {
40005fa8: 08 bf ff fe bleu 40005fa0 <_POSIX_Shm_Object_mmap_from_workspace+0x38> <== ALWAYS TAKEN
40005fac: 82 00 40 03 add %g1, %g3, %g1
return 0;
40005fb0: 82 10 20 00 clr %g1 <== NOT EXECUTED
}
40005fb4: 81 c3 e0 08 retl <== NOT EXECUTED
40005fb8: 90 10 00 01 mov %g1, %o0 <== NOT EXECUTED
40004e64 <_POSIX_Shm_Object_read_from_heap>:
int _POSIX_Shm_Object_read_from_heap(
POSIX_Shm_Object *shm_obj,
void *buf,
size_t count
)
{
40004e64: 9d e3 bf a0 save %sp, -96, %sp <== NOT EXECUTED
if ( shm_obj == NULL || shm_obj->handle == NULL )
40004e68: 80 a6 20 00 cmp %i0, 0 <== NOT EXECUTED
40004e6c: 02 80 00 10 be 40004eac <_POSIX_Shm_Object_read_from_heap+0x48> <== NOT EXECUTED
40004e70: 94 10 20 00 clr %o2 <== NOT EXECUTED
40004e74: d2 06 00 00 ld [ %i0 ], %o1 <== NOT EXECUTED
40004e78: 80 a2 60 00 cmp %o1, 0 <== NOT EXECUTED
40004e7c: 02 80 00 0a be 40004ea4 <_POSIX_Shm_Object_read_from_heap+0x40> <== NOT EXECUTED
40004e80: 01 00 00 00 nop <== NOT EXECUTED
return 0;
if ( shm_obj->size < count ) {
40004e84: f0 06 20 04 ld [ %i0 + 4 ], %i0 <== NOT EXECUTED
40004e88: 80 a6 00 1a cmp %i0, %i2 <== NOT EXECUTED
40004e8c: 38 80 00 02 bgu,a 40004e94 <_POSIX_Shm_Object_read_from_heap+0x30> <== NOT EXECUTED
40004e90: b0 10 00 1a mov %i2, %i0 <== NOT EXECUTED
count = shm_obj->size;
}
memcpy( buf, shm_obj->handle, count );
40004e94: 94 10 00 18 mov %i0, %o2 <== NOT EXECUTED
40004e98: 40 00 2e 3d call 4001078c <memcpy> <== NOT EXECUTED
40004e9c: 90 10 00 19 mov %i1, %o0 <== NOT EXECUTED
return count;
40004ea0: 94 10 00 18 mov %i0, %o2 <== NOT EXECUTED
}
40004ea4: 81 c7 e0 08 ret <== NOT EXECUTED
40004ea8: 91 e8 00 0a restore %g0, %o2, %o0 <== NOT EXECUTED
40004eac: 81 c7 e0 08 ret <== NOT EXECUTED
40004eb0: 91 e8 00 0a restore %g0, %o2, %o0 <== NOT EXECUTED
40005f18 <_POSIX_Shm_Object_read_from_workspace>:
int _POSIX_Shm_Object_read_from_workspace(
POSIX_Shm_Object *shm_obj,
void *buf,
size_t count
)
{
40005f18: 9d e3 bf a0 save %sp, -96, %sp
if ( shm_obj == NULL || shm_obj->handle == NULL )
40005f1c: 80 a6 20 00 cmp %i0, 0
40005f20: 02 80 00 10 be 40005f60 <_POSIX_Shm_Object_read_from_workspace+0x48> <== NEVER TAKEN
40005f24: 94 10 20 00 clr %o2
40005f28: d2 06 00 00 ld [ %i0 ], %o1
40005f2c: 80 a2 60 00 cmp %o1, 0
40005f30: 02 80 00 0a be 40005f58 <_POSIX_Shm_Object_read_from_workspace+0x40> <== NEVER TAKEN
40005f34: 01 00 00 00 nop
return 0;
if ( shm_obj->size < count ) {
40005f38: f0 06 20 04 ld [ %i0 + 4 ], %i0
40005f3c: 80 a6 00 1a cmp %i0, %i2
40005f40: 38 80 00 02 bgu,a 40005f48 <_POSIX_Shm_Object_read_from_workspace+0x30> <== NEVER TAKEN
40005f44: b0 10 00 1a mov %i2, %i0 <== NOT EXECUTED
count = shm_obj->size;
}
memcpy( buf, shm_obj->handle, count );
40005f48: 94 10 00 18 mov %i0, %o2
40005f4c: 40 00 2c a9 call 400111f0 <memcpy>
40005f50: 90 10 00 19 mov %i1, %o0
return count;
40005f54: 94 10 00 18 mov %i0, %o2
}
40005f58: 81 c7 e0 08 ret
40005f5c: 91 e8 00 0a restore %g0, %o2, %o0
40005f60: 81 c7 e0 08 ret <== NOT EXECUTED
40005f64: 91 e8 00 0a restore %g0, %o2, %o0 <== NOT EXECUTED
40004de8 <_POSIX_Shm_Object_resize_from_heap>:
int _POSIX_Shm_Object_resize_from_heap(
POSIX_Shm_Object *shm_obj,
size_t size
)
{
40004de8: 9d e3 bf a0 save %sp, -96, %sp
void *p;
int err = 0;
if ( size < shm_obj->size ) {
40004dec: d4 06 20 04 ld [ %i0 + 4 ], %o2
40004df0: 80 a2 80 19 cmp %o2, %i1
40004df4: 18 80 00 0f bgu 40004e30 <_POSIX_Shm_Object_resize_from_heap+0x48> <== NEVER TAKEN
40004df8: d0 06 00 00 ld [ %i0 ], %o0
/* zero out if shrinking */
p = (void*)((uintptr_t)shm_obj->handle + (uintptr_t)size);
memset( p, 0, shm_obj->size - size );
}
p = realloc( shm_obj->handle, size );
40004dfc: 40 00 12 07 call 40009618 <realloc>
40004e00: 92 10 00 19 mov %i1, %o1
if ( p != NULL ) {
40004e04: 82 92 20 00 orcc %o0, 0, %g1
40004e08: 02 80 00 15 be 40004e5c <_POSIX_Shm_Object_resize_from_heap+0x74> <== NEVER TAKEN
40004e0c: 01 00 00 00 nop
shm_obj->handle = p;
40004e10: c2 26 00 00 st %g1, [ %i0 ]
if ( size > shm_obj->size ) {
40004e14: d4 06 20 04 ld [ %i0 + 4 ], %o2
40004e18: 80 a2 80 19 cmp %o2, %i1
40004e1c: 2a 80 00 0b bcs,a 40004e48 <_POSIX_Shm_Object_resize_from_heap+0x60> <== ALWAYS TAKEN
40004e20: 94 26 40 0a sub %i1, %o2, %o2
/* initialize added memory */
memset( p, 0, size - shm_obj->size );
}
shm_obj->size = size;
40004e24: f2 26 20 04 st %i1, [ %i0 + 4 ] <== NOT EXECUTED
40004e28: 81 c7 e0 08 ret <== NOT EXECUTED
40004e2c: 91 e8 20 00 restore %g0, 0, %o0 <== NOT EXECUTED
memset( p, 0, shm_obj->size - size );
40004e30: 90 02 00 19 add %o0, %i1, %o0 <== NOT EXECUTED
40004e34: 94 22 80 19 sub %o2, %i1, %o2 <== NOT EXECUTED
40004e38: 40 00 2e 94 call 40010888 <memset> <== NOT EXECUTED
40004e3c: 92 10 20 00 clr %o1 <== NOT EXECUTED
p = realloc( shm_obj->handle, size );
40004e40: 10 bf ff ef b 40004dfc <_POSIX_Shm_Object_resize_from_heap+0x14> <== NOT EXECUTED
40004e44: d0 06 00 00 ld [ %i0 ], %o0 <== NOT EXECUTED
memset( p, 0, size - shm_obj->size );
40004e48: 40 00 2e 90 call 40010888 <memset>
40004e4c: 92 10 20 00 clr %o1
shm_obj->size = size;
40004e50: f2 26 20 04 st %i1, [ %i0 + 4 ]
40004e54: 81 c7 e0 08 ret
40004e58: 91 e8 20 00 restore %g0, 0, %o0
} else {
err = EIO;
}
return err;
}
40004e5c: 81 c7 e0 08 ret <== NOT EXECUTED
40004e60: 91 e8 20 05 restore %g0, 5, %o0 <== NOT EXECUTED
40005e8c <_POSIX_Shm_Object_resize_from_workspace>:
int _POSIX_Shm_Object_resize_from_workspace(
POSIX_Shm_Object *shm_obj,
size_t size
)
{
40005e8c: 9d e3 bf a0 save %sp, -96, %sp
memset( shm_obj->handle, 0, shm_obj->size );
40005e90: d0 06 00 00 ld [ %i0 ], %o0
int err;
if ( size == 0 ) {
40005e94: 80 a6 60 00 cmp %i1, 0
40005e98: 02 80 00 15 be 40005eec <_POSIX_Shm_Object_resize_from_workspace+0x60> <== NEVER TAKEN
40005e9c: ba 10 00 18 mov %i0, %i5
err = _POSIX_Shm_Object_delete_from_workspace( shm_obj );
} else if ( shm_obj->handle == NULL && shm_obj->size == 0 ) {
40005ea0: 80 a2 20 00 cmp %o0, 0
40005ea4: 12 80 00 10 bne 40005ee4 <_POSIX_Shm_Object_resize_from_workspace+0x58> <== NEVER TAKEN
40005ea8: b0 10 20 05 mov 5, %i0
40005eac: c2 07 60 04 ld [ %i5 + 4 ], %g1
40005eb0: 80 a0 60 00 cmp %g1, 0
40005eb4: 12 80 00 0c bne 40005ee4 <_POSIX_Shm_Object_resize_from_workspace+0x58> <== NEVER TAKEN
40005eb8: 01 00 00 00 nop
shm_obj->handle = _Workspace_Allocate( size );
40005ebc: 40 00 0c 63 call 40009048 <_Workspace_Allocate>
40005ec0: 90 10 00 19 mov %i1, %o0
if ( shm_obj->handle == NULL ) {
40005ec4: 80 a2 20 00 cmp %o0, 0
40005ec8: 02 80 00 12 be 40005f10 <_POSIX_Shm_Object_resize_from_workspace+0x84> <== NEVER TAKEN
40005ecc: d0 27 40 00 st %o0, [ %i5 ]
memset( shm_obj->handle, 0, size );
40005ed0: 94 10 00 19 mov %i1, %o2
40005ed4: 92 10 20 00 clr %o1
40005ed8: 40 00 2d 05 call 400112ec <memset>
40005edc: b0 10 20 00 clr %i0
shm_obj->size = size;
40005ee0: f2 27 60 04 st %i1, [ %i5 + 4 ]
return 0;
40005ee4: 81 c7 e0 08 ret
40005ee8: 81 e8 00 00 restore
memset( shm_obj->handle, 0, shm_obj->size );
40005eec: d4 06 20 04 ld [ %i0 + 4 ], %o2 <== NOT EXECUTED
40005ef0: 40 00 2c ff call 400112ec <memset> <== NOT EXECUTED
40005ef4: 92 10 20 00 clr %o1 <== NOT EXECUTED
_Workspace_Free( shm_obj->handle );
40005ef8: 40 00 0c 5c call 40009068 <_Workspace_Free> <== NOT EXECUTED
40005efc: d0 06 00 00 ld [ %i0 ], %o0 <== NOT EXECUTED
shm_obj->handle = NULL;
40005f00: c0 26 00 00 clr [ %i0 ] <== NOT EXECUTED
shm_obj->size = 0;
40005f04: c0 27 60 04 clr [ %i5 + 4 ] <== NOT EXECUTED
return 0;
40005f08: 81 c7 e0 08 ret <== NOT EXECUTED
40005f0c: 91 e8 20 00 restore %g0, 0, %o0 <== NOT EXECUTED
} else {
/* Refuse to resize a workspace object. */
err = EIO;
}
return err;
}
40005f10: 81 c7 e0 08 ret <== NOT EXECUTED
40005f14: 91 e8 20 0c restore %g0, 0xc, %o0 <== NOT EXECUTED
40007740 <_POSIX_Threads_Initialize_user_thread>:
#include <rtems/score/assert.h>
#include <rtems/score/threadimpl.h>
#include <rtems/score/interr.h>
void _POSIX_Threads_Initialize_user_thread( void )
{
40007740: 9d e3 bf 38 save %sp, -200, %sp
*/
/*
* There is no way for these calls to fail in this situation.
*/
eno = pthread_attr_init( &attr );
40007744: 40 00 13 57 call 4000c4a0 <pthread_attr_init>
40007748: 90 07 bf a0 add %fp, -96, %o0
_Assert( eno == 0 );
eno = pthread_attr_setinheritsched( &attr, PTHREAD_EXPLICIT_SCHED );
4000774c: 92 10 20 02 mov 2, %o1
40007750: 40 00 13 63 call 4000c4dc <pthread_attr_setinheritsched>
40007754: 90 07 bf a0 add %fp, -96, %o0
_Assert( eno == 0 );
eno = pthread_attr_setstacksize( &attr, user_thread->stack_size );
40007758: 3b 10 00 51 sethi %hi(0x40014400), %i5
4000775c: 82 17 63 80 or %i5, 0x380, %g1 ! 40014780 <_POSIX_Threads_User_thread_table>
40007760: d2 00 60 04 ld [ %g1 + 4 ], %o1
40007764: 40 00 13 6d call 4000c518 <pthread_attr_setstacksize>
40007768: 90 07 bf a0 add %fp, -96, %o0
_Assert( eno == 0 );
eno = pthread_create(
4000776c: d4 07 63 80 ld [ %i5 + 0x380 ], %o2
40007770: 96 10 20 00 clr %o3
40007774: 92 07 bf a0 add %fp, -96, %o1
40007778: 40 00 13 dd call 4000c6ec <pthread_create>
4000777c: 90 07 bf 9c add %fp, -100, %o0
&thread_id,
&attr,
user_thread->thread_entry,
NULL
);
if ( eno != 0 ) {
40007780: 80 a2 20 00 cmp %o0, 0
40007784: 12 80 00 09 bne 400077a8 <_POSIX_Threads_Initialize_user_thread+0x68>
40007788: 03 10 00 66 sethi %hi(0x40019800), %g1
_Internal_error( INTERNAL_ERROR_POSIX_INIT_THREAD_CREATE_FAILED );
}
if ( _Thread_Global_constructor == 0 ) {
4000778c: c4 00 63 18 ld [ %g1 + 0x318 ], %g2 ! 40019b18 <_Thread_Global_constructor>
40007790: 80 a0 a0 00 cmp %g2, 0
40007794: 12 80 00 03 bne 400077a0 <_POSIX_Threads_Initialize_user_thread+0x60>
40007798: c4 07 bf 9c ld [ %fp + -100 ], %g2
_Thread_Global_constructor = thread_id;
4000779c: c4 20 63 18 st %g2, [ %g1 + 0x318 ]
}
}
400077a0: 81 c7 e0 08 ret
400077a4: 81 e8 00 00 restore
_Internal_error( INTERNAL_ERROR_POSIX_INIT_THREAD_CREATE_FAILED );
400077a8: 40 00 02 00 call 40007fa8 <_Internal_error>
400077ac: 90 10 20 21 mov 0x21, %o0
400077b0: 01 00 00 00 nop <== NOT EXECUTED
40006be8 <_POSIX_Threads_Sporadic_budget_callout>:
{
40006be8: 9d e3 bf 78 save %sp, -136, %sp
40006bec: c0 27 bf f0 clr [ %fp + -16 ]
api = the_thread->API_Extensions[ THREAD_API_POSIX ];
40006bf0: d2 06 21 5c ld [ %i0 + 0x15c ], %o1
40006bf4: 91 d0 20 09 ta 9
40006bf8: c2 27 bf dc st %g1, [ %fp + -36 ]
the_thread->cpu_time_budget = UINT32_MAX;
40006bfc: 82 10 3f ff mov -1, %g1
40006c00: c2 26 20 8c st %g1, [ %i0 + 0x8c ]
if ( !_Priority_Node_is_active( &api->Sporadic.Low_priority ) ) {
40006c04: c2 02 60 34 ld [ %o1 + 0x34 ], %g1
40006c08: 80 a0 7f ff cmp %g1, -1
40006c0c: 02 80 00 09 be 40006c30 <_POSIX_Threads_Sporadic_budget_callout+0x48> <== ALWAYS TAKEN
40006c10: 90 10 00 18 mov %i0, %o0
register uint32_t _psr __asm__("g1") = psr; /* input to trap handler */
40006c14: c2 07 bf dc ld [ %fp + -36 ], %g1 <== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
40006c18: 91 d0 20 0a ta 0xa <== NOT EXECUTED
40006c1c: 01 00 00 00 nop <== NOT EXECUTED
_Thread_Priority_update( &queue_context );
40006c20: 40 00 07 3b call 4000890c <_Thread_Priority_update> <== NOT EXECUTED
40006c24: 90 07 bf dc add %fp, -36, %o0 <== NOT EXECUTED
}
40006c28: 81 c7 e0 08 ret <== NOT EXECUTED
40006c2c: 81 e8 00 00 restore <== NOT EXECUTED
_Thread_Priority_add(
40006c30: 94 07 bf dc add %fp, -36, %o2
40006c34: 40 00 06 f3 call 40008800 <_Thread_Priority_add>
40006c38: 92 02 60 28 add %o1, 0x28, %o1
_Thread_Priority_remove(
40006c3c: 94 07 bf dc add %fp, -36, %o2
40006c40: 92 06 20 20 add %i0, 0x20, %o1
40006c44: 40 00 07 10 call 40008884 <_Thread_Priority_remove>
40006c48: 90 10 00 18 mov %i0, %o0
register uint32_t _psr __asm__("g1") = psr; /* input to trap handler */
40006c4c: c2 07 bf dc ld [ %fp + -36 ], %g1
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
40006c50: 91 d0 20 0a ta 0xa
40006c54: 01 00 00 00 nop
_Thread_Priority_update( &queue_context );
40006c58: 40 00 07 2d call 4000890c <_Thread_Priority_update>
40006c5c: 90 07 bf dc add %fp, -36, %o0
}
40006c60: 81 c7 e0 08 ret
40006c64: 81 e8 00 00 restore
4000c2e4 <_POSIX_Timer_TSR>:
/*
* This is the operation that is run when a timer expires
*/
void _POSIX_Timer_TSR( Watchdog_Control *the_watchdog )
{
4000c2e4: 9d e3 bf 98 save %sp, -104, %sp
POSIX_Timer_Control *ptimer;
ISR_lock_Context lock_context;
Per_CPU_Control *cpu;
ptimer = RTEMS_CONTAINER_OF( the_watchdog, POSIX_Timer_Control, Timer );
4000c2e8: b0 06 3f f0 add %i0, -16, %i0
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
4000c2ec: 91 d0 20 09 ta 9
_ISR_lock_ISR_disable( &lock_context );
cpu = _POSIX_Timer_Acquire_critical( ptimer, &lock_context );
/* Increment the number of expirations. */
ptimer->overrun = ptimer->overrun + 1;
4000c2f0: c4 06 20 74 ld [ %i0 + 0x74 ], %g2
4000c2f4: 84 00 a0 01 inc %g2
4000c2f8: c4 26 20 74 st %g2, [ %i0 + 0x74 ]
/* The timer must be reprogrammed */
if ( ( ptimer->timer_data.it_interval.tv_sec != 0 ) ||
4000c2fc: c6 06 20 50 ld [ %i0 + 0x50 ], %g3
4000c300: c4 06 20 54 ld [ %i0 + 0x54 ], %g2
4000c304: 80 90 c0 02 orcc %g3, %g2, %g0
4000c308: 12 80 00 07 bne 4000c324 <_POSIX_Timer_TSR+0x40>
4000c30c: 84 10 20 03 mov 3, %g2
4000c310: c4 06 20 58 ld [ %i0 + 0x58 ], %g2
4000c314: 80 a0 a0 00 cmp %g2, 0
4000c318: 02 80 00 1a be 4000c380 <_POSIX_Timer_TSR+0x9c> <== NEVER TAKEN
4000c31c: 84 10 20 04 mov 4, %g2
ptimer->state = POSIX_TIMER_STATE_CREATE_RUN;
4000c320: 84 10 20 03 mov 3, %g2
4000c324: c4 2e 20 34 stb %g2, [ %i0 + 0x34 ]
_Timecounter_Nanotime( tod );
4000c328: 90 06 20 78 add %i0, 0x78, %o0
4000c32c: c2 27 bf fc st %g1, [ %fp + -4 ]
4000c330: 7f ff ed 90 call 40007970 <_Timecounter_Nanotime>
4000c334: fa 06 20 70 ld [ %i0 + 0x70 ], %i5
cpu->Watchdog.ticks + ticks
4000c338: 11 10 00 9f sethi %hi(0x40027c00), %o0
4000c33c: 90 12 20 40 or %o0, 0x40, %o0 ! 40027c40 <_Per_CPU_Information>
_Watchdog_Insert(
4000c340: d4 1a 20 30 ldd [ %o0 + 0x30 ], %o2
4000c344: 84 10 00 0a mov %o2, %g2
4000c348: 96 82 c0 1d addcc %o3, %i5, %o3
4000c34c: 92 06 20 10 add %i0, 0x10, %o1
4000c350: 94 40 a0 00 addx %g2, 0, %o2
4000c354: 7f ff fc 9c call 4000b5c4 <_Watchdog_Insert>
4000c358: 90 02 20 38 add %o0, 0x38, %o0
}
4000c35c: c2 07 bf fc ld [ %fp + -4 ], %g1
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
4000c360: 91 d0 20 0a ta 0xa
4000c364: 01 00 00 00 nop
/*
* The sending of the signal to the process running the handling function
* specified for that signal is simulated
*/
if ( pthread_kill ( ptimer->thread_id, ptimer->inf.sigev_signo ) ) {
4000c368: d2 06 20 3c ld [ %i0 + 0x3c ], %o1
4000c36c: 40 00 08 fe call 4000e764 <pthread_kill>
4000c370: d0 06 20 30 ld [ %i0 + 0x30 ], %o0
}
/* After the signal handler returns, the count of expirations of the
* timer must be set to 0.
*/
ptimer->overrun = 0;
4000c374: c0 26 20 74 clr [ %i0 + 0x74 ]
}
4000c378: 81 c7 e0 08 ret
4000c37c: 81 e8 00 00 restore
ptimer->state = POSIX_TIMER_STATE_CREATE_STOP;
4000c380: c4 2e 20 34 stb %g2, [ %i0 + 0x34 ] <== NOT EXECUTED
4000c384: 91 d0 20 0a ta 0xa <== NOT EXECUTED
4000c388: 01 00 00 00 nop <== NOT EXECUTED
if ( pthread_kill ( ptimer->thread_id, ptimer->inf.sigev_signo ) ) {
4000c38c: d2 06 20 3c ld [ %i0 + 0x3c ], %o1 <== NOT EXECUTED
4000c390: 40 00 08 f5 call 4000e764 <pthread_kill> <== NOT EXECUTED
4000c394: d0 06 20 30 ld [ %i0 + 0x30 ], %o0 <== NOT EXECUTED
ptimer->overrun = 0;
4000c398: c0 26 20 74 clr [ %i0 + 0x74 ] <== NOT EXECUTED
}
4000c39c: 81 c7 e0 08 ret <== NOT EXECUTED
4000c3a0: 81 e8 00 00 restore <== NOT EXECUTED
4001926c <_POSIX_signals_Abnormal_termination_handler>:
sigset_t _POSIX_signals_Pending;
void _POSIX_signals_Abnormal_termination_handler(
int signo RTEMS_UNUSED )
{
4001926c: 9d e3 bf a0 save %sp, -96, %sp
exit( 1 );
40019270: 40 00 17 62 call 4001eff8 <exit>
40019274: 90 10 20 01 mov 1, %o0
40019278: 01 00 00 00 nop <== NOT EXECUTED
400192ec <_POSIX_signals_Clear_process_signals>:
_Assert( _ISR_Get_level() != 0 );
clear_signal = true;
mask = signo_to_mask( signo );
if ( _POSIX_signals_Vectors[ signo ].sa_flags == SA_SIGINFO ) {
400192ec: 83 2a 20 01 sll %o0, 1, %g1
400192f0: 05 10 00 d4 sethi %hi(0x40035000), %g2
400192f4: 82 00 40 08 add %g1, %o0, %g1
400192f8: 84 10 a2 f4 or %g2, 0x2f4, %g2
400192fc: 83 28 60 02 sll %g1, 2, %g1
40019300: c4 00 80 01 ld [ %g2 + %g1 ], %g2
40019304: 90 02 3f ff add %o0, -1, %o0
40019308: 80 a0 a0 02 cmp %g2, 2
4001930c: 84 10 20 01 mov 1, %g2
40019310: 02 80 00 07 be 4001932c <_POSIX_signals_Clear_process_signals+0x40>
40019314: 91 28 80 08 sll %g2, %o0, %o0
if ( !_Chain_Is_empty( &_POSIX_signals_Siginfo[ signo ] ) )
clear_signal = false;
}
if ( clear_signal ) {
_POSIX_signals_Pending &= ~mask;
40019318: 03 10 00 d5 sethi %hi(0x40035400), %g1
4001931c: c4 00 60 74 ld [ %g1 + 0x74 ], %g2 ! 40035474 <_POSIX_signals_Pending>
40019320: 90 28 80 08 andn %g2, %o0, %o0
}
}
40019324: 81 c3 e0 08 retl
40019328: d0 20 60 74 st %o0, [ %g1 + 0x74 ]
return _Chain_Immutable_head( the_chain )->next;
4001932c: 05 10 00 d4 sethi %hi(0x40035000), %g2
40019330: 84 10 a1 68 or %g2, 0x168, %g2 ! 40035168 <_POSIX_signals_Siginfo>
if ( !_Chain_Is_empty( &_POSIX_signals_Siginfo[ signo ] ) )
40019334: c6 00 80 01 ld [ %g2 + %g1 ], %g3
return &the_chain->Tail.Node;
40019338: 82 00 60 04 add %g1, 4, %g1
4001933c: 82 00 40 02 add %g1, %g2, %g1
40019340: 80 a0 c0 01 cmp %g3, %g1
40019344: 02 bf ff f6 be 4001931c <_POSIX_signals_Clear_process_signals+0x30> <== ALWAYS TAKEN
40019348: 03 10 00 d5 sethi %hi(0x40035400), %g1
}
4001934c: 81 c3 e0 08 retl <== NOT EXECUTED
40019350: 01 00 00 00 nop <== NOT EXECUTED
40018ee8 <_POSIX_signals_Send>:
int _POSIX_signals_Send(
pid_t pid,
int sig,
const union sigval *value
)
{
40018ee8: 9d e3 bf 90 save %sp, -112, %sp
Per_CPU_Control *cpu_self;
/*
* Only supported for the "calling process" (i.e. this node).
*/
if ( pid != getpid() )
40018eec: 7f ff a3 4d call 40001c20 <getpid>
40018ef0: 01 00 00 00 nop
40018ef4: 80 a2 00 18 cmp %o0, %i0
40018ef8: 12 80 00 d0 bne 40019238 <_POSIX_signals_Send+0x350>
40018efc: 80 a6 60 00 cmp %i1, 0
rtems_set_errno_and_return_minus_one( ESRCH );
/*
* Validate the signal passed.
*/
if ( !sig )
40018f00: 02 80 00 c8 be 40019220 <_POSIX_signals_Send+0x338>
40018f04: ba 06 7f ff add %i1, -1, %i5
rtems_set_errno_and_return_minus_one( EINVAL );
if ( !is_valid_signo(sig) )
40018f08: 80 a7 60 1f cmp %i5, 0x1f
40018f0c: 18 80 00 c5 bgu 40019220 <_POSIX_signals_Send+0x338>
40018f10: b9 2e 60 01 sll %i1, 1, %i4
rtems_set_errno_and_return_minus_one( EINVAL );
/*
* If the signal is being ignored, then we are out of here.
*/
if ( _POSIX_signals_Vectors[ sig ].sa_handler == SIG_IGN )
40018f14: 37 10 00 d4 sethi %hi(0x40035000), %i3
40018f18: b8 07 00 19 add %i4, %i1, %i4
40018f1c: b6 16 e2 f4 or %i3, 0x2f4, %i3
40018f20: 83 2f 20 02 sll %i4, 2, %g1
40018f24: 82 06 c0 01 add %i3, %g1, %g1
40018f28: c2 00 60 08 ld [ %g1 + 8 ], %g1
40018f2c: 80 a0 60 01 cmp %g1, 1
40018f30: 02 80 00 5d be 400190a4 <_POSIX_signals_Send+0x1bc>
40018f34: 82 06 7f fc add %i1, -4, %g1
/*
* P1003.1c/Draft 10, p. 33 says that certain signals should always
* be directed to the executing thread such as those caused by hardware
* faults.
*/
if ( (sig == SIGFPE) || (sig == SIGILL) || (sig == SIGSEGV ) )
40018f38: 80 88 7f fb btst -5, %g1
40018f3c: 02 80 00 5c be 400190ac <_POSIX_signals_Send+0x1c4>
40018f40: 80 a6 60 0b cmp %i1, 0xb
40018f44: 02 80 00 5a be 400190ac <_POSIX_signals_Send+0x1c4>
40018f48: 82 10 20 01 mov 1, %g1
/*
* Build up a siginfo structure
*/
siginfo = &siginfo_struct;
siginfo->si_signo = sig;
40018f4c: f2 27 bf f4 st %i1, [ %fp + -12 ]
static inline sigset_t signo_to_mask(
uint32_t sig
)
{
return 1u << (sig - 1);
40018f50: bb 28 40 1d sll %g1, %i5, %i5
siginfo->si_code = SI_USER;
if ( !value ) {
40018f54: 80 a6 a0 00 cmp %i2, 0
40018f58: 02 80 00 59 be 400190bc <_POSIX_signals_Send+0x1d4>
40018f5c: c2 27 bf f8 st %g1, [ %fp + -8 ]
siginfo->si_value.sival_int = 0;
} else {
siginfo->si_value = *value;
40018f60: c2 06 80 00 ld [ %i2 ], %g1
40018f64: c2 27 bf fc st %g1, [ %fp + -4 ]
return _Thread_Dispatch_disable_with_CPU( _Per_CPU_Get(), lock_context );
40018f68: b0 10 00 06 mov %g6, %i0
disable_level = cpu_self->thread_dispatch_disable_level;
40018f6c: c2 01 a0 18 ld [ %g6 + 0x18 ], %g1
return cpu->executing;
40018f70: d0 01 a0 20 ld [ %g6 + 0x20 ], %o0
* get it an execute it as soon as the dispatcher executes.
*/
the_thread = _Per_CPU_Get_executing( cpu_self );
api = the_thread->API_Extensions[ THREAD_API_POSIX ];
if ( _POSIX_signals_Is_interested( api, mask ) ) {
40018f74: c4 02 21 5c ld [ %o0 + 0x15c ], %g2
cpu_self->thread_dispatch_disable_level = disable_level + 1;
40018f78: 82 00 60 01 inc %g1
40018f7c: c2 21 a0 18 st %g1, [ %g6 + 0x18 ]
40018f80: c2 00 a0 68 ld [ %g2 + 0x68 ], %g1
40018f84: 80 8f 40 01 btst %i5, %g1
40018f88: 12 80 00 1a bne 40018ff0 <_POSIX_signals_Send+0x108>
40018f8c: 03 10 00 cc sethi %hi(0x40033000), %g1
* There is no requirement on the order of threads pending on a sigwait().
*/
/* XXX violation of visibility -- need to define thread queue support */
heads = _POSIX_signals_Wait_queue.Queue.heads;
40018f90: c8 00 62 0c ld [ %g1 + 0x20c ], %g4 ! 4003320c <_POSIX_signals_Wait_queue>
if ( heads != NULL ) {
40018f94: 80 a1 20 00 cmp %g4, 0
40018f98: 02 80 00 4b be 400190c4 <_POSIX_signals_Send+0x1dc>
40018f9c: 1b 10 00 b5 sethi %hi(0x4002d400), %o5
40018fa0: c2 01 00 00 ld [ %g4 ], %g1
return &the_chain->Tail.Node;
40018fa4: 88 01 20 04 add %g4, 4, %g4
Chain_Control *the_chain = &heads->Heads.Fifo;
for ( the_node = _Chain_First( the_chain );
40018fa8: 80 a0 40 04 cmp %g1, %g4
40018fac: 32 80 00 0d bne,a 40018fe0 <_POSIX_signals_Send+0xf8> <== ALWAYS TAKEN
40018fb0: d0 00 7f f8 ld [ %g1 + -8 ], %o0
40018fb4: 10 80 00 45 b 400190c8 <_POSIX_signals_Send+0x1e0> <== NOT EXECUTED
40018fb8: 17 00 00 3f sethi %hi(0xfc00), %o3 <== NOT EXECUTED
/*
* Is this thread is blocked waiting for another signal but has
* not blocked this one?
*/
if (api->signals_unblocked & mask)
40018fbc: c4 00 e0 68 ld [ %g3 + 0x68 ], %g2
40018fc0: 80 8f 40 02 btst %i5, %g2
40018fc4: 12 80 00 0c bne 40018ff4 <_POSIX_signals_Send+0x10c>
40018fc8: 94 07 bf f4 add %fp, -12, %o2
the_node = the_node->next ) {
40018fcc: c2 00 40 00 ld [ %g1 ], %g1
for ( the_node = _Chain_First( the_chain );
40018fd0: 80 a0 40 04 cmp %g1, %g4
40018fd4: 02 80 00 3c be 400190c4 <_POSIX_signals_Send+0x1dc> <== ALWAYS TAKEN
40018fd8: 1b 10 00 b5 sethi %hi(0x4002d400), %o5
return node->owner;
40018fdc: d0 00 7f f8 ld [ %g1 + -8 ], %o0 <== NOT EXECUTED
if (the_thread->Wait.option & mask)
40018fe0: c4 02 20 48 ld [ %o0 + 0x48 ], %g2
40018fe4: 80 8f 40 02 btst %i5, %g2
40018fe8: 02 bf ff f5 be 40018fbc <_POSIX_signals_Send+0xd4>
40018fec: c6 02 21 5c ld [ %o0 + 0x15c ], %g3
/*
* Returns true if the signal was synchronously given to a thread
* blocked waiting for the signal.
*/
if ( _POSIX_signals_Unblock_thread( the_thread, sig, siginfo ) ) {
40018ff0: 94 07 bf f4 add %fp, -12, %o2
40018ff4: 40 00 01 9b call 40019660 <_POSIX_signals_Unblock_thread>
40018ff8: 92 10 00 19 mov %i1, %o1
40018ffc: 80 a2 20 00 cmp %o0, 0
40019000: 12 80 00 27 bne 4001909c <_POSIX_signals_Send+0x1b4>
40019004: 01 00 00 00 nop
/*
* We may have woken up a thread but we definitely need to post the
* signal to the process wide information set.
*/
_POSIX_signals_Set_process_signals( mask );
40019008: 40 00 01 28 call 400194a8 <_POSIX_signals_Set_process_signals>
4001900c: 90 10 00 1d mov %i5, %o0
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
40019010: 91 d0 20 09 ta 9
return psr;
40019014: 88 10 00 01 mov %g1, %g4
_Thread_queue_Context_initialize( &queue_context );
_POSIX_signals_Acquire( &queue_context );
if ( _POSIX_signals_Vectors[ sig ].sa_flags == SA_SIGINFO ) {
40019018: b9 2f 20 02 sll %i4, 2, %i4
4001901c: c4 06 c0 1c ld [ %i3 + %i4 ], %g2
40019020: 80 a0 a0 02 cmp %g2, 2
40019024: 12 80 00 1b bne 40019090 <_POSIX_signals_Send+0x1a8>
40019028: 07 10 00 d4 sethi %hi(0x40035000), %g3
return _Chain_Immutable_head( the_chain )->next;
4001902c: c4 00 e2 e8 ld [ %g3 + 0x2e8 ], %g2 ! 400352e8 <_POSIX_signals_Inactive_siginfo>
40019030: ba 10 e2 e8 or %g3, 0x2e8, %i5
if ( !_Chain_Is_empty(the_chain))
40019034: b6 07 60 04 add %i5, 4, %i3
40019038: 80 a0 80 1b cmp %g2, %i3
4001903c: 02 80 00 6f be 400191f8 <_POSIX_signals_Send+0x310>
40019040: 01 00 00 00 nop
new_first = old_first->next;
40019044: c2 00 80 00 ld [ %g2 ], %g1
new_first->previous = head;
40019048: fa 20 60 04 st %i5, [ %g1 + 4 ]
_POSIX_signals_Release( &queue_context );
_Thread_Dispatch_enable( cpu_self );
rtems_set_errno_and_return_minus_one( EAGAIN );
}
psiginfo->Info = *siginfo;
4001904c: f6 07 bf fc ld [ %fp + -4 ], %i3
40019050: f4 07 bf f8 ld [ %fp + -8 ], %i2
head->next = new_first;
40019054: c2 20 e2 e8 st %g1, [ %g3 + 0x2e8 ]
_Chain_Append_unprotected(
40019058: 03 10 00 d4 sethi %hi(0x40035000), %g1
psiginfo->Info = *siginfo;
4001905c: c6 07 bf f4 ld [ %fp + -12 ], %g3
40019060: c6 20 a0 08 st %g3, [ %g2 + 8 ]
_Chain_Append_unprotected(
40019064: 82 10 61 68 or %g1, 0x168, %g1
psiginfo->Info = *siginfo;
40019068: f4 20 a0 0c st %i2, [ %g2 + 0xc ]
_Chain_Append_unprotected(
4001906c: ba 07 00 01 add %i4, %g1, %i5
return &the_chain->Tail.Node;
40019070: b8 07 20 04 add %i4, 4, %i4
old_last = tail->previous;
40019074: c6 07 60 08 ld [ %i5 + 8 ], %g3
return &the_chain->Tail.Node;
40019078: b8 07 00 01 add %i4, %g1, %i4
psiginfo->Info = *siginfo;
4001907c: f6 20 a0 10 st %i3, [ %g2 + 0x10 ]
the_node->next = tail;
40019080: f8 20 80 00 st %i4, [ %g2 ]
tail->previous = the_node;
40019084: c4 27 60 08 st %g2, [ %i5 + 8 ]
old_last->next = the_node;
40019088: c4 20 c0 00 st %g2, [ %g3 ]
the_node->previous = old_last;
4001908c: c6 20 a0 04 st %g3, [ %g2 + 4 ]
register uint32_t _psr __asm__("g1") = psr; /* input to trap handler */
40019090: 82 10 00 04 mov %g4, %g1
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
40019094: 91 d0 20 0a ta 0xa
40019098: 01 00 00 00 nop
);
}
_POSIX_signals_Release( &queue_context );
DEBUG_STEP("\n");
_Thread_Dispatch_enable( cpu_self );
4001909c: 7f ff c7 40 call 4000ad9c <_Thread_Dispatch_enable>
400190a0: 90 10 00 18 mov %i0, %o0
return 0;
400190a4: 81 c7 e0 08 ret
400190a8: 91 e8 20 00 restore %g0, 0, %o0
return pthread_kill( pthread_self(), sig );
400190ac: 7f ff b5 b1 call 40006770 <pthread_self>
400190b0: 01 00 00 00 nop
400190b4: 40 00 01 db call 40019820 <pthread_kill>
400190b8: 91 e8 00 08 restore %g0, %o0, %o0
siginfo->si_value.sival_int = 0;
400190bc: 10 bf ff ab b 40018f68 <_POSIX_signals_Send+0x80>
400190c0: c0 27 bf fc clr [ %fp + -4 ]
400190c4: 17 00 00 3f sethi %hi(0xfc00), %o3
400190c8: 9a 13 60 7c or %o5, 0x7c, %o5
{
400190cc: 9e 10 3f ff mov -1, %o7
400190d0: 92 03 60 08 add %o5, 8, %o1
400190d4: 94 10 3f ff mov -1, %o2
400190d8: 90 10 20 00 clr %o0
400190dc: 96 12 e3 ff or %o3, 0x3ff, %o3
*/
RTEMS_INLINE_ROUTINE bool _States_Is_interruptible_by_signal (
States_Control the_states
)
{
return (the_states & STATES_INTERRUPTIBLE_BY_SIGNAL);
400190e0: 21 04 00 00 sethi %hi(0x10000000), %l0
the_info = _Objects_Information_table[ the_api ][ 1 ];
400190e4: c2 03 60 08 ld [ %o5 + 8 ], %g1
400190e8: c2 00 60 04 ld [ %g1 + 4 ], %g1
if ( !the_info )
400190ec: 80 a0 60 00 cmp %g1, 0
400190f0: 22 80 00 31 be,a 400191b4 <_POSIX_signals_Send+0x2cc>
400190f4: 9a 03 60 04 add %o5, 4, %o5
return
400190f8: f4 00 40 00 ld [ %g1 ], %i2
for ( index = 0 ; index < maximum ; ++index ) {
400190fc: b4 8e 80 0b andcc %i2, %o3, %i2
40019100: 02 80 00 2c be 400191b0 <_POSIX_signals_Send+0x2c8> <== NEVER TAKEN
40019104: c2 00 60 04 ld [ %g1 + 4 ], %g1
40019108: b5 2e a0 02 sll %i2, 2, %i2
4001910c: b4 00 40 1a add %g1, %i2, %i2
the_thread = (Thread_Control *) object_table[ index ];
40019110: c4 00 40 00 ld [ %g1 ], %g2
if ( !the_thread )
40019114: 80 a0 a0 00 cmp %g2, 0
40019118: 22 80 00 23 be,a 400191a4 <_POSIX_signals_Send+0x2bc>
4001911c: 82 00 60 04 add %g1, 4, %g1
return aggregation->Node.priority;
40019120: c6 00 a0 38 ld [ %g2 + 0x38 ], %g3
40019124: c8 00 e0 18 ld [ %g3 + 0x18 ], %g4
if ( _Thread_Get_priority( the_thread ) > interested_priority )
40019128: 80 a1 00 0f cmp %g4, %o7
4001912c: 18 80 00 1d bgu 400191a0 <_POSIX_signals_Send+0x2b8> <== NEVER TAKEN
40019130: c6 00 e0 1c ld [ %g3 + 0x1c ], %g3
40019134: 02 80 00 2d be 400191e8 <_POSIX_signals_Send+0x300>
40019138: 80 a0 c0 0a cmp %g3, %o2
if ( !_POSIX_signals_Is_interested( api, mask ) )
4001913c: d8 00 a1 5c ld [ %g2 + 0x15c ], %o4
40019140: d8 03 20 68 ld [ %o4 + 0x68 ], %o4
40019144: 80 8f 40 0c btst %i5, %o4
40019148: 02 80 00 16 be 400191a0 <_POSIX_signals_Send+0x2b8>
4001914c: 80 a3 c0 04 cmp %o7, %g4
if ( _Thread_Get_priority( the_thread ) < interested_priority ) {
40019150: 38 80 00 23 bgu,a 400191dc <_POSIX_signals_Send+0x2f4>
40019154: 9e 10 00 04 mov %g4, %o7
40019158: 02 80 00 1e be 400191d0 <_POSIX_signals_Send+0x2e8> <== ALWAYS TAKEN
4001915c: 80 a2 80 03 cmp %o2, %g3
if ( interested && !_States_Is_ready( interested->current_state ) ) {
40019160: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
40019164: 22 80 00 10 be,a 400191a4 <_POSIX_signals_Send+0x2bc> <== NEVER TAKEN
40019168: 82 00 60 04 add %g1, 4, %g1 <== NOT EXECUTED
4001916c: d8 02 20 1c ld [ %o0 + 0x1c ], %o4
40019170: 80 a3 20 00 cmp %o4, 0
40019174: 22 80 00 0c be,a 400191a4 <_POSIX_signals_Send+0x2bc>
40019178: 82 00 60 04 add %g1, 4, %g1
if ( _States_Is_ready( the_thread->current_state ) ) {
4001917c: e2 00 a0 1c ld [ %g2 + 0x1c ], %l1
40019180: 80 a4 60 00 cmp %l1, 0
40019184: 02 80 00 15 be 400191d8 <_POSIX_signals_Send+0x2f0>
40019188: 80 8b 00 10 btst %o4, %l0
if ( !_States_Is_interruptible_by_signal(interested->current_state) ) {
4001918c: 32 80 00 06 bne,a 400191a4 <_POSIX_signals_Send+0x2bc>
40019190: 82 00 60 04 add %g1, 4, %g1
if ( _States_Is_interruptible_by_signal(the_thread->current_state) ) {
40019194: 80 8c 40 10 btst %l1, %l0
40019198: 32 80 00 11 bne,a 400191dc <_POSIX_signals_Send+0x2f4>
4001919c: 9e 10 00 04 mov %g4, %o7
for ( index = 0 ; index < maximum ; ++index ) {
400191a0: 82 00 60 04 add %g1, 4, %g1
400191a4: 80 a6 80 01 cmp %i2, %g1
400191a8: 32 bf ff db bne,a 40019114 <_POSIX_signals_Send+0x22c>
400191ac: c4 00 40 00 ld [ %g1 ], %g2
for (the_api = OBJECTS_CLASSIC_API; the_api <= OBJECTS_APIS_LAST; the_api++) {
400191b0: 9a 03 60 04 add %o5, 4, %o5
400191b4: 80 a3 40 09 cmp %o5, %o1
400191b8: 32 bf ff cc bne,a 400190e8 <_POSIX_signals_Send+0x200>
400191bc: c2 03 60 08 ld [ %o5 + 8 ], %g1
if ( interested ) {
400191c0: 80 a2 20 00 cmp %o0, 0
400191c4: 12 bf ff 8c bne 40018ff4 <_POSIX_signals_Send+0x10c>
400191c8: 94 07 bf f4 add %fp, -12, %o2
400191cc: 30 bf ff 8f b,a 40019008 <_POSIX_signals_Send+0x120>
if ( _Thread_Get_priority( the_thread ) < interested_priority ) {
400191d0: 08 bf ff e5 bleu 40019164 <_POSIX_signals_Send+0x27c>
400191d4: 80 a2 20 00 cmp %o0, 0
400191d8: 9e 10 00 04 mov %g4, %o7
400191dc: 94 10 00 03 mov %g3, %o2
400191e0: 10 bf ff f0 b 400191a0 <_POSIX_signals_Send+0x2b8>
400191e4: 90 10 00 02 mov %g2, %o0
if ( _Thread_Get_priority( the_thread ) > interested_priority )
400191e8: 28 bf ff d6 bleu,a 40019140 <_POSIX_signals_Send+0x258>
400191ec: d8 00 a1 5c ld [ %g2 + 0x15c ], %o4
for ( index = 0 ; index < maximum ; ++index ) {
400191f0: 10 bf ff ed b 400191a4 <_POSIX_signals_Send+0x2bc>
400191f4: 82 00 60 04 add %g1, 4, %g1
400191f8: 91 d0 20 0a ta 0xa
400191fc: 01 00 00 00 nop
_Thread_Dispatch_enable( cpu_self );
40019200: 7f ff c6 e7 call 4000ad9c <_Thread_Dispatch_enable>
40019204: 90 10 00 18 mov %i0, %o0
rtems_set_errno_and_return_minus_one( EAGAIN );
40019208: 40 00 17 77 call 4001efe4 <__errno>
4001920c: b0 10 3f ff mov -1, %i0
40019210: 82 10 20 0b mov 0xb, %g1
40019214: c2 22 00 00 st %g1, [ %o0 ]
40019218: 81 c7 e0 08 ret
4001921c: 81 e8 00 00 restore
rtems_set_errno_and_return_minus_one( EINVAL );
40019220: 40 00 17 71 call 4001efe4 <__errno>
40019224: b0 10 3f ff mov -1, %i0
40019228: 82 10 20 16 mov 0x16, %g1
4001922c: c2 22 00 00 st %g1, [ %o0 ]
40019230: 81 c7 e0 08 ret
40019234: 81 e8 00 00 restore
rtems_set_errno_and_return_minus_one( ESRCH );
40019238: 40 00 17 6b call 4001efe4 <__errno>
4001923c: b0 10 3f ff mov -1, %i0
40019240: 82 10 20 03 mov 3, %g1
40019244: c2 22 00 00 st %g1, [ %o0 ]
40019248: 81 c7 e0 08 ret
4001924c: 81 e8 00 00 restore
40019660 <_POSIX_signals_Unblock_thread>:
bool _POSIX_signals_Unblock_thread(
Thread_Control *the_thread,
int signo,
siginfo_t *info
)
{
40019660: 9d e3 bf a0 save %sp, -96, %sp
POSIX_API_Control *api;
sigset_t mask;
siginfo_t *the_info = NULL;
api = the_thread->API_Extensions[ THREAD_API_POSIX ];
40019664: fa 06 21 5c ld [ %i0 + 0x15c ], %i5
/*
* Is the thread is specifically waiting for a signal?
*/
if ( _States_Is_interruptible_signal( the_thread->current_state ) ) {
40019668: c6 06 20 1c ld [ %i0 + 0x1c ], %g3
4001966c: 05 04 00 01 sethi %hi(0x10000400), %g2
40019670: 88 10 20 01 mov 1, %g4
40019674: 82 06 7f ff add %i1, -1, %g1
40019678: b8 08 c0 02 and %g3, %g2, %i4
4001967c: 83 29 00 01 sll %g4, %g1, %g1
40019680: 80 a7 00 02 cmp %i4, %g2
40019684: 02 80 00 19 be 400196e8 <_POSIX_signals_Unblock_thread+0x88>
40019688: b6 07 60 70 add %i5, 0x70, %i3
}
/*
* Thread is not waiting due to a sigwait.
*/
if ( api->signals_unblocked & mask ) {
4001968c: c4 07 60 68 ld [ %i5 + 0x68 ], %g2
40019690: 80 88 40 02 btst %g1, %g2
40019694: 02 80 00 05 be 400196a8 <_POSIX_signals_Unblock_thread+0x48>
40019698: 03 04 00 00 sethi %hi(0x10000000), %g1
* it is not blocked, THEN
* we need to dispatch at the end of this ISR.
* + Any other combination, do nothing.
*/
if ( _States_Is_interruptible_by_signal( the_thread->current_state ) ) {
4001969c: 80 88 c0 01 btst %g3, %g1
400196a0: 12 80 00 46 bne 400197b8 <_POSIX_signals_Unblock_thread+0x158>
400196a4: 82 10 24 0d mov 0x40d, %g1
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
400196a8: 91 d0 20 09 ta 9
action->handler = handler;
400196ac: 05 10 00 65 sethi %hi(0x40019400), %g2
400196b0: 84 10 a1 68 or %g2, 0x168, %g2 ! 40019568 <_POSIX_signals_Action_handler>
400196b4: c4 27 60 78 st %g2, [ %i5 + 0x78 ]
cpu_self->dispatch_necessary = true;
400196b8: 86 10 20 01 mov 1, %g3
400196bc: c6 29 a0 1c stb %g3, [ %g6 + 0x1c ]
if ( _Chain_Is_node_off_chain( the_node ) ) {
400196c0: c4 07 60 70 ld [ %i5 + 0x70 ], %g2
400196c4: 80 a0 a0 00 cmp %g2, 0
400196c8: 22 80 00 1a be,a 40019730 <_POSIX_signals_Unblock_thread+0xd0>
400196cc: c4 06 20 e8 ld [ %i0 + 0xe8 ], %g2
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
400196d0: 91 d0 20 0a ta 0xa
400196d4: 01 00 00 00 nop
the_thread->Wait.return_code = STATUS_INTERRUPTED;
_Thread_queue_Extract_with_proxy( the_thread );
}
}
return _POSIX_signals_Unblock_thread_done( the_thread, api, false );
400196d8: b0 10 20 00 clr %i0 ! 0 <PROM_START>
}
400196dc: b0 0e 20 01 and %i0, 1, %i0
400196e0: 81 c7 e0 08 ret
400196e4: 81 e8 00 00 restore
if ( (the_thread->Wait.option & mask) || (api->signals_unblocked & mask) ) {
400196e8: c4 06 20 48 ld [ %i0 + 0x48 ], %g2
400196ec: 80 88 40 02 btst %g1, %g2
400196f0: 32 80 00 16 bne,a 40019748 <_POSIX_signals_Unblock_thread+0xe8>
400196f4: 82 10 24 0d mov 0x40d, %g1
400196f8: c4 07 60 68 ld [ %i5 + 0x68 ], %g2
400196fc: 80 88 40 02 btst %g1, %g2
40019700: 12 80 00 12 bne 40019748 <_POSIX_signals_Unblock_thread+0xe8>
40019704: 82 10 24 0d mov 0x40d, %g1
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
40019708: 91 d0 20 09 ta 9
4001970c: 05 10 00 65 sethi %hi(0x40019400), %g2
40019710: 84 10 a1 68 or %g2, 0x168, %g2 ! 40019568 <_POSIX_signals_Action_handler>
40019714: c4 27 60 78 st %g2, [ %i5 + 0x78 ]
40019718: c8 29 a0 1c stb %g4, [ %g6 + 0x1c ]
4001971c: c4 07 60 70 ld [ %i5 + 0x70 ], %g2
40019720: 80 a0 a0 00 cmp %g2, 0
40019724: 12 bf ff eb bne 400196d0 <_POSIX_signals_Unblock_thread+0x70> <== NEVER TAKEN
40019728: 01 00 00 00 nop
old_last = tail->previous;
4001972c: c4 06 20 e8 ld [ %i0 + 0xe8 ], %g2
return &the_chain->Tail.Node;
40019730: 86 06 20 e4 add %i0, 0xe4, %g3
the_node->next = tail;
40019734: c6 27 60 70 st %g3, [ %i5 + 0x70 ]
tail->previous = the_node;
40019738: f6 26 20 e8 st %i3, [ %i0 + 0xe8 ]
old_last->next = the_node;
4001973c: f6 20 80 00 st %i3, [ %g2 ]
}
40019740: 10 bf ff e4 b 400196d0 <_POSIX_signals_Unblock_thread+0x70>
40019744: c4 27 60 74 st %g2, [ %i5 + 0x74 ]
the_thread->Wait.return_code = STATUS_INTERRUPTED;
40019748: c2 26 20 4c st %g1, [ %i0 + 0x4c ]
if ( !info ) {
4001974c: 80 a6 a0 00 cmp %i2, 0
40019750: 02 80 00 29 be 400197f4 <_POSIX_signals_Unblock_thread+0x194>
40019754: c2 06 20 40 ld [ %i0 + 0x40 ], %g1
*the_info = *info;
40019758: c4 06 80 00 ld [ %i2 ], %g2
4001975c: c4 20 40 00 st %g2, [ %g1 ]
40019760: c4 06 a0 04 ld [ %i2 + 4 ], %g2
40019764: c4 20 60 04 st %g2, [ %g1 + 4 ]
40019768: c4 06 a0 08 ld [ %i2 + 8 ], %g2
4001976c: c4 20 60 08 st %g2, [ %g1 + 8 ]
_Thread_queue_Extract_with_proxy( the_thread );
40019770: 7f ff c7 6b call 4000b51c <_Thread_queue_Extract_with_proxy>
40019774: 90 10 00 18 mov %i0, %o0
40019778: 91 d0 20 09 ta 9
4001977c: 05 10 00 65 sethi %hi(0x40019400), %g2
40019780: 84 10 a1 68 or %g2, 0x168, %g2 ! 40019568 <_POSIX_signals_Action_handler>
40019784: c4 27 60 78 st %g2, [ %i5 + 0x78 ]
40019788: 86 10 20 01 mov 1, %g3
4001978c: c6 29 a0 1c stb %g3, [ %g6 + 0x1c ]
if ( _Chain_Is_node_off_chain( the_node ) ) {
40019790: c4 07 60 70 ld [ %i5 + 0x70 ], %g2
40019794: 80 a0 a0 00 cmp %g2, 0
40019798: 22 80 00 1c be,a 40019808 <_POSIX_signals_Unblock_thread+0x1a8> <== ALWAYS TAKEN
4001979c: c4 06 20 e8 ld [ %i0 + 0xe8 ], %g2
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
400197a0: 91 d0 20 0a ta 0xa
400197a4: 01 00 00 00 nop
return _POSIX_signals_Unblock_thread_done( the_thread, api, true );
400197a8: b0 10 20 01 mov 1, %i0 ! 1 <_TLS_Alignment>
}
400197ac: b0 0e 20 01 and %i0, 1, %i0
400197b0: 81 c7 e0 08 ret
400197b4: 81 e8 00 00 restore
the_thread->Wait.return_code = STATUS_INTERRUPTED;
400197b8: c2 26 20 4c st %g1, [ %i0 + 0x4c ]
_Thread_queue_Extract_with_proxy( the_thread );
400197bc: 7f ff c7 58 call 4000b51c <_Thread_queue_Extract_with_proxy>
400197c0: 90 10 00 18 mov %i0, %o0
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
400197c4: 91 d0 20 09 ta 9
400197c8: 05 10 00 65 sethi %hi(0x40019400), %g2
400197cc: 84 10 a1 68 or %g2, 0x168, %g2 ! 40019568 <_POSIX_signals_Action_handler>
400197d0: c4 27 60 78 st %g2, [ %i5 + 0x78 ]
400197d4: 86 10 20 01 mov 1, %g3
400197d8: c6 29 a0 1c stb %g3, [ %g6 + 0x1c ]
400197dc: c4 07 60 70 ld [ %i5 + 0x70 ], %g2
400197e0: 80 a0 a0 00 cmp %g2, 0
400197e4: 12 bf ff bb bne 400196d0 <_POSIX_signals_Unblock_thread+0x70> <== NEVER TAKEN
400197e8: 01 00 00 00 nop
old_last = tail->previous;
400197ec: 10 bf ff d1 b 40019730 <_POSIX_signals_Unblock_thread+0xd0>
400197f0: c4 06 20 e8 ld [ %i0 + 0xe8 ], %g2
the_info->si_code = SI_USER;
400197f4: 84 10 20 01 mov 1, %g2
the_info->si_signo = signo;
400197f8: f2 20 40 00 st %i1, [ %g1 ]
the_info->si_code = SI_USER;
400197fc: c4 20 60 04 st %g2, [ %g1 + 4 ]
the_info->si_value.sival_int = 0;
40019800: 10 bf ff dc b 40019770 <_POSIX_signals_Unblock_thread+0x110>
40019804: c0 20 60 08 clr [ %g1 + 8 ]
return &the_chain->Tail.Node;
40019808: 86 06 20 e4 add %i0, 0xe4, %g3
the_node->next = tail;
4001980c: c6 27 60 70 st %g3, [ %i5 + 0x70 ]
tail->previous = the_node;
40019810: f6 26 20 e8 st %i3, [ %i0 + 0xe8 ]
old_last->next = the_node;
40019814: f6 20 80 00 st %i3, [ %g2 ]
}
40019818: 10 bf ff e2 b 400197a0 <_POSIX_signals_Unblock_thread+0x140>
4001981c: c4 27 60 74 st %g2, [ %i5 + 0x74 ]
40008d44 <aio_cancel>:
#include <errno.h>
#include <stdlib.h>
#include <rtems/seterr.h>
int aio_cancel(int fildes, struct aiocb *aiocbp)
{
40008d44: 9d e3 bf a0 save %sp, -96, %sp
rtems_chain_control *idle_req_chain = &aio_request_queue.idle_req;
rtems_chain_control *work_req_chain = &aio_request_queue.work_req;
rtems_aio_request_chain *r_chain;
int result;
pthread_mutex_lock (&aio_request_queue.mutex);
40008d48: 39 10 00 67 sethi %hi(0x40019c00), %i4
40008d4c: 40 00 08 ad call 4000b000 <pthread_mutex_lock>
40008d50: 90 17 20 20 or %i4, 0x20, %o0 ! 40019c20 <aio_request_queue>
if (fcntl (fildes, F_GETFD) < 0) {
40008d54: 92 10 20 01 mov 1, %o1
40008d58: 40 00 03 67 call 40009af4 <fcntl>
40008d5c: 90 10 00 18 mov %i0, %o0
40008d60: 80 a2 20 00 cmp %o0, 0
40008d64: 06 80 00 6b bl 40008f10 <aio_cancel+0x1cc>
40008d68: 80 a6 60 00 cmp %i1, 0
pthread_mutex_unlock(&aio_request_queue.mutex);
rtems_set_errno_and_return_minus_one (EBADF);
}
/* if aiocbp is NULL remove all request for given file descriptor */
if (aiocbp == NULL) {
40008d6c: 02 80 00 32 be 40008e34 <aio_cancel+0xf0>
40008d70: 94 10 20 00 clr %o2
pthread_mutex_unlock (&aio_request_queue.mutex);
return AIO_CANCELED;
} else {
AIO_printf ("Cancel request\n");
if (aiocbp->aio_fildes != fildes) {
40008d74: f6 06 40 00 ld [ %i1 ], %i3
40008d78: 80 a6 c0 18 cmp %i3, %i0
40008d7c: 12 80 00 5d bne 40008ef0 <aio_cancel+0x1ac>
40008d80: 90 17 20 20 or %i4, 0x20, %o0
pthread_mutex_unlock (&aio_request_queue.mutex);
rtems_set_errno_and_return_minus_one (EINVAL);
}
r_chain = rtems_aio_search_fd (work_req_chain, fildes, 0);
40008d84: 94 10 20 00 clr %o2
40008d88: 92 10 00 1b mov %i3, %o1
40008d8c: 11 10 00 67 sethi %hi(0x40019c00), %o0
40008d90: 40 00 01 96 call 400093e8 <rtems_aio_search_fd>
40008d94: 90 12 20 e0 or %o0, 0xe0, %o0 ! 40019ce0 <aio_request_queue+0xc0>
if (r_chain == NULL) {
40008d98: ba 92 20 00 orcc %o0, 0, %i5
40008d9c: 32 80 00 15 bne,a 40008df0 <aio_cancel+0xac>
40008da0: b6 07 60 20 add %i5, 0x20, %i3
return _Chain_Immutable_head( the_chain )->next;
40008da4: ba 17 20 20 or %i4, 0x20, %i5
if (!rtems_chain_is_empty (idle_req_chain)) {
40008da8: c4 07 60 cc ld [ %i5 + 0xcc ], %g2
40008dac: 82 07 60 d0 add %i5, 0xd0, %g1
40008db0: 80 a0 80 01 cmp %g2, %g1
40008db4: 02 80 00 1b be 40008e20 <aio_cancel+0xdc> <== NEVER TAKEN
40008db8: 94 10 20 00 clr %o2
r_chain = rtems_aio_search_fd (idle_req_chain, fildes, 0);
40008dbc: 92 10 00 1b mov %i3, %o1
40008dc0: 40 00 01 8a call 400093e8 <rtems_aio_search_fd>
40008dc4: 90 07 60 cc add %i5, 0xcc, %o0
if (r_chain == NULL) {
40008dc8: 80 a2 20 00 cmp %o0, 0
40008dcc: 02 80 00 48 be 40008eec <aio_cancel+0x1a8>
40008dd0: 92 10 00 19 mov %i1, %o1
rtems_set_errno_and_return_minus_one (EINVAL);
}
AIO_printf ("Request on [IQ]\n");
result = rtems_aio_remove_req (&r_chain->perfd, aiocbp);
40008dd4: 40 00 01 e7 call 40009570 <rtems_aio_remove_req>
40008dd8: 90 02 20 08 add %o0, 8, %o0
40008ddc: b0 10 00 08 mov %o0, %i0
pthread_mutex_unlock (&aio_request_queue.mutex);
40008de0: 40 00 09 55 call 4000b334 <pthread_mutex_unlock>
40008de4: 90 10 00 1d mov %i5, %o0
return result;
40008de8: 81 c7 e0 08 ret
40008dec: 81 e8 00 00 restore
return AIO_ALLDONE;
}
}
AIO_printf ("Request on [WQ]\n");
pthread_mutex_lock (&r_chain->mutex);
40008df0: 40 00 08 84 call 4000b000 <pthread_mutex_lock>
40008df4: 90 10 00 1b mov %i3, %o0
result = rtems_aio_remove_req (&r_chain->perfd, aiocbp);
40008df8: 92 10 00 19 mov %i1, %o1
40008dfc: 40 00 01 dd call 40009570 <rtems_aio_remove_req>
40008e00: 90 07 60 08 add %i5, 8, %o0
40008e04: b0 10 00 08 mov %o0, %i0
pthread_mutex_unlock (&r_chain->mutex);
40008e08: 40 00 09 4b call 4000b334 <pthread_mutex_unlock>
40008e0c: 90 10 00 1b mov %i3, %o0
pthread_mutex_unlock (&aio_request_queue.mutex);
40008e10: 40 00 09 49 call 4000b334 <pthread_mutex_unlock>
40008e14: 90 17 20 20 or %i4, 0x20, %o0
return result;
}
return AIO_ALLDONE;
}
40008e18: 81 c7 e0 08 ret
40008e1c: 81 e8 00 00 restore
return AIO_ALLDONE;
40008e20: b0 10 20 02 mov 2, %i0 <== NOT EXECUTED
pthread_mutex_unlock(&aio_request_queue.mutex);
40008e24: 40 00 09 44 call 4000b334 <pthread_mutex_unlock>
40008e28: 90 17 20 20 or %i4, 0x20, %o0
return AIO_ALLDONE;
40008e2c: 81 c7 e0 08 ret
40008e30: 81 e8 00 00 restore
r_chain = rtems_aio_search_fd (work_req_chain, fildes, 0);
40008e34: 92 10 00 18 mov %i0, %o1
40008e38: 11 10 00 67 sethi %hi(0x40019c00), %o0
40008e3c: 40 00 01 6b call 400093e8 <rtems_aio_search_fd>
40008e40: 90 12 20 e0 or %o0, 0xe0, %o0 ! 40019ce0 <aio_request_queue+0xc0>
if (r_chain == NULL) {
40008e44: ba 92 20 00 orcc %o0, 0, %i5
40008e48: 12 80 00 1b bne 40008eb4 <aio_cancel+0x170>
40008e4c: b6 17 20 20 or %i4, 0x20, %i3
if (!rtems_chain_is_empty (idle_req_chain)) {
40008e50: c4 06 e0 cc ld [ %i3 + 0xcc ], %g2
40008e54: 82 06 e0 d0 add %i3, 0xd0, %g1
40008e58: 80 a0 80 01 cmp %g2, %g1
40008e5c: 02 bf ff f1 be 40008e20 <aio_cancel+0xdc> <== NEVER TAKEN
40008e60: 94 10 20 00 clr %o2
r_chain = rtems_aio_search_fd (idle_req_chain, fildes, 0);
40008e64: 92 10 00 18 mov %i0, %o1
40008e68: 40 00 01 60 call 400093e8 <rtems_aio_search_fd>
40008e6c: 90 06 e0 cc add %i3, 0xcc, %o0
if (r_chain == NULL) {
40008e70: ba 92 20 00 orcc %o0, 0, %i5
40008e74: 22 bf ff ec be,a 40008e24 <aio_cancel+0xe0>
40008e78: b0 10 20 02 mov 2, %i0
rtems_chain_extract (&r_chain->next_fd);
40008e7c: 40 00 0c 87 call 4000c098 <rtems_chain_extract>
40008e80: b0 10 20 00 clr %i0
rtems_aio_remove_fd (r_chain);
40008e84: 40 00 01 a6 call 4000951c <rtems_aio_remove_fd>
40008e88: 90 10 00 1d mov %i5, %o0
pthread_mutex_destroy (&r_chain->mutex);
40008e8c: 40 00 07 f1 call 4000ae50 <pthread_mutex_destroy>
40008e90: 90 07 60 20 add %i5, 0x20, %o0
pthread_cond_destroy (&r_chain->cond);
40008e94: 40 00 06 df call 4000aa10 <pthread_cond_destroy>
40008e98: 90 07 60 60 add %i5, 0x60, %o0
free (r_chain);
40008e9c: 7f ff e2 d1 call 400019e0 <free>
40008ea0: 90 10 00 1d mov %i5, %o0
pthread_mutex_unlock (&aio_request_queue.mutex);
40008ea4: 40 00 09 24 call 4000b334 <pthread_mutex_unlock>
40008ea8: 90 10 00 1b mov %i3, %o0
return AIO_CANCELED;
40008eac: 81 c7 e0 08 ret
40008eb0: 81 e8 00 00 restore
pthread_mutex_lock (&r_chain->mutex);
40008eb4: b6 07 60 20 add %i5, 0x20, %i3
40008eb8: 40 00 08 52 call 4000b000 <pthread_mutex_lock>
40008ebc: 90 10 00 1b mov %i3, %o0
rtems_chain_extract (&r_chain->next_fd);
40008ec0: 40 00 0c 76 call 4000c098 <rtems_chain_extract>
40008ec4: 90 10 00 1d mov %i5, %o0
rtems_aio_remove_fd (r_chain);
40008ec8: 40 00 01 95 call 4000951c <rtems_aio_remove_fd>
40008ecc: 90 10 00 1d mov %i5, %o0
pthread_mutex_unlock (&r_chain->mutex);
40008ed0: 40 00 09 19 call 4000b334 <pthread_mutex_unlock>
40008ed4: 90 10 00 1b mov %i3, %o0
return AIO_CANCELED;
40008ed8: b0 10 20 00 clr %i0
pthread_mutex_unlock (&aio_request_queue.mutex);
40008edc: 40 00 09 16 call 4000b334 <pthread_mutex_unlock>
40008ee0: 90 17 20 20 or %i4, 0x20, %o0
return AIO_CANCELED;
40008ee4: 81 c7 e0 08 ret
40008ee8: 81 e8 00 00 restore
pthread_mutex_unlock (&aio_request_queue.mutex);
40008eec: 90 10 00 1d mov %i5, %o0
40008ef0: 40 00 09 11 call 4000b334 <pthread_mutex_unlock>
40008ef4: b0 10 3f ff mov -1, %i0
rtems_set_errno_and_return_minus_one (EINVAL);
40008ef8: 40 00 22 b3 call 400119c4 <__errno>
40008efc: 01 00 00 00 nop
40008f00: 82 10 20 16 mov 0x16, %g1 ! 16 <_TLS_Alignment+0x15>
40008f04: c2 22 00 00 st %g1, [ %o0 ]
40008f08: 81 c7 e0 08 ret
40008f0c: 81 e8 00 00 restore
pthread_mutex_unlock(&aio_request_queue.mutex);
40008f10: 40 00 09 09 call 4000b334 <pthread_mutex_unlock>
40008f14: 90 17 20 20 or %i4, 0x20, %o0
rtems_set_errno_and_return_minus_one (EBADF);
40008f18: 40 00 22 ab call 400119c4 <__errno>
40008f1c: b0 10 3f ff mov -1, %i0
40008f20: 82 10 20 09 mov 9, %g1
40008f24: c2 22 00 00 st %g1, [ %o0 ]
40008f28: 81 c7 e0 08 ret
40008f2c: 81 e8 00 00 restore
40008f38 <aio_fsync>:
int aio_fsync(
int op,
struct aiocb *aiocbp
)
{
40008f38: 9d e3 bf a0 save %sp, -96, %sp
rtems_aio_request *req;
int mode;
if (op != O_SYNC)
40008f3c: 03 00 00 08 sethi %hi(0x2000), %g1
40008f40: 80 a6 00 01 cmp %i0, %g1
40008f44: 12 80 00 14 bne 40008f94 <aio_fsync+0x5c>
40008f48: ba 10 20 16 mov 0x16, %i5
rtems_aio_set_errno_return_minus_one (EINVAL, aiocbp);
mode = fcntl (aiocbp->aio_fildes, F_GETFL);
40008f4c: d0 06 40 00 ld [ %i1 ], %o0
40008f50: 40 00 02 e9 call 40009af4 <fcntl>
40008f54: 92 10 20 03 mov 3, %o1
if (!(((mode & O_ACCMODE) == O_WRONLY) || ((mode & O_ACCMODE) == O_RDWR)))
40008f58: 90 0a 20 03 and %o0, 3, %o0
40008f5c: 90 02 3f ff add %o0, -1, %o0
40008f60: 80 a2 20 01 cmp %o0, 1
40008f64: 18 80 00 0c bgu 40008f94 <aio_fsync+0x5c>
40008f68: ba 10 20 09 mov 9, %i5
rtems_aio_set_errno_return_minus_one (EBADF, aiocbp);
req = malloc (sizeof (rtems_aio_request));
40008f6c: 7f ff e3 55 call 40001cc0 <malloc>
40008f70: 90 10 20 18 mov 0x18, %o0
if (req == NULL)
40008f74: b0 92 20 00 orcc %o0, 0, %i0
40008f78: 02 80 00 06 be 40008f90 <aio_fsync+0x58> <== NEVER TAKEN
40008f7c: 82 10 20 03 mov 3, %g1
rtems_aio_set_errno_return_minus_one (EAGAIN, aiocbp);
req->aiocbp = aiocbp;
40008f80: f2 26 20 14 st %i1, [ %i0 + 0x14 ]
req->aiocbp->aio_lio_opcode = LIO_SYNC;
40008f84: c2 26 60 30 st %g1, [ %i1 + 0x30 ]
return rtems_aio_enqueue (req);
40008f88: 40 00 01 9a call 400095f0 <rtems_aio_enqueue>
40008f8c: 81 e8 00 00 restore
rtems_aio_set_errno_return_minus_one (EAGAIN, aiocbp);
40008f90: ba 10 20 0b mov 0xb, %i5 <== NOT EXECUTED
40008f94: 82 10 3f ff mov -1, %g1
40008f98: fa 26 60 34 st %i5, [ %i1 + 0x34 ]
}
40008f9c: b0 10 3f ff mov -1, %i0
rtems_aio_set_errno_return_minus_one (EAGAIN, aiocbp);
40008fa0: 40 00 22 89 call 400119c4 <__errno>
40008fa4: c2 26 60 38 st %g1, [ %i1 + 0x38 ]
40008fa8: fa 22 00 00 st %i5, [ %o0 ]
}
40008fac: 81 c7 e0 08 ret
40008fb0: 81 e8 00 00 restore
40009810 <aio_read>:
* 0 - otherwise
*/
int
aio_read (struct aiocb *aiocbp)
{
40009810: 9d e3 bf a0 save %sp, -96, %sp
rtems_aio_request *req;
int mode;
mode = fcntl (aiocbp->aio_fildes, F_GETFL);
40009814: d0 06 00 00 ld [ %i0 ], %o0
40009818: 92 10 20 03 mov 3, %o1
4000981c: 40 00 00 b6 call 40009af4 <fcntl>
40009820: ba 10 00 18 mov %i0, %i5
if (!(((mode & O_ACCMODE) == O_RDONLY) || ((mode & O_ACCMODE) == O_RDWR)))
40009824: 80 8a 20 01 btst 1, %o0
40009828: 12 80 00 13 bne 40009874 <aio_read+0x64>
4000982c: b8 10 20 09 mov 9, %i4
rtems_aio_set_errno_return_minus_one (EBADF, aiocbp);
if (aiocbp->aio_reqprio < 0 || aiocbp->aio_reqprio > AIO_PRIO_DELTA_MAX)
40009830: c2 06 20 18 ld [ %i0 + 0x18 ], %g1
40009834: 80 a0 60 00 cmp %g1, 0
40009838: 32 80 00 0f bne,a 40009874 <aio_read+0x64>
4000983c: b8 10 20 16 mov 0x16, %i4
rtems_aio_set_errno_return_minus_one (EINVAL, aiocbp);
if (aiocbp->aio_offset < 0)
40009840: c2 06 20 08 ld [ %i0 + 8 ], %g1
40009844: 80 a0 60 00 cmp %g1, 0
40009848: 26 80 00 0b bl,a 40009874 <aio_read+0x64>
4000984c: b8 10 20 16 mov 0x16, %i4
rtems_aio_set_errno_return_minus_one (EINVAL, aiocbp);
req = malloc (sizeof (rtems_aio_request));
40009850: 7f ff e1 1c call 40001cc0 <malloc>
40009854: 90 10 20 18 mov 0x18, %o0
if (req == NULL)
40009858: b0 92 20 00 orcc %o0, 0, %i0
4000985c: 02 80 00 0e be 40009894 <aio_read+0x84> <== NEVER TAKEN
40009860: 82 10 20 01 mov 1, %g1
rtems_aio_set_errno_return_minus_one (EAGAIN, aiocbp);
req->aiocbp = aiocbp;
40009864: fa 26 20 14 st %i5, [ %i0 + 0x14 ]
req->aiocbp->aio_lio_opcode = LIO_READ;
40009868: c2 27 60 30 st %g1, [ %i5 + 0x30 ]
return rtems_aio_enqueue (req);
4000986c: 7f ff ff 61 call 400095f0 <rtems_aio_enqueue>
40009870: 81 e8 00 00 restore
rtems_aio_set_errno_return_minus_one (EAGAIN, aiocbp);
40009874: 82 10 3f ff mov -1, %g1
40009878: f8 27 60 34 st %i4, [ %i5 + 0x34 ]
}
4000987c: b0 10 3f ff mov -1, %i0
rtems_aio_set_errno_return_minus_one (EAGAIN, aiocbp);
40009880: 40 00 20 51 call 400119c4 <__errno>
40009884: c2 27 60 38 st %g1, [ %i5 + 0x38 ]
40009888: f8 22 00 00 st %i4, [ %o0 ]
}
4000988c: 81 c7 e0 08 ret
40009890: 81 e8 00 00 restore
rtems_aio_set_errno_return_minus_one (EAGAIN, aiocbp);
40009894: 10 bf ff f8 b 40009874 <aio_read+0x64> <== NOT EXECUTED
40009898: b8 10 20 0b mov 0xb, %i4 <== NOT EXECUTED
400098a4 <aio_write>:
* 0 - otherwise
*/
int
aio_write (struct aiocb *aiocbp)
{
400098a4: 9d e3 bf a0 save %sp, -96, %sp
rtems_aio_request *req;
int mode;
mode = fcntl (aiocbp->aio_fildes, F_GETFL);
400098a8: d0 06 00 00 ld [ %i0 ], %o0
400098ac: 40 00 00 92 call 40009af4 <fcntl>
400098b0: 92 10 20 03 mov 3, %o1
{
400098b4: ba 10 00 18 mov %i0, %i5
if (!(((mode & O_ACCMODE) == O_WRONLY) || ((mode & O_ACCMODE) == O_RDWR)))
400098b8: 90 0a 20 03 and %o0, 3, %o0
400098bc: 90 02 3f ff add %o0, -1, %o0
400098c0: 80 a2 20 01 cmp %o0, 1
400098c4: 18 80 00 13 bgu 40009910 <aio_write+0x6c>
400098c8: b8 10 20 09 mov 9, %i4
rtems_aio_set_errno_return_minus_one (EBADF, aiocbp);
if (aiocbp->aio_reqprio < 0 || aiocbp->aio_reqprio > AIO_PRIO_DELTA_MAX)
400098cc: c2 06 20 18 ld [ %i0 + 0x18 ], %g1
400098d0: 80 a0 60 00 cmp %g1, 0
400098d4: 32 80 00 0f bne,a 40009910 <aio_write+0x6c>
400098d8: b8 10 20 16 mov 0x16, %i4
rtems_aio_set_errno_return_minus_one (EINVAL, aiocbp);
if (aiocbp->aio_offset < 0)
400098dc: c2 06 20 08 ld [ %i0 + 8 ], %g1
400098e0: 80 a0 60 00 cmp %g1, 0
400098e4: 26 80 00 0b bl,a 40009910 <aio_write+0x6c>
400098e8: b8 10 20 16 mov 0x16, %i4
rtems_aio_set_errno_return_minus_one (EINVAL, aiocbp);
req = malloc (sizeof (rtems_aio_request));
400098ec: 7f ff e0 f5 call 40001cc0 <malloc>
400098f0: 90 10 20 18 mov 0x18, %o0
if (req == NULL)
400098f4: 80 a2 20 00 cmp %o0, 0
400098f8: 02 80 00 0e be 40009930 <aio_write+0x8c> <== NEVER TAKEN
400098fc: 82 10 20 02 mov 2, %g1
rtems_aio_set_errno_return_minus_one (EAGAIN, aiocbp);
req->aiocbp = aiocbp;
40009900: fa 22 20 14 st %i5, [ %o0 + 0x14 ]
req->aiocbp->aio_lio_opcode = LIO_WRITE;
40009904: c2 26 20 30 st %g1, [ %i0 + 0x30 ]
return rtems_aio_enqueue (req);
40009908: 7f ff ff 3a call 400095f0 <rtems_aio_enqueue>
4000990c: 91 e8 00 08 restore %g0, %o0, %o0
rtems_aio_set_errno_return_minus_one (EAGAIN, aiocbp);
40009910: 82 10 3f ff mov -1, %g1
40009914: f8 27 60 34 st %i4, [ %i5 + 0x34 ]
}
40009918: b0 10 3f ff mov -1, %i0
rtems_aio_set_errno_return_minus_one (EAGAIN, aiocbp);
4000991c: 40 00 20 2a call 400119c4 <__errno>
40009920: c2 27 60 38 st %g1, [ %i5 + 0x38 ]
40009924: f8 22 00 00 st %i4, [ %o0 ]
}
40009928: 81 c7 e0 08 ret
4000992c: 81 e8 00 00 restore
rtems_aio_set_errno_return_minus_one (EAGAIN, aiocbp);
40009930: 10 bf ff f8 b 40009910 <aio_write+0x6c> <== NOT EXECUTED
40009934: b8 10 20 0b mov 0xb, %i4 <== NOT EXECUTED
4000a2b8 <alarm>:
);
unsigned int alarm(
unsigned int seconds
)
{
4000a2b8: 9d e3 bf 98 save %sp, -104, %sp
uint64_t now;
uint32_t ticks_per_second;
uint32_t ticks;
the_watchdog = &_POSIX_signals_Alarm_watchdog;
ticks_per_second = TOD_TICKS_PER_SECOND;
4000a2bc: 40 00 07 f8 call 4000c29c <TOD_TICKS_PER_SECOND_method>
4000a2c0: 01 00 00 00 nop
4000a2c4: ba 10 00 08 mov %o0, %i5
ticks = seconds * ticks_per_second;
4000a2c8: b0 5a 00 18 smul %o0, %i0, %i0
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
4000a2cc: 91 d0 20 09 ta 9
&lock_context
);
cpu = _Watchdog_Get_CPU( the_watchdog );
_Watchdog_Per_CPU_acquire_critical( cpu, &lock_context2 );
now = cpu->Watchdog.ticks;
4000a2d0: 05 10 00 7b sethi %hi(0x4001ec00), %g2
expire = the_watchdog->expire;
4000a2d4: 37 10 00 71 sethi %hi(0x4001c400), %i3
4000a2d8: e0 18 a0 30 ldd [ %g2 + 0x30 ], %l0
4000a2dc: 84 16 e0 c8 or %i3, 0xc8, %g2
4000a2e0: c6 00 a0 18 ld [ %g2 + 0x18 ], %g3
if ( now < expire ) {
4000a2e4: 80 a0 c0 10 cmp %g3, %l0
4000a2e8: 18 80 00 1a bgu 4000a350 <alarm+0x98> <== NEVER TAKEN
4000a2ec: f8 00 a0 1c ld [ %g2 + 0x1c ], %i4
4000a2f0: 02 80 00 16 be 4000a348 <alarm+0x90> <== ALWAYS TAKEN
4000a2f4: 80 a7 00 11 cmp %i4, %l1
4000a2f8: c2 27 bf fc st %g1, [ %fp + -4 ] <== NOT EXECUTED
_Watchdog_Remove( header, the_watchdog );
4000a2fc: 92 16 e0 c8 or %i3, 0xc8, %o1
4000a300: 35 10 00 7b sethi %hi(0x4001ec00), %i2
4000a304: 7f ff fd bc call 400099f4 <_Watchdog_Remove>
4000a308: 90 16 a0 38 or %i2, 0x38, %o0 ! 4001ec38 <_Per_CPU_Information+0x38>
&cpu->Watchdog.Header[ PER_CPU_WATCHDOG_TICKS ],
the_watchdog,
now
);
if ( ticks != 0 ) {
4000a30c: c2 07 bf fc ld [ %fp + -4 ], %g1
4000a310: 80 a6 20 00 cmp %i0, 0
4000a314: 12 80 00 18 bne 4000a374 <alarm+0xbc>
4000a318: b8 10 20 00 clr %i4
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
4000a31c: 91 d0 20 0a ta 0xa
4000a320: 01 00 00 00 nop
_ISR_lock_Release_and_ISR_enable(
&_POSIX_signals_Alarm_lock,
&lock_context
);
return ( remaining + ticks_per_second - 1 ) / ticks_per_second;
4000a324: b0 07 7f ff add %i5, -1, %i0
4000a328: b0 06 00 1c add %i0, %i4, %i0
}
4000a32c: 81 80 20 00 wr %g0, %y
4000a330: 01 00 00 00 nop
4000a334: 01 00 00 00 nop
4000a338: 01 00 00 00 nop
4000a33c: b0 76 00 1d udiv %i0, %i5, %i0
4000a340: 81 c7 e0 08 ret
4000a344: 81 e8 00 00 restore
if ( now < expire ) {
4000a348: 28 bf ff ed bleu,a 4000a2fc <alarm+0x44>
4000a34c: c2 27 bf fc st %g1, [ %fp + -4 ]
remaining = expire - now;
4000a350: c2 27 bf fc st %g1, [ %fp + -4 ]
_Watchdog_Remove( header, the_watchdog );
4000a354: 92 16 e0 c8 or %i3, 0xc8, %o1
4000a358: 35 10 00 7b sethi %hi(0x4001ec00), %i2
4000a35c: 7f ff fd a6 call 400099f4 <_Watchdog_Remove>
4000a360: 90 16 a0 38 or %i2, 0x38, %o0 ! 4001ec38 <_Per_CPU_Information+0x38>
if ( ticks != 0 ) {
4000a364: c2 07 bf fc ld [ %fp + -4 ], %g1
4000a368: 80 a6 20 00 cmp %i0, 0
4000a36c: 02 bf ff ec be 4000a31c <alarm+0x64>
4000a370: b8 27 00 11 sub %i4, %l1, %i4
_Watchdog_Insert(
4000a374: 96 84 40 18 addcc %l1, %i0, %o3
4000a378: 92 16 e0 c8 or %i3, 0xc8, %o1
4000a37c: 94 44 20 00 addx %l0, 0, %o2
4000a380: 7f ff fd 6a call 40009928 <_Watchdog_Insert>
4000a384: 90 16 a0 38 or %i2, 0x38, %o0
4000a388: c2 07 bf fc ld [ %fp + -4 ], %g1
4000a38c: 91 d0 20 0a ta 0xa
4000a390: 01 00 00 00 nop
return ( remaining + ticks_per_second - 1 ) / ticks_per_second;
4000a394: b0 07 7f ff add %i5, -1, %i0
4000a398: b0 06 00 1c add %i0, %i4, %i0
}
4000a39c: 81 80 20 00 wr %g0, %y
4000a3a0: 01 00 00 00 nop
4000a3a4: 01 00 00 00 nop
4000a3a8: 01 00 00 00 nop
4000a3ac: b0 76 00 1d udiv %i0, %i5, %i0
4000a3b0: 81 c7 e0 08 ret
4000a3b4: 81 e8 00 00 restore
40010548 <clock_nanosleep>:
clockid_t clock_id,
int flags,
const struct timespec *rqtp,
struct timespec *rmtp
)
{
40010548: 9d e3 bf 58 save %sp, -168, %sp
struct timespec uptime;
const struct timespec *end;
Thread_Control *executing;
int eno;
if ( clock_id != CLOCK_REALTIME && clock_id != CLOCK_MONOTONIC ) {
4001054c: 80 a6 20 01 cmp %i0, 1
40010550: 02 80 00 04 be 40010560 <clock_nanosleep+0x18> <== ALWAYS TAKEN
40010554: 80 a6 20 04 cmp %i0, 4
40010558: 12 80 00 26 bne 400105f0 <clock_nanosleep+0xa8> <== NOT EXECUTED
4001055c: ba 10 20 86 mov 0x86, %i5 <== NOT EXECUTED
queue_context->thread_state = thread_state;
40010560: 03 04 00 00 sethi %hi(0x10000000), %g1
40010564: 82 10 61 00 or %g1, 0x100, %g1 ! 10000100 <RAM_SIZE+0xfc00100>
_Thread_queue_Context_set_thread_state(
&queue_context,
STATES_WAITING_FOR_TIME | STATES_INTERRUPTIBLE_BY_SIGNAL
);
if ( ( flags & TIMER_ABSTIME ) != 0 ) {
40010568: b2 8e 60 04 andcc %i1, 4, %i1
4001056c: 02 80 00 2b be 40010618 <clock_nanosleep+0xd0>
40010570: c2 27 bf e0 st %g1, [ %fp + -32 ]
end = rqtp;
if ( clock_id == CLOCK_REALTIME ) {
40010574: 80 a6 20 01 cmp %i0, 1
40010578: 02 80 00 55 be 400106cc <clock_nanosleep+0x184> <== ALWAYS TAKEN
4001057c: f4 27 bf e8 st %i2, [ %fp + -24 ]
queue_context->enqueue_callout =
40010580: 03 10 00 25 sethi %hi(0x40009400), %g1
40010584: 82 10 60 08 or %g1, 8, %g1 ! 40009408 <_Thread_queue_Add_timeout_monotonic_timespec>
40010588: c2 27 bf e4 st %g1, [ %fp + -28 ]
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
4001058c: 91 d0 20 09 ta 9
_ISR_lock_ISR_disable( &queue_context->Lock_context.Lock_context );
40010590: c2 27 bf dc st %g1, [ %fp + -36 ]
end
);
}
_Thread_queue_Acquire( &_Nanosleep_Pseudo_queue, &queue_context );
executing = _Thread_Executing;
40010594: fa 01 a0 20 ld [ %g6 + 0x20 ], %i5
_Thread_queue_Enqueue(
40010598: 94 10 00 1d mov %i5, %o2
4001059c: 96 07 bf dc add %fp, -36, %o3
400105a0: 13 10 00 44 sethi %hi(0x40011000), %o1
400105a4: 11 10 00 4f sethi %hi(0x40013c00), %o0
400105a8: 92 12 63 f0 or %o1, 0x3f0, %o1
400105ac: 7f ff e0 13 call 400085f8 <_Thread_queue_Enqueue>
400105b0: 90 12 20 a0 or %o0, 0xa0, %o0
if ( eno == ETIMEDOUT ) {
eno = 0;
}
if ( rmtp != NULL && ( flags & TIMER_ABSTIME ) == 0 ) {
400105b4: 80 a0 00 19 cmp %g0, %i1
return _POSIX_Get_by_name_error_table[ error ];
}
RTEMS_INLINE_ROUTINE int _POSIX_Get_error( Status_Control status )
{
return STATUS_GET_POSIX( status );
400105b8: f0 07 60 4c ld [ %i5 + 0x4c ], %i0
400105bc: 82 60 3f ff subx %g0, -1, %g1
400105c0: 80 a0 00 1b cmp %g0, %i3
400105c4: bb 3e 20 1f sra %i0, 0x1f, %i5
400105c8: 84 40 20 00 addx %g0, 0, %g2
400105cc: ba 0f 60 ff and %i5, 0xff, %i5
400105d0: ba 07 40 18 add %i5, %i0, %i5
400105d4: bb 3f 60 08 sra %i5, 8, %i5
if ( eno == ETIMEDOUT ) {
400105d8: 80 a7 60 74 cmp %i5, 0x74
400105dc: 02 80 00 07 be 400105f8 <clock_nanosleep+0xb0>
400105e0: 82 08 40 02 and %g1, %g2, %g1
if ( rmtp != NULL && ( flags & TIMER_ABSTIME ) == 0 ) {
400105e4: 80 a0 60 00 cmp %g1, 0
400105e8: 12 80 00 2a bne 40010690 <clock_nanosleep+0x148>
400105ec: 80 a7 60 04 cmp %i5, 4
_Timespec_Set_to_zero( rmtp );
}
}
return eno;
}
400105f0: 81 c7 e0 08 ret
400105f4: 91 e8 00 1d restore %g0, %i5, %o0
if ( rmtp != NULL && ( flags & TIMER_ABSTIME ) == 0 ) {
400105f8: 80 a0 60 00 cmp %g1, 0
400105fc: 02 bf ff fd be 400105f0 <clock_nanosleep+0xa8>
40010600: ba 10 20 00 clr %i5
_Timespec_Set_to_zero( rmtp );
40010604: c0 26 e0 08 clr [ %i3 + 8 ]
40010608: c0 26 c0 00 clr [ %i3 ]
4001060c: c0 26 e0 04 clr [ %i3 + 4 ]
}
40010610: 81 c7 e0 08 ret
40010614: 91 e8 00 1d restore %g0, %i5, %o0
_Timecounter_Nanouptime( &uptime );
40010618: 7f ff dc 3d call 4000770c <_Timecounter_Nanouptime>
4001061c: 90 07 bf b8 add %fp, -72, %o0
&& (unsigned long) ts->tv_nsec < WATCHDOG_NANOSECONDS_PER_SECOND;
40010620: 80 a6 a0 00 cmp %i2, 0
40010624: 02 80 00 19 be 40010688 <clock_nanosleep+0x140>
40010628: 05 0e e6 b2 sethi %hi(0x3b9ac800), %g2
4001062c: c2 06 a0 08 ld [ %i2 + 8 ], %g1
40010630: 84 10 a1 ff or %g2, 0x1ff, %g2
40010634: 80 a0 40 02 cmp %g1, %g2
40010638: 38 80 00 2a bgu,a 400106e0 <clock_nanosleep+0x198>
4001063c: b4 10 20 00 clr %i2
return _Watchdog_Is_valid_timespec( ts ) && ts->tv_sec >= 0;
40010640: d4 1e 80 00 ldd [ %i2 ], %o2
40010644: 80 a2 a0 00 cmp %o2, 0
40010648: 06 80 00 25 bl 400106dc <clock_nanosleep+0x194>
4001064c: f8 1f bf b8 ldd [ %fp + -72 ], %i4
sec += (uint64_t) delta->tv_sec;
40010650: 9a 82 c0 1d addcc %o3, %i5, %o5
now->tv_nsec += delta->tv_nsec;
40010654: c6 07 bf c0 ld [ %fp + -64 ], %g3
sec += (uint64_t) delta->tv_sec;
40010658: 98 42 80 1c addx %o2, %i4, %o4
now->tv_nsec += delta->tv_nsec;
4001065c: 82 00 40 03 add %g1, %g3, %g1
if ( now->tv_nsec >= WATCHDOG_NANOSECONDS_PER_SECOND ) {
40010660: 80 a0 40 02 cmp %g1, %g2
40010664: 14 80 00 21 bg 400106e8 <clock_nanosleep+0x1a0>
40010668: 05 31 19 4d sethi %hi(0xc4653400), %g2
now->tv_nsec += delta->tv_nsec;
4001066c: c2 27 bf c0 st %g1, [ %fp + -64 ]
if ( sec <= INT64_MAX ) {
40010670: 80 a3 20 00 cmp %o4, 0
40010674: 06 80 00 23 bl 40010700 <clock_nanosleep+0x1b8>
40010678: 05 1f ff ff sethi %hi(0x7ffffc00), %g2
now->tv_sec = sec;
4001067c: d8 27 bf b8 st %o4, [ %fp + -72 ]
return now;
40010680: b4 07 bf b8 add %fp, -72, %i2
now->tv_sec = sec;
40010684: da 27 bf bc st %o5, [ %fp + -68 ]
queue_context->Timeout.arg = abstime;
40010688: 10 bf ff be b 40010580 <clock_nanosleep+0x38>
4001068c: f4 27 bf e8 st %i2, [ %fp + -24 ]
if ( eno == EINTR ) {
40010690: 32 bf ff de bne,a 40010608 <clock_nanosleep+0xc0>
40010694: c0 26 e0 08 clr [ %i3 + 8 ]
_Timecounter_Nanouptime( &actual_end );
40010698: 7f ff dc 1d call 4000770c <_Timecounter_Nanouptime>
4001069c: 90 07 bf c8 add %fp, -56, %o0
if ( _Timespec_Less_than( &actual_end, end ) ) {
400106a0: 92 10 00 1a mov %i2, %o1
400106a4: 40 00 00 2d call 40010758 <_Timespec_Less_than>
400106a8: 90 07 bf c8 add %fp, -56, %o0
400106ac: 80 a2 20 00 cmp %o0, 0
400106b0: 22 bf ff d6 be,a 40010608 <clock_nanosleep+0xc0>
400106b4: c0 26 e0 08 clr [ %i3 + 8 ]
_Timespec_Subtract( &actual_end, end, rmtp );
400106b8: 94 10 00 1b mov %i3, %o2
400106bc: 92 10 00 1a mov %i2, %o1
400106c0: 40 00 00 44 call 400107d0 <_Timespec_Subtract>
400106c4: 90 07 bf c8 add %fp, -56, %o0
400106c8: 30 bf ff ca b,a 400105f0 <clock_nanosleep+0xa8>
queue_context->enqueue_callout = _Thread_queue_Add_timeout_realtime_timespec;
400106cc: 03 10 00 25 sethi %hi(0x40009400), %g1
400106d0: 82 10 60 30 or %g1, 0x30, %g1 ! 40009430 <_Thread_queue_Add_timeout_realtime_timespec>
}
400106d4: 10 bf ff ae b 4001058c <clock_nanosleep+0x44>
400106d8: c2 27 bf e4 st %g1, [ %fp + -28 ]
return NULL;
400106dc: b4 10 20 00 clr %i2
queue_context->Timeout.arg = abstime;
400106e0: 10 bf ff a8 b 40010580 <clock_nanosleep+0x38>
400106e4: f4 27 bf e8 st %i2, [ %fp + -24 ]
++sec;
400106e8: 9a 83 60 01 inccc %o5
now->tv_nsec -= WATCHDOG_NANOSECONDS_PER_SECOND;
400106ec: 84 10 a2 00 or %g2, 0x200, %g2
++sec;
400106f0: 98 43 20 00 addx %o4, 0, %o4
now->tv_nsec -= WATCHDOG_NANOSECONDS_PER_SECOND;
400106f4: 82 00 40 02 add %g1, %g2, %g1
400106f8: 10 bf ff de b 40010670 <clock_nanosleep+0x128>
400106fc: c2 27 bf c0 st %g1, [ %fp + -64 ]
now->tv_sec = INT64_MAX;
40010700: 86 10 3f ff mov -1, %g3
40010704: 84 10 a3 ff or %g2, 0x3ff, %g2
return now;
40010708: b4 07 bf b8 add %fp, -72, %i2
now->tv_sec = INT64_MAX;
4001070c: c4 3f bf b8 std %g2, [ %fp + -72 ]
40010710: 10 bf ff 9c b 40010580 <clock_nanosleep+0x38>
40010714: f4 27 bf e8 st %i2, [ %fp + -24 ]
40011a6c <clock_settime>:
int clock_settime(
clockid_t clock_id,
const struct timespec *tp
)
{
40011a6c: 9d e3 bf 98 save %sp, -104, %sp
Status_Control status;
if ( !tp )
40011a70: 80 a6 60 00 cmp %i1, 0
40011a74: 02 80 00 29 be 40011b18 <clock_settime+0xac> <== NEVER TAKEN
40011a78: 80 a6 20 01 cmp %i0, 1
rtems_set_errno_and_return_minus_one( EINVAL );
if ( clock_id == CLOCK_REALTIME ) {
40011a7c: 02 80 00 12 be 40011ac4 <clock_settime+0x58>
40011a80: 80 a6 20 02 cmp %i0, 2
if ( status != STATUS_SUCCESSFUL ) {
rtems_set_errno_and_return_minus_one( STATUS_GET_POSIX( status ) );
}
}
#ifdef _POSIX_CPUTIME
else if ( clock_id == CLOCK_PROCESS_CPUTIME_ID ) {
40011a84: 02 80 00 0a be 40011aac <clock_settime+0x40>
40011a88: 80 a6 20 03 cmp %i0, 3
rtems_set_errno_and_return_minus_one( ENOSYS );
}
#endif
#ifdef _POSIX_THREAD_CPUTIME
else if ( clock_id == CLOCK_THREAD_CPUTIME_ID ) {
40011a8c: 02 80 00 08 be 40011aac <clock_settime+0x40>
40011a90: 01 00 00 00 nop
rtems_set_errno_and_return_minus_one( ENOSYS );
}
#endif
else {
rtems_set_errno_and_return_minus_one( EINVAL );
40011a94: 40 00 ea 20 call 4004c314 <__errno>
40011a98: b0 10 3f ff mov -1, %i0 ! ffffffff <RAM_END+0xbfbfffff>
40011a9c: 82 10 20 16 mov 0x16, %g1
40011aa0: c2 22 00 00 st %g1, [ %o0 ]
}
return 0;
}
40011aa4: 81 c7 e0 08 ret
40011aa8: 81 e8 00 00 restore
rtems_set_errno_and_return_minus_one( ENOSYS );
40011aac: 40 00 ea 1a call 4004c314 <__errno>
40011ab0: b0 10 3f ff mov -1, %i0
40011ab4: 82 10 20 58 mov 0x58, %g1
40011ab8: c2 22 00 00 st %g1, [ %o0 ]
40011abc: 81 c7 e0 08 ret
40011ac0: 81 e8 00 00 restore
_TOD_Lock();
40011ac4: 40 00 09 53 call 40014010 <_TOD_Lock>
40011ac8: 01 00 00 00 nop
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
40011acc: 91 d0 20 09 ta 9
_Timecounter_Acquire( lock_context );
40011ad0: c2 27 bf fc st %g1, [ %fp + -4 ]
status = _TOD_Set( tp, &lock_context );
40011ad4: 92 07 bf fc add %fp, -4, %o1
40011ad8: 40 00 09 70 call 40014098 <_TOD_Set>
40011adc: 90 10 00 19 mov %i1, %o0
_TOD_Unlock();
40011ae0: 40 00 09 51 call 40014024 <_TOD_Unlock>
40011ae4: b0 10 00 08 mov %o0, %i0
if ( status != STATUS_SUCCESSFUL ) {
40011ae8: 80 a6 20 00 cmp %i0, 0
40011aec: 02 80 00 0f be 40011b28 <clock_settime+0xbc>
40011af0: 01 00 00 00 nop
rtems_set_errno_and_return_minus_one( STATUS_GET_POSIX( status ) );
40011af4: 40 00 ea 08 call 4004c314 <__errno>
40011af8: 01 00 00 00 nop
40011afc: 83 3e 20 1f sra %i0, 0x1f, %g1
40011b00: 82 08 60 ff and %g1, 0xff, %g1
40011b04: 82 00 40 18 add %g1, %i0, %g1
40011b08: 83 38 60 08 sra %g1, 8, %g1
40011b0c: c2 22 00 00 st %g1, [ %o0 ]
40011b10: 81 c7 e0 08 ret
40011b14: 91 e8 3f ff restore %g0, -1, %o0
rtems_set_errno_and_return_minus_one( EINVAL );
40011b18: 40 00 e9 ff call 4004c314 <__errno> <== NOT EXECUTED
40011b1c: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
40011b20: 82 10 20 16 mov 0x16, %g1 <== NOT EXECUTED
40011b24: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
40011b28: 81 c7 e0 08 ret
40011b2c: 81 e8 00 00 restore
400050e4 <mmap>:
CHAIN_DEFINE_EMPTY( mmap_mappings );
void *mmap(
void *addr, size_t len, int prot, int flags, int fildes, off_t off
)
{
400050e4: 9d e3 bf 30 save %sp, -208, %sp
400050e8: fa 27 a0 58 st %i5, [ %fp + 0x58 ]
400050ec: a0 10 00 1d mov %i5, %l0
map_anonymous = (flags & MAP_ANON) == MAP_ANON;
map_shared = (flags & MAP_SHARED) == MAP_SHARED;
map_private = (flags & MAP_PRIVATE) == MAP_PRIVATE;
/* Clear errno. */
errno = 0;
400050f0: 40 00 2f 6a call 40010e98 <__errno>
400050f4: e2 07 a0 5c ld [ %fp + 0x5c ], %l1
iop = NULL;
if ( len == 0 ) {
400050f8: 80 a6 60 00 cmp %i1, 0
400050fc: 02 80 00 5c be 4000526c <mmap+0x188> <== NEVER TAKEN
40005100: c0 22 00 00 clr [ %o0 ]
/*
* We can provide read, write and execute because the memory in RTEMS does
* not normally have protections but we cannot hide access to memory.
*/
if ( prot == PROT_NONE ) {
40005104: 80 a6 a0 00 cmp %i2, 0
40005108: 02 80 00 b5 be 400053dc <mmap+0x2f8> <== NEVER TAKEN
4000510c: 80 8e a0 02 btst 2, %i2
/*
* We can not normally provide restriction of write access. Reject any
* attempt to map without write permission, since we are not able to
* prevent a write from succeeding.
*/
if ( PROT_WRITE != (prot & PROT_WRITE) ) {
40005110: 02 80 00 b3 be 400053dc <mmap+0x2f8>
40005114: 01 00 00 00 nop
map_anonymous = (flags & MAP_ANON) == MAP_ANON;
40005118: 3b 00 00 04 sethi %hi(0x1000), %i5
map_fixed = (flags & MAP_FIXED) == MAP_FIXED;
4000511c: aa 0e e0 10 and %i3, 0x10, %l5
map_shared = (flags & MAP_SHARED) == MAP_SHARED;
40005120: a8 0e e0 01 and %i3, 1, %l4
/*
* Anonymous mappings must have file descriptor set to -1 and the offset
* set to 0. Shared mappings are not supported with Anonymous mappings at
* this time
*/
if ( map_anonymous && (fildes != -1 || off != 0 || map_shared) ) {
40005124: ba 8e c0 1d andcc %i3, %i5, %i5
40005128: 12 80 00 48 bne 40005248 <mmap+0x164>
4000512c: 84 0e e0 02 and %i3, 2, %g2
flags |= MAP_PRIVATE;
map_private = true;
}
/* Check for supported flags */
if ((flags & ~(MAP_SHARED | MAP_PRIVATE | MAP_FIXED | MAP_ANON)) != 0) {
40005130: 03 3f ff fb sethi %hi(0xffffec00), %g1
40005134: 82 10 63 ec or %g1, 0x3ec, %g1 ! ffffefec <RAM_END+0xbfbfefec>
40005138: 80 8e c0 01 btst %i3, %g1
4000513c: 12 80 00 4c bne 4000526c <mmap+0x188> <== NEVER TAKEN
40005140: 80 a5 20 00 cmp %l4, 0
errno = EINVAL;
return MAP_FAILED;
}
/* Either MAP_SHARED or MAP_PRIVATE must be defined, but not both */
if ( map_shared ) {
40005144: 12 80 00 51 bne 40005288 <mmap+0x1a4>
40005148: 80 a0 a0 00 cmp %g2, 0
if ( map_private ) {
errno = EINVAL;
return MAP_FAILED;
}
} else if ( !map_private ) {
4000514c: 02 80 00 48 be 4000526c <mmap+0x188>
40005150: 80 a5 60 00 cmp %l5, 0
errno = EINVAL;
return MAP_FAILED;
}
/* Check for illegal addresses. Watch out for address wrap. */
if ( map_fixed ) {
40005154: 02 80 00 09 be 40005178 <mmap+0x94>
40005158: a6 10 20 01 mov 1, %l3
if ((uintptr_t)addr & PAGE_MASK) {
4000515c: 80 8e 2f ff btst 0xfff, %i0
40005160: 12 80 00 43 bne 4000526c <mmap+0x188>
40005164: 80 a6 20 00 cmp %i0, 0
errno = EINVAL;
return MAP_FAILED;
}
if ( addr == NULL ) {
40005168: 02 80 00 41 be 4000526c <mmap+0x188>
4000516c: 80 a6 60 00 cmp %i1, 0
errno = EINVAL;
return MAP_FAILED;
}
if (addr + len < addr) {
40005170: 06 80 00 3f bl 4000526c <mmap+0x188> <== NEVER TAKEN
40005174: 01 00 00 00 nop
errno = EINVAL;
return MAP_FAILED;
}
}
if ( !map_anonymous ) {
40005178: 80 a7 60 00 cmp %i5, 0
4000517c: 02 80 00 47 be 40005298 <mmap+0x1b4>
40005180: 92 10 20 01 mov 1, %o1
return MAP_FAILED;
}
}
/* Create the mapping */
mapping = malloc( sizeof( mmap_mapping ));
40005184: 40 00 11 a3 call 40009810 <calloc>
40005188: 90 10 20 18 mov 0x18, %o0
if ( !mapping ) {
4000518c: ac 92 20 00 orcc %o0, 0, %l6
40005190: 02 80 00 b6 be 40005468 <mmap+0x384> <== NEVER TAKEN
40005194: 80 a5 60 00 cmp %l5, 0
errno = ENOMEM;
return MAP_FAILED;
}
memset( mapping, 0, sizeof( mmap_mapping ));
mapping->len = len;
40005198: f2 25 a0 0c st %i1, [ %l6 + 0xc ]
}
} else {
is_shared_shm = false;
}
if ( map_fixed ) {
4000519c: 02 80 00 d8 be 400054fc <mmap+0x418>
400051a0: f6 25 a0 10 st %i3, [ %l6 + 0x10 ]
mapping->addr = addr;
400051a4: f0 25 a0 08 st %i0, [ %l6 + 8 ]
iop = NULL;
400051a8: a4 10 20 00 clr %l2
extern rtems_chain_control mmap_mappings;
static inline void mmap_mappings_lock_obtain( void )
{
rtems_libio_lock();
400051ac: 7f ff f3 64 call 40001f3c <rtems_libio_lock>
400051b0: 37 10 00 6f sethi %hi(0x4001bc00), %i3
return _Chain_Immutable_head( the_chain )->next;
400051b4: c2 06 e1 84 ld [ %i3 + 0x184 ], %g1 ! 4001bd84 <mmap_mappings>
400051b8: b6 16 e1 84 or %i3, 0x184, %i3
mmap_mappings_lock_obtain();
if ( map_fixed ) {
rtems_chain_node* node = rtems_chain_first (&mmap_mappings);
while ( !rtems_chain_is_tail( &mmap_mappings, node )) {
400051bc: 86 06 e0 04 add %i3, 4, %g3
400051c0: 80 a0 40 03 cmp %g1, %g3
400051c4: 02 80 00 10 be 40005204 <mmap+0x120>
400051c8: 80 8c e0 ff btst 0xff, %l3
* point in time if there is an overlap in the mappings we return an
* error. POSIX allows us to also return successfully by unmapping
* the overlapping prior mappings.
*/
current_mapping = (mmap_mapping*) node;
if ( ( addr >= current_mapping->addr ) &&
400051cc: c4 00 60 08 ld [ %g1 + 8 ], %g2
400051d0: 80 a0 80 18 cmp %g2, %i0
400051d4: 38 80 00 08 bgu,a 400051f4 <mmap+0x110>
400051d8: c2 00 40 00 ld [ %g1 ], %g1
( addr < ( current_mapping->addr + current_mapping->len )) ) {
400051dc: c8 00 60 0c ld [ %g1 + 0xc ], %g4
400051e0: 84 00 80 04 add %g2, %g4, %g2
if ( ( addr >= current_mapping->addr ) &&
400051e4: 80 a6 00 02 cmp %i0, %g2
400051e8: 0a 80 00 f1 bcs 400055ac <mmap+0x4c8> <== NEVER TAKEN
400051ec: 01 00 00 00 nop
return the_node->next;
400051f0: c2 00 40 00 ld [ %g1 ], %g1
while ( !rtems_chain_is_tail( &mmap_mappings, node )) {
400051f4: 80 a0 40 03 cmp %g1, %g3
400051f8: 32 bf ff f6 bne,a 400051d0 <mmap+0xec>
400051fc: c4 00 60 08 ld [ %g1 + 8 ], %g2
node = rtems_chain_next( node );
}
}
/* Populate the data */
if ( map_private ) {
40005200: 80 8c e0 ff btst 0xff, %l3
40005204: 02 80 01 27 be 400056a0 <mmap+0x5bc> <== NEVER TAKEN
40005208: 80 a7 60 00 cmp %i5, 0
if ( !map_anonymous ) {
4000520c: 02 80 00 f2 be 400055d4 <mmap+0x4f0>
40005210: 80 a5 60 00 cmp %l5, 0
}
free( mapping );
errno = ENXIO;
return MAP_FAILED;
}
} else if ( !map_fixed ) {
40005214: 22 80 01 08 be,a 40005634 <mmap+0x550>
40005218: d0 05 a0 08 ld [ %l6 + 8 ], %o0
4000521c: 07 10 00 6f sethi %hi(0x4001bc00), %g3
40005220: 86 10 e1 88 or %g3, 0x188, %g3 ! 4001bd88 <mmap_mappings+0x4>
40005224: b6 00 ff fc add %g3, -4, %i3
old_last = tail->previous;
40005228: c2 06 e0 08 ld [ %i3 + 8 ], %g1
the_node->next = tail;
4000522c: c6 25 80 00 st %g3, [ %l6 ]
tail->previous = the_node;
40005230: ec 26 e0 08 st %l6, [ %i3 + 8 ]
old_last->next = the_node;
40005234: ec 20 40 00 st %l6, [ %g1 ]
}
static inline void mmap_mappings_lock_release( void )
{
rtems_libio_unlock();
40005238: 7f ff f3 46 call 40001f50 <rtems_libio_unlock>
4000523c: c2 25 a0 04 st %g1, [ %l6 + 4 ]
rtems_chain_append_unprotected( &mmap_mappings, &mapping->node );
mmap_mappings_lock_release( );
return mapping->addr;
40005240: 10 80 00 10 b 40005280 <mmap+0x19c>
40005244: c2 05 a0 08 ld [ %l6 + 8 ], %g1
if ( map_anonymous && (fildes != -1 || off != 0 || map_shared) ) {
40005248: 82 38 00 1c xnor %g0, %i4, %g1
4000524c: 80 a0 00 01 cmp %g0, %g1
40005250: 82 14 00 11 or %l0, %l1, %g1
40005254: 86 40 20 00 addx %g0, 0, %g3
40005258: 80 a0 00 01 cmp %g0, %g1
4000525c: 82 40 20 00 addx %g0, 0, %g1
40005260: 80 90 c0 01 orcc %g3, %g1, %g0
40005264: 02 80 00 65 be 400053f8 <mmap+0x314>
40005268: 80 a5 20 00 cmp %l4, 0
errno = EINVAL;
4000526c: 40 00 2f 0b call 40010e98 <__errno>
40005270: 01 00 00 00 nop
40005274: 84 10 20 16 mov 0x16, %g2 ! 16 <_TLS_Alignment+0x15>
40005278: c4 22 00 00 st %g2, [ %o0 ]
return MAP_FAILED;
4000527c: 82 10 3f ff mov -1, %g1
}
40005280: 81 c7 e0 08 ret
40005284: 91 e8 00 01 restore %g0, %g1, %o0
if ( map_private ) {
40005288: 12 bf ff f9 bne 4000526c <mmap+0x188>
4000528c: 80 a5 60 00 cmp %l5, 0
if ( map_fixed ) {
40005290: 12 bf ff b3 bne 4000515c <mmap+0x78> <== NEVER TAKEN
40005294: a6 10 20 00 clr %l3
if ( fstat( fildes, &sb ) < 0 ) {
40005298: 92 07 bf 98 add %fp, -104, %o1
4000529c: 40 00 11 c8 call 400099bc <fstat>
400052a0: 90 10 00 1c mov %i4, %o0
400052a4: 80 a2 20 00 cmp %o0, 0
400052a8: 06 80 00 bb bl 40005594 <mmap+0x4b0> <== NEVER TAKEN
400052ac: ee 07 bf a8 ld [ %fp + -88 ], %l7
if ( S_ISDIR( sb.st_mode ) || S_ISLNK( sb.st_mode )) {
400052b0: 03 00 00 3c sethi %hi(0xf000), %g1
400052b4: ae 0d c0 01 and %l7, %g1, %l7
return &rtems_libio_iops[ fd ];
400052b8: 03 10 00 75 sethi %hi(0x4001d400), %g1
400052bc: 82 10 63 28 or %g1, 0x328, %g1 ! 4001d728 <rtems_libio_iops>
400052c0: a5 2f 20 01 sll %i4, 1, %l2
400052c4: a4 04 80 1c add %l2, %i4, %l2
400052c8: a5 2c a0 04 sll %l2, 4, %l2
400052cc: a4 04 80 01 add %l2, %g1, %l2
400052d0: 03 00 00 10 sethi %hi(0x4000), %g1
400052d4: 80 a5 c0 01 cmp %l7, %g1
400052d8: 02 80 00 a9 be 4000557c <mmap+0x498> <== NEVER TAKEN
400052dc: 01 00 00 00 nop
400052e0: 03 00 00 28 sethi %hi(0xa000), %g1
400052e4: 80 a5 c0 01 cmp %l7, %g1
400052e8: 02 80 00 a5 be 4000557c <mmap+0x498> <== NEVER TAKEN
400052ec: 01 00 00 00 nop
if ( S_ISREG( sb.st_mode )
400052f0: 03 00 00 20 sethi %hi(0x8000), %g1
400052f4: 80 a5 c0 01 cmp %l7, %g1
400052f8: 02 80 00 62 be 40005480 <mmap+0x39c> <== NEVER TAKEN
400052fc: 03 00 00 08 sethi %hi(0x2000), %g1
if ( !S_ISCHR( sb.st_mode ) && sb.st_size < off + len ) {
40005300: 80 a5 c0 01 cmp %l7, %g1
40005304: 02 80 00 74 be 400054d4 <mmap+0x3f0>
40005308: 86 84 40 19 addcc %l1, %i1, %g3
4000530c: c2 07 bf c0 ld [ %fp + -64 ], %g1
&& (( off >= sb.st_size ) || (( off + len ) >= sb.st_size ))) {
40005310: 84 44 20 00 addx %l0, 0, %g2
if ( !S_ISCHR( sb.st_mode ) && sb.st_size < off + len ) {
40005314: 80 a0 40 02 cmp %g1, %g2
40005318: 06 80 00 bd bl 4000560c <mmap+0x528> <== NEVER TAKEN
4000531c: 01 00 00 00 nop
40005320: 02 80 00 d9 be 40005684 <mmap+0x5a0> <== ALWAYS TAKEN
40005324: c2 07 bf c4 ld [ %fp + -60 ], %g1
if ( S_ISREG( sb.st_mode ) || S_ISBLK( sb.st_mode ) ) {
40005328: 03 3f ff e8 sethi %hi(0xffffa000), %g1 <== NOT EXECUTED
4000532c: 05 3f ff f4 sethi %hi(0xffffd000), %g2
40005330: 82 05 c0 01 add %l7, %g1, %g1
40005334: 80 88 40 02 btst %g1, %g2
40005338: 02 80 00 5b be 400054a4 <mmap+0x3c0> <== NEVER TAKEN
4000533c: 03 00 00 08 sethi %hi(0x2000), %g1
if ( S_ISCHR( sb.st_mode ) && map_private ) {
40005340: 82 1d c0 01 xor %l7, %g1, %g1
40005344: 80 a0 00 01 cmp %g0, %g1
40005348: 84 60 3f ff subx %g0, -1, %g2
4000534c: 88 10 00 02 mov %g2, %g4
40005350: c8 2f bf 97 stb %g4, [ %fp + -105 ]
mapping = malloc( sizeof( mmap_mapping ));
40005354: 92 10 20 01 mov 1, %o1
40005358: 40 00 11 2e call 40009810 <calloc>
4000535c: 90 10 20 18 mov 0x18, %o0
if ( !mapping ) {
40005360: ac 92 20 00 orcc %o0, 0, %l6
40005364: 02 80 00 41 be 40005468 <mmap+0x384> <== NEVER TAKEN
40005368: c8 0f bf 97 ldub [ %fp + -105 ], %g4
if ( S_ISREG( sb.st_mode ) || S_ISBLK( sb.st_mode ) ||
4000536c: 03 00 00 18 sethi %hi(0x6000), %g1
S_ISCHR( sb.st_mode ) || S_ISFIFO( sb.st_mode ) ||
40005370: 07 00 00 04 sethi %hi(0x1000), %g3
if ( S_ISREG( sb.st_mode ) || S_ISBLK( sb.st_mode ) ||
40005374: 82 1d c0 01 xor %l7, %g1, %g1
S_ISCHR( sb.st_mode ) || S_ISFIFO( sb.st_mode ) ||
40005378: 86 1d c0 03 xor %l7, %g3, %g3
if ( S_ISREG( sb.st_mode ) || S_ISBLK( sb.st_mode ) ||
4000537c: 80 a0 00 01 cmp %g0, %g1
mapping->flags = flags;
40005380: f6 25 a0 10 st %i3, [ %l6 + 0x10 ]
if ( S_ISREG( sb.st_mode ) || S_ISBLK( sb.st_mode ) ||
40005384: 82 60 3f ff subx %g0, -1, %g1
mapping->len = len;
40005388: f2 25 a0 0c st %i1, [ %l6 + 0xc ]
S_ISCHR( sb.st_mode ) || S_ISFIFO( sb.st_mode ) ||
4000538c: 80 a0 00 03 cmp %g0, %g3
if ( S_ISREG( sb.st_mode ) || S_ISBLK( sb.st_mode ) ||
40005390: 07 00 00 2c sethi %hi(0xb000), %g3
S_ISCHR( sb.st_mode ) || S_ISFIFO( sb.st_mode ) ||
40005394: 84 60 3f ff subx %g0, -1, %g2
if ( S_ISREG( sb.st_mode ) || S_ISBLK( sb.st_mode ) ||
40005398: ae 0d c0 03 and %l7, %g3, %l7
4000539c: 07 00 00 20 sethi %hi(0x8000), %g3
400053a0: ae 1d c0 03 xor %l7, %g3, %l7
400053a4: 80 a0 00 17 cmp %g0, %l7
S_ISCHR( sb.st_mode ) || S_ISFIFO( sb.st_mode ) ||
400053a8: 84 10 40 02 or %g1, %g2, %g2
if ( S_ISREG( sb.st_mode ) || S_ISBLK( sb.st_mode ) ||
400053ac: 82 60 3f ff subx %g0, -1, %g1
S_ISCHR( sb.st_mode ) || S_ISFIFO( sb.st_mode ) ||
400053b0: 84 10 80 04 or %g2, %g4, %g2
if ( map_fixed ) {
400053b4: 80 a5 60 00 cmp %l5, 0
S_ISCHR( sb.st_mode ) || S_ISFIFO( sb.st_mode ) ||
400053b8: 82 10 40 02 or %g1, %g2, %g1
400053bc: 82 18 60 01 xor %g1, 1, %g1
if ( map_fixed ) {
400053c0: 02 80 00 51 be 40005504 <mmap+0x420> <== ALWAYS TAKEN
400053c4: b6 10 00 01 mov %g1, %i3
if ( map_fixed && is_shared_shm ) {
400053c8: 80 88 60 ff btst 0xff, %g1 <== NOT EXECUTED
400053cc: 22 bf ff 78 be,a 400051ac <mmap+0xc8> <== NOT EXECUTED
400053d0: f0 25 a0 08 st %i0, [ %l6 + 8 ] <== NOT EXECUTED
free( mapping );
400053d4: 40 00 11 2e call 4000988c <free> <== NOT EXECUTED
400053d8: 01 00 00 00 nop <== NOT EXECUTED
errno = ENOTSUP;
400053dc: 40 00 2e af call 40010e98 <__errno>
400053e0: 01 00 00 00 nop
return MAP_FAILED;
400053e4: 82 10 3f ff mov -1, %g1 ! ffffffff <RAM_END+0xbfbfffff>
errno = ENOTSUP;
400053e8: 84 10 20 86 mov 0x86, %g2
400053ec: c4 22 00 00 st %g2, [ %o0 ]
}
400053f0: 81 c7 e0 08 ret
400053f4: 91 e8 00 01 restore %g0, %g1, %o0
if ( map_anonymous && (fildes != -1 || off != 0 || map_shared) ) {
400053f8: 12 bf ff 9d bne 4000526c <mmap+0x188>
400053fc: 03 3f ff fb sethi %hi(0xffffec00), %g1
if ( map_anonymous && !map_private && !map_shared ) {
40005400: 80 a0 a0 00 cmp %g2, 0
40005404: 82 10 63 ec or %g1, 0x3ec, %g1
40005408: 12 80 00 ab bne 400056b4 <mmap+0x5d0>
4000540c: 82 0e c0 01 and %i3, %g1, %g1
if ((flags & ~(MAP_SHARED | MAP_PRIVATE | MAP_FIXED | MAP_ANON)) != 0) {
40005410: 80 a0 60 00 cmp %g1, 0
40005414: 12 bf ff 96 bne 4000526c <mmap+0x188>
40005418: b6 16 e0 02 or %i3, 2, %i3
if ( map_fixed ) {
4000541c: 80 a5 60 00 cmp %l5, 0
40005420: 12 bf ff 4f bne 4000515c <mmap+0x78> <== NEVER TAKEN
40005424: a6 10 20 01 mov 1, %l3
mapping = malloc( sizeof( mmap_mapping ));
40005428: 92 10 20 01 mov 1, %o1
4000542c: 40 00 10 f9 call 40009810 <calloc>
40005430: 90 10 20 18 mov 0x18, %o0
if ( !mapping ) {
40005434: ac 92 20 00 orcc %o0, 0, %l6
40005438: 02 80 00 0c be 40005468 <mmap+0x384> <== NEVER TAKEN
4000543c: 94 10 00 19 mov %i1, %o2
mapping->len = len;
40005440: f2 25 a0 0c st %i1, [ %l6 + 0xc ]
mapping->flags = flags;
40005444: f6 25 a0 10 st %i3, [ %l6 + 0x10 ]
err = posix_memalign( &mapping->addr, PAGE_SIZE, len );
40005448: 13 00 00 04 sethi %hi(0x1000), %o1
4000544c: 40 00 12 84 call 40009e5c <posix_memalign>
40005450: 90 05 a0 08 add %l6, 8, %o0
40005454: 80 a2 20 00 cmp %o0, 0
40005458: 02 80 00 73 be 40005624 <mmap+0x540> <== ALWAYS TAKEN
4000545c: 01 00 00 00 nop
free( mapping );
40005460: 40 00 11 0b call 4000988c <free> <== NOT EXECUTED
40005464: 90 10 00 16 mov %l6, %o0 <== NOT EXECUTED
errno = ENOMEM;
40005468: 40 00 2e 8c call 40010e98 <__errno> <== NOT EXECUTED
4000546c: 01 00 00 00 nop <== NOT EXECUTED
40005470: 84 10 20 0c mov 0xc, %g2 ! c <_TLS_Alignment+0xb> <== NOT EXECUTED
return MAP_FAILED;
40005474: 82 10 3f ff mov -1, %g1 <== NOT EXECUTED
40005478: 10 bf ff 82 b 40005280 <mmap+0x19c> <== NOT EXECUTED
4000547c: c4 22 00 00 st %g2, [ %o0 ] <== NOT EXECUTED
&& (( off >= sb.st_size ) || (( off + len ) >= sb.st_size ))) {
40005480: c2 07 bf c0 ld [ %fp + -64 ], %g1 <== NOT EXECUTED
40005484: 80 a0 40 10 cmp %g1, %l0 <== NOT EXECUTED
40005488: 04 80 00 7a ble 40005670 <mmap+0x58c> <== NOT EXECUTED
4000548c: c8 07 bf c4 ld [ %fp + -60 ], %g4 <== NOT EXECUTED
40005490: 86 84 40 19 addcc %l1, %i1, %g3 <== NOT EXECUTED
40005494: 84 44 20 00 addx %l0, 0, %g2 <== NOT EXECUTED
40005498: 80 a0 40 02 cmp %g1, %g2 <== NOT EXECUTED
4000549c: 04 80 00 6b ble 40005648 <mmap+0x564> <== NOT EXECUTED
400054a0: 01 00 00 00 nop <== NOT EXECUTED
if ( lseek( fildes, off, SEEK_SET ) < 0 ) {
400054a4: 96 10 20 00 clr %o3 ! 0 <PROM_START> <== NOT EXECUTED
400054a8: 92 10 00 10 mov %l0, %o1 <== NOT EXECUTED
400054ac: 94 10 00 11 mov %l1, %o2 <== NOT EXECUTED
400054b0: 40 00 11 b2 call 40009b78 <lseek> <== NOT EXECUTED
400054b4: 90 10 00 1c mov %i4, %o0 <== NOT EXECUTED
400054b8: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
400054bc: 06 bf ff 71 bl 40005280 <mmap+0x19c> <== NOT EXECUTED
400054c0: 82 10 3f ff mov -1, %g1 <== NOT EXECUTED
if ( S_ISCHR( sb.st_mode ) && map_private ) {
400054c4: ee 07 bf a8 ld [ %fp + -88 ], %l7 <== NOT EXECUTED
400054c8: 03 00 00 3c sethi %hi(0xf000), %g1 <== NOT EXECUTED
400054cc: ae 0d c0 01 and %l7, %g1, %l7 <== NOT EXECUTED
400054d0: 03 00 00 08 sethi %hi(0x2000), %g1 <== NOT EXECUTED
400054d4: 82 1d c0 01 xor %l7, %g1, %g1
400054d8: 80 a0 00 01 cmp %g0, %g1
400054dc: 82 60 3f ff subx %g0, -1, %g1
400054e0: 80 8c e0 ff btst 0xff, %l3
400054e4: 02 bf ff 9b be 40005350 <mmap+0x26c>
400054e8: 88 10 00 01 mov %g1, %g4
400054ec: 80 a0 60 00 cmp %g1, 0
400054f0: 22 bf ff 99 be,a 40005354 <mmap+0x270> <== NEVER TAKEN
400054f4: c8 2f bf 97 stb %g4, [ %fp + -105 ] <== NOT EXECUTED
400054f8: 30 bf ff 5d b,a 4000526c <mmap+0x188>
iop = NULL;
400054fc: a4 10 20 00 clr %l2
is_shared_shm = false;
40005500: b6 10 20 00 clr %i3
} else if ( map_private ) {
40005504: 80 8c e0 ff btst 0xff, %l3
40005508: 12 bf ff d0 bne 40005448 <mmap+0x364>
4000550c: 94 10 00 19 mov %i1, %o2
rtems_libio_lock();
40005510: 7f ff f2 8b call 40001f3c <rtems_libio_lock>
40005514: 01 00 00 00 nop
} else if ( map_shared ) {
40005518: 80 a5 20 00 cmp %l4, 0
4000551c: 02 bf ff 41 be 40005220 <mmap+0x13c> <== NEVER TAKEN
40005520: 07 10 00 6f sethi %hi(0x4001bc00), %g3
if ( is_shared_shm ) {
40005524: 80 8e e0 ff btst 0xff, %i3
40005528: 02 80 00 04 be 40005538 <mmap+0x454>
4000552c: 98 10 00 10 mov %l0, %o4
mapping->shm = iop_to_shm( iop );
40005530: c2 04 a0 2c ld [ %l2 + 0x2c ], %g1
40005534: c2 25 a0 14 st %g1, [ %l6 + 0x14 ]
err = (*iop->pathinfo.handlers->mmap_h)(
40005538: c2 04 a0 20 ld [ %l2 + 0x20 ], %g1
4000553c: c2 00 60 3c ld [ %g1 + 0x3c ], %g1
40005540: 9a 10 00 11 mov %l1, %o5
40005544: 96 10 00 1a mov %i2, %o3
40005548: 94 10 00 19 mov %i1, %o2
4000554c: 92 05 a0 08 add %l6, 8, %o1
40005550: 9f c0 40 00 call %g1
40005554: 90 10 00 12 mov %l2, %o0
if ( err != 0 ) {
40005558: 80 a2 20 00 cmp %o0, 0
4000555c: 02 bf ff 31 be 40005220 <mmap+0x13c>
40005560: 07 10 00 6f sethi %hi(0x4001bc00), %g3
rtems_libio_unlock();
40005564: 7f ff f2 7b call 40001f50 <rtems_libio_unlock>
40005568: 01 00 00 00 nop
free( mapping );
4000556c: 40 00 10 c8 call 4000988c <free>
40005570: 90 10 00 16 mov %l6, %o0
return MAP_FAILED;
40005574: 10 bf ff 43 b 40005280 <mmap+0x19c>
40005578: 82 10 3f ff mov -1, %g1
errno = ENODEV;
4000557c: 40 00 2e 47 call 40010e98 <__errno> <== NOT EXECUTED
40005580: 01 00 00 00 nop <== NOT EXECUTED
40005584: 84 10 20 13 mov 0x13, %g2 ! 13 <_TLS_Alignment+0x12> <== NOT EXECUTED
return MAP_FAILED;
40005588: 82 10 3f ff mov -1, %g1 <== NOT EXECUTED
4000558c: 10 bf ff 3d b 40005280 <mmap+0x19c> <== NOT EXECUTED
40005590: c4 22 00 00 st %g2, [ %o0 ] <== NOT EXECUTED
errno = EBADF;
40005594: 40 00 2e 41 call 40010e98 <__errno> <== NOT EXECUTED
40005598: 01 00 00 00 nop <== NOT EXECUTED
4000559c: 84 10 20 09 mov 9, %g2 ! 9 <_TLS_Alignment+0x8> <== NOT EXECUTED
return MAP_FAILED;
400055a0: 82 10 3f ff mov -1, %g1 <== NOT EXECUTED
400055a4: 10 bf ff 37 b 40005280 <mmap+0x19c> <== NOT EXECUTED
400055a8: c4 22 00 00 st %g2, [ %o0 ] <== NOT EXECUTED
free( mapping );
400055ac: 40 00 10 b8 call 4000988c <free> <== NOT EXECUTED
400055b0: 90 10 00 16 mov %l6, %o0 <== NOT EXECUTED
400055b4: 7f ff f2 67 call 40001f50 <rtems_libio_unlock> <== NOT EXECUTED
400055b8: 01 00 00 00 nop <== NOT EXECUTED
errno = ENXIO;
400055bc: 40 00 2e 37 call 40010e98 <__errno> <== NOT EXECUTED
400055c0: 01 00 00 00 nop <== NOT EXECUTED
400055c4: 84 10 20 06 mov 6, %g2 ! 6 <_TLS_Alignment+0x5> <== NOT EXECUTED
return MAP_FAILED;
400055c8: 82 10 3f ff mov -1, %g1 <== NOT EXECUTED
400055cc: 10 bf ff 2d b 40005280 <mmap+0x19c> <== NOT EXECUTED
400055d0: c4 22 00 00 st %g2, [ %o0 ] <== NOT EXECUTED
r = read( fildes, mapping->addr, len );
400055d4: d2 05 a0 08 ld [ %l6 + 8 ], %o1
400055d8: 94 10 00 19 mov %i1, %o2
400055dc: 40 00 12 55 call 40009f30 <read>
400055e0: 90 10 00 1c mov %i4, %o0
if ( r != len ) {
400055e4: 80 a2 00 19 cmp %o0, %i1
400055e8: 02 bf ff 0e be 40005220 <mmap+0x13c> <== ALWAYS TAKEN
400055ec: 07 10 00 6f sethi %hi(0x4001bc00), %g3
400055f0: 7f ff f2 58 call 40001f50 <rtems_libio_unlock> <== NOT EXECUTED
400055f4: 01 00 00 00 nop <== NOT EXECUTED
if ( !map_fixed ) {
400055f8: 80 a5 60 00 cmp %l5, 0 <== NOT EXECUTED
400055fc: 02 80 00 26 be 40005694 <mmap+0x5b0> <== NOT EXECUTED
40005600: 01 00 00 00 nop <== NOT EXECUTED
free( mapping );
40005604: 40 00 10 a2 call 4000988c <free> <== NOT EXECUTED
40005608: 90 10 00 16 mov %l6, %o0 <== NOT EXECUTED
errno = ENXIO;
4000560c: 40 00 2e 23 call 40010e98 <__errno> <== NOT EXECUTED
40005610: 01 00 00 00 nop <== NOT EXECUTED
40005614: 84 10 20 06 mov 6, %g2 ! 6 <_TLS_Alignment+0x5> <== NOT EXECUTED
return MAP_FAILED;
40005618: 82 10 3f ff mov -1, %g1 <== NOT EXECUTED
4000561c: 10 bf ff 19 b 40005280 <mmap+0x19c> <== NOT EXECUTED
40005620: c4 22 00 00 st %g2, [ %o0 ] <== NOT EXECUTED
rtems_libio_lock();
40005624: 7f ff f2 46 call 40001f3c <rtems_libio_lock>
40005628: 01 00 00 00 nop
if ( !map_anonymous ) {
4000562c: 10 bf fe f8 b 4000520c <mmap+0x128>
40005630: 80 a7 60 00 cmp %i5, 0
memset( mapping->addr, 0, len );
40005634: 94 10 00 19 mov %i1, %o2
40005638: 40 00 2f 2d call 400112ec <memset>
4000563c: 92 10 20 00 clr %o1
40005640: 10 bf fe f8 b 40005220 <mmap+0x13c>
40005644: 07 10 00 6f sethi %hi(0x4001bc00), %g3
&& (( off >= sb.st_size ) || (( off + len ) >= sb.st_size ))) {
40005648: 12 80 00 04 bne 40005658 <mmap+0x574> <== NOT EXECUTED
4000564c: 80 a1 00 03 cmp %g4, %g3 <== NOT EXECUTED
40005650: 18 bf ff 96 bgu 400054a8 <mmap+0x3c4> <== NOT EXECUTED
40005654: 96 10 20 00 clr %o3 <== NOT EXECUTED
errno = EOVERFLOW;
40005658: 40 00 2e 10 call 40010e98 <__errno> <== NOT EXECUTED
4000565c: 01 00 00 00 nop <== NOT EXECUTED
40005660: 84 10 20 8b mov 0x8b, %g2 ! 8b <_TLS_Alignment+0x8a> <== NOT EXECUTED
return MAP_FAILED;
40005664: 82 10 3f ff mov -1, %g1 <== NOT EXECUTED
40005668: 10 bf ff 06 b 40005280 <mmap+0x19c> <== NOT EXECUTED
4000566c: c4 22 00 00 st %g2, [ %o0 ] <== NOT EXECUTED
&& (( off >= sb.st_size ) || (( off + len ) >= sb.st_size ))) {
40005670: 12 bf ff fa bne 40005658 <mmap+0x574> <== NOT EXECUTED
40005674: 80 a1 00 11 cmp %g4, %l1 <== NOT EXECUTED
40005678: 18 bf ff 87 bgu 40005494 <mmap+0x3b0> <== NOT EXECUTED
4000567c: 86 84 40 19 addcc %l1, %i1, %g3 <== NOT EXECUTED
40005680: 30 bf ff f6 b,a 40005658 <mmap+0x574> <== NOT EXECUTED
if ( !S_ISCHR( sb.st_mode ) && sb.st_size < off + len ) {
40005684: 80 a0 40 03 cmp %g1, %g3
40005688: 3a bf ff 29 bcc,a 4000532c <mmap+0x248> <== ALWAYS TAKEN
4000568c: 03 3f ff e8 sethi %hi(0xffffa000), %g1
40005690: 30 bf ff df b,a 4000560c <mmap+0x528> <== NOT EXECUTED
free( mapping->addr );
40005694: 40 00 10 7e call 4000988c <free> <== NOT EXECUTED
40005698: d0 05 a0 08 ld [ %l6 + 8 ], %o0 <== NOT EXECUTED
4000569c: 30 bf ff da b,a 40005604 <mmap+0x520> <== NOT EXECUTED
} else if ( map_shared ) {
400056a0: 80 a5 20 00 cmp %l4, 0 <== NOT EXECUTED
400056a4: 12 bf ff a5 bne 40005538 <mmap+0x454> <== NOT EXECUTED
400056a8: 98 10 00 10 mov %l0, %o4 <== NOT EXECUTED
old_last = tail->previous;
400056ac: 10 bf fe e0 b 4000522c <mmap+0x148> <== NOT EXECUTED
400056b0: c2 06 e0 08 ld [ %i3 + 8 ], %g1 <== NOT EXECUTED
if ((flags & ~(MAP_SHARED | MAP_PRIVATE | MAP_FIXED | MAP_ANON)) != 0) {
400056b4: 80 a0 60 00 cmp %g1, 0
400056b8: 02 bf fe a7 be 40005154 <mmap+0x70> <== ALWAYS TAKEN
400056bc: 80 a5 60 00 cmp %l5, 0
400056c0: 30 bf fe eb b,a 4000526c <mmap+0x188> <== NOT EXECUTED
40005380 <mq_close>:
*/
int mq_close(
mqd_t mqdes
)
{
40005380: 9d e3 bf 78 save %sp, -136, %sp
*
* @see _Objects_Allocator_unlock() and _Objects_Allocate().
*/
RTEMS_INLINE_ROUTINE void _Objects_Allocator_lock( void )
{
_RTEMS_Lock_allocator();
40005384: 40 00 07 bf call 40007280 <_RTEMS_Lock_allocator>
40005388: 01 00 00 00 nop
Objects_Id id,
Thread_queue_Context *queue_context
)
{
_Thread_queue_Context_initialize( queue_context );
return (POSIX_Message_queue_Control *) _Objects_Get(
4000538c: 92 07 bf dc add %fp, -36, %o1
40005390: 15 10 00 5d sethi %hi(0x40017400), %o2
40005394: 90 10 00 18 mov %i0, %o0
40005398: 40 00 0c 13 call 400083e4 <_Objects_Get>
4000539c: 94 12 a1 04 or %o2, 0x104, %o2
Thread_queue_Context queue_context;
_Objects_Allocator_lock();
the_mq = _POSIX_Message_queue_Get( mqdes, &queue_context );
if ( the_mq == NULL ) {
400053a0: 82 92 20 00 orcc %o0, 0, %g1
400053a4: 02 80 00 11 be 400053e8 <mq_close+0x68> <== NEVER TAKEN
400053a8: 01 00 00 00 nop
_CORE_message_queue_Acquire_critical(
&the_mq->Message_queue,
&queue_context
);
if ( the_mq->open_count == 0 ) {
400053ac: c4 00 60 54 ld [ %g1 + 0x54 ], %g2
400053b0: 80 a0 a0 00 cmp %g2, 0
400053b4: 02 80 00 0a be 400053dc <mq_close+0x5c>
400053b8: 84 00 bf ff add %g2, -1, %g2
_CORE_message_queue_Release( &the_mq->Message_queue, &queue_context );
_Objects_Allocator_unlock();
rtems_set_errno_and_return_minus_one( EBADF );
}
the_mq->open_count -= 1;
400053bc: c4 20 60 54 st %g2, [ %g1 + 0x54 ]
_POSIX_Message_queue_Delete( the_mq, &queue_context );
400053c0: 92 07 bf dc add %fp, -36, %o1
400053c4: 40 00 00 11 call 40005408 <_POSIX_Message_queue_Delete>
400053c8: b0 10 20 00 clr %i0
* previous thread life protection state and thus may not return if the
* executing thread was restarted or deleted in the mean-time.
*/
RTEMS_INLINE_ROUTINE void _Objects_Allocator_unlock( void )
{
_RTEMS_Unlock_allocator();
400053cc: 40 00 07 b2 call 40007294 <_RTEMS_Unlock_allocator>
400053d0: 01 00 00 00 nop
_Objects_Allocator_unlock();
return 0;
}
400053d4: 81 c7 e0 08 ret
400053d8: 81 e8 00 00 restore
register uint32_t _psr __asm__("g1") = psr; /* input to trap handler */
400053dc: c2 07 bf dc ld [ %fp + -36 ], %g1
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
400053e0: 91 d0 20 0a ta 0xa
400053e4: 01 00 00 00 nop
400053e8: 40 00 07 ab call 40007294 <_RTEMS_Unlock_allocator>
400053ec: b0 10 3f ff mov -1, %i0 ! ffffffff <RAM_END+0xbfbfffff>
rtems_set_errno_and_return_minus_one( EBADF );
400053f0: 40 00 35 de call 40012b68 <__errno>
400053f4: 01 00 00 00 nop
400053f8: 82 10 20 09 mov 9, %g1 ! 9 <_TLS_Alignment+0x8>
400053fc: c2 22 00 00 st %g1, [ %o0 ]
40005400: 81 c7 e0 08 ret
40005404: 81 e8 00 00 restore
400092dc <mq_getattr>:
int mq_getattr(
mqd_t mqdes,
struct mq_attr *mqstat
)
{
400092dc: 9d e3 bf 78 save %sp, -136, %sp
POSIX_Message_queue_Control *the_mq;
Thread_queue_Context queue_context;
if ( mqstat == NULL ) {
400092e0: 80 a6 60 00 cmp %i1, 0
400092e4: 02 80 00 23 be 40009370 <mq_getattr+0x94>
400092e8: 92 07 bf dc add %fp, -36, %o1
return (POSIX_Message_queue_Control *) _Objects_Get(
400092ec: 15 10 00 a1 sethi %hi(0x40028400), %o2
400092f0: 90 10 00 18 mov %i0, %o0
400092f4: 40 00 07 da call 4000b25c <_Objects_Get>
400092f8: 94 12 a2 b8 or %o2, 0x2b8, %o2
rtems_set_errno_and_return_minus_one( EINVAL );
}
the_mq = _POSIX_Message_queue_Get( mqdes, &queue_context );
if ( the_mq == NULL ) {
400092fc: 80 a2 20 00 cmp %o0, 0
40009300: 02 80 00 16 be 40009358 <mq_getattr+0x7c> <== NEVER TAKEN
40009304: 01 00 00 00 nop
_CORE_message_queue_Acquire_critical(
&the_mq->Message_queue,
&queue_context
);
if ( the_mq->open_count == 0 ) {
40009308: c2 02 20 54 ld [ %o0 + 0x54 ], %g1
4000930c: 80 a0 60 00 cmp %g1, 0
40009310: 02 80 00 0f be 4000934c <mq_getattr+0x70>
40009314: 01 00 00 00 nop
}
/*
* Return the old values.
*/
mqstat->mq_flags = the_mq->oflag;
40009318: c8 02 20 6c ld [ %o0 + 0x6c ], %g4
mqstat->mq_msgsize = the_mq->Message_queue.maximum_message_size;
4000931c: c6 02 20 28 ld [ %o0 + 0x28 ], %g3
mqstat->mq_maxmsg = the_mq->Message_queue.maximum_pending_messages;
40009320: c4 02 20 20 ld [ %o0 + 0x20 ], %g2
mqstat->mq_curmsgs = the_mq->Message_queue.number_of_pending_messages;
40009324: c2 02 20 24 ld [ %o0 + 0x24 ], %g1
40009328: c2 26 60 0c st %g1, [ %i1 + 0xc ]
mqstat->mq_flags = the_mq->oflag;
4000932c: c8 26 40 00 st %g4, [ %i1 ]
mqstat->mq_msgsize = the_mq->Message_queue.maximum_message_size;
40009330: c6 26 60 08 st %g3, [ %i1 + 8 ]
mqstat->mq_maxmsg = the_mq->Message_queue.maximum_pending_messages;
40009334: c4 26 60 04 st %g2, [ %i1 + 4 ]
register uint32_t _psr __asm__("g1") = psr; /* input to trap handler */
40009338: c2 07 bf dc ld [ %fp + -36 ], %g1
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
4000933c: 91 d0 20 0a ta 0xa
40009340: 01 00 00 00 nop
_CORE_message_queue_Release( &the_mq->Message_queue, &queue_context );
return 0;
}
40009344: 81 c7 e0 08 ret
40009348: 91 e8 20 00 restore %g0, 0, %o0
register uint32_t _psr __asm__("g1") = psr; /* input to trap handler */
4000934c: c2 07 bf dc ld [ %fp + -36 ], %g1
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
40009350: 91 d0 20 0a ta 0xa
40009354: 01 00 00 00 nop
rtems_set_errno_and_return_minus_one( EBADF );
40009358: 40 00 35 50 call 40016898 <__errno>
4000935c: b0 10 3f ff mov -1, %i0 ! ffffffff <RAM_END+0xbfbfffff>
40009360: 82 10 20 09 mov 9, %g1
40009364: c2 22 00 00 st %g1, [ %o0 ]
40009368: 81 c7 e0 08 ret
4000936c: 81 e8 00 00 restore
rtems_set_errno_and_return_minus_one( EINVAL );
40009370: 40 00 35 4a call 40016898 <__errno>
40009374: b0 10 3f ff mov -1, %i0
40009378: 82 10 20 16 mov 0x16, %g1
4000937c: c2 22 00 00 st %g1, [ %o0 ]
40009380: 81 c7 e0 08 ret
40009384: 81 e8 00 00 restore
4000f02c <mq_notify>:
int mq_notify(
mqd_t mqdes,
const struct sigevent *notification
)
{
4000f02c: 9d e3 bf 78 save %sp, -136, %sp
return (POSIX_Message_queue_Control *) _Objects_Get(
4000f030: 15 10 00 a1 sethi %hi(0x40028400), %o2
4000f034: 92 07 bf dc add %fp, -36, %o1
4000f038: 94 12 a2 b8 or %o2, 0x2b8, %o2
4000f03c: 7f ff f0 88 call 4000b25c <_Objects_Get>
4000f040: 90 10 00 18 mov %i0, %o0
POSIX_Message_queue_Control *the_mq;
Thread_queue_Context queue_context;
the_mq = _POSIX_Message_queue_Get( mqdes, &queue_context );
if ( the_mq == NULL ) {
4000f044: 80 a2 20 00 cmp %o0, 0
4000f048: 02 80 00 2f be 4000f104 <mq_notify+0xd8> <== NEVER TAKEN
4000f04c: 01 00 00 00 nop
_CORE_message_queue_Acquire_critical(
&the_mq->Message_queue,
&queue_context
);
if ( the_mq->open_count == 0 ) {
4000f050: c2 02 20 54 ld [ %o0 + 0x54 ], %g1
4000f054: 80 a0 60 00 cmp %g1, 0
4000f058: 02 80 00 28 be 4000f0f8 <mq_notify+0xcc>
4000f05c: 80 a6 60 00 cmp %i1, 0
_CORE_message_queue_Release( &the_mq->Message_queue, &queue_context );
rtems_set_errno_and_return_minus_one( EBADF );
}
if ( notification != NULL ) {
4000f060: 22 80 00 18 be,a 4000f0c0 <mq_notify+0x94>
4000f064: c0 22 20 40 clr [ %o0 + 0x40 ]
if ( _CORE_message_queue_Is_notify_enabled( &the_mq->Message_queue ) ) {
4000f068: c2 02 20 40 ld [ %o0 + 0x40 ], %g1
4000f06c: 80 a0 60 00 cmp %g1, 0
4000f070: 12 80 00 19 bne 4000f0d4 <mq_notify+0xa8>
4000f074: 01 00 00 00 nop
_CORE_message_queue_Release( &the_mq->Message_queue, &queue_context );
rtems_set_errno_and_return_minus_one( EBUSY );
}
the_mq->notification = *notification;
4000f078: c2 06 40 00 ld [ %i1 ], %g1
4000f07c: c2 22 20 58 st %g1, [ %o0 + 0x58 ]
4000f080: c2 06 60 04 ld [ %i1 + 4 ], %g1
4000f084: c2 22 20 5c st %g1, [ %o0 + 0x5c ]
4000f088: c2 06 60 08 ld [ %i1 + 8 ], %g1
4000f08c: c2 22 20 60 st %g1, [ %o0 + 0x60 ]
4000f090: c2 06 60 0c ld [ %i1 + 0xc ], %g1
4000f094: c2 22 20 64 st %g1, [ %o0 + 0x64 ]
4000f098: c2 06 60 10 ld [ %i1 + 0x10 ], %g1
4000f09c: c2 22 20 68 st %g1, [ %o0 + 0x68 ]
4000f0a0: 03 10 00 3c sethi %hi(0x4000f000), %g1
4000f0a4: 82 10 60 04 or %g1, 4, %g1 ! 4000f004 <_POSIX_Message_queue_Notify_handler>
4000f0a8: c2 22 20 40 st %g1, [ %o0 + 0x40 ]
register uint32_t _psr __asm__("g1") = psr; /* input to trap handler */
4000f0ac: c2 07 bf dc ld [ %fp + -36 ], %g1
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
4000f0b0: 91 d0 20 0a ta 0xa
4000f0b4: 01 00 00 00 nop
_CORE_message_queue_Set_notify( &the_mq->Message_queue, NULL );
}
_CORE_message_queue_Release( &the_mq->Message_queue, &queue_context );
return 0;
}
4000f0b8: 81 c7 e0 08 ret
4000f0bc: 91 e8 20 00 restore %g0, 0, %o0
register uint32_t _psr __asm__("g1") = psr; /* input to trap handler */
4000f0c0: c2 07 bf dc ld [ %fp + -36 ], %g1
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
4000f0c4: 91 d0 20 0a ta 0xa
4000f0c8: 01 00 00 00 nop
4000f0cc: 81 c7 e0 08 ret
4000f0d0: 91 e8 20 00 restore %g0, 0, %o0
register uint32_t _psr __asm__("g1") = psr; /* input to trap handler */
4000f0d4: c2 07 bf dc ld [ %fp + -36 ], %g1
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
4000f0d8: 91 d0 20 0a ta 0xa
4000f0dc: 01 00 00 00 nop
rtems_set_errno_and_return_minus_one( EBUSY );
4000f0e0: 40 00 1d ee call 40016898 <__errno>
4000f0e4: b0 10 3f ff mov -1, %i0 ! ffffffff <RAM_END+0xbfbfffff>
4000f0e8: 82 10 20 10 mov 0x10, %g1
4000f0ec: c2 22 00 00 st %g1, [ %o0 ]
4000f0f0: 81 c7 e0 08 ret
4000f0f4: 81 e8 00 00 restore
register uint32_t _psr __asm__("g1") = psr; /* input to trap handler */
4000f0f8: c2 07 bf dc ld [ %fp + -36 ], %g1
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
4000f0fc: 91 d0 20 0a ta 0xa
4000f100: 01 00 00 00 nop
rtems_set_errno_and_return_minus_one( EBADF );
4000f104: 40 00 1d e5 call 40016898 <__errno>
4000f108: b0 10 3f ff mov -1, %i0 ! ffffffff <RAM_END+0xbfbfffff>
4000f10c: 82 10 20 09 mov 9, %g1
4000f110: c2 22 00 00 st %g1, [ %o0 ]
4000f114: 81 c7 e0 08 ret
4000f118: 81 e8 00 00 restore
40009800 <mq_setattr>:
int mq_setattr(
mqd_t mqdes,
const struct mq_attr *__restrict mqstat,
struct mq_attr *__restrict omqstat
)
{
40009800: 9d e3 bf 78 save %sp, -136, %sp
POSIX_Message_queue_Control *the_mq;
Thread_queue_Context queue_context;
if ( mqstat == NULL ) {
40009804: 80 a6 60 00 cmp %i1, 0
40009808: 02 80 00 27 be 400098a4 <mq_setattr+0xa4>
4000980c: 92 07 bf dc add %fp, -36, %o1
40009810: 15 10 00 a1 sethi %hi(0x40028400), %o2
40009814: 90 10 00 18 mov %i0, %o0
40009818: 40 00 06 91 call 4000b25c <_Objects_Get>
4000981c: 94 12 a2 b8 or %o2, 0x2b8, %o2
rtems_set_errno_and_return_minus_one( EINVAL );
}
the_mq = _POSIX_Message_queue_Get( mqdes, &queue_context );
if ( the_mq == NULL ) {
40009820: 80 a2 20 00 cmp %o0, 0
40009824: 02 80 00 1a be 4000988c <mq_setattr+0x8c> <== NEVER TAKEN
40009828: 01 00 00 00 nop
_CORE_message_queue_Acquire_critical(
&the_mq->Message_queue,
&queue_context
);
if ( the_mq->open_count == 0 ) {
4000982c: c2 02 20 54 ld [ %o0 + 0x54 ], %g1
40009830: 80 a0 60 00 cmp %g1, 0
40009834: 02 80 00 13 be 40009880 <mq_setattr+0x80>
40009838: 80 a6 a0 00 cmp %i2, 0
/*
* Return the old values.
*/
if ( omqstat != NULL ) {
4000983c: 22 80 00 0b be,a 40009868 <mq_setattr+0x68>
40009840: c2 06 40 00 ld [ %i1 ], %g1
omqstat->mq_flags = the_mq->oflag;
40009844: c8 02 20 6c ld [ %o0 + 0x6c ], %g4
omqstat->mq_msgsize = the_mq->Message_queue.maximum_message_size;
40009848: c6 02 20 28 ld [ %o0 + 0x28 ], %g3
omqstat->mq_maxmsg = the_mq->Message_queue.maximum_pending_messages;
4000984c: c4 02 20 20 ld [ %o0 + 0x20 ], %g2
omqstat->mq_curmsgs = the_mq->Message_queue.number_of_pending_messages;
40009850: c2 02 20 24 ld [ %o0 + 0x24 ], %g1
omqstat->mq_flags = the_mq->oflag;
40009854: c8 26 80 00 st %g4, [ %i2 ]
omqstat->mq_msgsize = the_mq->Message_queue.maximum_message_size;
40009858: c6 26 a0 08 st %g3, [ %i2 + 8 ]
omqstat->mq_maxmsg = the_mq->Message_queue.maximum_pending_messages;
4000985c: c4 26 a0 04 st %g2, [ %i2 + 4 ]
omqstat->mq_curmsgs = the_mq->Message_queue.number_of_pending_messages;
40009860: c2 26 a0 0c st %g1, [ %i2 + 0xc ]
}
the_mq->oflag = mqstat->mq_flags;
40009864: c2 06 40 00 ld [ %i1 ], %g1
40009868: c2 22 20 6c st %g1, [ %o0 + 0x6c ]
register uint32_t _psr __asm__("g1") = psr; /* input to trap handler */
4000986c: c2 07 bf dc ld [ %fp + -36 ], %g1
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
40009870: 91 d0 20 0a ta 0xa
40009874: 01 00 00 00 nop
_CORE_message_queue_Release( &the_mq->Message_queue, &queue_context );
return 0;
}
40009878: 81 c7 e0 08 ret
4000987c: 91 e8 20 00 restore %g0, 0, %o0
register uint32_t _psr __asm__("g1") = psr; /* input to trap handler */
40009880: c2 07 bf dc ld [ %fp + -36 ], %g1
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
40009884: 91 d0 20 0a ta 0xa
40009888: 01 00 00 00 nop
rtems_set_errno_and_return_minus_one( EBADF );
4000988c: 40 00 34 03 call 40016898 <__errno>
40009890: b0 10 3f ff mov -1, %i0 ! ffffffff <RAM_END+0xbfbfffff>
40009894: 82 10 20 09 mov 9, %g1
40009898: c2 22 00 00 st %g1, [ %o0 ]
4000989c: 81 c7 e0 08 ret
400098a0: 81 e8 00 00 restore
rtems_set_errno_and_return_minus_one( EINVAL );
400098a4: 40 00 33 fd call 40016898 <__errno>
400098a8: b0 10 3f ff mov -1, %i0
400098ac: 82 10 20 16 mov 0x16, %g1
400098b0: c2 22 00 00 st %g1, [ %o0 ]
400098b4: 81 c7 e0 08 ret
400098b8: 81 e8 00 00 restore
400056c4 <munmap>:
#include <rtems/posix/mmanimpl.h>
#include <rtems/posix/shmimpl.h>
int munmap(void *addr, size_t len)
{
400056c4: 9d e3 bf 98 save %sp, -104, %sp
rtems_chain_node *node;
/*
* Clear errno.
*/
errno = 0;
400056c8: 40 00 2d f4 call 40010e98 <__errno>
400056cc: 01 00 00 00 nop
/*
* Length cannot be 0.
*/
if ( len == 0 ) {
400056d0: 80 a6 60 00 cmp %i1, 0
400056d4: 02 80 00 53 be 40005820 <munmap+0x15c> <== NEVER TAKEN
400056d8: c0 22 00 00 clr [ %o0 ]
errno = EINVAL;
return -1;
}
/* Check for illegal addresses. Watch out for address wrap. */
if (addr + len < addr) {
400056dc: 06 80 00 51 bl 40005820 <munmap+0x15c> <== NEVER TAKEN
400056e0: 01 00 00 00 nop
400056e4: 7f ff f2 16 call 40001f3c <rtems_libio_lock>
400056e8: 01 00 00 00 nop
return _Chain_Immutable_head( the_chain )->next;
400056ec: 05 10 00 6f sethi %hi(0x4001bc00), %g2
400056f0: fa 00 a1 84 ld [ %g2 + 0x184 ], %i5 ! 4001bd84 <mmap_mappings>
400056f4: 84 10 a1 84 or %g2, 0x184, %g2
}
mmap_mappings_lock_obtain();
node = rtems_chain_first (&mmap_mappings);
while ( !rtems_chain_is_tail( &mmap_mappings, node )) {
400056f8: 84 00 a0 04 add %g2, 4, %g2
400056fc: 80 a7 40 02 cmp %i5, %g2
40005700: 02 80 00 0f be 4000573c <munmap+0x78> <== NEVER TAKEN
40005704: 01 00 00 00 nop
mapping = (mmap_mapping*) node;
if ( ( addr >= mapping->addr ) &&
40005708: c2 07 60 08 ld [ %i5 + 8 ], %g1
4000570c: 80 a0 40 18 cmp %g1, %i0
40005710: 38 80 00 08 bgu,a 40005730 <munmap+0x6c>
40005714: fa 07 40 00 ld [ %i5 ], %i5
( addr < ( mapping->addr + mapping->len )) ) {
40005718: c6 07 60 0c ld [ %i5 + 0xc ], %g3
4000571c: 82 00 40 03 add %g1, %g3, %g1
if ( ( addr >= mapping->addr ) &&
40005720: 80 a6 00 01 cmp %i0, %g1
40005724: 2a 80 00 0a bcs,a 4000574c <munmap+0x88>
40005728: c4 07 40 00 ld [ %i5 ], %g2
return the_node->next;
4000572c: fa 07 40 00 ld [ %i5 ], %i5
while ( !rtems_chain_is_tail( &mmap_mappings, node )) {
40005730: 80 a7 40 02 cmp %i5, %g2
40005734: 32 bf ff f6 bne,a 4000570c <munmap+0x48> <== ALWAYS TAKEN
40005738: c2 07 60 08 ld [ %i5 + 8 ], %g1
rtems_libio_unlock();
4000573c: 7f ff f2 05 call 40001f50 <rtems_libio_unlock> <== NOT EXECUTED
40005740: b0 10 20 00 clr %i0 <== NOT EXECUTED
node = rtems_chain_next( node );
}
mmap_mappings_lock_release( );
return 0;
}
40005744: 81 c7 e0 08 ret <== NOT EXECUTED
40005748: 81 e8 00 00 restore <== NOT EXECUTED
previous = the_node->previous;
4000574c: c2 07 60 04 ld [ %i5 + 4 ], %g1
next->previous = previous;
40005750: c2 20 a0 04 st %g1, [ %g2 + 4 ]
previous->next = next;
40005754: c4 20 40 00 st %g2, [ %g1 ]
if ( mapping->shm != NULL ) {
40005758: f8 07 60 14 ld [ %i5 + 0x14 ], %i4
4000575c: 80 a7 20 00 cmp %i4, 0
40005760: 22 80 00 1b be,a 400057cc <munmap+0x108>
40005764: c2 07 60 10 ld [ %i5 + 0x10 ], %g1
*
* @see _Objects_Allocator_unlock() and _Objects_Allocate().
*/
RTEMS_INLINE_ROUTINE void _Objects_Allocator_lock( void )
{
_RTEMS_Lock_allocator();
40005768: 40 00 02 7f call 40006164 <_RTEMS_Lock_allocator>
4000576c: 01 00 00 00 nop
int err;
err = 0;
_Objects_Allocator_lock();
--shm->reference_count;
40005770: c2 07 20 1c ld [ %i4 + 0x1c ], %g1
40005774: 82 00 7f ff add %g1, -1, %g1
if ( shm->reference_count == 0 ) {
40005778: 80 a0 60 00 cmp %g1, 0
4000577c: 12 80 00 06 bne 40005794 <munmap+0xd0> <== ALWAYS TAKEN
40005780: c2 27 20 1c st %g1, [ %i4 + 0x1c ]
if ( (*shm->shm_object.ops->object_delete)( &shm->shm_object ) != 0 ) {
40005784: c2 07 20 28 ld [ %i4 + 0x28 ], %g1 <== NOT EXECUTED
40005788: c2 00 60 08 ld [ %g1 + 8 ], %g1 <== NOT EXECUTED
4000578c: 9f c0 40 00 call %g1 <== NOT EXECUTED
40005790: 90 07 20 20 add %i4, 0x20, %o0 <== NOT EXECUTED
err = EIO;
}
}
/* check if the object has been unlinked yet. */
obj = _Objects_Get( shm->Object.id, &lock_ctx, &_POSIX_Shm_Information );
40005794: d0 07 20 08 ld [ %i4 + 8 ], %o0
40005798: 37 10 00 6e sethi %hi(0x4001b800), %i3
4000579c: 92 07 bf fc add %fp, -4, %o1
400057a0: 40 00 04 6b call 4000694c <_Objects_Get>
400057a4: 94 16 e3 84 or %i3, 0x384, %o2
if ( obj == NULL ) {
400057a8: 80 a2 20 00 cmp %o0, 0
400057ac: 02 80 00 16 be 40005804 <munmap+0x140> <== NEVER TAKEN
400057b0: 90 16 e3 84 or %i3, 0x384, %o0
register uint32_t _psr __asm__("g1") = psr; /* input to trap handler */
400057b4: c2 07 bf fc ld [ %fp + -4 ], %g1
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
400057b8: 91 d0 20 0a ta 0xa
400057bc: 01 00 00 00 nop
* previous thread life protection state and thus may not return if the
* executing thread was restarted or deleted in the mean-time.
*/
RTEMS_INLINE_ROUTINE void _Objects_Allocator_unlock( void )
{
_RTEMS_Unlock_allocator();
400057c0: 40 00 02 6e call 40006178 <_RTEMS_Unlock_allocator>
400057c4: 01 00 00 00 nop
if (( mapping->flags & MAP_SHARED ) != MAP_SHARED ) {
400057c8: c2 07 60 10 ld [ %i5 + 0x10 ], %g1
400057cc: 80 88 60 11 btst 0x11, %g1
400057d0: 02 80 00 09 be 400057f4 <munmap+0x130>
400057d4: 01 00 00 00 nop
free( mapping );
400057d8: 90 10 00 1d mov %i5, %o0
400057dc: 40 00 10 2c call 4000988c <free>
400057e0: b0 10 20 00 clr %i0
400057e4: 7f ff f1 db call 40001f50 <rtems_libio_unlock>
400057e8: 01 00 00 00 nop
}
400057ec: 81 c7 e0 08 ret
400057f0: 81 e8 00 00 restore
free( mapping->addr );
400057f4: 40 00 10 26 call 4000988c <free>
400057f8: d0 07 60 08 ld [ %i5 + 8 ], %o0
free( mapping );
400057fc: 10 bf ff f8 b 400057dc <munmap+0x118>
40005800: 90 10 00 1d mov %i5, %o0
Objects_Control *the_object
)
{
_Assert( _Objects_Allocator_is_owner() );
_Assert( information->deallocate != NULL );
( *information->deallocate )( information, the_object );
40005804: c2 02 20 0c ld [ %o0 + 0xc ], %g1 <== NOT EXECUTED
40005808: 9f c0 40 00 call %g1 <== NOT EXECUTED
4000580c: 92 10 00 1c mov %i4, %o1 <== NOT EXECUTED
_RTEMS_Unlock_allocator();
40005810: 40 00 02 5a call 40006178 <_RTEMS_Unlock_allocator> <== NOT EXECUTED
40005814: 01 00 00 00 nop <== NOT EXECUTED
if (( mapping->flags & MAP_SHARED ) != MAP_SHARED ) {
40005818: 10 bf ff ed b 400057cc <munmap+0x108> <== NOT EXECUTED
4000581c: c2 07 60 10 ld [ %i5 + 0x10 ], %g1 <== NOT EXECUTED
errno = EINVAL;
40005820: 40 00 2d 9e call 40010e98 <__errno> <== NOT EXECUTED
40005824: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
40005828: 82 10 20 16 mov 0x16, %g1 <== NOT EXECUTED
4000582c: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
return -1;
40005830: 81 c7 e0 08 ret <== NOT EXECUTED
40005834: 81 e8 00 00 restore <== NOT EXECUTED
40004844 <pthread_attr_getaffinity_np>:
const pthread_attr_t *attr,
size_t cpusetsize,
cpu_set_t *cpuset
)
{
if ( attr == NULL || !attr->is_initialized ) {
40004844: 82 92 20 00 orcc %o0, 0, %g1
40004848: 22 80 00 12 be,a 40004890 <pthread_attr_getaffinity_np+0x4c> <== NEVER TAKEN
4000484c: 90 10 20 16 mov 0x16, %o0 <== NOT EXECUTED
40004850: c4 00 40 00 ld [ %g1 ], %g2
return EINVAL;
}
if ( cpuset == NULL || cpusetsize != attr->affinitysetsize ) {
40004854: 80 a0 a0 00 cmp %g2, 0
40004858: 02 80 00 0d be 4000488c <pthread_attr_getaffinity_np+0x48> <== NEVER TAKEN
4000485c: 80 a2 a0 00 cmp %o2, 0
40004860: 02 80 00 0c be 40004890 <pthread_attr_getaffinity_np+0x4c> <== NEVER TAKEN
40004864: 90 10 20 16 mov 0x16, %o0
40004868: c4 00 60 54 ld [ %g1 + 0x54 ], %g2
4000486c: 80 a0 80 09 cmp %g2, %o1
40004870: 12 80 00 08 bne 40004890 <pthread_attr_getaffinity_np+0x4c> <== NEVER TAKEN
40004874: 01 00 00 00 nop
return CPU_ISSET_S(cpu, sizeof(*set), set);
}
static __inline void CPU_COPY(const cpu_set_t *src, cpu_set_t *dest)
{
BIT_COPY(_cpu_set_bits(setsize), src, dest);
40004878: c2 00 60 58 ld [ %g1 + 0x58 ], %g1
4000487c: c2 00 40 00 ld [ %g1 ], %g1
40004880: c2 22 80 00 st %g1, [ %o2 ]
return EINVAL;
}
CPU_COPY( attr->affinityset, cpuset );
return 0;
40004884: 81 c3 e0 08 retl
40004888: 90 10 20 00 clr %o0
return EINVAL;
4000488c: 90 10 20 16 mov 0x16, %o0 <== NOT EXECUTED
}
40004890: 81 c3 e0 08 retl <== NOT EXECUTED
40004894: 01 00 00 00 nop <== NOT EXECUTED
40004b0c <pthread_attr_setaffinity_np>:
pthread_attr_t *attr,
size_t cpusetsize,
const cpu_set_t *cpuset
)
{
if ( attr == NULL || !attr->is_initialized ) {
40004b0c: 82 92 20 00 orcc %o0, 0, %g1
40004b10: 22 80 00 12 be,a 40004b58 <pthread_attr_setaffinity_np+0x4c> <== NEVER TAKEN
40004b14: 90 10 20 16 mov 0x16, %o0 <== NOT EXECUTED
40004b18: c4 00 40 00 ld [ %g1 ], %g2
return EINVAL;
}
if ( cpuset == NULL || cpusetsize != attr->affinitysetsize ) {
40004b1c: 80 a0 a0 00 cmp %g2, 0
40004b20: 02 80 00 0d be 40004b54 <pthread_attr_setaffinity_np+0x48> <== NEVER TAKEN
40004b24: 80 a2 a0 00 cmp %o2, 0
40004b28: 02 80 00 0c be 40004b58 <pthread_attr_setaffinity_np+0x4c> <== NEVER TAKEN
40004b2c: 90 10 20 16 mov 0x16, %o0
40004b30: c4 00 60 54 ld [ %g1 + 0x54 ], %g2
40004b34: 80 a0 80 09 cmp %g2, %o1
40004b38: 12 80 00 08 bne 40004b58 <pthread_attr_setaffinity_np+0x4c> <== NEVER TAKEN
40004b3c: 01 00 00 00 nop
40004b40: c2 00 60 58 ld [ %g1 + 0x58 ], %g1
40004b44: c4 02 80 00 ld [ %o2 ], %g2
40004b48: c4 20 40 00 st %g2, [ %g1 ]
return EINVAL;
}
CPU_COPY( cpuset, attr->affinityset );
return 0;
40004b4c: 81 c3 e0 08 retl
40004b50: 90 10 20 00 clr %o0
return EINVAL;
40004b54: 90 10 20 16 mov 0x16, %o0 <== NOT EXECUTED
}
40004b58: 81 c3 e0 08 retl <== NOT EXECUTED
40004b5c: 01 00 00 00 nop <== NOT EXECUTED
400065fc <pthread_attr_setschedpolicy>:
int pthread_attr_setschedpolicy(
pthread_attr_t *attr,
int policy
)
{
if ( !attr || !attr->is_initialized )
400065fc: 80 a2 20 00 cmp %o0, 0
40006600: 02 80 00 13 be 4000664c <pthread_attr_setschedpolicy+0x50>
40006604: 82 10 20 16 mov 0x16, %g1
40006608: c4 02 00 00 ld [ %o0 ], %g2
4000660c: 80 a0 a0 00 cmp %g2, 0
40006610: 02 80 00 09 be 40006634 <pthread_attr_setschedpolicy+0x38>
40006614: 80 a2 60 02 cmp %o1, 2
return EINVAL;
switch ( policy ) {
40006618: 04 80 00 09 ble 4000663c <pthread_attr_setschedpolicy+0x40>
4000661c: 80 a2 60 00 cmp %o1, 0
40006620: 80 a2 60 04 cmp %o1, 4
40006624: 12 80 00 04 bne 40006634 <pthread_attr_setschedpolicy+0x38> <== NEVER TAKEN
40006628: 82 10 20 86 mov 0x86, %g1
case SCHED_OTHER:
case SCHED_FIFO:
case SCHED_RR:
case SCHED_SPORADIC:
attr->schedpolicy = policy;
4000662c: d2 22 20 14 st %o1, [ %o0 + 0x14 ]
return 0;
40006630: 82 10 20 00 clr %g1
default:
return ENOTSUP;
}
}
40006634: 81 c3 e0 08 retl
40006638: 90 10 00 01 mov %g1, %o0
switch ( policy ) {
4000663c: 16 bf ff fc bge 4000662c <pthread_attr_setschedpolicy+0x30>
40006640: 82 10 20 86 mov 0x86, %g1
}
40006644: 81 c3 e0 08 retl
40006648: 90 10 00 01 mov %g1, %o0
4000664c: 81 c3 e0 08 retl
40006650: 90 10 00 01 mov %g1, %o0
400052a0 <pthread_cancel>:
/*
* 18.2.1 Canceling Execution of a Thread, P1003.1c/Draft 10, p. 181
*/
int pthread_cancel( pthread_t thread )
{
400052a0: 9d e3 bf 98 save %sp, -104, %sp
/*
* Don't even think about deleting a resource from an ISR.
*/
if ( _ISR_Is_in_progress() ) {
400052a4: 40 00 04 10 call 400062e4 <_ISR_Is_in_progress>
400052a8: 01 00 00 00 nop
400052ac: 80 a2 20 00 cmp %o0, 0
400052b0: 12 80 00 18 bne 40005310 <pthread_cancel+0x70>
400052b4: 82 10 20 47 mov 0x47, %g1
return EPROTO;
}
the_thread = _Thread_Get( thread, &lock_context );
400052b8: 92 07 bf fc add %fp, -4, %o1
400052bc: 40 00 0a 63 call 40007c48 <_Thread_Get>
400052c0: 90 10 00 18 mov %i0, %o0
if ( the_thread == NULL ) {
400052c4: 84 92 20 00 orcc %o0, 0, %g2
400052c8: 02 80 00 12 be 40005310 <pthread_cancel+0x70>
400052cc: 82 10 20 03 mov 3, %g1
const ISR_lock_Context *lock_context
)
{
uint32_t disable_level;
disable_level = cpu_self->thread_dispatch_disable_level;
400052d0: c2 01 a0 18 ld [ %g6 + 0x18 ], %g1
_Profiling_Thread_dispatch_disable_critical(
cpu_self,
disable_level,
lock_context
);
cpu_self->thread_dispatch_disable_level = disable_level + 1;
400052d4: 82 00 60 01 inc %g1
*/
RTEMS_INLINE_ROUTINE Per_CPU_Control *_Thread_Dispatch_disable_critical(
const ISR_lock_Context *lock_context
)
{
return _Thread_Dispatch_disable_with_CPU( _Per_CPU_Get(), lock_context );
400052d8: ba 10 00 06 mov %g6, %i5
cpu_self->thread_dispatch_disable_level = disable_level + 1;
400052dc: c2 21 a0 18 st %g1, [ %g6 + 0x18 ]
register uint32_t _psr __asm__("g1") = psr; /* input to trap handler */
400052e0: c2 07 bf fc ld [ %fp + -4 ], %g1
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
400052e4: 91 d0 20 0a ta 0xa
400052e8: 01 00 00 00 nop
static inline struct _Thread_Control *_Per_CPU_Get_executing(
const Per_CPU_Control *cpu
)
{
return cpu->executing;
400052ec: d2 01 a0 20 ld [ %g6 + 0x20 ], %o1
cpu_self = _Thread_Dispatch_disable_critical( &lock_context );
_ISR_lock_ISR_enable( &lock_context );
executing = _Per_CPU_Get_executing( cpu_self );
if ( the_thread == executing ) {
400052f0: 80 a0 80 09 cmp %g2, %o1
400052f4: 02 80 00 09 be 40005318 <pthread_cancel+0x78> <== NEVER TAKEN
400052f8: 94 10 3f ff mov -1, %o2
_Thread_Exit( executing, THREAD_LIFE_TERMINATING, PTHREAD_CANCELED );
} else {
_Thread_Cancel( the_thread, executing, PTHREAD_CANCELED );
400052fc: 40 00 10 13 call 40009348 <_Thread_Cancel>
40005300: 01 00 00 00 nop
}
_Thread_Dispatch_enable( cpu_self );
40005304: 40 00 0a 36 call 40007bdc <_Thread_Dispatch_enable>
40005308: 90 10 00 1d mov %i5, %o0
return 0;
4000530c: 82 10 20 00 clr %g1
}
40005310: 81 c7 e0 08 ret
40005314: 91 e8 00 01 restore %g0, %g1, %o0
_Thread_Exit( executing, THREAD_LIFE_TERMINATING, PTHREAD_CANCELED );
40005318: 40 00 10 61 call 4000949c <_Thread_Exit> <== NOT EXECUTED
4000531c: 92 10 20 04 mov 4, %o1 <== NOT EXECUTED
40005320: 30 bf ff f9 b,a 40005304 <pthread_cancel+0x64> <== NOT EXECUTED
400052d0 <pthread_cond_init>:
{
POSIX_Condition_variables_Control *the_cond;
the_cond = _POSIX_Condition_variables_Get( cond );
if ( the_cond == NULL ) {
400052d0: 82 92 20 00 orcc %o0, 0, %g1
400052d4: 02 80 00 19 be 40005338 <pthread_cond_init+0x68>
400052d8: 80 a2 60 00 cmp %o1, 0
return EINVAL;
}
if ( attr == NULL ) {
400052dc: 22 80 00 1a be,a 40005344 <pthread_cond_init+0x74>
400052e0: 13 10 00 4b sethi %hi(0x40012c00), %o1
attr = &_POSIX_Condition_variables_Default_attributes;
}
if ( !attr->is_initialized ) {
400052e4: c4 02 40 00 ld [ %o1 ], %g2
400052e8: 80 a0 a0 00 cmp %g2, 0
400052ec: 02 80 00 14 be 4000533c <pthread_cond_init+0x6c>
400052f0: 90 10 20 16 mov 0x16, %o0
return EINVAL;
}
if ( !_POSIX_Is_valid_pshared( attr->process_shared ) ) {
400052f4: c4 02 60 10 ld [ %o1 + 0x10 ], %g2
400052f8: 80 a0 a0 01 cmp %g2, 1
400052fc: 18 80 00 10 bgu 4000533c <pthread_cond_init+0x6c>
40005300: 05 06 37 ec sethi %hi(0x18dfb000), %g2
)
{
#if defined(RTEMS_SMP)
_SMP_ticket_lock_Initialize( &queue->Lock );
#endif
queue->heads = NULL;
40005304: c0 20 60 0c clr [ %g1 + 0xc ]
queue->owner = NULL;
40005308: c0 20 60 10 clr [ %g1 + 0x10 ]
flags = (uintptr_t) the_cond ^ POSIX_CONDITION_VARIABLES_MAGIC;
4000530c: 84 10 a1 fe or %g2, 0x1fe, %g2
queue->name = name;
40005310: c0 20 60 14 clr [ %g1 + 0x14 ]
40005314: 84 18 40 02 xor %g1, %g2, %g2
the_cond->mutex = POSIX_CONDITION_VARIABLES_NO_MUTEX;
40005318: c0 20 60 18 clr [ %g1 + 0x18 ]
if ( the_attr->clock == CLOCK_MONOTONIC ) {
4000531c: c6 02 60 08 ld [ %o1 + 8 ], %g3
40005320: 80 a0 e0 00 cmp %g3, 0
40005324: 02 80 00 0a be 4000534c <pthread_cond_init+0x7c> <== ALWAYS TAKEN
40005328: 84 08 bf fe and %g2, -2, %g2
the_cond->flags = flags;
4000532c: c4 20 40 00 st %g2, [ %g1 ] <== NOT EXECUTED
return EINVAL;
}
_POSIX_Condition_variables_Initialize( the_cond, attr );
return 0;
40005330: 81 c3 e0 08 retl
40005334: 90 10 20 00 clr %o0
return EINVAL;
40005338: 90 10 20 16 mov 0x16, %o0
}
4000533c: 81 c3 e0 08 retl
40005340: 01 00 00 00 nop
attr = &_POSIX_Condition_variables_Default_attributes;
40005344: 10 bf ff e8 b 400052e4 <pthread_cond_init+0x14>
40005348: 92 12 62 30 or %o1, 0x230, %o1
if ( the_attr->clock == CLOCK_MONOTONIC ) {
4000534c: c6 02 60 0c ld [ %o1 + 0xc ], %g3
40005350: 80 a0 e0 04 cmp %g3, 4
40005354: 32 bf ff f7 bne,a 40005330 <pthread_cond_init+0x60> <== ALWAYS TAKEN
40005358: c4 20 40 00 st %g2, [ %g1 ]
flags |= POSIX_CONDITION_VARIABLES_CLOCK_MONOTONIC;
4000535c: 84 10 a0 01 or %g2, 1, %g2 <== NOT EXECUTED
return 0;
40005360: 90 10 20 00 clr %o0 <== NOT EXECUTED
40005364: 81 c3 e0 08 retl <== NOT EXECUTED
40005368: c4 20 40 00 st %g2, [ %g1 ] <== NOT EXECUTED
4000517c <pthread_condattr_destroy>:
int pthread_condattr_destroy(
pthread_condattr_t *attr
)
{
if ( attr == NULL || !attr->is_initialized )
4000517c: 82 92 20 00 orcc %o0, 0, %g1
40005180: 02 80 00 09 be 400051a4 <pthread_condattr_destroy+0x28>
40005184: 90 10 20 16 mov 0x16, %o0
40005188: c4 00 40 00 ld [ %g1 ], %g2
4000518c: 80 a0 a0 00 cmp %g2, 0
40005190: 02 80 00 05 be 400051a4 <pthread_condattr_destroy+0x28> <== NEVER TAKEN
40005194: 01 00 00 00 nop
return EINVAL;
attr->is_initialized = false;
40005198: c0 20 40 00 clr [ %g1 ]
return 0;
4000519c: 81 c3 e0 08 retl
400051a0: 90 10 20 00 clr %o0
}
400051a4: 81 c3 e0 08 retl
400051a8: 01 00 00 00 nop
400044d4 <pthread_condattr_getclock>:
{
if ( attr == NULL ) {
return EINVAL;
}
if ( clock == NULL ) {
400044d4: 80 a2 20 00 cmp %o0, 0
400044d8: 02 80 00 08 be 400044f8 <pthread_condattr_getclock+0x24>
400044dc: 80 a2 60 00 cmp %o1, 0
400044e0: 02 80 00 06 be 400044f8 <pthread_condattr_getclock+0x24> <== ALWAYS TAKEN
400044e4: 01 00 00 00 nop
return EINVAL;
}
*clock = attr->clock;
400044e8: c2 02 20 0c ld [ %o0 + 0xc ], %g1 <== NOT EXECUTED
400044ec: c2 22 40 00 st %g1, [ %o1 ] <== NOT EXECUTED
return 0;
400044f0: 81 c3 e0 08 retl <== NOT EXECUTED
400044f4: 90 10 20 00 clr %o0 <== NOT EXECUTED
}
400044f8: 81 c3 e0 08 retl
400044fc: 90 10 20 16 mov 0x16, %o0
40006828 <pthread_create>:
{
40006828: 9d e3 bf 28 save %sp, -216, %sp
Thread_Entry_information entry = {
4000682c: 03 10 00 22 sethi %hi(0x40008800), %g1
40006830: 82 10 63 b4 or %g1, 0x3b4, %g1 ! 40008bb4 <_Thread_Entry_adaptor_pointer>
40006834: f4 27 bf 98 st %i2, [ %fp + -104 ]
if ( !start_routine )
40006838: 80 a6 a0 00 cmp %i2, 0
Thread_Entry_information entry = {
4000683c: c2 27 bf 94 st %g1, [ %fp + -108 ]
int schedpolicy = SCHED_RR;
40006840: 82 10 20 02 mov 2, %g1
Thread_Entry_information entry = {
40006844: f6 27 bf 9c st %i3, [ %fp + -100 ]
if ( !start_routine )
40006848: 02 80 00 c6 be 40006b60 <pthread_create+0x338>
4000684c: c2 27 bf 8c st %g1, [ %fp + -116 ]
the_attr = (attr) ? attr : &_POSIX_Threads_Default_attributes;
40006850: 80 a6 60 00 cmp %i1, 0
40006854: 22 80 00 ac be,a 40006b04 <pthread_create+0x2dc>
40006858: 33 10 02 68 sethi %hi(0x4009a000), %i1
if ( !the_attr->is_initialized )
4000685c: c2 06 40 00 ld [ %i1 ], %g1
40006860: 80 a0 60 00 cmp %g1, 0
40006864: 02 80 00 a5 be 40006af8 <pthread_create+0x2d0>
40006868: 82 10 21 01 mov 0x101, %g1
memset( &config, 0, sizeof( config ) );
4000686c: c0 27 bf c8 clr [ %fp + -56 ]
40006870: c0 27 bf cc clr [ %fp + -52 ]
config.is_fp = true;
40006874: c2 37 bf c8 sth %g1, [ %fp + -56 ]
memset( &config, 0, sizeof( config ) );
40006878: c0 27 bf a0 clr [ %fp + -96 ]
4000687c: c0 27 bf a4 clr [ %fp + -92 ]
40006880: c0 27 bf a8 clr [ %fp + -88 ]
40006884: c0 27 bf ac clr [ %fp + -84 ]
40006888: c0 27 bf b0 clr [ %fp + -80 ]
4000688c: c0 27 bf b4 clr [ %fp + -76 ]
40006890: c0 27 bf b8 clr [ %fp + -72 ]
40006894: c0 27 bf bc clr [ %fp + -68 ]
40006898: c0 27 bf c0 clr [ %fp + -64 ]
4000689c: c0 27 bf c4 clr [ %fp + -60 ]
if ( the_attr->stackaddr != NULL ) {
400068a0: c2 06 60 04 ld [ %i1 + 4 ], %g1
400068a4: 80 a0 60 00 cmp %g1, 0
400068a8: 02 80 00 99 be 40006b0c <pthread_create+0x2e4>
400068ac: fa 06 60 08 ld [ %i1 + 8 ], %i5
bool is_fp
)
{
size_t minimum;
minimum = _TLS_Get_allocation_size();
400068b0: 40 00 0f b6 call 4000a788 <_TLS_Get_allocation_size>
400068b4: 01 00 00 00 nop
return rtems_minimum_stack_size;
400068b8: 03 10 02 8c sethi %hi(0x400a3000), %g1
minimum += _Stack_Minimum();
#if ( CPU_HARDWARE_FP == TRUE ) || ( CPU_SOFTWARE_FP == TRUE )
if ( is_fp ) {
minimum += CONTEXT_FP_SIZE;
400068bc: c2 00 60 44 ld [ %g1 + 0x44 ], %g1 ! 400a3044 <rtems_minimum_stack_size>
400068c0: 82 00 60 88 add %g1, 0x88, %g1
400068c4: 82 00 40 08 add %g1, %o0, %g1
if ( !_Stack_Is_enough( the_attr->stacksize, config.is_fp ) ) {
400068c8: 80 a7 40 01 cmp %i5, %g1
400068cc: 2a 80 00 8c bcs,a 40006afc <pthread_create+0x2d4>
400068d0: ba 10 20 16 mov 0x16, %i5
config.stack_size = the_attr->stacksize;
400068d4: c2 06 60 08 ld [ %i1 + 8 ], %g1
config.stack_area = the_attr->stackaddr;
400068d8: c4 06 60 04 ld [ %i1 + 4 ], %g2
config.stack_size = the_attr->stacksize;
400068dc: c2 27 bf a8 st %g1, [ %fp + -88 ]
config.stack_area = the_attr->stackaddr;
400068e0: c4 27 bf a4 st %g2, [ %fp + -92 ]
switch ( the_attr->inheritsched ) {
400068e4: c2 06 60 10 ld [ %i1 + 0x10 ], %g1
400068e8: 80 a0 60 01 cmp %g1, 1
400068ec: 02 80 00 96 be 40006b44 <pthread_create+0x31c> <== ALWAYS TAKEN
400068f0: 80 a0 60 02 cmp %g1, 2
400068f4: 12 80 00 82 bne 40006afc <pthread_create+0x2d4>
400068f8: ba 10 20 16 mov 0x16, %i5
schedpolicy = the_attr->schedpolicy;
400068fc: c2 06 60 14 ld [ %i1 + 0x14 ], %g1
schedparam = the_attr->schedparam;
40006900: d8 1e 60 18 ldd [ %i1 + 0x18 ], %o4
40006904: f4 1e 60 20 ldd [ %i1 + 0x20 ], %i2
40006908: f8 1e 60 28 ldd [ %i1 + 0x28 ], %i4
4000690c: c4 1e 60 30 ldd [ %i1 + 0x30 ], %g2
40006910: d4 1e 60 38 ldd [ %i1 + 0x38 ], %o2
40006914: d0 1e 60 40 ldd [ %i1 + 0x40 ], %o0
schedpolicy = the_attr->schedpolicy;
40006918: c2 27 bf 8c st %g1, [ %fp + -116 ]
schedparam = the_attr->schedparam;
4000691c: d8 3f bf d0 std %o4, [ %fp + -48 ]
40006920: f4 3f bf d8 std %i2, [ %fp + -40 ]
40006924: f8 3f bf e0 std %i4, [ %fp + -32 ]
40006928: c4 3f bf e8 std %g2, [ %fp + -24 ]
4000692c: d4 3f bf f0 std %o2, [ %fp + -16 ]
40006930: d0 3f bf f8 std %o0, [ %fp + -8 ]
return ENOTSUP;
40006934: ba 10 20 86 mov 0x86, %i5
if ( the_attr->contentionscope != PTHREAD_SCOPE_PROCESS )
40006938: c2 06 60 0c ld [ %i1 + 0xc ], %g1
4000693c: 80 a0 60 00 cmp %g1, 0
40006940: 12 80 00 6f bne 40006afc <pthread_create+0x2d4>
40006944: d0 07 bf 8c ld [ %fp + -116 ], %o0
error = _POSIX_Thread_Translate_sched_param(
40006948: 96 07 bf bc add %fp, -68, %o3
4000694c: 94 07 bf b8 add %fp, -72, %o2
40006950: 40 00 16 53 call 4000c29c <_POSIX_Thread_Translate_sched_param>
40006954: 92 07 bf d0 add %fp, -48, %o1
if ( error != 0 ) {
40006958: ba 92 20 00 orcc %o0, 0, %i5
4000695c: 32 80 00 83 bne,a 40006b68 <pthread_create+0x340>
40006960: b0 10 00 1d mov %i5, %i0
normal_prio = schedparam.sched_priority;
40006964: f8 07 bf d0 ld [ %fp + -48 ], %i4
config.scheduler = _Thread_Scheduler_get_home( executing );
40006968: 11 10 02 65 sethi %hi(0x40099400), %o0
config.priority = _POSIX_Priority_To_core(
4000696c: 94 07 bf 8b add %fp, -117, %o2
config.scheduler = _Thread_Scheduler_get_home( executing );
40006970: 90 12 20 c0 or %o0, 0xc0, %o0
config.priority = _POSIX_Priority_To_core(
40006974: 92 10 00 1c mov %i4, %o1
40006978: 40 00 13 03 call 4000b584 <_POSIX_Priority_To_core>
4000697c: d0 27 bf a0 st %o0, [ %fp + -96 ]
40006980: d0 3f bf b0 std %o0, [ %fp + -80 ]
if ( !valid ) {
40006984: c2 0f bf 8b ldub [ %fp + -117 ], %g1
40006988: 80 a0 60 00 cmp %g1, 0
4000698c: 02 80 00 5b be 40006af8 <pthread_create+0x2d0> <== NEVER TAKEN
40006990: c2 07 bf 8c ld [ %fp + -116 ], %g1
if ( schedpolicy == SCHED_SPORADIC ) {
40006994: 80 a0 60 04 cmp %g1, 4
40006998: 22 80 00 02 be,a 400069a0 <pthread_create+0x178>
4000699c: f8 07 bf d4 ld [ %fp + -44 ], %i4
core_low_prio = _POSIX_Priority_To_core( config.scheduler, low_prio, &valid );
400069a0: d0 07 bf a0 ld [ %fp + -96 ], %o0
400069a4: 94 07 bf 8b add %fp, -117, %o2
400069a8: 40 00 12 f7 call 4000b584 <_POSIX_Priority_To_core>
400069ac: 92 10 00 1c mov %i4, %o1
if ( !valid ) {
400069b0: c2 0f bf 8b ldub [ %fp + -117 ], %g1
core_low_prio = _POSIX_Priority_To_core( config.scheduler, low_prio, &valid );
400069b4: b4 10 00 08 mov %o0, %i2
if ( !valid ) {
400069b8: 80 a0 60 00 cmp %g1, 0
400069bc: 02 80 00 4f be 40006af8 <pthread_create+0x2d0>
400069c0: b6 10 00 09 mov %o1, %i3
if ( the_attr->affinityset == NULL ) {
400069c4: c2 06 60 58 ld [ %i1 + 0x58 ], %g1
400069c8: 80 a0 60 00 cmp %g1, 0
400069cc: 22 80 00 4c be,a 40006afc <pthread_create+0x2d4> <== NEVER TAKEN
400069d0: ba 10 20 16 mov 0x16, %i5 <== NOT EXECUTED
*
* @see _Objects_Allocator_unlock() and _Objects_Allocate().
*/
RTEMS_INLINE_ROUTINE void _Objects_Allocator_lock( void )
{
_RTEMS_Lock_allocator();
400069d4: 40 00 02 36 call 400072ac <_RTEMS_Lock_allocator>
400069d8: 23 10 02 8c sethi %hi(0x400a3000), %l1
RTEMS_INLINE_ROUTINE Thread_Control *_POSIX_Threads_Allocate(void)
{
_Objects_Allocator_lock();
_Thread_Kill_zombies();
400069dc: 40 00 0d c7 call 4000a0f8 <_Thread_Kill_zombies>
400069e0: a0 14 60 48 or %l1, 0x48, %l0 ! 400a3048 <_POSIX_Threads_Information>
_Assert(
_Objects_Allocator_is_owner()
|| !_System_state_Is_up( _System_state_Get() )
);
return ( *information->allocate )( information );
400069e4: c2 04 20 08 ld [ %l0 + 8 ], %g1
400069e8: 9f c0 40 00 call %g1
400069ec: 90 10 00 10 mov %l0, %o0
if ( !the_thread ) {
400069f0: b8 92 20 00 orcc %o0, 0, %i4
400069f4: 02 80 00 79 be 40006bd8 <pthread_create+0x3b0>
400069f8: c2 07 bf a4 ld [ %fp + -92 ], %g1
if ( config.stack_area == NULL ) {
400069fc: 80 a0 60 00 cmp %g1, 0
40006a00: 02 80 00 5c be 40006b70 <pthread_create+0x348>
40006a04: 03 10 00 21 sethi %hi(0x40008400), %g1
config.stack_free = _Stack_Free_nothing;
40006a08: 82 10 60 6c or %g1, 0x6c, %g1 ! 4000846c <_Stack_Free_nothing>
40006a0c: c2 27 bf ac st %g1, [ %fp + -84 ]
status = _Thread_Initialize(
40006a10: 94 07 bf a0 add %fp, -96, %o2
40006a14: 92 10 00 1c mov %i4, %o1
40006a18: 40 00 08 ad call 40008ccc <_Thread_Initialize>
40006a1c: 90 14 60 48 or %l1, 0x48, %o0
if ( !status ) {
40006a20: 80 a2 20 00 cmp %o0, 0
40006a24: 22 80 00 5c be,a 40006b94 <pthread_create+0x36c> <== NEVER TAKEN
40006a28: c2 04 20 0c ld [ %l0 + 0xc ], %g1 <== NOT EXECUTED
if ( the_attr->detachstate == PTHREAD_CREATE_DETACHED ) {
40006a2c: c4 06 60 50 ld [ %i1 + 0x50 ], %g2
40006a30: 80 a0 a0 00 cmp %g2, 0
40006a34: 12 80 00 03 bne 40006a40 <pthread_create+0x218>
40006a38: c2 07 21 70 ld [ %i4 + 0x170 ], %g1
the_thread->Life.state |= THREAD_LIFE_DETACHED;
40006a3c: 82 10 60 10 or %g1, 0x10, %g1
the_thread->Life.state |= THREAD_LIFE_CHANGE_DEFERRED;
40006a40: 82 10 60 08 or %g1, 8, %g1
40006a44: c2 27 21 70 st %g1, [ %i4 + 0x170 ]
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
40006a48: 91 d0 20 09 ta 9
_ISR_lock_ISR_disable( &lock_context );
40006a4c: c2 27 bf 90 st %g1, [ %fp + -112 ]
status = _Scheduler_Set_affinity(
40006a50: d4 06 60 58 ld [ %i1 + 0x58 ], %o2
40006a54: d2 06 60 54 ld [ %i1 + 0x54 ], %o1
40006a58: 40 00 06 73 call 40008424 <_Scheduler_Set_affinity>
40006a5c: 90 10 00 1c mov %i4, %o0
register uint32_t _psr __asm__("g1") = psr; /* input to trap handler */
40006a60: c2 07 bf 90 ld [ %fp + -112 ], %g1
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
40006a64: 91 d0 20 0a ta 0xa
40006a68: 01 00 00 00 nop
if ( !status ) {
40006a6c: 80 a2 20 00 cmp %o0, 0
40006a70: 22 80 00 50 be,a 40006bb0 <pthread_create+0x388> <== NEVER TAKEN
40006a74: c2 04 20 0c ld [ %l0 + 0xc ], %g1 <== NOT EXECUTED
( the_attr->inheritsched == PTHREAD_INHERIT_SCHED );
40006a78: c2 06 60 10 ld [ %i1 + 0x10 ], %g1
40006a7c: 82 18 60 01 xor %g1, 1, %g1
api->Sporadic.sched_ss_repl_period =
40006a80: e0 1e 60 20 ldd [ %i1 + 0x20 ], %l0
40006a84: d4 1e 60 28 ldd [ %i1 + 0x28 ], %o2
api->Sporadic.sched_ss_init_budget =
40006a88: d8 1e 60 30 ldd [ %i1 + 0x30 ], %o4
40006a8c: c4 1e 60 38 ldd [ %i1 + 0x38 ], %g2
api->Sporadic.sched_ss_max_repl =
40006a90: c8 06 60 40 ld [ %i1 + 0x40 ], %g4
api = the_thread->API_Extensions[ THREAD_API_POSIX ];
40006a94: d0 07 21 5c ld [ %i4 + 0x15c ], %o0
( the_attr->inheritsched == PTHREAD_INHERIT_SCHED );
40006a98: 80 a0 00 01 cmp %g0, %g1
40006a9c: 82 60 3f ff subx %g0, -1, %g1
40006aa0: c2 2f 20 8b stb %g1, [ %i4 + 0x8b ]
RTEMS_INLINE_ROUTINE void _Priority_Node_set_priority(
Priority_Node *node,
Priority_Control priority
)
{
node->priority = priority;
40006aa4: f4 3a 20 38 std %i2, [ %o0 + 0x38 ]
api->Sporadic.sched_ss_repl_period =
40006aa8: e0 3a 20 40 std %l0, [ %o0 + 0x40 ]
40006aac: d4 3a 20 48 std %o2, [ %o0 + 0x48 ]
api->Sporadic.sched_ss_init_budget =
40006ab0: d8 3a 20 50 std %o4, [ %o0 + 0x50 ]
40006ab4: c4 3a 20 58 std %g2, [ %o0 + 0x58 ]
api->Sporadic.sched_ss_max_repl =
40006ab8: c8 22 20 60 st %g4, [ %o0 + 0x60 ]
if ( schedpolicy == SCHED_SPORADIC ) {
40006abc: c2 07 bf 8c ld [ %fp + -116 ], %g1
40006ac0: 80 a0 60 04 cmp %g1, 4
40006ac4: 02 80 00 42 be 40006bcc <pthread_create+0x3a4>
40006ac8: 01 00 00 00 nop
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
40006acc: 91 d0 20 09 ta 9
_ISR_lock_ISR_disable( &lock_context );
40006ad0: c2 27 bf 90 st %g1, [ %fp + -112 ]
status = _Thread_Start( the_thread, &entry, &lock_context );
40006ad4: 94 07 bf 90 add %fp, -112, %o2
40006ad8: 92 07 bf 94 add %fp, -108, %o1
40006adc: 40 00 0e 65 call 4000a470 <_Thread_Start>
40006ae0: 90 10 00 1c mov %i4, %o0
*thread = the_thread->Object.id;
40006ae4: c2 07 20 08 ld [ %i4 + 8 ], %g1
_RTEMS_Unlock_allocator();
40006ae8: 40 00 01 f6 call 400072c0 <_RTEMS_Unlock_allocator>
40006aec: c2 26 00 00 st %g1, [ %i0 ]
return 0;
40006af0: 81 c7 e0 08 ret
40006af4: 91 e8 00 1d restore %g0, %i5, %o0
switch ( the_attr->inheritsched ) {
40006af8: ba 10 20 16 mov 0x16, %i5
}
40006afc: 81 c7 e0 08 ret
40006b00: 91 e8 00 1d restore %g0, %i5, %o0
the_attr = (attr) ? attr : &_POSIX_Threads_Default_attributes;
40006b04: 10 bf ff 56 b 4000685c <pthread_create+0x34>
40006b08: b2 16 61 70 or %i1, 0x170, %i1
if ( size >= PTHREAD_MINIMUM_STACK_SIZE )
40006b0c: 03 10 02 65 sethi %hi(0x40099400), %g1
40006b10: c2 00 60 80 ld [ %g1 + 0x80 ], %g1 ! 40099480 <_POSIX_Threads_Minimum_stack_size>
40006b14: 80 a0 40 1d cmp %g1, %i5
40006b18: 2a 80 00 02 bcs,a 40006b20 <pthread_create+0x2f8>
40006b1c: 82 10 00 1d mov %i5, %g1
bool is_fp
)
{
#if ( CPU_HARDWARE_FP == TRUE ) || ( CPU_SOFTWARE_FP == TRUE )
if ( is_fp ) {
stack_size += CONTEXT_FP_SIZE;
40006b20: ba 00 60 88 add %g1, 0x88, %i5
}
#else
(void) is_fp;
#endif
stack_size += _TLS_Get_allocation_size();
40006b24: 40 00 0f 19 call 4000a788 <_TLS_Get_allocation_size>
40006b28: c2 27 bf a8 st %g1, [ %fp + -88 ]
40006b2c: 90 02 00 1d add %o0, %i5, %o0
config.stack_size = _Stack_Extend_size( config.stack_size, config.is_fp );
40006b30: d0 27 bf a8 st %o0, [ %fp + -88 ]
switch ( the_attr->inheritsched ) {
40006b34: c2 06 60 10 ld [ %i1 + 0x10 ], %g1
40006b38: 80 a0 60 01 cmp %g1, 1
40006b3c: 12 bf ff 6e bne 400068f4 <pthread_create+0xcc>
40006b40: 80 a0 60 02 cmp %g1, 2
error = pthread_getschedparam(
40006b44: 40 00 01 30 call 40007004 <pthread_self>
40006b48: ba 10 20 86 mov 0x86, %i5
40006b4c: 94 07 bf d0 add %fp, -48, %o2
40006b50: 40 00 00 bf call 40006e4c <pthread_getschedparam>
40006b54: 92 07 bf 8c add %fp, -116, %o1
break;
40006b58: 10 bf ff 79 b 4000693c <pthread_create+0x114>
40006b5c: c2 06 60 0c ld [ %i1 + 0xc ], %g1
return EFAULT;
40006b60: ba 10 20 0e mov 0xe, %i5
}
40006b64: b0 10 00 1d mov %i5, %i0
40006b68: 81 c7 e0 08 ret
40006b6c: 81 e8 00 00 restore
config.stack_area = _Stack_Allocate( config.stack_size );
40006b70: d0 07 bf a8 ld [ %fp + -88 ], %o0
config.stack_free = _Stack_Free;
40006b74: 03 10 00 29 sethi %hi(0x4000a400), %g1
40006b78: 82 10 60 54 or %g1, 0x54, %g1 ! 4000a454 <_Stack_Free>
config.stack_area = _Stack_Allocate( config.stack_size );
40006b7c: 40 00 0e 2f call 4000a438 <_Stack_Allocate>
40006b80: c2 27 bf ac st %g1, [ %fp + -84 ]
if ( status ) {
40006b84: 80 a2 20 00 cmp %o0, 0
40006b88: 12 bf ff a2 bne 40006a10 <pthread_create+0x1e8>
40006b8c: d0 27 bf a4 st %o0, [ %fp + -92 ]
Objects_Control *the_object
)
{
_Assert( _Objects_Allocator_is_owner() );
_Assert( information->deallocate != NULL );
( *information->deallocate )( information, the_object );
40006b90: c2 04 20 0c ld [ %l0 + 0xc ], %g1
40006b94: 92 10 00 1c mov %i4, %o1
40006b98: 90 10 00 10 mov %l0, %o0
40006b9c: 9f c0 40 00 call %g1
40006ba0: ba 10 20 0b mov 0xb, %i5
_RTEMS_Unlock_allocator();
40006ba4: 40 00 01 c7 call 400072c0 <_RTEMS_Unlock_allocator>
40006ba8: b0 10 00 1d mov %i5, %i0
return EAGAIN;
40006bac: 30 bf ff ef b,a 40006b68 <pthread_create+0x340>
( *information->deallocate )( information, the_object );
40006bb0: 92 10 00 1c mov %i4, %o1
40006bb4: 90 10 00 10 mov %l0, %o0 <== NOT EXECUTED
40006bb8: 9f c0 40 00 call %g1 <== NOT EXECUTED
40006bbc: ba 10 20 16 mov 0x16, %i5 <== NOT EXECUTED
_RTEMS_Unlock_allocator();
40006bc0: 40 00 01 c0 call 400072c0 <_RTEMS_Unlock_allocator> <== NOT EXECUTED
40006bc4: b0 10 00 1d mov %i5, %i0 <== NOT EXECUTED
return EINVAL;
40006bc8: 30 bf ff e8 b,a 40006b68 <pthread_create+0x340> <== NOT EXECUTED
_POSIX_Threads_Sporadic_timer( &api->Sporadic.Timer );
40006bcc: 7f ff fe d7 call 40006728 <_POSIX_Threads_Sporadic_timer>
40006bd0: 90 02 20 08 add %o0, 8, %o0
40006bd4: 30 bf ff be b,a 40006acc <pthread_create+0x2a4>
_RTEMS_Unlock_allocator();
40006bd8: 40 00 01 ba call 400072c0 <_RTEMS_Unlock_allocator>
40006bdc: ba 10 20 0b mov 0xb, %i5
return EAGAIN;
40006be0: 81 c7 e0 08 ret
40006be4: 91 e8 00 1d restore %g0, %i5, %o0
40006c68 <pthread_exit>:
#include <pthread.h>
#include <rtems/score/threadimpl.h>
void pthread_exit( void *value_ptr )
{
40006c68: 9d e3 bf a0 save %sp, -96, %sp
const ISR_lock_Context *lock_context
)
{
uint32_t disable_level;
disable_level = cpu_self->thread_dispatch_disable_level;
40006c6c: c2 01 a0 18 ld [ %g6 + 0x18 ], %g1
_Profiling_Thread_dispatch_disable_critical(
cpu_self,
disable_level,
lock_context
);
cpu_self->thread_dispatch_disable_level = disable_level + 1;
40006c70: 82 00 60 01 inc %g1
40006c74: c2 21 a0 18 st %g1, [ %g6 + 0x18 ]
*/
RTEMS_INLINE_ROUTINE Per_CPU_Control *_Thread_Dispatch_disable_critical(
const ISR_lock_Context *lock_context
)
{
return _Thread_Dispatch_disable_with_CPU( _Per_CPU_Get(), lock_context );
40006c78: ba 10 00 06 mov %g6, %i5
Per_CPU_Control *cpu_self;
cpu_self = _Thread_Dispatch_disable();
executing = _Per_CPU_Get_executing( cpu_self );
_Thread_Exit( executing, THREAD_LIFE_TERMINATING, value_ptr );
40006c7c: d0 01 a0 20 ld [ %g6 + 0x20 ], %o0
40006c80: 94 10 00 18 mov %i0, %o2
40006c84: 40 00 0d 78 call 4000a264 <_Thread_Exit>
40006c88: 92 10 20 04 mov 4, %o1
_Thread_Dispatch_direct( cpu_self );
40006c8c: 40 00 07 a5 call 40008b20 <_Thread_Dispatch_direct>
40006c90: 90 10 00 1d mov %i5, %o0
RTEMS_UNREACHABLE();
40006c94: 01 00 00 00 nop <== NOT EXECUTED
40006c98 <pthread_getattr_np>:
int pthread_getattr_np(
pthread_t thread,
pthread_attr_t *attr
)
{
40006c98: 9d e3 bf 98 save %sp, -104, %sp
Thread_CPU_budget_algorithms budget_algorithm;
const Scheduler_Control *scheduler;
Priority_Control priority;
bool ok;
if ( attr == NULL ) {
40006c9c: 80 a6 60 00 cmp %i1, 0
40006ca0: 02 80 00 48 be 40006dc0 <pthread_getattr_np+0x128>
40006ca4: 94 10 20 60 mov 0x60, %o2
return EINVAL;
}
attr = memset( attr, 0, sizeof( *attr ) );
40006ca8: 92 10 20 00 clr %o1
40006cac: 40 01 9c 89 call 4006ded0 <memset>
40006cb0: 90 10 00 19 mov %i1, %o0
the_thread = _Thread_Get( thread, &lock_context );
40006cb4: 92 07 bf fc add %fp, -4, %o1
attr = memset( attr, 0, sizeof( *attr ) );
40006cb8: ba 10 00 08 mov %o0, %i5
the_thread = _Thread_Get( thread, &lock_context );
40006cbc: 40 00 07 c5 call 40008bd0 <_Thread_Get>
40006cc0: 90 10 00 18 mov %i0, %o0
if ( the_thread == NULL ) {
40006cc4: b8 92 20 00 orcc %o0, 0, %i4
40006cc8: 02 80 00 40 be 40006dc8 <pthread_getattr_np+0x130>
40006ccc: 25 10 02 65 sethi %hi(0x40099400), %l2
_Thread_State_acquire_critical( the_thread, &lock_context );
attr->stackaddr = the_thread->Start.Initial_stack.area;
attr->stacksize = the_thread->Start.Initial_stack.size;
if ( the_thread->was_created_with_inherited_scheduler ) {
40006cd0: c6 0f 20 8b ldub [ %i4 + 0x8b ], %g3
attr->stackaddr = the_thread->Start.Initial_stack.area;
40006cd4: c2 07 20 d0 ld [ %i4 + 0xd0 ], %g1
attr->stacksize = the_thread->Start.Initial_stack.size;
40006cd8: c4 07 20 cc ld [ %i4 + 0xcc ], %g2
)
{
#if defined(RTEMS_POSIX_API)
const POSIX_API_Control *api;
api = the_thread->API_Extensions[ THREAD_API_POSIX ];
40006cdc: f6 07 21 5c ld [ %i4 + 0x15c ], %i3
attr->inheritsched = PTHREAD_INHERIT_SCHED;
} else {
attr->inheritsched = PTHREAD_EXPLICIT_SCHED;
40006ce0: 80 a0 00 03 cmp %g0, %g3
attr->stackaddr = the_thread->Start.Initial_stack.area;
40006ce4: c2 27 60 04 st %g1, [ %i5 + 4 ]
attr->inheritsched = PTHREAD_EXPLICIT_SCHED;
40006ce8: 82 60 3f ff subx %g0, -1, %g1
attr->stacksize = the_thread->Start.Initial_stack.size;
40006cec: c4 27 60 08 st %g2, [ %i5 + 8 ]
attr->inheritsched = PTHREAD_EXPLICIT_SCHED;
40006cf0: 82 00 60 01 inc %g1
40006cf4: c2 27 60 10 st %g1, [ %i5 + 0x10 ]
param->sched_ss_low_priority = _POSIX_Priority_From_core(
40006cf8: d2 06 e0 38 ld [ %i3 + 0x38 ], %o1
40006cfc: d4 06 e0 3c ld [ %i3 + 0x3c ], %o2
40006d00: 40 00 12 3e call 4000b5f8 <_POSIX_Priority_From_core>
40006d04: 90 14 a0 c0 or %l2, 0xc0, %o0
scheduler,
&attr->schedparam
);
priority = the_thread->Real_priority.priority;
if ( _Thread_Is_joinable( the_thread ) ) {
40006d08: c2 07 21 70 ld [ %i4 + 0x170 ], %g1
scheduler,
api->Sporadic.Low_priority.priority
);
param->sched_ss_repl_period = api->Sporadic.sched_ss_repl_period;
param->sched_ss_init_budget = api->Sporadic.sched_ss_init_budget;
40006d0c: f0 1e e0 50 ldd [ %i3 + 0x50 ], %i0
param->sched_ss_repl_period = api->Sporadic.sched_ss_repl_period;
40006d10: e0 1e e0 40 ldd [ %i3 + 0x40 ], %l0
40006d14: d8 1e e0 48 ldd [ %i3 + 0x48 ], %o4
param->sched_ss_init_budget = api->Sporadic.sched_ss_init_budget;
40006d18: c4 1e e0 58 ldd [ %i3 + 0x58 ], %g2
param->sched_ss_max_repl = api->Sporadic.sched_ss_max_repl;
40006d1c: c8 06 e0 60 ld [ %i3 + 0x60 ], %g4
40006d20: 83 30 60 04 srl %g1, 4, %g1
40006d24: 82 18 60 01 xor %g1, 1, %g1
40006d28: 82 08 60 01 and %g1, 1, %g1
priority = the_thread->Real_priority.priority;
40006d2c: f4 1f 20 30 ldd [ %i4 + 0x30 ], %i2
attr->detachstate = PTHREAD_CREATE_JOINABLE;
} else {
attr->detachstate = PTHREAD_CREATE_DETACHED;
}
attr->affinityset = &attr->affinitysetpreallocated;
40006d30: 94 07 60 5c add %i5, 0x5c, %o2
param->sched_ss_low_priority = _POSIX_Priority_From_core(
40006d34: d0 27 60 1c st %o0, [ %i5 + 0x1c ]
attr->affinitysetsize = sizeof( attr->affinitysetpreallocated );
ok = _Scheduler_Get_affinity(
40006d38: 92 10 20 04 mov 4, %o1
param->sched_ss_init_budget = api->Sporadic.sched_ss_init_budget;
40006d3c: f0 3f 60 30 std %i0, [ %i5 + 0x30 ]
40006d40: 90 10 00 1c mov %i4, %o0
40006d44: c2 27 60 50 st %g1, [ %i5 + 0x50 ]
attr->affinitysetsize = sizeof( attr->affinitysetpreallocated );
40006d48: 82 10 20 04 mov 4, %g1
param->sched_ss_repl_period = api->Sporadic.sched_ss_repl_period;
40006d4c: e0 3f 60 20 std %l0, [ %i5 + 0x20 ]
40006d50: d8 3f 60 28 std %o4, [ %i5 + 0x28 ]
param->sched_ss_init_budget = api->Sporadic.sched_ss_init_budget;
40006d54: c4 3f 60 38 std %g2, [ %i5 + 0x38 ]
param->sched_ss_max_repl = api->Sporadic.sched_ss_max_repl;
40006d58: c8 27 60 40 st %g4, [ %i5 + 0x40 ]
attr->affinityset = &attr->affinitysetpreallocated;
40006d5c: d4 27 60 58 st %o2, [ %i5 + 0x58 ]
ok = _Scheduler_Get_affinity(
40006d60: 40 00 03 f5 call 40007d34 <_Scheduler_Get_affinity>
40006d64: c2 27 60 54 st %g1, [ %i5 + 0x54 ]
the_thread,
attr->affinitysetsize,
attr->affinityset
);
budget_algorithm = the_thread->budget_algorithm;
40006d68: f2 07 20 90 ld [ %i4 + 0x90 ], %i1
ok = _Scheduler_Get_affinity(
40006d6c: b8 10 00 08 mov %o0, %i4
register uint32_t _psr __asm__("g1") = psr; /* input to trap handler */
40006d70: c2 07 bf fc ld [ %fp + -4 ], %g1
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
40006d74: 91 d0 20 0a ta 0xa
40006d78: 01 00 00 00 nop
_Thread_State_release( the_thread, &lock_context );
attr->is_initialized = true;
40006d7c: 82 10 20 01 mov 1, %g1 ! 1 <_TLS_Alignment>
attr->contentionscope = PTHREAD_SCOPE_PROCESS;
40006d80: c0 27 60 0c clr [ %i5 + 0xc ]
attr->cputime_clock_allowed = 1;
attr->schedparam.sched_priority = _POSIX_Priority_From_core(
40006d84: 92 10 00 1a mov %i2, %o1
attr->is_initialized = true;
40006d88: c2 27 40 00 st %g1, [ %i5 ]
attr->schedparam.sched_priority = _POSIX_Priority_From_core(
40006d8c: 94 10 00 1b mov %i3, %o2
attr->cputime_clock_allowed = 1;
40006d90: c2 27 60 4c st %g1, [ %i5 + 0x4c ]
attr->schedparam.sched_priority = _POSIX_Priority_From_core(
40006d94: 40 00 12 19 call 4000b5f8 <_POSIX_Priority_From_core>
40006d98: 90 14 a0 c0 or %l2, 0xc0, %o0
40006d9c: d0 27 60 18 st %o0, [ %i5 + 0x18 ]
scheduler,
priority
);
attr->schedpolicy =
_POSIX_Thread_Translate_to_sched_policy( budget_algorithm );
40006da0: 40 00 15 36 call 4000c278 <_POSIX_Thread_Translate_to_sched_policy>
40006da4: 90 10 00 19 mov %i1, %o0
attr->schedpolicy =
40006da8: d0 27 60 14 st %o0, [ %i5 + 0x14 ]
return ok ? 0 : EINVAL;
40006dac: 80 a7 20 00 cmp %i4, 0
40006db0: 02 80 00 04 be 40006dc0 <pthread_getattr_np+0x128> <== NEVER TAKEN
40006db4: b0 10 20 00 clr %i0
}
40006db8: 81 c7 e0 08 ret
40006dbc: 81 e8 00 00 restore
return ok ? 0 : EINVAL;
40006dc0: 81 c7 e0 08 ret
40006dc4: 91 e8 20 16 restore %g0, 0x16, %o0
}
40006dc8: 81 c7 e0 08 ret
40006dcc: 91 e8 20 03 restore %g0, 3, %o0
40006ca4 <pthread_getspecific>:
ISR_Level level;
_ISR_Local_disable( level );
#endif
executing = _Thread_Executing;
40006ca4: c4 01 a0 20 ld [ %g6 + 0x20 ], %g2
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
40006ca8: 91 d0 20 09 ta 9
RBTree_Node *parent;
link = _RBTree_Root_const_reference( the_rbtree );
parent = NULL;
while ( *link != NULL ) {
40006cac: c4 00 a1 60 ld [ %g2 + 0x160 ], %g2
40006cb0: 80 a0 a0 00 cmp %g2, 0
40006cb4: 32 80 00 0b bne,a 40006ce0 <pthread_getspecific+0x3c>
40006cb8: c6 00 a0 10 ld [ %g2 + 0x10 ], %g3
40006cbc: 30 80 00 0d b,a 40006cf0 <pthread_getspecific+0x4c>
parent = *link;
if ( ( *equal )( key, parent ) ) {
return ( *map )( parent );
} else if ( ( *less )( key, parent ) ) {
40006cc0: 1a 80 00 03 bcc 40006ccc <pthread_getspecific+0x28> <== ALWAYS TAKEN
40006cc4: 86 00 a0 04 add %g2, 4, %g3
return &RB_LEFT( the_node, Node );
40006cc8: 86 10 00 02 mov %g2, %g3 <== NOT EXECUTED
while ( *link != NULL ) {
40006ccc: c4 00 c0 00 ld [ %g3 ], %g2
40006cd0: 80 a0 a0 00 cmp %g2, 0
40006cd4: 02 80 00 07 be 40006cf0 <pthread_getspecific+0x4c>
40006cd8: 01 00 00 00 nop
const POSIX_Keys_Key_value_pair *the_right;
the_left = left;
the_right = POSIX_KEYS_RBTREE_NODE_TO_KEY_VALUE_PAIR( right );
return *the_left == the_right->key;
40006cdc: c6 00 a0 10 ld [ %g2 + 0x10 ], %g3
if ( ( *equal )( key, parent ) ) {
40006ce0: 80 a2 00 03 cmp %o0, %g3
40006ce4: 12 bf ff f7 bne 40006cc0 <pthread_getspecific+0x1c>
40006ce8: 88 00 bf f8 add %g2, -8, %g4
_POSIX_Keys_Key_value_acquire( executing, &lock_context );
key_value_pair = _POSIX_Keys_Key_value_find( key, executing );
if ( key_value_pair != NULL ) {
value = key_value_pair->value;
40006cec: c4 01 20 20 ld [ %g4 + 0x20 ], %g2
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
40006cf0: 91 d0 20 0a ta 0xa
40006cf4: 01 00 00 00 nop
}
_POSIX_Keys_Key_value_release( executing, &lock_context );
return value;
}
40006cf8: 81 c3 e0 08 retl
40006cfc: 90 10 00 02 mov %g2, %o0
40006be4 <pthread_key_delete>:
* 17.1.3 Thread-Specific Data Key Deletion, P1003.1c/Draft 10, p. 167
*/
int pthread_key_delete(
pthread_key_t key
)
{
40006be4: 9d e3 bf 98 save %sp, -104, %sp
_RTEMS_Lock_allocator();
40006be8: 40 00 02 fd call 400077dc <_RTEMS_Lock_allocator>
40006bec: 33 10 01 3e sethi %hi(0x4004f800), %i1
_Objects_Get_no_protection( (Objects_Id) key, &_POSIX_Keys_Information );
40006bf0: 90 10 00 18 mov %i0, %o0
the_key = _POSIX_Keys_Get( key );
if ( the_key != NULL ) {
_POSIX_Keys_Destroy( the_key );
eno = 0;
} else {
eno = EINVAL;
40006bf4: b0 10 20 16 mov 0x16, %i0
40006bf8: 40 00 0c cc call 40009f28 <_Objects_Get_no_protection>
40006bfc: 92 16 62 88 or %i1, 0x288, %o1
if ( the_key != NULL ) {
40006c00: b8 92 20 00 orcc %o0, 0, %i4
40006c04: 02 80 00 24 be 40006c94 <pthread_key_delete+0xb0>
40006c08: 92 10 00 1c mov %i4, %o1
_Objects_Close( &_POSIX_Keys_Information, &the_key->Object );
40006c0c: 40 00 0c 7d call 40009e00 <_Objects_Close>
40006c10: 90 16 62 88 or %i1, 0x288, %o0
return _Chain_Immutable_head( the_chain )->next;
40006c14: fa 07 20 14 ld [ %i4 + 0x14 ], %i5
return &the_chain->Tail.Node;
40006c18: b4 07 20 18 add %i4, 0x18, %i2
while ( !_Chain_Is_empty( &the_key->Key_value_pairs ) ) {
40006c1c: 80 a6 80 1d cmp %i2, %i5
40006c20: 22 80 00 19 be,a 40006c84 <pthread_key_delete+0xa0>
40006c24: 90 16 62 88 or %i1, 0x288, %o0
40006c28: 37 10 01 46 sethi %hi(0x40051800), %i3
_Freechain_Put( &_POSIX_Keys_Keypool, key_value_pair );
40006c2c: b6 16 e1 d8 or %i3, 0x1d8, %i3 ! 400519d8 <_POSIX_Keys_Keypool>
the_thread = key_value_pair->thread;
40006c30: d0 07 60 1c ld [ %i5 + 0x1c ], %o0
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
40006c34: 91 d0 20 09 ta 9
return psr;
40006c38: c2 27 bf fc st %g1, [ %fp + -4 ]
_RBTree_Extract(
40006c3c: 92 07 60 08 add %i5, 8, %o1
40006c40: 40 00 0d 32 call 4000a108 <_RBTree_Extract>
40006c44: 90 02 21 60 add %o0, 0x160, %o0
register uint32_t _psr __asm__("g1") = psr; /* input to trap handler */
40006c48: c2 07 bf fc ld [ %fp + -4 ], %g1
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
40006c4c: 91 d0 20 0a ta 0xa
40006c50: 01 00 00 00 nop
next = the_node->next;
40006c54: c4 07 40 00 ld [ %i5 ], %g2
previous = the_node->previous;
40006c58: c2 07 60 04 ld [ %i5 + 4 ], %g1
next->previous = previous;
40006c5c: c2 20 a0 04 st %g1, [ %g2 + 4 ]
40006c60: 92 10 00 1d mov %i5, %o1
previous->next = next;
40006c64: c4 20 40 00 st %g2, [ %g1 ]
40006c68: 40 00 03 7a call 40007a50 <_Freechain_Put>
40006c6c: 90 10 00 1b mov %i3, %o0
return _Chain_Immutable_head( the_chain )->next;
40006c70: fa 07 20 14 ld [ %i4 + 0x14 ], %i5
while ( !_Chain_Is_empty( &the_key->Key_value_pairs ) ) {
40006c74: 80 a7 40 1a cmp %i5, %i2
40006c78: 32 bf ff ef bne,a 40006c34 <pthread_key_delete+0x50> <== NEVER TAKEN
40006c7c: d0 07 60 1c ld [ %i5 + 0x1c ], %o0 <== NOT EXECUTED
Objects_Control *the_object
)
{
_Assert( _Objects_Allocator_is_owner() );
_Assert( information->deallocate != NULL );
( *information->deallocate )( information, the_object );
40006c80: 90 16 62 88 or %i1, 0x288, %o0
40006c84: c2 02 20 0c ld [ %o0 + 0xc ], %g1
40006c88: 92 10 00 1c mov %i4, %o1
40006c8c: 9f c0 40 00 call %g1
40006c90: b0 10 20 00 clr %i0
_RTEMS_Unlock_allocator();
40006c94: 40 00 02 d7 call 400077f0 <_RTEMS_Unlock_allocator>
40006c98: 01 00 00 00 nop
}
_Objects_Allocator_unlock();
return eno;
}
40006c9c: 81 c7 e0 08 ret
40006ca0: 81 e8 00 00 restore
40007634 <pthread_mutex_getprioceiling>:
#else
pthread_mutex_t *mutex,
#endif
int *prioceiling
)
{
40007634: 9d e3 bf 98 save %sp, -104, %sp
if ( prioceiling == NULL ) {
return EINVAL;
}
the_mutex = _POSIX_Mutex_Get( RTEMS_DECONST( pthread_mutex_t *, mutex ) );
POSIX_MUTEX_VALIDATE_OBJECT( the_mutex, flags );
40007638: 80 a6 60 00 cmp %i1, 0
4000763c: 02 80 00 1a be 400076a4 <pthread_mutex_getprioceiling+0x70>
40007640: 80 a6 20 00 cmp %i0, 0
40007644: 02 80 00 18 be 400076a4 <pthread_mutex_getprioceiling+0x70>
40007648: 05 25 87 04 sethi %hi(0x961c1000), %g2
4000764c: fa 06 00 00 ld [ %i0 ], %i5
40007650: 82 1e 00 1d xor %i0, %i5, %g1
40007654: 84 10 a3 b8 or %g2, 0x3b8, %g2
40007658: 82 18 40 02 xor %g1, %g2, %g1
4000765c: 80 88 7f f8 btst -8, %g1
40007660: 12 80 00 0c bne 40007690 <pthread_mutex_getprioceiling+0x5c>
40007664: 01 00 00 00 nop
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
40007668: 91 d0 20 09 ta 9
RTEMS_INLINE_ROUTINE POSIX_Mutex_Protocol _POSIX_Mutex_Get_protocol(
unsigned long flags
)
{
return flags & POSIX_MUTEX_PROTOCOL_MASK;
4000766c: ba 0f 60 03 and %i5, 3, %i5
_POSIX_Mutex_Acquire( the_mutex, &queue_context );
if ( _POSIX_Mutex_Get_protocol( flags ) == POSIX_MUTEX_PRIORITY_CEILING ) {
40007670: 80 a7 60 02 cmp %i5, 2
40007674: 22 80 00 0e be,a 400076ac <pthread_mutex_getprioceiling+0x78>
40007678: d2 06 20 30 ld [ %i0 + 0x30 ], %o1
*prioceiling = _POSIX_Priority_From_core(
_POSIX_Mutex_Get_scheduler( the_mutex ),
_POSIX_Mutex_Get_priority( the_mutex )
);
} else {
*prioceiling = 0;
4000767c: c0 26 40 00 clr [ %i1 ]
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
40007680: 91 d0 20 0a ta 0xa
40007684: 01 00 00 00 nop
}
_POSIX_Mutex_Release( the_mutex, &queue_context );
return 0;
}
40007688: 81 c7 e0 08 ret
4000768c: 91 e8 20 00 restore %g0, 0, %o0
POSIX_MUTEX_VALIDATE_OBJECT( the_mutex, flags );
40007690: 40 00 01 55 call 40007be4 <_POSIX_Mutex_Auto_initialization>
40007694: 90 10 00 18 mov %i0, %o0
40007698: 80 a2 20 00 cmp %o0, 0
4000769c: 12 bf ff f3 bne 40007668 <pthread_mutex_getprioceiling+0x34> <== ALWAYS TAKEN
400076a0: 01 00 00 00 nop
400076a4: 81 c7 e0 08 ret
400076a8: 91 e8 20 16 restore %g0, 0x16, %o0
*prioceiling = _POSIX_Priority_From_core(
400076ac: d4 06 20 34 ld [ %i0 + 0x34 ], %o2
400076b0: c2 27 bf fc st %g1, [ %fp + -4 ]
400076b4: 11 10 00 68 sethi %hi(0x4001a000), %o0
400076b8: 40 00 02 0f call 40007ef4 <_POSIX_Priority_From_core>
400076bc: 90 12 20 60 or %o0, 0x60, %o0 ! 4001a060 <_Scheduler_Table>
400076c0: c2 07 bf fc ld [ %fp + -4 ], %g1
400076c4: d0 26 40 00 st %o0, [ %i1 ]
400076c8: 91 d0 20 0a ta 0xa
400076cc: 01 00 00 00 nop
}
400076d0: 81 c7 e0 08 ret
400076d4: 91 e8 20 00 restore %g0, 0, %o0
400076d8 <pthread_mutex_init>:
int pthread_mutex_init(
pthread_mutex_t *mutex,
const pthread_mutexattr_t *attr
)
{
400076d8: 9d e3 bf 98 save %sp, -104, %sp
POSIX_Mutex_Protocol protocol;
unsigned long flags;
Priority_Control priority;
const Scheduler_Control *scheduler;
if ( attr ) the_attr = attr;
400076dc: 80 a6 60 00 cmp %i1, 0
400076e0: 02 80 00 13 be 4000772c <pthread_mutex_init+0x54>
400076e4: ba 10 00 18 mov %i0, %i5
else the_attr = &_POSIX_Mutex_Default_attributes;
/* Check for NULL mutex */
if ( !mutex )
400076e8: 80 a6 20 00 cmp %i0, 0
400076ec: 02 80 00 3e be 400077e4 <pthread_mutex_init+0x10c>
400076f0: 01 00 00 00 nop
* value in an uninitialized variable to make this fail.
*
* Thus, we do not look at *mutex.
*/
if ( !the_attr->is_initialized )
400076f4: c2 06 40 00 ld [ %i1 ], %g1
400076f8: 80 a0 60 00 cmp %g1, 0
400076fc: 02 80 00 0a be 40007724 <pthread_mutex_init+0x4c>
40007700: b0 10 20 16 mov 0x16, %i0
return EINVAL;
if ( !_POSIX_Is_valid_pshared( the_attr->process_shared ) ) {
40007704: c2 06 60 04 ld [ %i1 + 4 ], %g1
40007708: 80 a0 60 01 cmp %g1, 1
4000770c: 18 80 00 06 bgu 40007724 <pthread_mutex_init+0x4c>
40007710: 01 00 00 00 nop
40007714: c2 06 60 0c ld [ %i1 + 0xc ], %g1
}
/*
* Determine the discipline of the mutex
*/
switch ( the_attr->protocol ) {
40007718: 80 a0 60 02 cmp %g1, 2
#if defined(_UNIX98_THREAD_MUTEX_ATTRIBUTES)
/*
* Validate the mutex type and set appropriate SuperCore mutex
* attributes.
*/
switch ( the_attr->type ) {
4000771c: 28 80 00 15 bleu,a 40007770 <pthread_mutex_init+0x98>
40007720: c4 06 60 10 ld [ %i1 + 0x10 ], %g2
);
the_mutex->Recursive.nest_level = 0;
_Priority_Node_initialize( &the_mutex->Priority_ceiling, priority );
the_mutex->scheduler = scheduler;
return 0;
}
40007724: 81 c7 e0 08 ret
40007728: 81 e8 00 00 restore
if ( !mutex )
4000772c: 80 a6 20 00 cmp %i0, 0
40007730: 02 80 00 2d be 400077e4 <pthread_mutex_init+0x10c>
40007734: 03 25 87 04 sethi %hi(0x961c1000), %g1
flags = (uintptr_t) the_mutex ^ POSIX_MUTEX_MAGIC;
40007738: 82 10 63 b8 or %g1, 0x3b8, %g1 ! 961c13b8 <RAM_END+0x55dc13b8>
4000773c: 82 1e 00 01 xor %i0, %g1, %g1
flags &= ~POSIX_MUTEX_FLAGS_MASK;
40007740: 82 08 7f f8 and %g1, -8, %g1
the_mutex->flags = flags;
40007744: c2 26 00 00 st %g1, [ %i0 ]
priority = 0;
40007748: 90 10 20 00 clr %o0
4000774c: 92 10 20 00 clr %o1
)
{
#if defined(RTEMS_SMP)
_SMP_ticket_lock_Initialize( &queue->Lock );
#endif
queue->heads = NULL;
40007750: c0 27 60 0c clr [ %i5 + 0xc ]
queue->owner = NULL;
40007754: c0 27 60 10 clr [ %i5 + 0x10 ]
queue->name = name;
40007758: c0 27 60 14 clr [ %i5 + 0x14 ]
the_mutex->Recursive.nest_level = 0;
4000775c: c0 27 60 18 clr [ %i5 + 0x18 ]
RTEMS_INLINE_ROUTINE void _Priority_Node_initialize(
Priority_Node *node,
Priority_Control priority
)
{
node->priority = priority;
40007760: d0 3f 60 30 std %o0, [ %i5 + 0x30 ]
the_mutex->scheduler = scheduler;
40007764: f2 27 60 38 st %i1, [ %i5 + 0x38 ]
return 0;
40007768: 81 c7 e0 08 ret
4000776c: 91 e8 20 00 restore %g0, 0, %o0
switch ( the_attr->type ) {
40007770: 80 a0 a0 03 cmp %g2, 3
40007774: 18 bf ff ec bgu 40007724 <pthread_mutex_init+0x4c>
40007778: 80 a0 a0 01 cmp %g2, 1
flags = (uintptr_t) the_mutex ^ POSIX_MUTEX_MAGIC;
4000777c: 05 25 87 04 sethi %hi(0x961c1000), %g2
40007780: 84 10 a3 b8 or %g2, 0x3b8, %g2 ! 961c13b8 <RAM_END+0x55dc13b8>
40007784: 84 1f 40 02 xor %i5, %g2, %g2
flags &= ~POSIX_MUTEX_FLAGS_MASK;
40007788: 84 08 bf f8 and %g2, -8, %g2
if ( the_attr->type == PTHREAD_MUTEX_RECURSIVE ) {
4000778c: 12 80 00 03 bne 40007798 <pthread_mutex_init+0xc0> <== ALWAYS TAKEN
40007790: 84 10 80 01 or %g2, %g1, %g2
flags |= POSIX_MUTEX_RECURSIVE;
40007794: 84 10 a0 04 or %g2, 4, %g2 <== NOT EXECUTED
if ( protocol == POSIX_MUTEX_PRIORITY_CEILING ) {
40007798: 80 a0 60 02 cmp %g1, 2
4000779c: 12 80 00 14 bne 400077ec <pthread_mutex_init+0x114>
400077a0: c4 27 40 00 st %g2, [ %i5 ]
prio_ceiling = the_attr->prio_ceiling;
400077a4: d2 06 60 08 ld [ %i1 + 8 ], %o1
if ( prio_ceiling == INT_MAX ) {
400077a8: 03 1f ff ff sethi %hi(0x7ffffc00), %g1
400077ac: 82 10 63 ff or %g1, 0x3ff, %g1 ! 7fffffff <RAM_END+0x3fbfffff>
400077b0: 80 a2 40 01 cmp %o1, %g1
400077b4: 12 80 00 05 bne 400077c8 <pthread_mutex_init+0xf0>
400077b8: 33 10 00 68 sethi %hi(0x4001a000), %i1
RTEMS_INLINE_ROUTINE int _POSIX_Priority_Get_maximum(
const Scheduler_Control *scheduler
)
{
_Assert( (int) scheduler->maximum_priority > 1 );
return (int) scheduler->maximum_priority - 1;
400077bc: 82 16 60 60 or %i1, 0x60, %g1 ! 4001a060 <_Scheduler_Table>
400077c0: d2 00 60 44 ld [ %g1 + 0x44 ], %o1
400077c4: 92 02 7f ff add %o1, -1, %o1
priority = _POSIX_Priority_To_core( scheduler, prio_ceiling, &valid );
400077c8: 90 16 60 60 or %i1, 0x60, %o0
400077cc: 40 00 01 ad call 40007e80 <_POSIX_Priority_To_core>
400077d0: 94 07 bf ff add %fp, -1, %o2
if ( !valid ) {
400077d4: c2 0f bf ff ldub [ %fp + -1 ], %g1
400077d8: 80 a0 60 00 cmp %g1, 0
400077dc: 12 bf ff dd bne 40007750 <pthread_mutex_init+0x78>
400077e0: b2 16 60 60 or %i1, 0x60, %i1
return EINVAL;
400077e4: 81 c7 e0 08 ret
400077e8: 91 e8 20 16 restore %g0, 0x16, %o0
scheduler = NULL;
400077ec: b2 10 20 00 clr %i1
priority = 0;
400077f0: 90 10 20 00 clr %o0
400077f4: 10 bf ff d7 b 40007750 <pthread_mutex_init+0x78>
400077f8: 92 10 20 00 clr %o1
40007a94 <pthread_mutex_setprioceiling>:
int pthread_mutex_setprioceiling(
pthread_mutex_t *mutex,
int prioceiling,
int *old_ceiling
)
{
40007a94: 9d e3 bf 78 save %sp, -136, %sp
POSIX_Mutex_Control *the_mutex;
int error;
int unlock_error;
if ( old_ceiling == NULL ) {
40007a98: 80 a6 a0 00 cmp %i2, 0
40007a9c: 02 80 00 12 be 40007ae4 <pthread_mutex_setprioceiling+0x50>
40007aa0: ba 10 20 16 mov 0x16, %i5
/*
* Must acquire the mutex before we can change it's ceiling.
* POSIX says block until we acquire it.
*/
error = pthread_mutex_lock( mutex );
40007aa4: 7f ff ff 56 call 400077fc <pthread_mutex_lock>
40007aa8: 90 10 00 18 mov %i0, %o0
if ( error != 0 ) {
40007aac: ba 92 20 00 orcc %o0, 0, %i5
40007ab0: 32 80 00 0d bne,a 40007ae4 <pthread_mutex_setprioceiling+0x50>
40007ab4: ba 10 20 16 mov 0x16, %i5
return flags & POSIX_MUTEX_PROTOCOL_MASK;
40007ab8: c2 06 00 00 ld [ %i0 ], %g1
40007abc: 82 08 60 03 and %g1, 3, %g1
return EINVAL;
}
the_mutex = _POSIX_Mutex_Get( mutex );
if (
40007ac0: 80 a0 60 02 cmp %g1, 2
40007ac4: 22 80 00 0a be,a 40007aec <pthread_mutex_setprioceiling+0x58>
40007ac8: d2 06 20 30 ld [ %i0 + 0x30 ], %o1
error = 0;
} else {
error = EINVAL;
}
} else {
*old_ceiling = 0;
40007acc: c0 26 80 00 clr [ %i2 ]
error = 0;
}
unlock_error = pthread_mutex_unlock( mutex );
40007ad0: 90 10 00 18 mov %i0, %o0
40007ad4: 40 00 00 6b call 40007c80 <pthread_mutex_unlock>
40007ad8: b0 10 00 1d mov %i5, %i0
_Assert( unlock_error == 0 );
(void) unlock_error;
return error;
}
40007adc: 81 c7 e0 08 ret
40007ae0: 81 e8 00 00 restore
40007ae4: 81 c7 e0 08 ret
40007ae8: 91 e8 00 1d restore %g0, %i5, %o0
*old_ceiling = _POSIX_Priority_From_core( scheduler, old_priority );
40007aec: d4 06 20 34 ld [ %i0 + 0x34 ], %o2
40007af0: 39 10 00 68 sethi %hi(0x4001a000), %i4
40007af4: 40 00 01 00 call 40007ef4 <_POSIX_Priority_From_core>
40007af8: 90 17 20 60 or %i4, 0x60, %o0 ! 4001a060 <_Scheduler_Table>
40007afc: d0 26 80 00 st %o0, [ %i2 ]
new_priority = _POSIX_Priority_To_core( scheduler, prioceiling, &valid );
40007b00: 94 07 bf db add %fp, -37, %o2
40007b04: 92 10 00 19 mov %i1, %o1
40007b08: 40 00 00 de call 40007e80 <_POSIX_Priority_To_core>
40007b0c: 90 17 20 60 or %i4, 0x60, %o0
if ( valid ) {
40007b10: c2 0f bf db ldub [ %fp + -37 ], %g1
40007b14: 80 a0 60 00 cmp %g1, 0
40007b18: 32 80 00 04 bne,a 40007b28 <pthread_mutex_setprioceiling+0x94>
40007b1c: c0 27 bf f0 clr [ %fp + -16 ]
error = EINVAL;
40007b20: 10 bf ff ec b 40007ad0 <pthread_mutex_setprioceiling+0x3c>
40007b24: ba 10 20 16 mov 0x16, %i5
return the_mutex->Recursive.Mutex.Queue.Queue.owner;
40007b28: c4 06 20 10 ld [ %i0 + 0x10 ], %g2
if ( owner != NULL ) {
40007b2c: 80 a0 a0 00 cmp %g2, 0
40007b30: 22 80 00 19 be,a 40007b94 <pthread_mutex_setprioceiling+0x100> <== NEVER TAKEN
40007b34: d0 26 20 30 st %o0, [ %i0 + 0x30 ] <== NOT EXECUTED
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
40007b38: 91 d0 20 09 ta 9
RTEMS_INLINE_ROUTINE void _Thread_Wait_acquire(
Thread_Control *the_thread,
Thread_queue_Context *queue_context
)
{
_ISR_lock_ISR_disable( &queue_context->Lock_context.Lock_context );
40007b3c: c2 27 bf dc st %g1, [ %fp + -36 ]
node->priority = priority;
40007b40: d0 26 20 30 st %o0, [ %i0 + 0x30 ]
_Thread_Priority_changed(
40007b44: b6 07 bf dc add %fp, -36, %i3
40007b48: d2 26 20 34 st %o1, [ %i0 + 0x34 ]
40007b4c: 96 10 00 1b mov %i3, %o3
40007b50: 94 10 20 00 clr %o2
40007b54: 92 06 20 20 add %i0, 0x20, %o1
40007b58: 40 00 0a 10 call 4000a398 <_Thread_Priority_changed>
40007b5c: 90 10 00 02 mov %g2, %o0
register uint32_t _psr __asm__("g1") = psr; /* input to trap handler */
40007b60: c2 07 bf dc ld [ %fp + -36 ], %g1
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
40007b64: 91 d0 20 0a ta 0xa
40007b68: 01 00 00 00 nop
disable_level = cpu_self->thread_dispatch_disable_level;
40007b6c: c2 01 a0 18 ld [ %g6 + 0x18 ], %g1
cpu_self->thread_dispatch_disable_level = disable_level + 1;
40007b70: 82 00 60 01 inc %g1
40007b74: c2 21 a0 18 st %g1, [ %g6 + 0x18 ]
return _Thread_Dispatch_disable_with_CPU( _Per_CPU_Get(), lock_context );
40007b78: b8 10 00 06 mov %g6, %i4
_Thread_Priority_update( &queue_context );
40007b7c: 40 00 0a 29 call 4000a420 <_Thread_Priority_update>
40007b80: 90 10 00 1b mov %i3, %o0
_Thread_Dispatch_enable( cpu_self );
40007b84: 40 00 0a b7 call 4000a660 <_Thread_Dispatch_enable>
40007b88: 90 10 00 1c mov %i4, %o0
error = 0;
40007b8c: 10 bf ff d2 b 40007ad4 <pthread_mutex_setprioceiling+0x40>
40007b90: 90 10 00 18 mov %i0, %o0
the_mutex->Priority_ceiling.priority = priority_ceiling;
40007b94: b6 07 bf dc add %fp, -36, %i3 <== NOT EXECUTED
40007b98: 10 bf ff f5 b 40007b6c <pthread_mutex_setprioceiling+0xd8> <== NOT EXECUTED
40007b9c: d2 26 20 34 st %o1, [ %i0 + 0x34 ] <== NOT EXECUTED
40007c80 <pthread_mutex_unlock>:
*/
int pthread_mutex_unlock(
pthread_mutex_t *mutex
)
{
40007c80: 9d e3 bf 70 save %sp, -144, %sp
Thread_queue_Context queue_context;
Thread_Control *executing;
Status_Control status;
the_mutex = _POSIX_Mutex_Get( mutex );
POSIX_MUTEX_VALIDATE_OBJECT( the_mutex, flags );
40007c84: 80 a6 20 00 cmp %i0, 0
40007c88: 02 80 00 5c be 40007df8 <pthread_mutex_unlock+0x178>
40007c8c: 05 25 87 04 sethi %hi(0x961c1000), %g2
40007c90: fa 06 00 00 ld [ %i0 ], %i5
40007c94: 82 1e 00 1d xor %i0, %i5, %g1
40007c98: 84 10 a3 b8 or %g2, 0x3b8, %g2
40007c9c: 82 18 40 02 xor %g1, %g2, %g1
40007ca0: 80 88 7f f8 btst -8, %g1
40007ca4: 12 80 00 50 bne 40007de4 <pthread_mutex_unlock+0x164>
40007ca8: 01 00 00 00 nop
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
40007cac: 91 d0 20 09 ta 9
40007cb0: c2 27 bf dc st %g1, [ %fp + -36 ]
executing = _POSIX_Mutex_Acquire( the_mutex, &queue_context );
switch ( _POSIX_Mutex_Get_protocol( flags ) ) {
40007cb4: ba 8f 60 03 andcc %i5, 3, %i5
40007cb8: 02 80 00 42 be 40007dc0 <pthread_mutex_unlock+0x140>
40007cbc: d0 01 a0 20 ld [ %g6 + 0x20 ], %o0
40007cc0: 80 a7 60 02 cmp %i5, 2
40007cc4: 02 80 00 16 be 40007d1c <pthread_mutex_unlock+0x9c>
40007cc8: c2 06 20 10 ld [ %i0 + 0x10 ], %g1
if ( !_POSIX_Mutex_Is_owner( the_mutex, executing ) ) {
40007ccc: 80 a2 00 01 cmp %o0, %g1
40007cd0: 12 80 00 40 bne 40007dd0 <pthread_mutex_unlock+0x150>
40007cd4: 01 00 00 00 nop
nest_level = the_mutex->Recursive.nest_level;
40007cd8: c2 06 20 18 ld [ %i0 + 0x18 ], %g1
if ( nest_level > 0 ) {
40007cdc: 80 a0 60 00 cmp %g1, 0
40007ce0: 12 80 00 58 bne 40007e40 <pthread_mutex_unlock+0x1c0> <== NEVER TAKEN
40007ce4: 82 00 7f ff add %g1, -1, %g1
the_mutex->Recursive.Mutex.Queue.Queue.owner = owner;
40007ce8: c0 26 20 10 clr [ %i0 + 0x10 ]
heads = the_mutex->Recursive.Mutex.Queue.Queue.heads;
40007cec: d2 06 20 0c ld [ %i0 + 0xc ], %o1
if ( heads == NULL ) {
40007cf0: 80 a2 60 00 cmp %o1, 0
40007cf4: 02 80 00 59 be 40007e58 <pthread_mutex_unlock+0x1d8>
40007cf8: 94 10 00 08 mov %o0, %o2
_Thread_queue_Surrender(
40007cfc: 96 07 bf dc add %fp, -36, %o3
40007d00: 90 06 20 0c add %i0, 0xc, %o0
40007d04: 19 10 00 69 sethi %hi(0x4001a400), %o4
return STATUS_SUCCESSFUL;
40007d08: b0 10 20 00 clr %i0
_Thread_queue_Surrender(
40007d0c: 40 00 0c 0a call 4000ad34 <_Thread_queue_Surrender>
40007d10: 98 13 23 48 or %o4, 0x348, %o4
);
break;
}
return _POSIX_Get_error( status );
}
40007d14: 81 c7 e0 08 ret
40007d18: 81 e8 00 00 restore
unsigned int nest_level;
ISR_lock_Context lock_context;
Per_CPU_Control *cpu_self;
Thread_queue_Heads *heads;
if ( !_POSIX_Mutex_Is_owner( the_mutex, executing ) ) {
40007d1c: 80 a2 00 01 cmp %o0, %g1
40007d20: 12 80 00 2c bne 40007dd0 <pthread_mutex_unlock+0x150> <== NEVER TAKEN
40007d24: 01 00 00 00 nop
_POSIX_Mutex_Release( the_mutex, queue_context );
return STATUS_NOT_OWNER;
}
nest_level = the_mutex->Recursive.nest_level;
40007d28: c2 06 20 18 ld [ %i0 + 0x18 ], %g1
if ( nest_level > 0 ) {
40007d2c: 80 a0 60 00 cmp %g1, 0
40007d30: 12 80 00 44 bne 40007e40 <pthread_mutex_unlock+0x1c0> <== NEVER TAKEN
40007d34: 82 00 7f ff add %g1, -1, %g1
_Thread_Resource_count_decrement( executing );
_Thread_queue_Context_clear_priority_updates( queue_context );
_Thread_Wait_acquire_default_critical( executing, &lock_context );
_Thread_Priority_remove(
40007d38: 92 06 20 20 add %i0, 0x20, %o1
40007d3c: c0 27 bf f0 clr [ %fp + -16 ]
40007d40: 94 07 bf dc add %fp, -36, %o2
40007d44: 40 00 09 73 call 4000a310 <_Thread_Priority_remove>
40007d48: d2 27 bf d4 st %o1, [ %fp + -44 ]
disable_level = cpu_self->thread_dispatch_disable_level;
40007d4c: c2 01 a0 18 ld [ %g6 + 0x18 ], %g1
cpu_self->thread_dispatch_disable_level = disable_level + 1;
40007d50: 82 00 60 01 inc %g1
40007d54: c2 21 a0 18 st %g1, [ %g6 + 0x18 ]
);
_Thread_Wait_release_default_critical( executing, &lock_context );
cpu_self = _Thread_queue_Dispatch_disable( queue_context );
heads = the_mutex->Recursive.Mutex.Queue.Queue.heads;
40007d58: d0 06 20 0c ld [ %i0 + 0xc ], %o0
if ( heads != NULL ) {
40007d5c: 80 a2 20 00 cmp %o0, 0
40007d60: 02 80 00 43 be 40007e6c <pthread_mutex_unlock+0x1ec>
40007d64: ba 10 00 06 mov %g6, %i5
const Thread_queue_Operations *operations;
Thread_Control *new_owner;
operations = POSIX_MUTEX_PRIORITY_CEILING_TQ_OPERATIONS;
new_owner = ( *operations->first )( heads );
40007d68: 39 10 00 69 sethi %hi(0x4001a400), %i4
40007d6c: b8 17 23 5c or %i4, 0x35c, %i4 ! 4001a75c <_Thread_queue_Operations_priority>
40007d70: c2 07 20 10 ld [ %i4 + 0x10 ], %g1
40007d74: 9f c0 40 00 call %g1
40007d78: 01 00 00 00 nop
the_mutex->Recursive.Mutex.Queue.Queue.owner = owner;
40007d7c: d0 26 20 10 st %o0, [ %i0 + 0x10 ]
new_owner = ( *operations->first )( heads );
40007d80: b6 10 00 08 mov %o0, %i3
_POSIX_Mutex_Set_owner( the_mutex, new_owner );
_Thread_Resource_count_increment( new_owner );
_Thread_Priority_add(
40007d84: d2 07 bf d4 ld [ %fp + -44 ], %o1
40007d88: 40 00 09 41 call 4000a28c <_Thread_Priority_add>
40007d8c: 94 07 bf dc add %fp, -36, %o2
new_owner,
&the_mutex->Priority_ceiling,
queue_context
);
_Thread_queue_Extract_critical(
40007d90: 96 07 bf dc add %fp, -36, %o3
40007d94: 94 10 00 1b mov %i3, %o2
40007d98: 92 10 00 1c mov %i4, %o1
40007d9c: 40 00 0b a5 call 4000ac30 <_Thread_queue_Extract_critical>
40007da0: 90 06 20 0c add %i0, 0xc, %o0
} else {
_POSIX_Mutex_Set_owner( the_mutex, NULL );
_POSIX_Mutex_Release( the_mutex, queue_context );
}
_Thread_Priority_update( queue_context );
40007da4: 40 00 09 9f call 4000a420 <_Thread_Priority_update>
40007da8: 90 07 bf dc add %fp, -36, %o0
_Thread_Dispatch_enable( cpu_self );
40007dac: 90 10 00 1d mov %i5, %o0
40007db0: 40 00 0a 2c call 4000a660 <_Thread_Dispatch_enable>
40007db4: b0 10 20 00 clr %i0
return STATUS_SUCCESSFUL;
40007db8: 81 c7 e0 08 ret
40007dbc: 81 e8 00 00 restore
if ( !_POSIX_Mutex_Is_owner( the_mutex, executing ) ) {
40007dc0: c2 06 20 10 ld [ %i0 + 0x10 ], %g1
40007dc4: 80 a2 00 01 cmp %o0, %g1
40007dc8: 22 80 00 0e be,a 40007e00 <pthread_mutex_unlock+0x180>
40007dcc: c2 06 20 18 ld [ %i0 + 0x18 ], %g1
register uint32_t _psr __asm__("g1") = psr; /* input to trap handler */
40007dd0: c2 07 bf dc ld [ %fp + -36 ], %g1
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
40007dd4: 91 d0 20 0a ta 0xa
40007dd8: 01 00 00 00 nop
return STATUS_NOT_OWNER;
40007ddc: 81 c7 e0 08 ret
40007de0: 91 e8 20 01 restore %g0, 1, %o0
POSIX_MUTEX_VALIDATE_OBJECT( the_mutex, flags );
40007de4: 7f ff ff 80 call 40007be4 <_POSIX_Mutex_Auto_initialization>
40007de8: 90 10 00 18 mov %i0, %o0
40007dec: 80 a2 20 00 cmp %o0, 0
40007df0: 12 bf ff af bne 40007cac <pthread_mutex_unlock+0x2c>
40007df4: 01 00 00 00 nop
40007df8: 81 c7 e0 08 ret
40007dfc: 91 e8 20 16 restore %g0, 0x16, %o0
if ( nest_level > 0 ) {
40007e00: 80 a0 60 00 cmp %g1, 0
40007e04: 12 80 00 0f bne 40007e40 <pthread_mutex_unlock+0x1c0> <== NEVER TAKEN
40007e08: 82 00 7f ff add %g1, -1, %g1
the_mutex->Recursive.Mutex.Queue.Queue.owner = owner;
40007e0c: c0 26 20 10 clr [ %i0 + 0x10 ]
heads = the_mutex->Recursive.Mutex.Queue.Queue.heads;
40007e10: d2 06 20 0c ld [ %i0 + 0xc ], %o1
if ( heads == NULL ) {
40007e14: 80 a2 60 00 cmp %o1, 0
40007e18: 02 80 00 10 be 40007e58 <pthread_mutex_unlock+0x1d8>
40007e1c: 94 10 00 08 mov %o0, %o2
_Thread_queue_Surrender(
40007e20: 96 07 bf dc add %fp, -36, %o3
40007e24: 90 06 20 0c add %i0, 0xc, %o0
40007e28: 19 10 00 69 sethi %hi(0x4001a400), %o4
return STATUS_SUCCESSFUL;
40007e2c: b0 10 20 00 clr %i0
_Thread_queue_Surrender(
40007e30: 40 00 0b c1 call 4000ad34 <_Thread_queue_Surrender>
40007e34: 98 13 23 70 or %o4, 0x370, %o4
return STATUS_SUCCESSFUL;
40007e38: 81 c7 e0 08 ret
40007e3c: 81 e8 00 00 restore
the_mutex->Recursive.nest_level = nest_level - 1;
40007e40: c2 26 20 18 st %g1, [ %i0 + 0x18 ] <== NOT EXECUTED
register uint32_t _psr __asm__("g1") = psr; /* input to trap handler */
40007e44: c2 07 bf dc ld [ %fp + -36 ], %g1 <== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
40007e48: 91 d0 20 0a ta 0xa <== NOT EXECUTED
40007e4c: 01 00 00 00 nop <== NOT EXECUTED
return STATUS_SUCCESSFUL;
40007e50: 81 c7 e0 08 ret <== NOT EXECUTED
40007e54: 91 e8 20 00 restore %g0, 0, %o0 <== NOT EXECUTED
register uint32_t _psr __asm__("g1") = psr; /* input to trap handler */
40007e58: c2 07 bf dc ld [ %fp + -36 ], %g1
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
40007e5c: 91 d0 20 0a ta 0xa
40007e60: 01 00 00 00 nop
40007e64: 81 c7 e0 08 ret
40007e68: 91 e8 20 00 restore %g0, 0, %o0
the_mutex->Recursive.Mutex.Queue.Queue.owner = owner;
40007e6c: c0 26 20 10 clr [ %i0 + 0x10 ]
register uint32_t _psr __asm__("g1") = psr; /* input to trap handler */
40007e70: c2 07 bf dc ld [ %fp + -36 ], %g1
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
40007e74: 91 d0 20 0a ta 0xa
40007e78: 01 00 00 00 nop
}
40007e7c: 30 bf ff ca b,a 40007da4 <pthread_mutex_unlock+0x124>
40004250 <pthread_mutexattr_gettype>:
int pthread_mutexattr_gettype(
const pthread_mutexattr_t *attr,
int *type
)
{
if ( attr == NULL || !attr->is_initialized || type == NULL )
40004250: 80 a2 20 00 cmp %o0, 0
40004254: 02 80 00 0c be 40004284 <pthread_mutexattr_gettype+0x34>
40004258: 01 00 00 00 nop
4000425c: c2 02 00 00 ld [ %o0 ], %g1
40004260: 80 a0 60 00 cmp %g1, 0
40004264: 02 80 00 08 be 40004284 <pthread_mutexattr_gettype+0x34>
40004268: 80 a2 60 00 cmp %o1, 0
4000426c: 02 80 00 06 be 40004284 <pthread_mutexattr_gettype+0x34> <== NEVER TAKEN
40004270: 01 00 00 00 nop
return EINVAL;
*type = attr->type;
40004274: c2 02 20 10 ld [ %o0 + 0x10 ], %g1
40004278: c2 22 40 00 st %g1, [ %o1 ]
return 0;
4000427c: 81 c3 e0 08 retl
40004280: 90 10 20 00 clr %o0
}
40004284: 81 c3 e0 08 retl
40004288: 90 10 20 16 mov 0x16, %o0
40007570 <pthread_mutexattr_setpshared>:
int pthread_mutexattr_setpshared(
pthread_mutexattr_t *attr,
int pshared
)
{
if ( !attr || !attr->is_initialized )
40007570: 82 92 20 00 orcc %o0, 0, %g1
40007574: 02 80 00 0b be 400075a0 <pthread_mutexattr_setpshared+0x30>
40007578: 90 10 20 16 mov 0x16, %o0
4000757c: c4 00 40 00 ld [ %g1 ], %g2
40007580: 80 a0 a0 00 cmp %g2, 0
40007584: 02 80 00 07 be 400075a0 <pthread_mutexattr_setpshared+0x30>
40007588: 80 a2 60 01 cmp %o1, 1
return EINVAL;
switch ( pshared ) {
4000758c: 18 80 00 05 bgu 400075a0 <pthread_mutexattr_setpshared+0x30> <== NEVER TAKEN
40007590: 01 00 00 00 nop
case PTHREAD_PROCESS_SHARED:
case PTHREAD_PROCESS_PRIVATE:
attr->process_shared = pshared;
40007594: d2 20 60 04 st %o1, [ %g1 + 4 ]
return 0;
40007598: 81 c3 e0 08 retl
4000759c: 90 10 20 00 clr %o0
default:
return EINVAL;
}
}
400075a0: 81 c3 e0 08 retl
400075a4: 01 00 00 00 nop
400042dc <pthread_mutexattr_settype>:
int pthread_mutexattr_settype(
pthread_mutexattr_t *attr,
int type
)
{
if ( !attr || !attr->is_initialized )
400042dc: 82 92 20 00 orcc %o0, 0, %g1
400042e0: 02 80 00 0b be 4000430c <pthread_mutexattr_settype+0x30>
400042e4: 90 10 20 16 mov 0x16, %o0
400042e8: c4 00 40 00 ld [ %g1 ], %g2
400042ec: 80 a0 a0 00 cmp %g2, 0
400042f0: 02 80 00 07 be 4000430c <pthread_mutexattr_settype+0x30> <== NEVER TAKEN
400042f4: 80 a2 60 03 cmp %o1, 3
return EINVAL;
switch ( type ) {
400042f8: 18 80 00 05 bgu 4000430c <pthread_mutexattr_settype+0x30>
400042fc: 01 00 00 00 nop
case PTHREAD_MUTEX_NORMAL:
case PTHREAD_MUTEX_RECURSIVE:
case PTHREAD_MUTEX_ERRORCHECK:
case PTHREAD_MUTEX_DEFAULT:
attr->type = type;
40004300: d2 20 60 10 st %o1, [ %g1 + 0x10 ]
return 0;
40004304: 81 c3 e0 08 retl
40004308: 90 10 20 00 clr %o0
default:
return EINVAL;
}
}
4000430c: 81 c3 e0 08 retl
40004310: 01 00 00 00 nop
4000631c <pthread_rwlock_init>:
int pthread_rwlock_init(
pthread_rwlock_t *rwlock,
const pthread_rwlockattr_t *attr
)
{
4000631c: 9d e3 bf a0 save %sp, -96, %sp
POSIX_RWLock_Control *the_rwlock;
the_rwlock = _POSIX_RWLock_Get( rwlock );
if ( the_rwlock == NULL ) {
40006320: 90 96 20 00 orcc %i0, 0, %o0
40006324: 02 80 00 14 be 40006374 <pthread_rwlock_init+0x58>
40006328: 80 a6 60 00 cmp %i1, 0
return EINVAL;
}
if ( attr != NULL ) {
4000632c: 02 80 00 0a be 40006354 <pthread_rwlock_init+0x38>
40006330: 03 25 88 76 sethi %hi(0x9621d800), %g1
if ( !attr->is_initialized ) {
40006334: c2 06 40 00 ld [ %i1 ], %g1
40006338: 80 a0 60 00 cmp %g1, 0
4000633c: 02 80 00 0c be 4000636c <pthread_rwlock_init+0x50> <== NEVER TAKEN
40006340: b0 10 20 16 mov 0x16, %i0
return EINVAL;
}
if ( !_POSIX_Is_valid_pshared( attr->process_shared ) ) {
40006344: c2 06 60 04 ld [ %i1 + 4 ], %g1
40006348: 80 a0 60 01 cmp %g1, 1
4000634c: 18 80 00 08 bgu 4000636c <pthread_rwlock_init+0x50>
40006350: 03 25 88 76 sethi %hi(0x9621d800), %g1
return EINVAL;
}
}
the_rwlock->flags = (uintptr_t) the_rwlock ^ POSIX_RWLOCK_MAGIC;
40006354: 82 10 62 bd or %g1, 0x2bd, %g1 ! 9621dabd <RAM_END+0x55e1dabd>
40006358: 82 1a 00 01 xor %o0, %g1, %g1
4000635c: c2 22 00 00 st %g1, [ %o0 ]
_CORE_RWLock_Initialize( &the_rwlock->RWLock );
return 0;
40006360: b0 10 20 00 clr %i0
_CORE_RWLock_Initialize( &the_rwlock->RWLock );
40006364: 40 00 05 07 call 40007780 <_CORE_RWLock_Initialize>
40006368: 90 02 20 04 add %o0, 4, %o0
return 0;
4000636c: 81 c7 e0 08 ret
40006370: 81 e8 00 00 restore
return EINVAL;
40006374: b0 10 20 16 mov 0x16, %i0
}
40006378: 81 c7 e0 08 ret
4000637c: 81 e8 00 00 restore
40006f5c <pthread_rwlockattr_setpshared>:
int pthread_rwlockattr_setpshared(
pthread_rwlockattr_t *attr,
int pshared
)
{
if ( !attr )
40006f5c: 82 92 20 00 orcc %o0, 0, %g1
40006f60: 02 80 00 0b be 40006f8c <pthread_rwlockattr_setpshared+0x30>
40006f64: 90 10 20 16 mov 0x16, %o0
return EINVAL;
if ( !attr->is_initialized )
40006f68: c4 00 40 00 ld [ %g1 ], %g2
40006f6c: 80 a0 a0 00 cmp %g2, 0
40006f70: 02 80 00 07 be 40006f8c <pthread_rwlockattr_setpshared+0x30>
40006f74: 80 a2 60 01 cmp %o1, 1
return EINVAL;
switch ( pshared ) {
40006f78: 18 80 00 05 bgu 40006f8c <pthread_rwlockattr_setpshared+0x30> <== NEVER TAKEN
40006f7c: 01 00 00 00 nop
case PTHREAD_PROCESS_SHARED:
case PTHREAD_PROCESS_PRIVATE:
attr->process_shared = pshared;
40006f80: d2 20 60 04 st %o1, [ %g1 + 4 ]
return 0;
40006f84: 81 c3 e0 08 retl
40006f88: 90 10 20 00 clr %o0
default:
return EINVAL;
}
}
40006f8c: 81 c3 e0 08 retl
40006f90: 01 00 00 00 nop
40005e48 <pthread_setcancelstate>:
int pthread_setcancelstate(
int state,
int *oldstate
)
{
40005e48: 9d e3 bf a0 save %sp, -96, %sp
Thread_Life_state new_life_protection;
Thread_Life_state previous_life_state;
if ( _ISR_Is_in_progress() ) {
40005e4c: 40 00 01 26 call 400062e4 <_ISR_Is_in_progress>
40005e50: 01 00 00 00 nop
40005e54: 80 a2 20 00 cmp %o0, 0
40005e58: 12 80 00 11 bne 40005e9c <pthread_setcancelstate+0x54>
40005e5c: 82 10 20 47 mov 0x47, %g1
return EPROTO;
}
if ( state == PTHREAD_CANCEL_DISABLE ) {
40005e60: 80 a6 20 01 cmp %i0, 1
40005e64: 02 80 00 12 be 40005eac <pthread_setcancelstate+0x64> <== NEVER TAKEN
40005e68: 80 a6 20 00 cmp %i0, 0
new_life_protection = THREAD_LIFE_PROTECTED;
} else if ( state == PTHREAD_CANCEL_ENABLE ) {
40005e6c: 12 80 00 0c bne 40005e9c <pthread_setcancelstate+0x54>
40005e70: 82 10 20 16 mov 0x16, %g1
new_life_protection = 0;
} else {
return EINVAL;
}
previous_life_state = _Thread_Set_life_protection( new_life_protection );
40005e74: 40 00 0d d8 call 400095d4 <_Thread_Set_life_protection>
40005e78: 01 00 00 00 nop
if ( oldstate != NULL ) {
40005e7c: 80 a6 60 00 cmp %i1, 0
40005e80: 02 80 00 07 be 40005e9c <pthread_setcancelstate+0x54>
40005e84: 82 10 20 00 clr %g1
if ( ( previous_life_state & THREAD_LIFE_PROTECTED ) != 0 ) {
40005e88: 80 8a 20 01 btst 1, %o0
40005e8c: 22 80 00 06 be,a 40005ea4 <pthread_setcancelstate+0x5c> <== ALWAYS TAKEN
40005e90: c0 26 40 00 clr [ %i1 ]
*oldstate = PTHREAD_CANCEL_DISABLE;
40005e94: 84 10 20 01 mov 1, %g2 <== NOT EXECUTED
40005e98: c4 26 40 00 st %g2, [ %i1 ] <== NOT EXECUTED
*oldstate = PTHREAD_CANCEL_ENABLE;
}
}
return 0;
}
40005e9c: 81 c7 e0 08 ret
40005ea0: 91 e8 00 01 restore %g0, %g1, %o0
40005ea4: 81 c7 e0 08 ret
40005ea8: 91 e8 00 01 restore %g0, %g1, %o0
previous_life_state = _Thread_Set_life_protection( new_life_protection );
40005eac: 40 00 0d ca call 400095d4 <_Thread_Set_life_protection> <== NOT EXECUTED
40005eb0: 90 10 20 01 mov 1, %o0 <== NOT EXECUTED
if ( oldstate != NULL ) {
40005eb4: 80 a6 60 00 cmp %i1, 0 <== NOT EXECUTED
40005eb8: 12 bf ff f4 bne 40005e88 <pthread_setcancelstate+0x40> <== NOT EXECUTED
40005ebc: 82 10 20 00 clr %g1 <== NOT EXECUTED
40005ec0: 30 bf ff f7 b,a 40005e9c <pthread_setcancelstate+0x54> <== NOT EXECUTED
40005ec4 <pthread_setcanceltype>:
int pthread_setcanceltype(
int type,
int *oldtype
)
{
40005ec4: 9d e3 bf a0 save %sp, -96, %sp
Thread_Life_state set_life_state;
Thread_Life_state previous_life_state;
if ( _ISR_Is_in_progress() ) {
40005ec8: 40 00 01 07 call 400062e4 <_ISR_Is_in_progress>
40005ecc: 01 00 00 00 nop
40005ed0: 80 a2 20 00 cmp %o0, 0
40005ed4: 12 80 00 12 bne 40005f1c <pthread_setcanceltype+0x58>
40005ed8: 82 10 20 47 mov 0x47, %g1
return EPROTO;
}
if ( type == PTHREAD_CANCEL_DEFERRED ) {
40005edc: 80 a6 20 00 cmp %i0, 0
40005ee0: 02 80 00 11 be 40005f24 <pthread_setcanceltype+0x60>
40005ee4: 82 10 20 16 mov 0x16, %g1
set_life_state = THREAD_LIFE_CHANGE_DEFERRED;
} else if ( type == PTHREAD_CANCEL_ASYNCHRONOUS ) {
40005ee8: 80 a6 20 01 cmp %i0, 1
40005eec: 12 80 00 0c bne 40005f1c <pthread_setcanceltype+0x58>
40005ef0: 92 10 20 00 clr %o1
set_life_state = 0;
} else {
return EINVAL;
}
previous_life_state = _Thread_Change_life(
40005ef4: 94 10 20 00 clr %o2
40005ef8: 40 00 0d 8a call 40009520 <_Thread_Change_life>
40005efc: 90 10 20 08 mov 8, %o0
THREAD_LIFE_CHANGE_DEFERRED,
set_life_state,
0
);
if ( oldtype != NULL ) {
40005f00: 80 a6 60 00 cmp %i1, 0
40005f04: 02 80 00 06 be 40005f1c <pthread_setcanceltype+0x58>
40005f08: 82 10 20 00 clr %g1
if ( ( previous_life_state & THREAD_LIFE_CHANGE_DEFERRED ) != 0 ) {
40005f0c: 80 8a 20 08 btst 8, %o0
40005f10: 02 80 00 0d be 40005f44 <pthread_setcanceltype+0x80> <== NEVER TAKEN
40005f14: 84 10 20 01 mov 1, %g2
*oldtype = PTHREAD_CANCEL_DEFERRED;
40005f18: c0 26 40 00 clr [ %i1 ]
*oldtype = PTHREAD_CANCEL_ASYNCHRONOUS;
}
}
return 0;
}
40005f1c: 81 c7 e0 08 ret
40005f20: 91 e8 00 01 restore %g0, %g1, %o0
set_life_state = THREAD_LIFE_CHANGE_DEFERRED;
40005f24: 92 10 20 08 mov 8, %o1
previous_life_state = _Thread_Change_life(
40005f28: 94 10 20 00 clr %o2
40005f2c: 40 00 0d 7d call 40009520 <_Thread_Change_life>
40005f30: 90 10 20 08 mov 8, %o0
if ( oldtype != NULL ) {
40005f34: 80 a6 60 00 cmp %i1, 0
40005f38: 12 bf ff f5 bne 40005f0c <pthread_setcanceltype+0x48>
40005f3c: 82 10 20 00 clr %g1
40005f40: 30 bf ff f7 b,a 40005f1c <pthread_setcanceltype+0x58>
*oldtype = PTHREAD_CANCEL_ASYNCHRONOUS;
40005f44: c4 26 40 00 st %g2, [ %i1 ]
}
40005f48: 81 c7 e0 08 ret <== NOT EXECUTED
40005f4c: 91 e8 00 01 restore %g0, %g1, %o0 <== NOT EXECUTED
40008768 <pthread_setschedparam>:
const struct sched_param *param
#else
struct sched_param *param
#endif
)
{
40008768: 9d e3 bf 70 save %sp, -144, %sp
Thread_Control *the_thread;
Per_CPU_Control *cpu_self;
Thread_queue_Context queue_context;
int error;
if ( param == NULL ) {
4000876c: 80 a6 a0 00 cmp %i2, 0
40008770: 02 80 00 61 be 400088f4 <pthread_setschedparam+0x18c>
40008774: 96 07 bf d8 add %fp, -40, %o3
return EINVAL;
}
error = _POSIX_Thread_Translate_sched_param(
40008778: 94 07 bf d4 add %fp, -44, %o2
4000877c: 92 10 00 1a mov %i2, %o1
40008780: 40 00 15 20 call 4000dc00 <_POSIX_Thread_Translate_sched_param>
40008784: 90 10 00 19 mov %i1, %o0
policy,
param,
&budget_algorithm,
&budget_callout
);
if ( error != 0 ) {
40008788: ba 92 20 00 orcc %o0, 0, %i5
4000878c: 22 80 00 04 be,a 4000879c <pthread_setschedparam+0x34>
40008790: c0 27 bf f0 clr [ %fp + -16 ]
cpu_self = _Thread_queue_Dispatch_disable( &queue_context );
_Thread_Wait_release( the_thread, &queue_context );
_Thread_Priority_update( &queue_context );
_Thread_Dispatch_enable( cpu_self );
return error;
}
40008794: 81 c7 e0 08 ret
40008798: 91 e8 00 1d restore %g0, %i5, %o0
the_thread = _Thread_Get( thread, &queue_context.Lock_context.Lock_context );
4000879c: 90 10 00 18 mov %i0, %o0
400087a0: 40 00 07 cb call 4000a6cc <_Thread_Get>
400087a4: 92 07 bf dc add %fp, -36, %o1
if ( the_thread == NULL ) {
400087a8: b8 92 20 00 orcc %o0, 0, %i4
400087ac: 02 80 00 55 be 40008900 <pthread_setschedparam+0x198>
400087b0: ea 07 bf d4 ld [ %fp + -44 ], %l5
normal_prio = param->sched_priority;
400087b4: f6 06 80 00 ld [ %i2 ], %i3
error = _POSIX_Set_sched_param(
400087b8: e8 07 bf d8 ld [ %fp + -40 ], %l4
core_normal_prio = _POSIX_Priority_To_core( scheduler, normal_prio, &valid );
400087bc: 92 10 00 1b mov %i3, %o1
400087c0: 94 07 bf d3 add %fp, -45, %o2
400087c4: 31 10 00 68 sethi %hi(0x4001a000), %i0
400087c8: 7f ff fd ae call 40007e80 <_POSIX_Priority_To_core>
400087cc: 90 16 20 60 or %i0, 0x60, %o0 ! 4001a060 <_Scheduler_Table>
if ( !valid ) {
400087d0: c2 0f bf d3 ldub [ %fp + -45 ], %g1
core_normal_prio = _POSIX_Priority_To_core( scheduler, normal_prio, &valid );
400087d4: a6 10 00 08 mov %o0, %l3
if ( !valid ) {
400087d8: 80 a0 60 00 cmp %g1, 0
400087dc: 02 80 00 44 be 400088ec <pthread_setschedparam+0x184> <== NEVER TAKEN
400087e0: a4 10 00 09 mov %o1, %l2
if ( policy == SCHED_SPORADIC ) {
400087e4: 80 a6 60 04 cmp %i1, 4
400087e8: 22 80 00 02 be,a 400087f0 <pthread_setschedparam+0x88>
400087ec: f6 06 a0 04 ld [ %i2 + 4 ], %i3
core_low_prio = _POSIX_Priority_To_core( scheduler, low_prio, &valid );
400087f0: 92 10 00 1b mov %i3, %o1
400087f4: 90 16 20 60 or %i0, 0x60, %o0
400087f8: 7f ff fd a2 call 40007e80 <_POSIX_Priority_To_core>
400087fc: 94 07 bf d3 add %fp, -45, %o2
if ( !valid ) {
40008800: c2 0f bf d3 ldub [ %fp + -45 ], %g1
core_low_prio = _POSIX_Priority_To_core( scheduler, low_prio, &valid );
40008804: b0 10 00 08 mov %o0, %i0
if ( !valid ) {
40008808: 80 a0 60 00 cmp %g1, 0
4000880c: 02 80 00 38 be 400088ec <pthread_setschedparam+0x184>
40008810: b6 10 00 09 mov %o1, %i3
api = the_thread->API_Extensions[ THREAD_API_POSIX ];
40008814: e2 07 21 5c ld [ %i4 + 0x15c ], %l1
_Watchdog_Per_CPU_remove_ticks( &api->Sporadic.Timer );
40008818: a0 04 60 08 add %l1, 8, %l0
_Watchdog_Remove(
4000881c: 11 10 00 7f sethi %hi(0x4001fc00), %o0
40008820: 92 10 00 10 mov %l0, %o1
40008824: 40 00 0f b1 call 4000c6e8 <_Watchdog_Remove>
40008828: 90 12 20 b8 or %o0, 0xb8, %o0
4000882c: e6 27 20 30 st %l3, [ %i4 + 0x30 ]
40008830: e4 27 20 34 st %l2, [ %i4 + 0x34 ]
if ( _Priority_Node_is_active( &api->Sporadic.Low_priority ) ) {
40008834: c2 04 60 34 ld [ %l1 + 0x34 ], %g1
40008838: 80 a0 7f ff cmp %g1, -1
4000883c: 02 80 00 33 be 40008908 <pthread_setschedparam+0x1a0>
40008840: 92 07 20 20 add %i4, 0x20, %o1
_Thread_Priority_add(
40008844: 90 10 00 1c mov %i4, %o0
40008848: 40 00 06 91 call 4000a28c <_Thread_Priority_add>
4000884c: 94 07 bf dc add %fp, -36, %o2
_Thread_Priority_remove(
40008850: 94 07 bf dc add %fp, -36, %o2
40008854: 92 04 60 28 add %l1, 0x28, %o1
40008858: 40 00 06 ae call 4000a310 <_Thread_Priority_remove>
4000885c: 90 10 00 1c mov %i4, %o0
40008860: 82 10 3f ff mov -1, %g1
40008864: c2 24 60 34 st %g1, [ %l1 + 0x34 ]
if ( policy == SCHED_SPORADIC ) {
40008868: 80 a6 60 04 cmp %i1, 4
the_thread->budget_algorithm = budget_algorithm;
4000886c: ea 27 20 90 st %l5, [ %i4 + 0x90 ]
the_thread->budget_callout = budget_callout;
40008870: e8 27 20 94 st %l4, [ %i4 + 0x94 ]
api->Sporadic.sched_ss_repl_period = param->sched_ss_repl_period;
40008874: d0 1e a0 08 ldd [ %i2 + 8 ], %o0
40008878: d4 1e a0 10 ldd [ %i2 + 0x10 ], %o2
api->Sporadic.sched_ss_init_budget = param->sched_ss_init_budget;
4000887c: d8 1e a0 18 ldd [ %i2 + 0x18 ], %o4
40008880: c4 1e a0 20 ldd [ %i2 + 0x20 ], %g2
api->Sporadic.sched_ss_max_repl = param->sched_ss_max_repl;
40008884: c2 06 a0 28 ld [ %i2 + 0x28 ], %g1
40008888: c2 24 60 60 st %g1, [ %l1 + 0x60 ]
4000888c: f0 24 60 38 st %i0, [ %l1 + 0x38 ]
40008890: f6 24 60 3c st %i3, [ %l1 + 0x3c ]
api->Sporadic.sched_ss_repl_period = param->sched_ss_repl_period;
40008894: d0 3c 60 40 std %o0, [ %l1 + 0x40 ]
40008898: d4 3c 60 48 std %o2, [ %l1 + 0x48 ]
api->Sporadic.sched_ss_init_budget = param->sched_ss_init_budget;
4000889c: d8 3c 60 50 std %o4, [ %l1 + 0x50 ]
if ( policy == SCHED_SPORADIC ) {
400088a0: 02 80 00 20 be 40008920 <pthread_setschedparam+0x1b8>
400088a4: c4 3c 60 58 std %g2, [ %l1 + 0x58 ]
the_thread->cpu_time_budget =
400088a8: 03 10 00 69 sethi %hi(0x4001a400), %g1
400088ac: c2 00 63 98 ld [ %g1 + 0x398 ], %g1 ! 4001a798 <_Watchdog_Ticks_per_timeslice>
400088b0: c2 27 20 8c st %g1, [ %i4 + 0x8c ]
return _Thread_Dispatch_disable_with_CPU( _Per_CPU_Get(), lock_context );
400088b4: b8 10 00 06 mov %g6, %i4
disable_level = cpu_self->thread_dispatch_disable_level;
400088b8: c2 01 a0 18 ld [ %g6 + 0x18 ], %g1
cpu_self->thread_dispatch_disable_level = disable_level + 1;
400088bc: 82 00 60 01 inc %g1
400088c0: c2 21 a0 18 st %g1, [ %g6 + 0x18 ]
register uint32_t _psr __asm__("g1") = psr; /* input to trap handler */
400088c4: c2 07 bf dc ld [ %fp + -36 ], %g1
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
400088c8: 91 d0 20 0a ta 0xa
400088cc: 01 00 00 00 nop
_Thread_Priority_update( &queue_context );
400088d0: 40 00 06 d4 call 4000a420 <_Thread_Priority_update>
400088d4: 90 07 bf dc add %fp, -36, %o0
_Thread_Dispatch_enable( cpu_self );
400088d8: 90 10 00 1c mov %i4, %o0
400088dc: 40 00 07 61 call 4000a660 <_Thread_Dispatch_enable>
400088e0: b0 10 00 1d mov %i5, %i0
}
400088e4: 81 c7 e0 08 ret
400088e8: 81 e8 00 00 restore
return EINVAL;
400088ec: 10 bf ff f2 b 400088b4 <pthread_setschedparam+0x14c>
400088f0: ba 10 20 16 mov 0x16, %i5
return EINVAL;
400088f4: ba 10 20 16 mov 0x16, %i5
}
400088f8: 81 c7 e0 08 ret
400088fc: 91 e8 00 1d restore %g0, %i5, %o0
return ESRCH;
40008900: 10 bf ff a5 b 40008794 <pthread_setschedparam+0x2c>
40008904: ba 10 20 03 mov 3, %i5
_Thread_Priority_changed(
40008908: 96 07 bf dc add %fp, -36, %o3
4000890c: 94 10 20 00 clr %o2
40008910: 40 00 06 a2 call 4000a398 <_Thread_Priority_changed>
40008914: 90 10 00 1c mov %i4, %o0
if ( policy == SCHED_SPORADIC ) {
40008918: 10 bf ff d5 b 4000886c <pthread_setschedparam+0x104>
4000891c: 80 a6 60 04 cmp %i1, 4
_Timespec_To_ticks( &api->Sporadic.sched_ss_init_budget );
40008920: 40 00 0e 04 call 4000c130 <_Timespec_To_ticks>
40008924: 90 04 60 50 add %l1, 0x50, %o0
the_thread->cpu_time_budget =
40008928: d0 27 20 8c st %o0, [ %i4 + 0x8c ]
_Watchdog_Per_CPU_insert_ticks(
4000892c: b8 10 00 06 mov %g6, %i4
40008930: 40 00 0e 00 call 4000c130 <_Timespec_To_ticks>
40008934: 90 04 60 40 add %l1, 0x40, %o0
expire = ticks + cpu->Watchdog.ticks;
40008938: d4 1f 20 30 ldd [ %i4 + 0x30 ], %o2
_Watchdog_Insert(header, the_watchdog, expire);
4000893c: 84 10 00 0a mov %o2, %g2
40008940: 96 82 c0 08 addcc %o3, %o0, %o3
40008944: 92 10 00 10 mov %l0, %o1
40008948: 94 40 a0 00 addx %g2, 0, %o2
4000894c: 40 00 0f 34 call 4000c61c <_Watchdog_Insert>
40008950: 90 07 20 38 add %i4, 0x38, %o0
}
40008954: 10 bf ff d9 b 400088b8 <pthread_setschedparam+0x150>
40008958: b8 10 00 06 mov %g6, %i4
40006d00 <pthread_setspecific>:
int pthread_setspecific(
pthread_key_t key,
const void *value
)
{
40006d00: 9d e3 bf 98 save %sp, -104, %sp
40006d04: f8 01 a0 20 ld [ %g6 + 0x20 ], %i4
Thread_Control *executing;
int eno;
executing = _Thread_Get_executing();
if ( value != NULL ) {
40006d08: 80 a6 60 00 cmp %i1, 0
40006d0c: 02 80 00 18 be 40006d6c <pthread_setspecific+0x6c>
40006d10: ba 10 00 18 mov %i0, %i5
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
40006d14: 91 d0 20 09 ta 9
while ( *link != NULL ) {
40006d18: c4 07 21 60 ld [ %i4 + 0x160 ], %g2
40006d1c: 80 a0 a0 00 cmp %g2, 0
40006d20: 32 80 00 0b bne,a 40006d4c <pthread_setspecific+0x4c>
40006d24: c6 00 a0 10 ld [ %g2 + 0x10 ], %g3
40006d28: 30 80 00 45 b,a 40006e3c <pthread_setspecific+0x13c>
} else if ( ( *less )( key, parent ) ) {
40006d2c: 1a 80 00 03 bcc 40006d38 <pthread_setspecific+0x38> <== ALWAYS TAKEN
40006d30: 86 00 a0 04 add %g2, 4, %g3
return &RB_LEFT( the_node, Node );
40006d34: 86 10 00 02 mov %g2, %g3 <== NOT EXECUTED
while ( *link != NULL ) {
40006d38: c4 00 c0 00 ld [ %g3 ], %g2
40006d3c: 80 a0 a0 00 cmp %g2, 0
40006d40: 02 80 00 3f be 40006e3c <pthread_setspecific+0x13c>
40006d44: 01 00 00 00 nop
40006d48: c6 00 a0 10 ld [ %g2 + 0x10 ], %g3
if ( ( *equal )( key, parent ) ) {
40006d4c: 80 a7 40 03 cmp %i5, %g3
40006d50: 12 bf ff f7 bne 40006d2c <pthread_setspecific+0x2c>
40006d54: 88 00 bf f8 add %g2, -8, %g4
key_value_pair->value = RTEMS_DECONST( void *, value );
40006d58: f2 21 20 20 st %i1, [ %g4 + 0x20 ]
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
40006d5c: 91 d0 20 0a ta 0xa
40006d60: 01 00 00 00 nop
} else {
eno = _POSIX_Keys_Delete_value( key, executing );
}
return eno;
}
40006d64: 81 c7 e0 08 ret
40006d68: 91 e8 20 00 restore %g0, 0, %o0
_RTEMS_Lock_allocator();
40006d6c: 40 00 02 9c call 400077dc <_RTEMS_Lock_allocator>
40006d70: 01 00 00 00 nop
_Objects_Get_no_protection( (Objects_Id) key, &_POSIX_Keys_Information );
40006d74: 90 10 00 18 mov %i0, %o0
40006d78: 13 10 01 3e sethi %hi(0x4004f800), %o1
eno = EINVAL;
40006d7c: b0 10 20 16 mov 0x16, %i0
40006d80: 40 00 0c 6a call 40009f28 <_Objects_Get_no_protection>
40006d84: 92 12 62 88 or %o1, 0x288, %o1
if ( the_key != NULL ) {
40006d88: 80 a2 20 00 cmp %o0, 0
40006d8c: 02 80 00 0a be 40006db4 <pthread_setspecific+0xb4>
40006d90: 01 00 00 00 nop
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
40006d94: 91 d0 20 09 ta 9
while ( *link != NULL ) {
40006d98: d2 07 21 60 ld [ %i4 + 0x160 ], %o1
40006d9c: 80 a2 60 00 cmp %o1, 0
40006da0: 32 80 00 11 bne,a 40006de4 <pthread_setspecific+0xe4>
40006da4: c4 02 60 10 ld [ %o1 + 0x10 ], %g2
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
40006da8: 91 d0 20 0a ta 0xa
40006dac: 01 00 00 00 nop
eno = 0;
40006db0: b0 10 20 00 clr %i0 ! 0 <PROM_START>
_RTEMS_Unlock_allocator();
40006db4: 40 00 02 8f call 400077f0 <_RTEMS_Unlock_allocator>
40006db8: 01 00 00 00 nop
return eno;
40006dbc: 81 c7 e0 08 ret
40006dc0: 81 e8 00 00 restore
} else if ( ( *less )( key, parent ) ) {
40006dc4: 1a 80 00 03 bcc 40006dd0 <pthread_setspecific+0xd0> <== ALWAYS TAKEN
40006dc8: 84 02 60 04 add %o1, 4, %g2
return &RB_LEFT( the_node, Node );
40006dcc: 84 10 00 09 mov %o1, %g2 <== NOT EXECUTED
while ( *link != NULL ) {
40006dd0: d2 00 80 00 ld [ %g2 ], %o1
40006dd4: 80 a2 60 00 cmp %o1, 0
40006dd8: 02 bf ff f4 be 40006da8 <pthread_setspecific+0xa8> <== NEVER TAKEN
40006ddc: 01 00 00 00 nop
return *the_left == the_right->key;
40006de0: c4 02 60 10 ld [ %o1 + 0x10 ], %g2
if ( ( *equal )( key, parent ) ) {
40006de4: 80 a7 40 02 cmp %i5, %g2
40006de8: 12 bf ff f7 bne 40006dc4 <pthread_setspecific+0xc4>
40006dec: b6 02 7f f8 add %o1, -8, %i3
_RBTree_Extract(
40006df0: c2 27 bf fc st %g1, [ %fp + -4 ]
40006df4: 40 00 0c c5 call 4000a108 <_RBTree_Extract>
40006df8: 90 07 21 60 add %i4, 0x160, %o0
register uint32_t _psr __asm__("g1") = psr; /* input to trap handler */
40006dfc: c2 07 bf fc ld [ %fp + -4 ], %g1
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
40006e00: 91 d0 20 0a ta 0xa
40006e04: 01 00 00 00 nop
next = the_node->next;
40006e08: c4 06 c0 00 ld [ %i3 ], %g2
previous = the_node->previous;
40006e0c: c2 06 e0 04 ld [ %i3 + 4 ], %g1
next->previous = previous;
40006e10: c2 20 a0 04 st %g1, [ %g2 + 4 ]
_Freechain_Put( &_POSIX_Keys_Keypool, key_value_pair );
40006e14: 92 10 00 1b mov %i3, %o1
previous->next = next;
40006e18: c4 20 40 00 st %g2, [ %g1 ]
40006e1c: 11 10 01 46 sethi %hi(0x40051800), %o0
40006e20: 90 12 21 d8 or %o0, 0x1d8, %o0 ! 400519d8 <_POSIX_Keys_Keypool>
40006e24: 40 00 03 0b call 40007a50 <_Freechain_Put>
40006e28: b0 10 20 00 clr %i0
40006e2c: 40 00 02 71 call 400077f0 <_RTEMS_Unlock_allocator>
40006e30: 01 00 00 00 nop
return eno;
40006e34: 81 c7 e0 08 ret
40006e38: 81 e8 00 00 restore
40006e3c: 91 d0 20 0a ta 0xa
40006e40: 01 00 00 00 nop
_RTEMS_Lock_allocator();
40006e44: 40 00 02 66 call 400077dc <_RTEMS_Lock_allocator>
40006e48: b0 10 20 16 mov 0x16, %i0 ! 16 <_TLS_Alignment+0x15>
_Objects_Get_no_protection( (Objects_Id) key, &_POSIX_Keys_Information );
40006e4c: 90 10 00 1d mov %i5, %o0
40006e50: 13 10 01 3e sethi %hi(0x4004f800), %o1
40006e54: 40 00 0c 35 call 40009f28 <_Objects_Get_no_protection>
40006e58: 92 12 62 88 or %o1, 0x288, %o1 ! 4004fa88 <_POSIX_Keys_Information>
if ( the_key != NULL ) {
40006e5c: b4 92 20 00 orcc %o0, 0, %i2
40006e60: 02 bf ff d5 be 40006db4 <pthread_setspecific+0xb4>
40006e64: 01 00 00 00 nop
key_value_pair = _POSIX_Keys_Key_value_allocate();
40006e68: 7f ff ff 4f call 40006ba4 <_POSIX_Keys_Key_value_allocate>
40006e6c: b0 10 20 0c mov 0xc, %i0 ! c <_TLS_Alignment+0xb>
if ( key_value_pair != NULL ) {
40006e70: b6 92 20 00 orcc %o0, 0, %i3
40006e74: 02 bf ff d0 be 40006db4 <pthread_setspecific+0xb4> <== NEVER TAKEN
40006e78: 84 06 a0 18 add %i2, 0x18, %g2
old_last = tail->previous;
40006e7c: c2 06 a0 1c ld [ %i2 + 0x1c ], %g1
key_value_pair->key = key;
40006e80: fa 26 e0 18 st %i5, [ %i3 + 0x18 ]
return &RB_ROOT( the_rbtree );
40006e84: 90 07 21 60 add %i4, 0x160, %o0
key_value_pair->thread = executing;
40006e88: f8 26 e0 1c st %i4, [ %i3 + 0x1c ]
_RBTree_Initialize_node( &key_value_pair->Lookup_node );
40006e8c: 92 06 e0 08 add %i3, 8, %o1
key_value_pair->value = RTEMS_DECONST( void *, value );
40006e90: f2 26 e0 20 st %i1, [ %i3 + 0x20 ]
the_node->next = tail;
40006e94: c4 26 c0 00 st %g2, [ %i3 ]
tail->previous = the_node;
40006e98: f6 26 a0 1c st %i3, [ %i2 + 0x1c ]
old_last->next = the_node;
40006e9c: f6 20 40 00 st %i3, [ %g1 ]
the_node->previous = old_last;
40006ea0: c2 26 e0 04 st %g1, [ %i3 + 4 ]
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
40006ea4: 91 d0 20 09 ta 9
while ( *link != NULL ) {
40006ea8: c4 07 21 60 ld [ %i4 + 0x160 ], %g2
40006eac: 80 a0 a0 00 cmp %g2, 0
40006eb0: 32 80 00 05 bne,a 40006ec4 <pthread_setspecific+0x1c4>
40006eb4: c6 00 a0 10 ld [ %g2 + 0x10 ], %g3
link = _RBTree_Root_reference( the_rbtree );
40006eb8: 10 80 00 18 b 40006f18 <pthread_setspecific+0x218>
40006ebc: 88 10 00 08 mov %o0, %g4
if ( ( *less )( key, parent ) ) {
40006ec0: c6 00 a0 10 ld [ %g2 + 0x10 ], %g3
40006ec4: 80 a7 40 03 cmp %i5, %g3
40006ec8: 1a 80 00 03 bcc 40006ed4 <pthread_setspecific+0x1d4> <== ALWAYS TAKEN
40006ecc: 88 00 a0 04 add %g2, 4, %g4
return &RB_LEFT( the_node, Node );
40006ed0: 88 10 00 02 mov %g2, %g4 <== NOT EXECUTED
while ( *link != NULL ) {
40006ed4: c6 01 00 00 ld [ %g4 ], %g3
40006ed8: 80 a0 e0 00 cmp %g3, 0
40006edc: 32 bf ff f9 bne,a 40006ec0 <pthread_setspecific+0x1c0>
40006ee0: 84 10 00 03 mov %g3, %g2
RB_SET( child, parent, Node );
40006ee4: c4 26 e0 10 st %g2, [ %i3 + 0x10 ]
40006ee8: 84 10 20 01 mov 1, %g2
40006eec: c0 26 e0 0c clr [ %i3 + 0xc ]
40006ef0: c0 26 e0 08 clr [ %i3 + 8 ]
40006ef4: c4 26 e0 14 st %g2, [ %i3 + 0x14 ]
*link = child;
40006ef8: d2 21 00 00 st %o1, [ %g4 ]
_RBTree_Insert_color( the_rbtree, the_node );
40006efc: 40 00 0d eb call 4000a6a8 <_RBTree_Insert_color>
40006f00: c2 27 bf fc st %g1, [ %fp + -4 ]
register uint32_t _psr __asm__("g1") = psr; /* input to trap handler */
40006f04: c2 07 bf fc ld [ %fp + -4 ], %g1
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
40006f08: 91 d0 20 0a ta 0xa
40006f0c: 01 00 00 00 nop
_RTEMS_Unlock_allocator();
40006f10: 10 bf ff a9 b 40006db4 <pthread_setspecific+0xb4>
40006f14: b0 10 20 00 clr %i0 ! 0 <PROM_START>
RB_SET( child, parent, Node );
40006f18: 10 bf ff f4 b 40006ee8 <pthread_setspecific+0x1e8>
40006f1c: c4 26 e0 10 st %g2, [ %i3 + 0x10 ]
40005f50 <pthread_testcancel>:
/*
* 18.2.2 Setting Cancelability State, P1003.1c/Draft 10, p. 183
*/
void pthread_testcancel( void )
{
40005f50: 9d e3 bf a0 save %sp, -96, %sp
if ( _ISR_Is_in_progress() ) {
40005f54: 40 00 00 e4 call 400062e4 <_ISR_Is_in_progress>
40005f58: 01 00 00 00 nop
40005f5c: 80 a2 20 00 cmp %o0, 0
40005f60: 02 80 00 04 be 40005f70 <pthread_testcancel+0x20> <== ALWAYS TAKEN
40005f64: b4 10 20 08 mov 8, %i2
return;
}
_Thread_Change_life( 0, 0, THREAD_LIFE_CHANGE_DEFERRED );
}
40005f68: 81 c7 e0 08 ret <== NOT EXECUTED
40005f6c: 81 e8 00 00 restore <== NOT EXECUTED
_Thread_Change_life( 0, 0, THREAD_LIFE_CHANGE_DEFERRED );
40005f70: b2 10 20 00 clr %i1
40005f74: 40 00 0d 6b call 40009520 <_Thread_Change_life>
40005f78: 91 e8 20 00 restore %g0, 0, %o0
400095f0 <rtems_aio_enqueue>:
{
400095f0: 9d e3 bf 68 save %sp, -152, %sp
result = pthread_mutex_lock (&aio_request_queue.mutex);
400095f4: 35 10 00 67 sethi %hi(0x40019c00), %i2
{
400095f8: b8 10 00 18 mov %i0, %i4
result = pthread_mutex_lock (&aio_request_queue.mutex);
400095fc: 40 00 06 81 call 4000b000 <pthread_mutex_lock>
40009600: 90 16 a0 20 or %i2, 0x20, %o0
if (result != 0) {
40009604: b0 92 20 00 orcc %o0, 0, %i0
40009608: 12 80 00 3e bne 40009700 <rtems_aio_enqueue+0x110> <== NEVER TAKEN
4000960c: 01 00 00 00 nop
pthread_getschedparam (pthread_self(), &policy, ¶m);
40009610: 40 00 09 e8 call 4000bdb0 <pthread_self>
40009614: b6 16 a0 20 or %i2, 0x20, %i3
40009618: 94 07 bf d0 add %fp, -48, %o2
4000961c: 40 00 09 b6 call 4000bcf4 <pthread_getschedparam>
40009620: 92 07 bf cc add %fp, -52, %o1
req->caller_thread = pthread_self ();
40009624: 40 00 09 e3 call 4000bdb0 <pthread_self>
40009628: 01 00 00 00 nop
req->priority = param.sched_priority - req->aiocbp->aio_reqprio;
4000962c: c2 07 20 14 ld [ %i4 + 0x14 ], %g1
40009630: c6 00 60 18 ld [ %g1 + 0x18 ], %g3
40009634: c4 07 bf d0 ld [ %fp + -48 ], %g2
40009638: 84 20 80 03 sub %g2, %g3, %g2
req->policy = policy;
4000963c: c6 07 bf cc ld [ %fp + -52 ], %g3
req->priority = param.sched_priority - req->aiocbp->aio_reqprio;
40009640: c4 27 20 0c st %g2, [ %i4 + 0xc ]
req->aiocbp->error_code = EINPROGRESS;
40009644: 84 10 20 77 mov 0x77, %g2
req->caller_thread = pthread_self ();
40009648: d0 27 20 10 st %o0, [ %i4 + 0x10 ]
req->policy = policy;
4000964c: c6 27 20 08 st %g3, [ %i4 + 8 ]
req->aiocbp->error_code = EINPROGRESS;
40009650: c4 20 60 34 st %g2, [ %g1 + 0x34 ]
req->aiocbp->return_value = 0;
40009654: c0 20 60 38 clr [ %g1 + 0x38 ]
if ((aio_request_queue.idle_threads == 0) &&
40009658: c4 06 e0 e0 ld [ %i3 + 0xe0 ], %g2
4000965c: 80 a0 a0 00 cmp %g2, 0
40009660: 12 80 00 06 bne 40009678 <rtems_aio_enqueue+0x88> <== NEVER TAKEN
40009664: d2 00 40 00 ld [ %g1 ], %o1
40009668: c4 06 e0 dc ld [ %i3 + 0xdc ], %g2
4000966c: 80 a0 a0 04 cmp %g2, 4
40009670: 04 80 00 3c ble 40009760 <rtems_aio_enqueue+0x170>
40009674: 94 10 20 01 mov 1, %o2
return _Chain_Immutable_head( the_chain )->next;
40009678: fa 06 e0 c0 ld [ %i3 + 0xc0 ], %i5
while (r_chain->fildes < fildes && !rtems_chain_is_tail (chain, node)) {
4000967c: c2 07 60 14 ld [ %i5 + 0x14 ], %g1
40009680: 80 a2 40 01 cmp %o1, %g1
40009684: 04 80 00 23 ble 40009710 <rtems_aio_enqueue+0x120>
40009688: 84 06 e0 c4 add %i3, 0xc4, %g2
4000968c: 10 80 00 07 b 400096a8 <rtems_aio_enqueue+0xb8>
40009690: 80 a7 40 02 cmp %i5, %g2
40009694: c2 07 60 14 ld [ %i5 + 0x14 ], %g1
40009698: 80 a0 40 09 cmp %g1, %o1
4000969c: 16 80 00 1d bge 40009710 <rtems_aio_enqueue+0x120>
400096a0: 80 a2 40 01 cmp %o1, %g1
400096a4: 80 a7 40 02 cmp %i5, %g2
400096a8: 32 bf ff fb bne,a 40009694 <rtems_aio_enqueue+0xa4> <== ALWAYS TAKEN
400096ac: fa 07 40 00 ld [ %i5 ], %i5
r_chain = rtems_aio_search_fd (chain, req->aiocbp->aio_fildes, 1);
400096b0: 94 10 20 01 mov 1, %o2 <== NOT EXECUTED
400096b4: 11 10 00 67 sethi %hi(0x40019c00), %o0
400096b8: 7f ff ff 4c call 400093e8 <rtems_aio_search_fd>
400096bc: 90 12 20 ec or %o0, 0xec, %o0 ! 40019cec <aio_request_queue+0xcc>
if (r_chain->new_fd == 1) {
400096c0: c2 02 20 18 ld [ %o0 + 0x18 ], %g1
r_chain = rtems_aio_search_fd (chain, req->aiocbp->aio_fildes, 1);
400096c4: ba 10 00 08 mov %o0, %i5
rtems_chain_prepend (&r_chain->perfd, &req->next_prio);
400096c8: 92 10 00 1c mov %i4, %o1
if (r_chain->new_fd == 1) {
400096cc: 80 a0 60 01 cmp %g1, 1
400096d0: 02 80 00 41 be 400097d4 <rtems_aio_enqueue+0x1e4>
400096d4: 90 02 20 08 add %o0, 8, %o0
rtems_aio_insert_prio (&r_chain->perfd, req);
400096d8: 7f ff fe 37 call 40008fb4 <rtems_aio_insert_prio>
400096dc: 01 00 00 00 nop
if (aio_request_queue.idle_threads > 0)
400096e0: c2 06 e0 e0 ld [ %i3 + 0xe0 ], %g1
400096e4: 80 a0 60 00 cmp %g1, 0
400096e8: 14 80 00 1b bg 40009754 <rtems_aio_enqueue+0x164> <== NEVER TAKEN
400096ec: 01 00 00 00 nop
pthread_mutex_unlock (&aio_request_queue.mutex);
400096f0: 40 00 07 11 call 4000b334 <pthread_mutex_unlock>
400096f4: 90 16 a0 20 or %i2, 0x20, %o0
}
400096f8: 81 c7 e0 08 ret
400096fc: 81 e8 00 00 restore
free (req);
40009700: 7f ff e0 b8 call 400019e0 <free> <== NOT EXECUTED
40009704: 90 10 00 1c mov %i4, %o0 <== NOT EXECUTED
return result;
40009708: 81 c7 e0 08 ret <== NOT EXECUTED
4000970c: 81 e8 00 00 restore <== NOT EXECUTED
if (r_chain->fildes == fildes)
40009710: 12 bf ff e9 bne 400096b4 <rtems_aio_enqueue+0xc4>
40009714: 94 10 20 01 mov 1, %o2
r_chain->new_fd = 0;
40009718: c0 27 60 18 clr [ %i5 + 0x18 ]
pthread_mutex_lock (&r_chain->mutex);
4000971c: b6 07 60 20 add %i5, 0x20, %i3
40009720: 40 00 06 38 call 4000b000 <pthread_mutex_lock>
40009724: 90 10 00 1b mov %i3, %o0
rtems_aio_insert_prio (&r_chain->perfd, req);
40009728: 92 10 00 1c mov %i4, %o1
4000972c: 7f ff fe 22 call 40008fb4 <rtems_aio_insert_prio>
40009730: 90 07 60 08 add %i5, 8, %o0
pthread_cond_signal (&r_chain->cond);
40009734: 40 00 05 00 call 4000ab34 <pthread_cond_signal>
40009738: 90 07 60 60 add %i5, 0x60, %o0
pthread_mutex_unlock (&r_chain->mutex);
4000973c: 40 00 06 fe call 4000b334 <pthread_mutex_unlock>
40009740: 90 10 00 1b mov %i3, %o0
pthread_mutex_unlock (&aio_request_queue.mutex);
40009744: 40 00 06 fc call 4000b334 <pthread_mutex_unlock>
40009748: 90 16 a0 20 or %i2, 0x20, %o0
}
4000974c: 81 c7 e0 08 ret
40009750: 81 e8 00 00 restore
pthread_cond_signal (&aio_request_queue.new_req);
40009754: 40 00 04 f8 call 4000ab34 <pthread_cond_signal> <== NOT EXECUTED
40009758: 90 06 e0 40 add %i3, 0x40, %o0 <== NOT EXECUTED
4000975c: 30 bf ff e5 b,a 400096f0 <rtems_aio_enqueue+0x100> <== NOT EXECUTED
r_chain = rtems_aio_search_fd (chain, req->aiocbp->aio_fildes, 1);
40009760: 7f ff ff 22 call 400093e8 <rtems_aio_search_fd>
40009764: 90 06 e0 c0 add %i3, 0xc0, %o0
if (r_chain->new_fd == 1) {
40009768: c2 02 20 18 ld [ %o0 + 0x18 ], %g1
4000976c: 80 a0 60 01 cmp %g1, 1
40009770: 12 bf ff eb bne 4000971c <rtems_aio_enqueue+0x12c>
40009774: ba 10 00 08 mov %o0, %i5
rtems_chain_prepend (&r_chain->perfd, &req->next_prio);
40009778: 92 10 00 1c mov %i4, %o1
4000977c: 40 00 0a 5a call 4000c0e4 <rtems_chain_prepend>
40009780: 90 02 20 08 add %o0, 8, %o0
r_chain->new_fd = 0;
40009784: c0 27 60 18 clr [ %i5 + 0x18 ]
pthread_mutex_init (&r_chain->mutex, NULL);
40009788: 92 10 20 00 clr %o1
4000978c: 40 00 05 d4 call 4000aedc <pthread_mutex_init>
40009790: 90 07 60 20 add %i5, 0x20, %o0
pthread_cond_init (&r_chain->cond, NULL);
40009794: 92 10 20 00 clr %o1
40009798: 40 00 04 c0 call 4000aa98 <pthread_cond_init>
4000979c: 90 07 60 60 add %i5, 0x60, %o0
result = pthread_create (&thid, &aio_request_queue.attr,
400097a0: 96 10 00 1d mov %i5, %o3
400097a4: 92 06 e0 60 add %i3, 0x60, %o1
400097a8: 15 10 00 24 sethi %hi(0x40009000), %o2
400097ac: 90 07 bf c8 add %fp, -56, %o0
400097b0: 40 00 08 35 call 4000b884 <pthread_create>
400097b4: 94 12 a0 38 or %o2, 0x38, %o2
if (result != 0) {
400097b8: 82 92 20 00 orcc %o0, 0, %g1
400097bc: 32 80 00 11 bne,a 40009800 <rtems_aio_enqueue+0x210> <== NEVER TAKEN
400097c0: b0 10 00 01 mov %g1, %i0 <== NOT EXECUTED
++aio_request_queue.active_threads;
400097c4: c2 06 e0 dc ld [ %i3 + 0xdc ], %g1
400097c8: 82 00 60 01 inc %g1
400097cc: 10 bf ff c9 b 400096f0 <rtems_aio_enqueue+0x100>
400097d0: c2 26 e0 dc st %g1, [ %i3 + 0xdc ]
rtems_chain_prepend (&r_chain->perfd, &req->next_prio);
400097d4: 40 00 0a 44 call 4000c0e4 <rtems_chain_prepend>
400097d8: 01 00 00 00 nop
r_chain->new_fd = 0;
400097dc: c0 27 60 18 clr [ %i5 + 0x18 ]
pthread_mutex_init (&r_chain->mutex, NULL);
400097e0: 92 10 20 00 clr %o1
400097e4: 40 00 05 be call 4000aedc <pthread_mutex_init>
400097e8: 90 07 60 20 add %i5, 0x20, %o0
pthread_cond_init (&r_chain->cond, NULL);
400097ec: 92 10 20 00 clr %o1
400097f0: 40 00 04 aa call 4000aa98 <pthread_cond_init>
400097f4: 90 07 60 60 add %i5, 0x60, %o0
400097f8: 10 bf ff bb b 400096e4 <rtems_aio_enqueue+0xf4>
400097fc: c2 06 e0 e0 ld [ %i3 + 0xe0 ], %g1
pthread_mutex_unlock (&aio_request_queue.mutex);
40009800: 40 00 06 cd call 4000b334 <pthread_mutex_unlock> <== NOT EXECUTED
40009804: 90 10 00 1b mov %i3, %o0 <== NOT EXECUTED
return result;
40009808: 81 c7 e0 08 ret <== NOT EXECUTED
4000980c: 81 e8 00 00 restore <== NOT EXECUTED
400092e0 <rtems_aio_init>:
{
400092e0: 9d e3 bf a0 save %sp, -96, %sp
result = pthread_attr_init (&aio_request_queue.attr);
400092e4: 39 10 00 67 sethi %hi(0x40019c00), %i4
400092e8: 40 00 08 c6 call 4000b600 <pthread_attr_init>
400092ec: 90 17 20 80 or %i4, 0x80, %o0 ! 40019c80 <aio_request_queue+0x60>
if (result != 0)
400092f0: b0 92 20 00 orcc %o0, 0, %i0
400092f4: 12 80 00 23 bne 40009380 <rtems_aio_init+0xa0> <== NEVER TAKEN
400092f8: 92 10 20 00 clr %o1
pthread_attr_setdetachstate (&aio_request_queue.attr,
400092fc: 40 00 08 d0 call 4000b63c <pthread_attr_setdetachstate>
40009300: 90 17 20 80 or %i4, 0x80, %o0
if (result != 0)
40009304: 80 a2 20 00 cmp %o0, 0
40009308: 12 80 00 20 bne 40009388 <rtems_aio_init+0xa8> <== NEVER TAKEN
4000930c: 92 10 20 00 clr %o1
result = pthread_mutex_init (&aio_request_queue.mutex, NULL);
40009310: 3b 10 00 67 sethi %hi(0x40019c00), %i5
40009314: 40 00 06 f2 call 4000aedc <pthread_mutex_init>
40009318: 90 17 60 20 or %i5, 0x20, %o0 ! 40019c20 <aio_request_queue>
if (result != 0)
4000931c: 80 a2 20 00 cmp %o0, 0
40009320: 12 80 00 23 bne 400093ac <rtems_aio_init+0xcc> <== NEVER TAKEN
40009324: 92 10 20 00 clr %o1
result = pthread_cond_init (&aio_request_queue.new_req, NULL);
40009328: 11 10 00 67 sethi %hi(0x40019c00), %o0
4000932c: 40 00 05 db call 4000aa98 <pthread_cond_init>
40009330: 90 12 20 60 or %o0, 0x60, %o0 ! 40019c60 <aio_request_queue+0x40>
if (result != 0) {
40009334: b0 92 20 00 orcc %o0, 0, %i0
40009338: 12 80 00 26 bne 400093d0 <rtems_aio_init+0xf0> <== NEVER TAKEN
4000933c: 01 00 00 00 nop
head->next = tail;
40009340: 82 17 60 20 or %i5, 0x20, %g1
tail->previous = head;
40009344: 84 00 60 cc add %g1, 0xcc, %g2
head->next = tail;
40009348: ba 00 60 c4 add %g1, 0xc4, %i5
tail->previous = head;
4000934c: c4 20 60 d4 st %g2, [ %g1 + 0xd4 ]
40009350: 88 00 60 c0 add %g1, 0xc0, %g4
head->next = tail;
40009354: 86 00 60 d0 add %g1, 0xd0, %g3
40009358: fa 20 60 c0 st %i5, [ %g1 + 0xc0 ]
aio_request_queue.initialized = AIO_QUEUE_INITIALIZED;
4000935c: 05 00 00 2c sethi %hi(0xb000), %g2
head->previous = NULL;
40009360: c0 20 60 c4 clr [ %g1 + 0xc4 ]
40009364: 84 10 a0 0b or %g2, 0xb, %g2
tail->previous = head;
40009368: c8 20 60 c8 st %g4, [ %g1 + 0xc8 ]
head->next = tail;
4000936c: c6 20 60 cc st %g3, [ %g1 + 0xcc ]
head->previous = NULL;
40009370: c0 20 60 d0 clr [ %g1 + 0xd0 ]
aio_request_queue.active_threads = 0;
40009374: c0 20 60 dc clr [ %g1 + 0xdc ]
aio_request_queue.idle_threads = 0;
40009378: c0 20 60 e0 clr [ %g1 + 0xe0 ]
aio_request_queue.initialized = AIO_QUEUE_INITIALIZED;
4000937c: c4 20 60 d8 st %g2, [ %g1 + 0xd8 ]
}
40009380: 81 c7 e0 08 ret
40009384: 81 e8 00 00 restore
pthread_attr_destroy (&aio_request_queue.attr);
40009388: 40 00 08 92 call 4000b5d0 <pthread_attr_destroy> <== NOT EXECUTED
4000938c: 90 17 20 80 or %i4, 0x80, %o0 <== NOT EXECUTED
result = pthread_mutex_init (&aio_request_queue.mutex, NULL);
40009390: 92 10 20 00 clr %o1 <== NOT EXECUTED
40009394: 3b 10 00 67 sethi %hi(0x40019c00), %i5 <== NOT EXECUTED
40009398: 40 00 06 d1 call 4000aedc <pthread_mutex_init> <== NOT EXECUTED
4000939c: 90 17 60 20 or %i5, 0x20, %o0 ! 40019c20 <aio_request_queue> <== NOT EXECUTED
if (result != 0)
400093a0: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
400093a4: 02 bf ff e1 be 40009328 <rtems_aio_init+0x48> <== NOT EXECUTED
400093a8: 92 10 20 00 clr %o1 <== NOT EXECUTED
pthread_attr_destroy (&aio_request_queue.attr);
400093ac: 40 00 08 89 call 4000b5d0 <pthread_attr_destroy> <== NOT EXECUTED
400093b0: 90 17 20 80 or %i4, 0x80, %o0 <== NOT EXECUTED
result = pthread_cond_init (&aio_request_queue.new_req, NULL);
400093b4: 92 10 20 00 clr %o1 <== NOT EXECUTED
400093b8: 11 10 00 67 sethi %hi(0x40019c00), %o0 <== NOT EXECUTED
400093bc: 40 00 05 b7 call 4000aa98 <pthread_cond_init> <== NOT EXECUTED
400093c0: 90 12 20 60 or %o0, 0x60, %o0 ! 40019c60 <aio_request_queue+0x40> <== NOT EXECUTED
if (result != 0) {
400093c4: b0 92 20 00 orcc %o0, 0, %i0 <== NOT EXECUTED
400093c8: 22 bf ff df be,a 40009344 <rtems_aio_init+0x64> <== NOT EXECUTED
400093cc: 82 17 60 20 or %i5, 0x20, %g1 <== NOT EXECUTED
pthread_mutex_destroy (&aio_request_queue.mutex);
400093d0: 40 00 06 a0 call 4000ae50 <pthread_mutex_destroy> <== NOT EXECUTED
400093d4: 90 17 60 20 or %i5, 0x20, %o0 <== NOT EXECUTED
pthread_attr_destroy (&aio_request_queue.attr);
400093d8: 40 00 08 7e call 4000b5d0 <pthread_attr_destroy> <== NOT EXECUTED
400093dc: 90 17 20 80 or %i4, 0x80, %o0 <== NOT EXECUTED
head->next = tail;
400093e0: 10 bf ff d9 b 40009344 <rtems_aio_init+0x64> <== NOT EXECUTED
400093e4: 82 17 60 20 or %i5, 0x20, %g1 <== NOT EXECUTED
4000951c <rtems_aio_remove_fd>:
{
4000951c: 9d e3 bf 98 save %sp, -104, %sp
return _Chain_Immutable_head( the_chain )->next;
40009520: fa 06 20 08 ld [ %i0 + 8 ], %i5
return &the_chain->Tail.Node;
40009524: b0 06 20 0c add %i0, 0xc, %i0
while (!rtems_chain_is_tail (chain, node))
40009528: 80 a7 40 18 cmp %i5, %i0
4000952c: 02 80 00 0f be 40009568 <rtems_aio_remove_fd+0x4c> <== NEVER TAKEN
40009530: b6 10 20 8c mov 0x8c, %i3
req->aiocbp->return_value = -1;
40009534: b8 10 3f ff mov -1, %i4
return the_node->next;
40009538: 90 10 00 1d mov %i5, %o0
4000953c: fa 07 40 00 ld [ %i5 ], %i5
rtems_chain_extract (&req->next_prio);
40009540: 40 00 0a d6 call 4000c098 <rtems_chain_extract>
40009544: d0 27 bf fc st %o0, [ %fp + -4 ]
req->aiocbp->error_code = ECANCELED;
40009548: d0 07 bf fc ld [ %fp + -4 ], %o0
4000954c: c2 02 20 14 ld [ %o0 + 0x14 ], %g1
40009550: f6 20 60 34 st %i3, [ %g1 + 0x34 ]
free (req);
40009554: 7f ff e1 23 call 400019e0 <free>
40009558: f8 20 60 38 st %i4, [ %g1 + 0x38 ]
while (!rtems_chain_is_tail (chain, node))
4000955c: 80 a7 40 18 cmp %i5, %i0
40009560: 12 bf ff f7 bne 4000953c <rtems_aio_remove_fd+0x20>
40009564: 90 10 00 1d mov %i5, %o0
}
40009568: 81 c7 e0 08 ret
4000956c: 81 e8 00 00 restore
40009570 <rtems_aio_remove_req>:
{
40009570: 9d e3 bf a0 save %sp, -96, %sp
return _Chain_Immutable_head( the_chain )->next;
40009574: fa 06 00 00 ld [ %i0 ], %i5
return &the_chain->Tail.Node;
40009578: b0 06 20 04 add %i0, 4, %i0
if (rtems_chain_is_empty (chain))
4000957c: 80 a6 00 1d cmp %i0, %i5
40009580: 02 80 00 1a be 400095e8 <rtems_aio_remove_req+0x78>
40009584: 01 00 00 00 nop
while (!rtems_chain_is_tail (chain, node) && current->aiocbp != aiocbp) {
40009588: c2 07 60 14 ld [ %i5 + 0x14 ], %g1
4000958c: 80 a0 40 19 cmp %g1, %i1
40009590: 02 80 00 08 be 400095b0 <rtems_aio_remove_req+0x40> <== ALWAYS TAKEN
40009594: 80 a6 00 1d cmp %i0, %i5
return the_node->next;
40009598: fa 07 40 00 ld [ %i5 ], %i5 <== NOT EXECUTED
4000959c: 80 a7 40 18 cmp %i5, %i0 <== NOT EXECUTED
400095a0: 32 bf ff fb bne,a 4000958c <rtems_aio_remove_req+0x1c> <== NOT EXECUTED
400095a4: c2 07 60 14 ld [ %i5 + 0x14 ], %g1 <== NOT EXECUTED
}
400095a8: 81 c7 e0 08 ret <== NOT EXECUTED
400095ac: 91 e8 20 01 restore %g0, 1, %o0 <== NOT EXECUTED
if (rtems_chain_is_tail (chain, node))
400095b0: 02 bf ff fe be 400095a8 <rtems_aio_remove_req+0x38> <== NEVER TAKEN
400095b4: 01 00 00 00 nop
rtems_chain_extract (node);
400095b8: 40 00 0a b8 call 4000c098 <rtems_chain_extract>
400095bc: 90 10 00 1d mov %i5, %o0
current->aiocbp->error_code = ECANCELED;
400095c0: c2 07 60 14 ld [ %i5 + 0x14 ], %g1
400095c4: 84 10 20 8c mov 0x8c, %g2
400095c8: c4 20 60 34 st %g2, [ %g1 + 0x34 ]
current->aiocbp->return_value = -1;
400095cc: 84 10 3f ff mov -1, %g2
400095d0: c4 20 60 38 st %g2, [ %g1 + 0x38 ]
free (current);
400095d4: 90 10 00 1d mov %i5, %o0
400095d8: 7f ff e1 02 call 400019e0 <free>
400095dc: b0 10 20 00 clr %i0
return AIO_CANCELED;
400095e0: 81 c7 e0 08 ret
400095e4: 81 e8 00 00 restore
return AIO_ALLDONE;
400095e8: 81 c7 e0 08 ret
400095ec: 91 e8 20 02 restore %g0, 2, %o0
400093e8 <rtems_aio_search_fd>:
{
400093e8: 9d e3 bf a0 save %sp, -96, %sp
return _Chain_Immutable_head( the_chain )->next;
400093ec: f6 06 00 00 ld [ %i0 ], %i3
while (r_chain->fildes < fildes && !rtems_chain_is_tail (chain, node)) {
400093f0: c2 06 e0 14 ld [ %i3 + 0x14 ], %g1
400093f4: 80 a6 40 01 cmp %i1, %g1
400093f8: 04 80 00 10 ble 40009438 <rtems_aio_search_fd+0x50>
400093fc: ba 10 00 1b mov %i3, %i5
return &the_chain->Tail.Node;
40009400: b8 06 20 04 add %i0, 4, %i4
40009404: 80 a6 c0 1c cmp %i3, %i4
40009408: 02 80 00 36 be 400094e0 <rtems_aio_search_fd+0xf8>
4000940c: 80 a6 a0 00 cmp %i2, 0
return the_node->next;
40009410: 10 80 00 05 b 40009424 <rtems_aio_search_fd+0x3c>
40009414: fa 07 40 00 ld [ %i5 ], %i5
40009418: 02 80 00 0d be 4000944c <rtems_aio_search_fd+0x64>
4000941c: 80 a6 a0 00 cmp %i2, 0
40009420: fa 07 40 00 ld [ %i5 ], %i5
40009424: c2 07 60 14 ld [ %i5 + 0x14 ], %g1
40009428: 80 a0 40 19 cmp %g1, %i1
4000942c: 06 bf ff fb bl 40009418 <rtems_aio_search_fd+0x30>
40009430: 80 a7 40 1c cmp %i5, %i4
if (r_chain->fildes == fildes)
40009434: 80 a6 40 01 cmp %i1, %g1
40009438: 12 80 00 17 bne 40009494 <rtems_aio_search_fd+0xac>
4000943c: 80 a6 a0 00 cmp %i2, 0
r_chain->new_fd = 0;
40009440: c0 27 60 18 clr [ %i5 + 0x18 ]
}
40009444: 81 c7 e0 08 ret
40009448: 91 e8 00 1d restore %g0, %i5, %o0
if (create == 0)
4000944c: 02 bf ff fe be 40009444 <rtems_aio_search_fd+0x5c>
40009450: ba 10 20 00 clr %i5
r_chain = malloc (sizeof (rtems_aio_request_chain));
40009454: 7f ff e2 1b call 40001cc0 <malloc>
40009458: 90 10 20 80 mov 0x80, %o0
return &the_chain->Tail.Node;
4000945c: 82 02 20 08 add %o0, 8, %g1
40009460: 84 02 20 0c add %o0, 0xc, %g2
head->previous = NULL;
40009464: c0 22 20 0c clr [ %o0 + 0xc ]
40009468: ba 10 00 08 mov %o0, %i5
head->next = tail;
4000946c: c4 22 20 08 st %g2, [ %o0 + 8 ]
rtems_chain_initialize_node (&r_chain->next_fd);
40009470: 92 10 00 08 mov %o0, %o1
tail->previous = head;
40009474: c2 22 20 10 st %g1, [ %o0 + 0x10 ]
rtems_chain_insert (rtems_chain_previous (node), &r_chain->next_fd);
40009478: 40 00 0b 11 call 4000c0bc <rtems_chain_insert>
4000947c: d0 07 20 04 ld [ %i4 + 4 ], %o0
r_chain->new_fd = 1;
40009480: 82 10 20 01 mov 1, %g1
r_chain->fildes = fildes;
40009484: f2 27 60 14 st %i1, [ %i5 + 0x14 ]
r_chain->new_fd = 1;
40009488: c2 27 60 18 st %g1, [ %i5 + 0x18 ]
}
4000948c: 81 c7 e0 08 ret
40009490: 91 e8 00 1d restore %g0, %i5, %o0
if (create == 0)
40009494: 22 bf ff ec be,a 40009444 <rtems_aio_search_fd+0x5c>
40009498: ba 10 20 00 clr %i5
r_chain = malloc (sizeof (rtems_aio_request_chain));
4000949c: 7f ff e2 09 call 40001cc0 <malloc>
400094a0: 90 10 20 80 mov 0x80, %o0
return &the_chain->Tail.Node;
400094a4: 82 02 20 0c add %o0, 0xc, %g1
400094a8: 86 02 20 08 add %o0, 8, %g3
head->next = tail;
400094ac: c2 22 20 08 st %g1, [ %o0 + 8 ]
return &the_chain->Tail.Node;
400094b0: 84 06 20 04 add %i0, 4, %g2
head->previous = NULL;
400094b4: c0 22 20 0c clr [ %o0 + 0xc ]
400094b8: 82 10 00 08 mov %o0, %g1
tail->previous = head;
400094bc: c6 22 20 10 st %g3, [ %o0 + 0x10 ]
if (rtems_chain_is_empty (chain))
400094c0: 80 a6 c0 02 cmp %i3, %g2
400094c4: 12 80 00 13 bne 40009510 <rtems_aio_search_fd+0x128>
400094c8: 92 10 00 08 mov %o0, %o1
rtems_chain_prepend (chain, &r_chain->next_fd);
400094cc: 90 10 00 18 mov %i0, %o0
400094d0: 40 00 0b 05 call 4000c0e4 <rtems_chain_prepend>
400094d4: ba 10 00 01 mov %g1, %i5
400094d8: 10 bf ff eb b 40009484 <rtems_aio_search_fd+0x9c>
400094dc: 82 10 20 01 mov 1, %g1
if (create == 0)
400094e0: 02 bf ff d9 be 40009444 <rtems_aio_search_fd+0x5c> <== NEVER TAKEN
400094e4: ba 10 20 00 clr %i5
r_chain = malloc (sizeof (rtems_aio_request_chain));
400094e8: 7f ff e1 f6 call 40001cc0 <malloc>
400094ec: 90 10 20 80 mov 0x80, %o0
return &the_chain->Tail.Node;
400094f0: 84 02 20 08 add %o0, 8, %g2
400094f4: 86 02 20 0c add %o0, 0xc, %g3
head->previous = NULL;
400094f8: c0 22 20 0c clr [ %o0 + 0xc ]
400094fc: 82 10 00 08 mov %o0, %g1
head->next = tail;
40009500: c6 22 20 08 st %g3, [ %o0 + 8 ]
rtems_chain_initialize_node (&r_chain->next_fd);
40009504: 92 10 00 08 mov %o0, %o1
tail->previous = head;
40009508: 10 bf ff f1 b 400094cc <rtems_aio_search_fd+0xe4>
4000950c: c4 22 20 10 st %g2, [ %o0 + 0x10 ]
40009510: b8 10 00 1d mov %i5, %i4
40009514: 10 bf ff d9 b 40009478 <rtems_aio_search_fd+0x90>
40009518: ba 10 00 08 mov %o0, %i5
40004ce8 <sched_get_priority_max>:
#include <rtems/score/schedulerimpl.h>
int sched_get_priority_max(
int policy
)
{
40004ce8: 9d e3 bf a0 save %sp, -96, %sp
const Scheduler_Control *scheduler;
switch ( policy ) {
40004cec: 80 a6 20 02 cmp %i0, 2
40004cf0: 04 80 00 08 ble 40004d10 <sched_get_priority_max+0x28>
40004cf4: 80 a6 20 00 cmp %i0, 0
40004cf8: 80 a6 20 04 cmp %i0, 4
40004cfc: 12 80 00 07 bne 40004d18 <sched_get_priority_max+0x30> <== NEVER TAKEN
40004d00: 03 10 00 56 sethi %hi(0x40015800), %g1
RTEMS_INLINE_ROUTINE int _POSIX_Priority_Get_maximum(
const Scheduler_Control *scheduler
)
{
_Assert( (int) scheduler->maximum_priority > 1 );
return (int) scheduler->maximum_priority - 1;
40004d04: f0 00 62 2c ld [ %g1 + 0x22c ], %i0 ! 40015a2c <_Scheduler_Table+0x44>
rtems_set_errno_and_return_minus_one( EINVAL );
}
scheduler = _Thread_Scheduler_get_home( _Thread_Get_executing() );
return _POSIX_Priority_Get_maximum( scheduler );
}
40004d08: 81 c7 e0 08 ret
40004d0c: 91 ee 3f ff restore %i0, -1, %o0
switch ( policy ) {
40004d10: 16 bf ff fd bge 40004d04 <sched_get_priority_max+0x1c>
40004d14: 03 10 00 56 sethi %hi(0x40015800), %g1
rtems_set_errno_and_return_minus_one( EINVAL );
40004d18: 40 00 2a 68 call 4000f6b8 <__errno>
40004d1c: b0 10 3f ff mov -1, %i0
40004d20: 82 10 20 16 mov 0x16, %g1
40004d24: c2 22 00 00 st %g1, [ %o0 ]
40004d28: 81 c7 e0 08 ret
40004d2c: 81 e8 00 00 restore
40004d30 <sched_get_priority_min>:
* 13.3.6 Get Scheduling Parameter Limits, P1003.1b-1993, p. 258
*/
int sched_get_priority_min(
int policy
)
{
40004d30: 9d e3 bf a0 save %sp, -96, %sp
40004d34: 82 10 00 18 mov %i0, %g1
switch ( policy ) {
40004d38: 80 a0 60 02 cmp %g1, 2
40004d3c: 14 80 00 0b bg 40004d68 <sched_get_priority_min+0x38> <== NEVER TAKEN
40004d40: b0 10 20 01 mov 1, %i0
40004d44: 80 a0 60 00 cmp %g1, 0
40004d48: 16 80 00 0d bge 40004d7c <sched_get_priority_min+0x4c>
40004d4c: 01 00 00 00 nop
case SCHED_RR:
case SCHED_SPORADIC:
break;
default:
rtems_set_errno_and_return_minus_one( EINVAL );
40004d50: 40 00 2a 5a call 4000f6b8 <__errno>
40004d54: b0 10 3f ff mov -1, %i0 ! ffffffff <RAM_END+0xbfbfffff>
40004d58: 82 10 20 16 mov 0x16, %g1
40004d5c: c2 22 00 00 st %g1, [ %o0 ]
}
return POSIX_SCHEDULER_MINIMUM_PRIORITY;
}
40004d60: 81 c7 e0 08 ret
40004d64: 81 e8 00 00 restore
switch ( policy ) {
40004d68: 80 a0 60 04 cmp %g1, 4 <== NOT EXECUTED
40004d6c: 12 bf ff f9 bne 40004d50 <sched_get_priority_min+0x20> <== NOT EXECUTED
40004d70: 01 00 00 00 nop <== NOT EXECUTED
}
40004d74: 81 c7 e0 08 ret <== NOT EXECUTED
40004d78: 81 e8 00 00 restore <== NOT EXECUTED
40004d7c: 81 c7 e0 08 ret
40004d80: 81 e8 00 00 restore
40004d84 <sched_rr_get_interval>:
int sched_rr_get_interval(
pid_t pid,
struct timespec *interval
)
{
40004d84: 9d e3 bf a0 save %sp, -96, %sp
/*
* Only supported for the "calling process" (i.e. this node).
*/
if ( pid && pid != getpid() )
40004d88: 80 a6 20 00 cmp %i0, 0
40004d8c: 12 80 00 0a bne 40004db4 <sched_rr_get_interval+0x30> <== ALWAYS TAKEN
40004d90: 80 a6 60 00 cmp %i1, 0
rtems_set_errno_and_return_minus_one( ESRCH );
if ( !interval )
40004d94: 02 80 00 13 be 40004de0 <sched_rr_get_interval+0x5c>
40004d98: 03 10 00 57 sethi %hi(0x40015c00), %g1
rtems_set_errno_and_return_minus_one( EINVAL );
_Timespec_From_ticks(
40004d9c: d0 00 63 e4 ld [ %g1 + 0x3e4 ], %o0 ! 40015fe4 <_Watchdog_Ticks_per_timeslice>
40004da0: 92 10 00 19 mov %i1, %o1
40004da4: 40 00 0b db call 40007d10 <_Timespec_From_ticks>
40004da8: b0 10 20 00 clr %i0
rtems_configuration_get_ticks_per_timeslice(),
interval
);
return 0;
}
40004dac: 81 c7 e0 08 ret
40004db0: 81 e8 00 00 restore
if ( pid && pid != getpid() )
40004db4: 7f ff f2 b7 call 40001890 <getpid>
40004db8: 01 00 00 00 nop
40004dbc: 80 a2 00 18 cmp %o0, %i0
40004dc0: 02 bf ff f5 be 40004d94 <sched_rr_get_interval+0x10>
40004dc4: 80 a6 60 00 cmp %i1, 0
rtems_set_errno_and_return_minus_one( ESRCH );
40004dc8: 40 00 2a 3c call 4000f6b8 <__errno>
40004dcc: b0 10 3f ff mov -1, %i0
40004dd0: 82 10 20 03 mov 3, %g1
40004dd4: c2 22 00 00 st %g1, [ %o0 ]
40004dd8: 81 c7 e0 08 ret
40004ddc: 81 e8 00 00 restore
rtems_set_errno_and_return_minus_one( EINVAL );
40004de0: 40 00 2a 36 call 4000f6b8 <__errno>
40004de4: b0 10 3f ff mov -1, %i0
40004de8: 82 10 20 16 mov 0x16, %g1
40004dec: c2 22 00 00 st %g1, [ %o0 ]
40004df0: 81 c7 e0 08 ret
40004df4: 81 e8 00 00 restore
40009574 <sem_close>:
#endif
#include <rtems/posix/semaphoreimpl.h>
int sem_close( sem_t *sem )
{
40009574: 9d e3 bf a0 save %sp, -96, %sp
POSIX_Semaphore_Control *the_semaphore;
uint32_t open_count;
POSIX_SEMAPHORE_VALIDATE_OBJECT( sem );
40009578: 80 a6 20 00 cmp %i0, 0
4000957c: 02 80 00 2a be 40009624 <sem_close+0xb0>
40009580: 03 17 4d 9f sethi %hi(0x5d367c00), %g1
40009584: c4 06 00 00 ld [ %i0 ], %g2
40009588: 82 10 63 e7 or %g1, 0x3e7, %g1
4000958c: 82 1e 00 01 xor %i0, %g1, %g1
40009590: 80 a0 40 02 cmp %g1, %g2
40009594: 12 80 00 24 bne 40009624 <sem_close+0xb0>
40009598: 01 00 00 00 nop
if ( !_POSIX_Semaphore_Is_named( sem ) ) {
4000959c: c2 06 20 14 ld [ %i0 + 0x14 ], %g1
400095a0: 80 a0 60 00 cmp %g1, 0
400095a4: 02 80 00 20 be 40009624 <sem_close+0xb0> <== NEVER TAKEN
400095a8: 01 00 00 00 nop
_RTEMS_Lock_allocator();
400095ac: 40 00 01 f6 call 40009d84 <_RTEMS_Lock_allocator>
400095b0: 01 00 00 00 nop
the_semaphore = _POSIX_Semaphore_Get( sem );
_Objects_Allocator_lock();
open_count = the_semaphore->open_count;
400095b4: c2 06 20 20 ld [ %i0 + 0x20 ], %g1
if ( open_count == 0 ) {
400095b8: 80 a0 60 00 cmp %g1, 0
400095bc: 02 80 00 18 be 4000961c <sem_close+0xa8> <== NEVER TAKEN
400095c0: 90 06 3f f0 add %i0, -16, %o0
_Objects_Allocator_unlock();
rtems_set_errno_and_return_minus_one( EINVAL );
}
if ( open_count == 1 && _POSIX_Semaphore_Is_busy( sem ) ) {
400095c4: 80 a0 60 01 cmp %g1, 1
400095c8: 12 80 00 06 bne 400095e0 <sem_close+0x6c>
400095cc: 82 00 7f ff add %g1, -1, %g1
400095d0: c4 06 20 0c ld [ %i0 + 0xc ], %g2
400095d4: 80 a0 a0 00 cmp %g2, 0
400095d8: 12 80 00 09 bne 400095fc <sem_close+0x88>
400095dc: 01 00 00 00 nop
_Objects_Allocator_unlock();
rtems_set_errno_and_return_minus_one( EBUSY );
}
the_semaphore->open_count = open_count - 1;
400095e0: c2 22 20 30 st %g1, [ %o0 + 0x30 ]
_POSIX_Semaphore_Delete( the_semaphore );
400095e4: 40 00 16 27 call 4000ee80 <_POSIX_Semaphore_Delete>
400095e8: b0 10 20 00 clr %i0
_RTEMS_Unlock_allocator();
400095ec: 40 00 01 eb call 40009d98 <_RTEMS_Unlock_allocator>
400095f0: 01 00 00 00 nop
_Objects_Allocator_unlock();
return 0;
}
400095f4: 81 c7 e0 08 ret
400095f8: 81 e8 00 00 restore
400095fc: 40 00 01 e7 call 40009d98 <_RTEMS_Unlock_allocator>
40009600: b0 10 3f ff mov -1, %i0
rtems_set_errno_and_return_minus_one( EBUSY );
40009604: 40 00 2c 9d call 40014878 <__errno>
40009608: 01 00 00 00 nop
4000960c: 82 10 20 10 mov 0x10, %g1 ! 10 <_TLS_Alignment+0xf>
40009610: c2 22 00 00 st %g1, [ %o0 ]
40009614: 81 c7 e0 08 ret
40009618: 81 e8 00 00 restore
4000961c: 40 00 01 df call 40009d98 <_RTEMS_Unlock_allocator> <== NOT EXECUTED
40009620: 01 00 00 00 nop <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( EINVAL );
40009624: 40 00 2c 95 call 40014878 <__errno>
40009628: b0 10 3f ff mov -1, %i0 ! ffffffff <RAM_END+0xbfbfffff>
4000962c: 82 10 20 16 mov 0x16, %g1
40009630: c2 22 00 00 st %g1, [ %o0 ]
40009634: 81 c7 e0 08 ret
40009638: 81 e8 00 00 restore
40005f80 <sem_open>:
{
40005f80: 9d e3 bf 90 save %sp, -112, %sp
va_start(arg, oflag);
40005f84: f4 27 a0 4c st %i2, [ %fp + 0x4c ]
if ( oflag & O_CREAT ) {
40005f88: 80 8e 62 00 btst 0x200, %i1
va_start(arg, oflag);
40005f8c: f6 27 a0 50 st %i3, [ %fp + 0x50 ]
40005f90: f8 27 a0 54 st %i4, [ %fp + 0x54 ]
if ( oflag & O_CREAT ) {
40005f94: 12 80 00 18 bne 40005ff4 <sem_open+0x74>
40005f98: fa 27 a0 58 st %i5, [ %fp + 0x58 ]
_RTEMS_Lock_allocator();
40005f9c: 40 00 03 3c call 40006c8c <_RTEMS_Lock_allocator>
40005fa0: 01 00 00 00 nop
const char *name,
size_t *name_length_p,
Objects_Get_by_name_error *error
)
{
return (POSIX_Semaphore_Control *) _Objects_Get_by_name(
40005fa4: 96 07 bf fc add %fp, -4, %o3
40005fa8: 94 07 bf f8 add %fp, -8, %o2
40005fac: 92 10 00 18 mov %i0, %o1
40005fb0: 11 10 00 5b sethi %hi(0x40016c00), %o0
40005fb4: 40 00 07 e5 call 40007f48 <_Objects_Get_by_name>
40005fb8: 90 12 20 34 or %o0, 0x34, %o0 ! 40016c34 <_POSIX_Semaphore_Information>
if ( the_semaphore == NULL ) {
40005fbc: ba 92 20 00 orcc %o0, 0, %i5
40005fc0: 02 80 00 40 be 400060c0 <sem_open+0x140>
40005fc4: 01 00 00 00 nop
if ( (oflag & (O_CREAT | O_EXCL)) == (O_CREAT | O_EXCL) ) {
40005fc8: b2 0e 6a 00 and %i1, 0xa00, %i1
40005fcc: 80 a6 6a 00 cmp %i1, 0xa00
40005fd0: 02 80 00 48 be 400060f0 <sem_open+0x170>
40005fd4: 01 00 00 00 nop
the_semaphore->open_count += 1;
40005fd8: c2 07 60 30 ld [ %i5 + 0x30 ], %g1
40005fdc: 82 00 60 01 inc %g1
40005fe0: c2 27 60 30 st %g1, [ %i5 + 0x30 ]
_RTEMS_Unlock_allocator();
40005fe4: 40 00 03 2f call 40006ca0 <_RTEMS_Unlock_allocator>
40005fe8: ba 07 60 10 add %i5, 0x10, %i5
}
40005fec: 81 c7 e0 08 ret
40005ff0: 91 e8 00 1d restore %g0, %i5, %o0
va_start(arg, oflag);
40005ff4: 82 07 a0 4c add %fp, 0x4c, %g1
_RTEMS_Lock_allocator();
40005ff8: 40 00 03 25 call 40006c8c <_RTEMS_Lock_allocator>
40005ffc: c2 27 bf f4 st %g1, [ %fp + -12 ]
40006000: 39 10 00 5b sethi %hi(0x40016c00), %i4
40006004: 96 07 bf fc add %fp, -4, %o3
40006008: 94 07 bf f8 add %fp, -8, %o2
4000600c: 92 10 00 18 mov %i0, %o1
40006010: 90 17 20 34 or %i4, 0x34, %o0
40006014: 40 00 07 cd call 40007f48 <_Objects_Get_by_name>
40006018: b4 10 00 1b mov %i3, %i2
if ( the_semaphore == NULL ) {
4000601c: ba 92 20 00 orcc %o0, 0, %i5
40006020: 12 bf ff ea bne 40005fc8 <sem_open+0x48>
40006024: c2 07 bf fc ld [ %fp + -4 ], %g1
if ( !( error == OBJECTS_GET_BY_NAME_NO_OBJECT && (oflag & O_CREAT) ) ) {
40006028: 80 a0 60 02 cmp %g1, 2
4000602c: 12 80 00 25 bne 400060c0 <sem_open+0x140>
40006030: 80 a6 e0 00 cmp %i3, 0
if ( value > SEM_VALUE_MAX ) {
40006034: 06 80 00 37 bl 40006110 <sem_open+0x190>
40006038: d2 07 bf f8 ld [ %fp + -8 ], %o1
name = _Workspace_String_duplicate( name_arg, name_len );
4000603c: 40 00 16 81 call 4000ba40 <_Workspace_String_duplicate>
40006040: 90 10 00 18 mov %i0, %o0
if ( name == NULL ) {
40006044: b6 92 20 00 orcc %o0, 0, %i3
40006048: 02 80 00 38 be 40006128 <sem_open+0x1a8> <== NEVER TAKEN
4000604c: b8 17 20 34 or %i4, 0x34, %i4
return ( *information->allocate )( information );
40006050: c2 07 20 08 ld [ %i4 + 8 ], %g1
40006054: 9f c0 40 00 call %g1
40006058: 90 10 00 1c mov %i4, %o0
if ( the_semaphore == NULL ) {
4000605c: 80 a2 20 00 cmp %o0, 0
40006060: 02 80 00 38 be 40006140 <sem_open+0x1c0> <== NEVER TAKEN
40006064: 84 10 20 01 mov 1, %g2
_POSIX_Semaphore_Initialize( &the_semaphore->Semaphore, name, value );
40006068: ba 02 20 10 add %o0, 0x10, %i5
the_semaphore->open_count = 1;
4000606c: c4 22 20 30 st %g2, [ %o0 + 0x30 ]
the_semaphore->linked = true;
40006070: c4 2a 20 2c stb %g2, [ %o0 + 0x2c ]
sem->_flags = (uintptr_t) sem ^ POSIX_SEMAPHORE_MAGIC;
40006074: 05 17 4d 9f sethi %hi(0x5d367c00), %g2
40006078: 84 10 a3 e7 or %g2, 0x3e7, %g2 ! 5d367fe7 <RAM_END+0x1cf67fe7>
4000607c: 84 1f 40 02 xor %i5, %g2, %g2
information->local_table[ index - OBJECTS_INDEX_MINIMUM ] = the_object;
40006080: c2 12 20 0a lduh [ %o0 + 0xa ], %g1
40006084: c4 22 20 10 st %g2, [ %o0 + 0x10 ]
40006088: 83 28 60 02 sll %g1, 2, %g1
const char *_name, unsigned int _count)
{
struct _Semaphore_Control _init =
_SEMAPHORE_NAMED_INITIALIZER(_name, _count);
*_semaphore = _init;
4000608c: c0 22 20 14 clr [ %o0 + 0x14 ]
40006090: 82 00 7f fc add %g1, -4, %g1
40006094: c0 22 20 18 clr [ %o0 + 0x18 ]
40006098: c0 22 20 1c clr [ %o0 + 0x1c ]
4000609c: c0 22 20 20 clr [ %o0 + 0x20 ]
400060a0: f6 22 20 24 st %i3, [ %o0 + 0x24 ]
400060a4: f4 22 20 28 st %i2, [ %o0 + 0x28 ]
the_object->name.name_p = name;
400060a8: f6 22 20 0c st %i3, [ %o0 + 0xc ]
information->local_table[ index - OBJECTS_INDEX_MINIMUM ] = the_object;
400060ac: c4 07 20 04 ld [ %i4 + 4 ], %g2
_RTEMS_Unlock_allocator();
400060b0: 40 00 02 fc call 40006ca0 <_RTEMS_Unlock_allocator>
400060b4: d0 20 80 01 st %o0, [ %g2 + %g1 ]
}
400060b8: 81 c7 e0 08 ret
400060bc: 91 e8 00 1d restore %g0, %i5, %o0
400060c0: 40 00 02 f8 call 40006ca0 <_RTEMS_Unlock_allocator>
400060c4: 01 00 00 00 nop
rtems_set_errno_and_return_value(
400060c8: 40 00 30 fc call 400124b8 <__errno>
400060cc: fa 07 bf fc ld [ %fp + -4 ], %i5
400060d0: bb 2f 60 02 sll %i5, 2, %i5
400060d4: 03 10 00 4f sethi %hi(0x40013c00), %g1
400060d8: 82 10 63 b4 or %g1, 0x3b4, %g1 ! 40013fb4 <_POSIX_Get_by_name_error_table>
400060dc: c2 00 40 1d ld [ %g1 + %i5 ], %g1
400060e0: c2 22 00 00 st %g1, [ %o0 ]
400060e4: ba 10 20 00 clr %i5
}
400060e8: 81 c7 e0 08 ret
400060ec: 91 e8 00 1d restore %g0, %i5, %o0
400060f0: 40 00 02 ec call 40006ca0 <_RTEMS_Unlock_allocator>
400060f4: ba 10 20 00 clr %i5
rtems_set_errno_and_return_value( EEXIST, SEM_FAILED );
400060f8: 40 00 30 f0 call 400124b8 <__errno>
400060fc: b0 10 00 1d mov %i5, %i0
40006100: 82 10 20 11 mov 0x11, %g1
40006104: c2 22 00 00 st %g1, [ %o0 ]
}
40006108: 81 c7 e0 08 ret
4000610c: 81 e8 00 00 restore
rtems_set_errno_and_return_value( EINVAL, SEM_FAILED );
40006110: 40 00 30 ea call 400124b8 <__errno>
40006114: b0 10 00 1d mov %i5, %i0
40006118: 82 10 20 16 mov 0x16, %g1
4000611c: 40 00 02 e1 call 40006ca0 <_RTEMS_Unlock_allocator>
40006120: c2 22 00 00 st %g1, [ %o0 ]
return sem;
40006124: 30 bf ff f9 b,a 40006108 <sem_open+0x188>
rtems_set_errno_and_return_value( ENOMEM, SEM_FAILED );
40006128: 40 00 30 e4 call 400124b8 <__errno>
4000612c: b0 10 00 1d mov %i5, %i0 <== NOT EXECUTED
40006130: 82 10 20 0c mov 0xc, %g1 <== NOT EXECUTED
40006134: 40 00 02 db call 40006ca0 <_RTEMS_Unlock_allocator> <== NOT EXECUTED
40006138: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
return sem;
4000613c: 30 bf ff f3 b,a 40006108 <sem_open+0x188> <== NOT EXECUTED
_Workspace_Free( name );
40006140: 40 00 16 3a call 4000ba28 <_Workspace_Free> <== NOT EXECUTED
40006144: 90 10 00 1b mov %i3, %o0 <== NOT EXECUTED
rtems_set_errno_and_return_value( ENOSPC, SEM_FAILED );
40006148: 40 00 30 dc call 400124b8 <__errno> <== NOT EXECUTED
4000614c: b0 10 00 1d mov %i5, %i0 <== NOT EXECUTED
40006150: 82 10 20 1c mov 0x1c, %g1 <== NOT EXECUTED
40006154: 40 00 02 d3 call 40006ca0 <_RTEMS_Unlock_allocator> <== NOT EXECUTED
40006158: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
return sem;
4000615c: 30 bf ff eb b,a 40006108 <sem_open+0x188> <== NOT EXECUTED
40005d18 <sem_post>:
#include <rtems/posix/semaphoreimpl.h>
#include <limits.h>
int sem_post( sem_t *_sem )
{
40005d18: 9d e3 bf 78 save %sp, -136, %sp
ISR_Level level;
Thread_queue_Context queue_context;
Thread_queue_Heads *heads;
unsigned int count;
POSIX_SEMAPHORE_VALIDATE_OBJECT( _sem );
40005d1c: 80 a6 20 00 cmp %i0, 0
40005d20: 02 80 00 30 be 40005de0 <sem_post+0xc8>
40005d24: 03 17 4d 9f sethi %hi(0x5d367c00), %g1
40005d28: c4 06 00 00 ld [ %i0 ], %g2
40005d2c: 82 10 63 e7 or %g1, 0x3e7, %g1
40005d30: 82 1e 00 01 xor %i0, %g1, %g1
40005d34: 80 a0 40 02 cmp %g1, %g2
40005d38: 12 80 00 2a bne 40005de0 <sem_post+0xc8>
40005d3c: 01 00 00 00 nop
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
40005d40: 91 d0 20 09 ta 9
return psr;
40005d44: 88 10 00 01 mov %g1, %g4
sem = _Sem_Get( &_sem->_Semaphore );
_Thread_queue_Context_initialize( &queue_context );
_Thread_queue_Context_ISR_disable( &queue_context, level );
_Sem_Queue_acquire_critical( sem, &queue_context );
heads = sem->Queue.Queue.heads;
40005d48: d0 06 20 0c ld [ %i0 + 0xc ], %o0
count = sem->count;
if ( RTEMS_PREDICT_TRUE( heads == NULL && count < SEM_VALUE_MAX ) ) {
40005d4c: 80 a2 20 00 cmp %o0, 0
40005d50: 12 80 00 0c bne 40005d80 <sem_post+0x68>
40005d54: c4 06 20 18 ld [ %i0 + 0x18 ], %g2
40005d58: 07 1f ff ff sethi %hi(0x7ffffc00), %g3
40005d5c: 86 10 e3 fe or %g3, 0x3fe, %g3 ! 7ffffffe <RAM_END+0x3fbffffe>
40005d60: 80 a0 c0 02 cmp %g3, %g2
40005d64: 0a 80 00 14 bcs 40005db4 <sem_post+0x9c>
40005d68: 84 00 a0 01 inc %g2
sem->count = count + 1;
40005d6c: c4 26 20 18 st %g2, [ %i0 + 0x18 ]
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
40005d70: 91 d0 20 0a ta 0xa
40005d74: 01 00 00 00 nop
_Sem_Queue_release( sem, level, &queue_context );
return 0;
40005d78: 81 c7 e0 08 ret
40005d7c: 91 e8 20 00 restore %g0, 0, %o0
const Thread_queue_Operations *operations;
Thread_Control *first;
_Thread_queue_Context_set_ISR_level( &queue_context, level );
operations = SEMAPHORE_TQ_OPERATIONS;
first = ( *operations->first )( heads );
40005d80: 3b 10 00 4f sethi %hi(0x40013c00), %i5
40005d84: ba 17 62 a4 or %i5, 0x2a4, %i5 ! 40013ea4 <_Thread_queue_Operations_priority>
40005d88: c2 07 60 10 ld [ %i5 + 0x10 ], %g1
40005d8c: 9f c0 40 00 call %g1
40005d90: c8 27 bf dc st %g4, [ %fp + -36 ]
_Thread_queue_Extract_critical(
40005d94: 96 07 bf dc add %fp, -36, %o3
first = ( *operations->first )( heads );
40005d98: 94 10 00 08 mov %o0, %o2
_Thread_queue_Extract_critical(
40005d9c: 92 10 00 1d mov %i5, %o1
40005da0: 90 06 20 0c add %i0, 0xc, %o0
40005da4: 40 00 08 fe call 4000819c <_Thread_queue_Extract_critical>
40005da8: b0 10 20 00 clr %i0
&sem->Queue.Queue,
operations,
first,
&queue_context
);
return 0;
40005dac: 81 c7 e0 08 ret
40005db0: 81 e8 00 00 restore
if ( RTEMS_PREDICT_TRUE( heads != NULL ) ) {
40005db4: 80 a2 20 00 cmp %o0, 0
40005db8: 12 bf ff f3 bne 40005d84 <sem_post+0x6c> <== NEVER TAKEN
40005dbc: 3b 10 00 4f sethi %hi(0x40013c00), %i5
40005dc0: 91 d0 20 0a ta 0xa
40005dc4: 01 00 00 00 nop
}
_Sem_Queue_release( sem, level, &queue_context );
rtems_set_errno_and_return_minus_one( EOVERFLOW );
40005dc8: 40 00 2c c7 call 400110e4 <__errno>
40005dcc: b0 10 3f ff mov -1, %i0 ! ffffffff <RAM_END+0xbfbfffff>
40005dd0: 82 10 20 8b mov 0x8b, %g1
40005dd4: c2 22 00 00 st %g1, [ %o0 ]
}
40005dd8: 81 c7 e0 08 ret
40005ddc: 81 e8 00 00 restore
POSIX_SEMAPHORE_VALIDATE_OBJECT( _sem );
40005de0: 40 00 2c c1 call 400110e4 <__errno>
40005de4: b0 10 3f ff mov -1, %i0
40005de8: 82 10 20 16 mov 0x16, %g1
40005dec: c2 22 00 00 st %g1, [ %o0 ]
40005df0: 81 c7 e0 08 ret
40005df4: 81 e8 00 00 restore
40006f98 <sem_timedwait>:
int sem_timedwait(
sem_t *__restrict _sem,
const struct timespec *__restrict abstime
)
{
40006f98: 9d e3 bf 78 save %sp, -136, %sp
Thread_queue_Context queue_context;
ISR_Level level;
Thread_Control *executing;
unsigned int count;
POSIX_SEMAPHORE_VALIDATE_OBJECT( _sem );
40006f9c: 80 a6 20 00 cmp %i0, 0
40006fa0: 02 80 00 2f be 4000705c <sem_timedwait+0xc4>
40006fa4: 03 17 4d 9f sethi %hi(0x5d367c00), %g1
40006fa8: c4 06 00 00 ld [ %i0 ], %g2
40006fac: 82 10 63 e7 or %g1, 0x3e7, %g1
40006fb0: 82 1e 00 01 xor %i0, %g1, %g1
40006fb4: 80 a0 40 02 cmp %g1, %g2
40006fb8: 12 80 00 29 bne 4000705c <sem_timedwait+0xc4>
40006fbc: 01 00 00 00 nop
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
40006fc0: 91 d0 20 09 ta 9
sem = _Sem_Get( &_sem->_Semaphore );
_Thread_queue_Context_initialize( &queue_context );
_Thread_queue_Context_ISR_disable( &queue_context, level );
executing = _Sem_Queue_acquire_critical( sem, &queue_context );
count = sem->count;
40006fc4: c4 06 20 18 ld [ %i0 + 0x18 ], %g2
if ( RTEMS_PREDICT_TRUE( count > 0 ) ) {
40006fc8: 80 a0 a0 00 cmp %g2, 0
40006fcc: 02 80 00 07 be 40006fe8 <sem_timedwait+0x50>
40006fd0: 84 00 bf ff add %g2, -1, %g2
sem->count = count - 1;
40006fd4: c4 26 20 18 st %g2, [ %i0 + 0x18 ]
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
40006fd8: 91 d0 20 0a ta 0xa
40006fdc: 01 00 00 00 nop
_Sem_Queue_release( sem, level, &queue_context );
return 0;
40006fe0: 81 c7 e0 08 ret
40006fe4: 91 e8 20 00 restore %g0, 0, %o0
40006fe8: c2 27 bf dc st %g1, [ %fp + -36 ]
queue_context->thread_state = thread_state;
40006fec: 82 10 20 02 mov 2, %g1
Thread_queue_Context *queue_context
)
{
Thread_Control *executing;
executing = _Thread_Executing;
40006ff0: fa 01 a0 20 ld [ %g6 + 0x20 ], %i5
40006ff4: c2 27 bf e0 st %g1, [ %fp + -32 ]
queue_context->enqueue_callout = _Thread_queue_Add_timeout_realtime_timespec;
40006ff8: 03 10 00 2a sethi %hi(0x4000a800), %g1
40006ffc: 82 10 61 c0 or %g1, 0x1c0, %g1 ! 4000a9c0 <_Thread_queue_Add_timeout_realtime_timespec>
_Thread_queue_Context_set_enqueue_timeout_realtime_timespec(
&queue_context,
abstime
);
_Thread_queue_Context_set_ISR_level( &queue_context, level );
_Thread_queue_Enqueue(
40007000: 90 06 20 0c add %i0, 0xc, %o0
queue_context->Timeout.arg = abstime;
40007004: f2 27 bf e8 st %i1, [ %fp + -24 ]
40007008: 96 07 bf dc add %fp, -36, %o3
queue_context->enqueue_callout = _Thread_queue_Add_timeout_realtime_timespec;
4000700c: c2 27 bf e4 st %g1, [ %fp + -28 ]
40007010: 94 10 00 1d mov %i5, %o2
40007014: 13 10 00 51 sethi %hi(0x40014400), %o1
40007018: 40 00 0a 63 call 400099a4 <_Thread_queue_Enqueue>
4000701c: 92 12 62 30 or %o1, 0x230, %o1 ! 40014630 <_Thread_queue_Operations_priority>
*/
RTEMS_INLINE_ROUTINE Status_Control _Thread_Wait_get_status(
const Thread_Control *the_thread
)
{
return (Status_Control) the_thread->Wait.return_code;
40007020: f0 07 60 4c ld [ %i5 + 0x4c ], %i0
if ( status == STATUS_SUCCESSFUL ) {
40007024: 80 a6 20 00 cmp %i0, 0
40007028: 12 80 00 04 bne 40007038 <sem_timedwait+0xa0> <== ALWAYS TAKEN
4000702c: 01 00 00 00 nop
&queue_context
);
status = _Thread_Wait_get_status( executing );
return _POSIX_Zero_or_minus_one_plus_errno( status );
}
}
40007030: 81 c7 e0 08 ret <== NOT EXECUTED
40007034: 81 e8 00 00 restore <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( _POSIX_Get_error( status ) );
40007038: 40 00 2e cc call 40012b68 <__errno>
4000703c: 01 00 00 00 nop
return STATUS_GET_POSIX( status );
40007040: 83 3e 20 1f sra %i0, 0x1f, %g1
40007044: 82 08 60 ff and %g1, 0xff, %g1
40007048: 82 00 40 18 add %g1, %i0, %g1
4000704c: 83 38 60 08 sra %g1, 8, %g1
rtems_set_errno_and_return_minus_one( _POSIX_Get_error( status ) );
40007050: c2 22 00 00 st %g1, [ %o0 ]
40007054: 81 c7 e0 08 ret
40007058: 91 e8 3f ff restore %g0, -1, %o0
POSIX_SEMAPHORE_VALIDATE_OBJECT( _sem );
4000705c: 40 00 2e c3 call 40012b68 <__errno>
40007060: b0 10 3f ff mov -1, %i0
40007064: 82 10 20 16 mov 0x16, %g1
40007068: c2 22 00 00 st %g1, [ %o0 ]
4000706c: 81 c7 e0 08 ret
40007070: 81 e8 00 00 restore
40005afc <shm_open>:
{
40005afc: 9d e3 bf 88 save %sp, -120, %sp
if ( ( oflag & O_ACCMODE ) != O_RDONLY && ( oflag & O_ACCMODE ) != O_RDWR ) {
40005b00: b6 0e 60 03 and %i1, 3, %i3
40005b04: 82 1e e0 02 xor %i3, 2, %g1
40005b08: 80 a0 00 01 cmp %g0, %g1
40005b0c: 82 40 20 00 addx %g0, 0, %g1
40005b10: 80 8e 60 01 btst 1, %i1
40005b14: 12 80 00 ad bne 40005dc8 <shm_open+0x2cc> <== NEVER TAKEN
40005b18: 80 8e 71 fd btst -3587, %i1
if ( ( oflag & ~( O_RDONLY | O_RDWR | O_CREAT | O_EXCL | O_TRUNC ) ) != 0 ) {
40005b1c: 12 80 00 ab bne 40005dc8 <shm_open+0x2cc> <== NEVER TAKEN
40005b20: a2 8e 64 00 andcc %i1, 0x400, %l1
if ( ( oflag & O_TRUNC ) != 0 && ( oflag & O_ACCMODE ) != O_RDWR ) {
40005b24: 02 80 00 04 be 40005b34 <shm_open+0x38> <== ALWAYS TAKEN
40005b28: 80 a0 60 00 cmp %g1, 0
40005b2c: 12 80 00 a7 bne 40005dc8 <shm_open+0x2cc> <== NOT EXECUTED
40005b30: 01 00 00 00 nop <== NOT EXECUTED
iop = rtems_libio_allocate();
40005b34: 7f ff f0 ba call 40001e1c <rtems_libio_allocate>
40005b38: 01 00 00 00 nop
if ( iop == NULL ) {
40005b3c: ba 92 20 00 orcc %o0, 0, %i5
40005b40: 02 80 00 a8 be 40005de0 <shm_open+0x2e4> <== NEVER TAKEN
40005b44: 01 00 00 00 nop
_RTEMS_Lock_allocator();
40005b48: 40 00 01 87 call 40006164 <_RTEMS_Lock_allocator>
40005b4c: 21 10 00 6e sethi %hi(0x4001b800), %l0
return (POSIX_Shm_Control *) _Objects_Get_by_name(
40005b50: 96 07 bf ec add %fp, -20, %o3
40005b54: 94 07 bf e8 add %fp, -24, %o2
40005b58: 92 10 00 18 mov %i0, %o1
40005b5c: 40 00 03 c2 call 40006a64 <_Objects_Get_by_name>
40005b60: 90 14 23 84 or %l0, 0x384, %o0
if ( shm == NULL ) {
40005b64: b8 92 20 00 orcc %o0, 0, %i4
40005b68: 02 80 00 48 be 40005c88 <shm_open+0x18c> <== ALWAYS TAKEN
40005b6c: c2 07 bf ec ld [ %fp + -20 ], %g1
if ( ( oflag & ( O_EXCL | O_CREAT ) ) == ( O_EXCL | O_CREAT ) ) {
40005b70: b2 0e 6a 00 and %i1, 0xa00, %i1 <== NOT EXECUTED
40005b74: 80 a6 6a 00 cmp %i1, 0xa00 <== NOT EXECUTED
40005b78: 12 80 00 0c bne 40005ba8 <shm_open+0xac> <== NOT EXECUTED
40005b7c: 80 a0 00 1b cmp %g0, %i3 <== NOT EXECUTED
_RTEMS_Unlock_allocator();
40005b80: 40 00 01 7e call 40006178 <_RTEMS_Unlock_allocator> <== NOT EXECUTED
40005b84: b8 10 20 11 mov 0x11, %i4 <== NOT EXECUTED
rtems_libio_free( iop );
40005b88: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
40005b8c: 7f ff f0 b9 call 40001e70 <rtems_libio_free> <== NOT EXECUTED
40005b90: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( err );
40005b94: 40 00 2c c1 call 40010e98 <__errno> <== NOT EXECUTED
40005b98: 01 00 00 00 nop <== NOT EXECUTED
40005b9c: f8 22 00 00 st %i4, [ %o0 ] <== NOT EXECUTED
40005ba0: 81 c7 e0 08 ret <== NOT EXECUTED
40005ba4: 81 e8 00 00 restore <== NOT EXECUTED
return rtems_filesystem_check_access( flags, shm->mode, shm->uid, shm->gid );
40005ba8: d6 17 20 2e lduh [ %i4 + 0x2e ], %o3 <== NOT EXECUTED
40005bac: d4 17 20 2c lduh [ %i4 + 0x2c ], %o2 <== NOT EXECUTED
40005bb0: d2 07 20 30 ld [ %i4 + 0x30 ], %o1 <== NOT EXECUTED
flags = RTEMS_FS_PERMS_WRITE;
40005bb4: 90 40 3f ff addx %g0, -1, %o0 <== NOT EXECUTED
40005bb8: 90 0a 20 02 and %o0, 2, %o0 <== NOT EXECUTED
return rtems_filesystem_check_access( flags, shm->mode, shm->uid, shm->gid );
40005bbc: 40 00 11 27 call 4000a058 <rtems_filesystem_check_access> <== NOT EXECUTED
40005bc0: 90 02 20 02 add %o0, 2, %o0 <== NOT EXECUTED
} else if ( !shm_access_ok( shm, oflag ) ) {
40005bc4: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED
40005bc8: 02 80 00 66 be 40005d60 <shm_open+0x264> <== NOT EXECUTED
40005bcc: 01 00 00 00 nop <== NOT EXECUTED
++shm->reference_count;
40005bd0: c2 07 20 1c ld [ %i4 + 0x1c ], %g1 <== NOT EXECUTED
40005bd4: 82 00 60 01 inc %g1 <== NOT EXECUTED
40005bd8: 40 00 01 68 call 40006178 <_RTEMS_Unlock_allocator> <== NOT EXECUTED
40005bdc: c2 27 20 1c st %g1, [ %i4 + 0x1c ] <== NOT EXECUTED
if ( oflag & O_TRUNC ) {
40005be0: 80 a4 60 00 cmp %l1, 0 <== NOT EXECUTED
40005be4: 12 80 00 70 bne 40005da4 <shm_open+0x2a8> <== NEVER TAKEN
40005be8: 92 10 20 00 clr %o1
fd = rtems_libio_iop_to_descriptor( iop );
40005bec: 03 2a aa aa sethi %hi(0xaaaaa800), %g1
40005bf0: 82 10 62 ab or %g1, 0x2ab, %g1 ! aaaaaaab <RAM_END+0x6a6aaaab>
40005bf4: 31 10 00 75 sethi %hi(0x4001d400), %i0
40005bf8: b0 16 23 28 or %i0, 0x328, %i0 ! 4001d728 <rtems_libio_iops>
40005bfc: b0 27 40 18 sub %i5, %i0, %i0
40005c00: b1 3e 20 04 sra %i0, 4, %i0
40005c04: b0 5e 00 01 smul %i0, %g1, %i0
iop->pathinfo.handlers = &shm_handlers;
40005c08: 03 10 00 64 sethi %hi(0x40019000), %g1
40005c0c: 82 10 60 2c or %g1, 0x2c, %g1 ! 4001902c <shm_handlers>
iop->data0 = fd;
40005c10: f0 27 60 28 st %i0, [ %i5 + 0x28 ]
rtems_filesystem_location_add_to_mt_entry( &iop->pathinfo );
40005c14: 88 07 60 10 add %i5, 0x10, %g4
iop->pathinfo.handlers = &shm_handlers;
40005c18: c2 27 60 20 st %g1, [ %i5 + 0x20 ]
iop->pathinfo.mt_entry = &rtems_filesystem_null_mt_entry;
40005c1c: 03 10 00 6f sethi %hi(0x4001bc00), %g1
iop->data1 = shm;
40005c20: f8 27 60 2c st %i4, [ %i5 + 0x2c ]
iop->pathinfo.mt_entry = &rtems_filesystem_null_mt_entry;
40005c24: 82 10 61 44 or %g1, 0x144, %g1
iop->pathinfo.node_access = shm;
40005c28: f8 27 60 18 st %i4, [ %i5 + 0x18 ]
iop->pathinfo.mt_entry = &rtems_filesystem_null_mt_entry;
40005c2c: c2 27 60 24 st %g1, [ %i5 + 0x24 ]
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
40005c30: 91 d0 20 09 ta 9
&loc->mt_entry->location_chain,
40005c34: c4 07 60 24 ld [ %i5 + 0x24 ], %g2
old_last = tail->previous;
40005c38: c6 00 a0 1c ld [ %g2 + 0x1c ], %g3
return &the_chain->Tail.Node;
40005c3c: b8 00 a0 18 add %g2, 0x18, %i4
the_node->next = tail;
40005c40: f8 27 60 10 st %i4, [ %i5 + 0x10 ]
tail->previous = the_node;
40005c44: c8 20 a0 1c st %g4, [ %g2 + 0x1c ]
old_last->next = the_node;
40005c48: c8 20 c0 00 st %g4, [ %g3 ]
the_node->previous = old_last;
40005c4c: c6 27 60 14 st %g3, [ %i5 + 0x14 ]
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
40005c50: 91 d0 20 0a ta 0xa
40005c54: 01 00 00 00 nop
flags |= LIBIO_FLAGS_READ_WRITE;
40005c58: 80 a0 00 1b cmp %g0, %i3
40005c5c: 84 40 3f ff addx %g0, -1, %g2
40005c60: 84 08 bf fc and %g2, -4, %g2
40005c64: 84 00 a9 06 add %g2, 0x906, %g2
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
40005c68: 91 d0 20 09 ta 9
*obj = val | arg;
40005c6c: c6 07 40 00 ld [ %i5 ], %g3
40005c70: 84 10 c0 02 or %g3, %g2, %g2
40005c74: c4 27 40 00 st %g2, [ %i5 ]
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
40005c78: 91 d0 20 0a ta 0xa
40005c7c: 01 00 00 00 nop
}
40005c80: 81 c7 e0 08 ret
40005c84: 81 e8 00 00 restore
switch ( obj_err ) {
40005c88: 80 a0 60 00 cmp %g1, 0
40005c8c: 02 80 00 42 be 40005d94 <shm_open+0x298> <== NEVER TAKEN
40005c90: 80 a0 60 01 cmp %g1, 1
40005c94: 02 80 00 3c be 40005d84 <shm_open+0x288> <== NEVER TAKEN
40005c98: 01 00 00 00 nop
if ( name_arg[0] != '/' ) {
40005c9c: c2 4e 00 00 ldsb [ %i0 ], %g1
40005ca0: 80 a0 60 2f cmp %g1, 0x2f
40005ca4: 12 80 00 3c bne 40005d94 <shm_open+0x298> <== NEVER TAKEN
40005ca8: 80 8e 62 00 btst 0x200, %i1
if ( ( oflag & O_CREAT ) != O_CREAT ) {
40005cac: 02 80 00 43 be 40005db8 <shm_open+0x2bc> <== NEVER TAKEN
40005cb0: d2 07 bf e8 ld [ %fp + -24 ], %o1
name = _Workspace_String_duplicate( name_arg, name_len );
40005cb4: 40 00 0c f3 call 40009080 <_Workspace_String_duplicate>
40005cb8: 90 10 00 18 mov %i0, %o0
if ( name == NULL ) {
40005cbc: b0 92 20 00 orcc %o0, 0, %i0
40005cc0: 02 80 00 4e be 40005df8 <shm_open+0x2fc> <== NEVER TAKEN
40005cc4: 01 00 00 00 nop
return ( *information->allocate )( information );
40005cc8: a0 14 23 84 or %l0, 0x384, %l0
40005ccc: c2 04 20 08 ld [ %l0 + 8 ], %g1
40005cd0: 9f c0 40 00 call %g1
40005cd4: 90 10 00 10 mov %l0, %o0
if ( shm == NULL ) {
40005cd8: b8 92 20 00 orcc %o0, 0, %i4
40005cdc: 02 80 00 4b be 40005e08 <shm_open+0x30c> <== NEVER TAKEN
40005ce0: 92 10 20 00 clr %o1
gettimeofday( &tv, 0 );
40005ce4: 40 00 0f 81 call 40009ae8 <gettimeofday>
40005ce8: 90 07 bf f0 add %fp, -16, %o0
shm->reference_count = 1;
40005cec: 82 10 20 01 mov 1, %g1
shm->shm_object.handle = NULL;
40005cf0: c0 27 20 20 clr [ %i4 + 0x20 ]
shm->reference_count = 1;
40005cf4: c2 27 20 1c st %g1, [ %i4 + 0x1c ]
shm->shm_object.ops = &_POSIX_Shm_Object_operations;
40005cf8: 03 10 00 64 sethi %hi(0x40019000), %g1
shm->shm_object.size = 0;
40005cfc: c0 27 20 24 clr [ %i4 + 0x24 ]
shm->shm_object.ops = &_POSIX_Shm_Object_operations;
40005d00: 82 10 60 6c or %g1, 0x6c, %g1
shm->mode = mode & ~rtems_filesystem_umask;
40005d04: 7f ff f5 b7 call 400033e0 <rtems_current_user_env_get>
40005d08: c2 27 20 28 st %g1, [ %i4 + 0x28 ]
40005d0c: c2 02 20 08 ld [ %o0 + 8 ], %g1
40005d10: b4 2e 80 01 andn %i2, %g1, %i2
shm->oflag = oflag;
40005d14: f2 27 20 34 st %i1, [ %i4 + 0x34 ]
shm->uid = geteuid();
40005d18: 40 00 0f 6e call 40009ad0 <geteuid>
40005d1c: f4 27 20 30 st %i2, [ %i4 + 0x30 ]
shm->gid = getegid();
40005d20: 40 00 0f 66 call 40009ab8 <getegid>
40005d24: d0 37 20 2c sth %o0, [ %i4 + 0x2c ]
shm->atime = (time_t) tv.tv_sec;
40005d28: c4 1f bf f0 ldd [ %fp + -16 ], %g2
40005d2c: c4 3f 20 38 std %g2, [ %i4 + 0x38 ]
shm->mtime = (time_t) tv.tv_sec;
40005d30: c4 3f 20 40 std %g2, [ %i4 + 0x40 ]
shm->ctime = (time_t) tv.tv_sec;
40005d34: c4 3f 20 48 std %g2, [ %i4 + 0x48 ]
information->local_table[ index - OBJECTS_INDEX_MINIMUM ] = the_object;
40005d38: c2 17 20 0a lduh [ %i4 + 0xa ], %g1
shm->gid = getegid();
40005d3c: d0 37 20 2e sth %o0, [ %i4 + 0x2e ]
40005d40: 83 28 60 02 sll %g1, 2, %g1
the_object->name.name_p = name;
40005d44: f0 27 20 0c st %i0, [ %i4 + 0xc ]
information->local_table[ index - OBJECTS_INDEX_MINIMUM ] = the_object;
40005d48: 82 00 7f fc add %g1, -4, %g1
40005d4c: c4 04 20 04 ld [ %l0 + 4 ], %g2
_RTEMS_Unlock_allocator();
40005d50: 40 00 01 0a call 40006178 <_RTEMS_Unlock_allocator>
40005d54: f8 20 80 01 st %i4, [ %g2 + %g1 ]
if ( oflag & O_TRUNC ) {
40005d58: 10 bf ff a3 b 40005be4 <shm_open+0xe8>
40005d5c: 80 a4 60 00 cmp %l1, 0
40005d60: 40 00 01 06 call 40006178 <_RTEMS_Unlock_allocator> <== NOT EXECUTED
40005d64: b8 10 20 0d mov 0xd, %i4 <== NOT EXECUTED
rtems_libio_free( iop );
40005d68: 7f ff f0 42 call 40001e70 <rtems_libio_free> <== NOT EXECUTED
40005d6c: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( err );
40005d70: 40 00 2c 4a call 40010e98 <__errno> <== NOT EXECUTED
40005d74: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
40005d78: f8 22 00 00 st %i4, [ %o0 ] <== NOT EXECUTED
40005d7c: 81 c7 e0 08 ret <== NOT EXECUTED
40005d80: 81 e8 00 00 restore <== NOT EXECUTED
40005d84: 40 00 00 fd call 40006178 <_RTEMS_Unlock_allocator> <== NOT EXECUTED
40005d88: b8 10 20 5b mov 0x5b, %i4 <== NOT EXECUTED
rtems_libio_free( iop );
40005d8c: 10 bf ff 80 b 40005b8c <shm_open+0x90> <== NOT EXECUTED
40005d90: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
40005d94: 40 00 00 f9 call 40006178 <_RTEMS_Unlock_allocator> <== NOT EXECUTED
40005d98: b8 10 20 16 mov 0x16, %i4 <== NOT EXECUTED
40005d9c: 10 bf ff 7c b 40005b8c <shm_open+0x90> <== NOT EXECUTED
40005da0: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
err = shm_ftruncate( iop, 0 );
40005da4: 94 10 20 00 clr %o2 <== NOT EXECUTED
40005da8: 7f ff fe f5 call 4000597c <shm_ftruncate> <== NOT EXECUTED
40005dac: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
fd = rtems_libio_iop_to_descriptor( iop );
40005db0: 10 bf ff 90 b 40005bf0 <shm_open+0xf4> <== NOT EXECUTED
40005db4: 03 2a aa aa sethi %hi(0xaaaaa800), %g1 <== NOT EXECUTED
40005db8: 40 00 00 f0 call 40006178 <_RTEMS_Unlock_allocator> <== NOT EXECUTED
40005dbc: b8 10 20 02 mov 2, %i4 <== NOT EXECUTED
rtems_libio_free( iop );
40005dc0: 10 bf ff 73 b 40005b8c <shm_open+0x90> <== NOT EXECUTED
40005dc4: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( EACCES );
40005dc8: 40 00 2c 34 call 40010e98 <__errno> <== NOT EXECUTED
40005dcc: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
40005dd0: 82 10 20 0d mov 0xd, %g1 <== NOT EXECUTED
40005dd4: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
40005dd8: 81 c7 e0 08 ret <== NOT EXECUTED
40005ddc: 81 e8 00 00 restore <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( EMFILE );
40005de0: 40 00 2c 2e call 40010e98 <__errno> <== NOT EXECUTED
40005de4: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
40005de8: 82 10 20 18 mov 0x18, %g1 <== NOT EXECUTED
40005dec: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
40005df0: 81 c7 e0 08 ret <== NOT EXECUTED
40005df4: 81 e8 00 00 restore <== NOT EXECUTED
40005df8: 40 00 00 e0 call 40006178 <_RTEMS_Unlock_allocator> <== NOT EXECUTED
40005dfc: b8 10 20 1c mov 0x1c, %i4 <== NOT EXECUTED
rtems_libio_free( iop );
40005e00: 10 bf ff 63 b 40005b8c <shm_open+0x90> <== NOT EXECUTED
40005e04: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
_Workspace_Free( name );
40005e08: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED
40005e0c: 40 00 0c 97 call 40009068 <_Workspace_Free> <== NOT EXECUTED
40005e10: b8 10 20 17 mov 0x17, %i4 <== NOT EXECUTED
40005e14: 40 00 00 d9 call 40006178 <_RTEMS_Unlock_allocator> <== NOT EXECUTED
40005e18: 01 00 00 00 nop <== NOT EXECUTED
rtems_libio_free( iop );
40005e1c: 10 bf ff 5c b 40005b8c <shm_open+0x90> <== NOT EXECUTED
40005e20: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED
40007aa8 <shm_unlink>:
#include <rtems/seterr.h>
#include <rtems/posix/shmimpl.h>
int shm_unlink( const char *name )
{
40007aa8: 9d e3 bf 98 save %sp, -104, %sp
_RTEMS_Lock_allocator();
40007aac: 40 00 08 e0 call 40009e2c <_RTEMS_Lock_allocator>
40007ab0: 39 10 00 6c sethi %hi(0x4001b000), %i4
40007ab4: 96 07 bf fc add %fp, -4, %o3
40007ab8: 94 10 20 00 clr %o2
40007abc: 92 10 00 18 mov %i0, %o1
40007ac0: 40 00 0f 68 call 4000b860 <_Objects_Get_by_name>
40007ac4: 90 17 21 f4 or %i4, 0x1f4, %o0
POSIX_Shm_Control *shm;
_Objects_Allocator_lock();
shm = _POSIX_Shm_Get_by_name( name, 0, &obj_err );
if ( shm ) {
40007ac8: ba 92 20 00 orcc %o0, 0, %i5
40007acc: 02 80 00 13 be 40007b18 <shm_unlink+0x70> <== NEVER TAKEN
40007ad0: 92 10 00 1d mov %i5, %o1
_Objects_Namespace_remove_string(
40007ad4: 40 00 0f 5e call 4000b84c <_Objects_Namespace_remove_string>
40007ad8: 90 17 21 f4 or %i4, 0x1f4, %o0
&_POSIX_Shm_Information,
&shm->Object
);
if ( shm->reference_count == 0 ) {
40007adc: f0 07 60 1c ld [ %i5 + 0x1c ], %i0
40007ae0: 80 a6 20 00 cmp %i0, 0
40007ae4: 12 80 00 09 bne 40007b08 <shm_unlink+0x60> <== NEVER TAKEN
40007ae8: 90 17 21 f4 or %i4, 0x1f4, %o0
( *information->deallocate )( information, the_object );
40007aec: c2 02 20 0c ld [ %o0 + 0xc ], %g1
40007af0: 9f c0 40 00 call %g1
40007af4: 92 10 00 1d mov %i5, %o1
_RTEMS_Unlock_allocator();
40007af8: 40 00 08 d2 call 40009e40 <_RTEMS_Unlock_allocator>
40007afc: 01 00 00 00 nop
}
}
_Objects_Allocator_unlock();
if ( err != 0 )
40007b00: 81 c7 e0 08 ret
40007b04: 81 e8 00 00 restore
40007b08: 40 00 08 ce call 40009e40 <_RTEMS_Unlock_allocator> <== NOT EXECUTED
40007b0c: b0 10 20 00 clr %i0 <== NOT EXECUTED
40007b10: 81 c7 e0 08 ret <== NOT EXECUTED
40007b14: 81 e8 00 00 restore <== NOT EXECUTED
switch ( obj_err ) {
40007b18: c2 07 bf fc ld [ %fp + -4 ], %g1 <== NOT EXECUTED
40007b1c: 80 a0 60 01 cmp %g1, 1 <== NOT EXECUTED
40007b20: 02 80 00 09 be 40007b44 <shm_unlink+0x9c> <== NOT EXECUTED
40007b24: 01 00 00 00 nop <== NOT EXECUTED
40007b28: 40 00 08 c6 call 40009e40 <_RTEMS_Unlock_allocator> <== NOT EXECUTED
40007b2c: ba 10 20 02 mov 2, %i5 ! 2 <_TLS_Alignment+0x1> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( err );
40007b30: 40 00 36 b4 call 40015600 <__errno> <== NOT EXECUTED
40007b34: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
40007b38: fa 22 00 00 st %i5, [ %o0 ] <== NOT EXECUTED
return 0;
}
40007b3c: 81 c7 e0 08 ret <== NOT EXECUTED
40007b40: 81 e8 00 00 restore <== NOT EXECUTED
40007b44: 40 00 08 bf call 40009e40 <_RTEMS_Unlock_allocator> <== NOT EXECUTED
40007b48: ba 10 20 5b mov 0x5b, %i5 <== NOT EXECUTED
if ( err != 0 )
40007b4c: 30 bf ff f9 b,a 40007b30 <shm_unlink+0x88> <== NOT EXECUTED
4000fc08 <sigaction>:
int sigaction(
int sig,
const struct sigaction *__restrict act,
struct sigaction *__restrict oact
)
{
4000fc08: 9d e3 bf 98 save %sp, -104, %sp
Thread_queue_Context queue_context;
if ( !sig )
4000fc0c: 80 a6 20 00 cmp %i0, 0
4000fc10: 02 80 00 43 be 4000fd1c <sigaction+0x114>
4000fc14: 82 06 3f ff add %i0, -1, %g1
rtems_set_errno_and_return_minus_one( EINVAL );
if ( !is_valid_signo(sig) )
4000fc18: 80 a0 60 1f cmp %g1, 0x1f
4000fc1c: 18 80 00 40 bgu 4000fd1c <sigaction+0x114>
4000fc20: 80 a6 20 09 cmp %i0, 9
*
* NOTE: Solaris documentation claims to "silently enforce" this which
* contradicts the POSIX specification.
*/
if ( sig == SIGKILL )
4000fc24: 02 80 00 3e be 4000fd1c <sigaction+0x114>
4000fc28: 01 00 00 00 nop
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
4000fc2c: 91 d0 20 09 ta 9
rtems_set_errno_and_return_minus_one( EINVAL );
_Thread_queue_Context_initialize( &queue_context );
_POSIX_signals_Acquire( &queue_context );
if ( oact )
4000fc30: 80 a6 a0 00 cmp %i2, 0
4000fc34: 02 80 00 0d be 4000fc68 <sigaction+0x60>
4000fc38: 85 2e 20 01 sll %i0, 1, %g2
*oact = _POSIX_signals_Vectors[ sig ];
4000fc3c: 07 10 00 68 sethi %hi(0x4001a000), %g3
4000fc40: 84 00 80 18 add %g2, %i0, %g2
4000fc44: 86 10 e1 dc or %g3, 0x1dc, %g3
4000fc48: 85 28 a0 02 sll %g2, 2, %g2
4000fc4c: fa 00 c0 02 ld [ %g3 + %g2 ], %i5
4000fc50: 88 00 c0 02 add %g3, %g2, %g4
4000fc54: c6 01 20 04 ld [ %g4 + 4 ], %g3
4000fc58: c4 01 20 08 ld [ %g4 + 8 ], %g2
4000fc5c: fa 26 80 00 st %i5, [ %i2 ]
4000fc60: c6 26 a0 04 st %g3, [ %i2 + 4 ]
4000fc64: c4 26 a0 08 st %g2, [ %i2 + 8 ]
/*
* Evaluate the new action structure and set the global signal vector
* appropriately.
*/
if ( act ) {
4000fc68: 80 a6 60 00 cmp %i1, 0
4000fc6c: 02 80 00 16 be 4000fcc4 <sigaction+0xbc> <== NEVER TAKEN
4000fc70: 01 00 00 00 nop
/*
* Unless the user is installing the default signal actions, then
* we can just copy the provided sigaction structure into the vectors.
*/
if ( act->sa_handler == SIG_DFL ) {
4000fc74: c4 06 60 08 ld [ %i1 + 8 ], %g2
4000fc78: 80 a0 a0 00 cmp %g2, 0
4000fc7c: 02 80 00 16 be 4000fcd4 <sigaction+0xcc>
4000fc80: 85 2e 20 01 sll %i0, 1, %g2
4000fc84: c2 27 bf fc st %g1, [ %fp + -4 ]
_POSIX_signals_Vectors[ sig ] = _POSIX_signals_Default_vectors[ sig ];
} else {
_POSIX_signals_Clear_process_signals( sig );
4000fc88: 40 00 03 8e call 40010ac0 <_POSIX_signals_Clear_process_signals>
4000fc8c: 90 10 00 18 mov %i0, %o0
_POSIX_signals_Vectors[ sig ] = *act;
4000fc90: f8 06 40 00 ld [ %i1 ], %i4
4000fc94: fa 06 60 04 ld [ %i1 + 4 ], %i5
4000fc98: c8 06 60 08 ld [ %i1 + 8 ], %g4
4000fc9c: 87 2e 20 01 sll %i0, 1, %g3
4000fca0: 05 10 00 68 sethi %hi(0x4001a000), %g2
4000fca4: b0 00 c0 18 add %g3, %i0, %i0
4000fca8: 84 10 a1 dc or %g2, 0x1dc, %g2
4000fcac: b1 2e 20 02 sll %i0, 2, %i0
4000fcb0: f8 20 80 18 st %i4, [ %g2 + %i0 ]
4000fcb4: 84 00 80 18 add %g2, %i0, %g2
4000fcb8: fa 20 a0 04 st %i5, [ %g2 + 4 ]
4000fcbc: c8 20 a0 08 st %g4, [ %g2 + 8 ]
4000fcc0: c2 07 bf fc ld [ %fp + -4 ], %g1
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
4000fcc4: 91 d0 20 0a ta 0xa
4000fcc8: 01 00 00 00 nop
}
_POSIX_signals_Release( &queue_context );
return 0;
}
4000fccc: 81 c7 e0 08 ret
4000fcd0: 91 e8 20 00 restore %g0, 0, %o0
_POSIX_signals_Vectors[ sig ] = _POSIX_signals_Default_vectors[ sig ];
4000fcd4: 07 10 00 54 sethi %hi(0x40015000), %g3
4000fcd8: b0 00 80 18 add %g2, %i0, %i0
4000fcdc: 86 10 e2 d0 or %g3, 0x2d0, %g3
4000fce0: b1 2e 20 02 sll %i0, 2, %i0
4000fce4: fa 00 c0 18 ld [ %g3 + %i0 ], %i5
4000fce8: 05 10 00 68 sethi %hi(0x4001a000), %g2
4000fcec: 86 00 c0 18 add %g3, %i0, %g3
4000fcf0: 84 10 a1 dc or %g2, 0x1dc, %g2
4000fcf4: c8 00 e0 04 ld [ %g3 + 4 ], %g4
4000fcf8: fa 20 80 18 st %i5, [ %g2 + %i0 ]
4000fcfc: b0 00 80 18 add %g2, %i0, %i0
4000fd00: c6 00 e0 08 ld [ %g3 + 8 ], %g3
4000fd04: c8 26 20 04 st %g4, [ %i0 + 4 ]
4000fd08: c6 26 20 08 st %g3, [ %i0 + 8 ]
4000fd0c: 91 d0 20 0a ta 0xa
4000fd10: 01 00 00 00 nop
}
4000fd14: 81 c7 e0 08 ret
4000fd18: 91 e8 20 00 restore %g0, 0, %o0
rtems_set_errno_and_return_minus_one( EINVAL );
4000fd1c: 40 00 0c d3 call 40013068 <__errno>
4000fd20: b0 10 3f ff mov -1, %i0
4000fd24: 82 10 20 16 mov 0x16, %g1
4000fd28: c2 22 00 00 st %g1, [ %o0 ]
4000fd2c: 81 c7 e0 08 ret
4000fd30: 81 e8 00 00 restore
40009e1c <sigtimedwait>:
int sigtimedwait(
const sigset_t *__restrict set,
siginfo_t *__restrict info,
const struct timespec *__restrict timeout
)
{
40009e1c: 9d e3 bf 58 save %sp, -168, %sp
int error;
/*
* Error check parameters before disabling interrupts.
*/
if ( !set )
40009e20: 80 a6 20 00 cmp %i0, 0
40009e24: 02 80 00 c4 be 4000a134 <sigtimedwait+0x318>
40009e28: 80 a6 a0 00 cmp %i2, 0
/* NOTE: This is very specifically a RELATIVE not ABSOLUTE time
* in the Open Group specification.
*/
if ( timeout != NULL ) {
40009e2c: 02 80 00 54 be 40009f7c <sigtimedwait+0x160>
40009e30: 03 10 00 1b sethi %hi(0x40006c00), %g1
const struct timespec *end;
_Timecounter_Nanouptime( &uptime );
40009e34: 7f ff ee 3e call 4000572c <_Timecounter_Nanouptime>
40009e38: 90 07 bf c8 add %fp, -56, %o0
&& (unsigned long) ts->tv_nsec < WATCHDOG_NANOSECONDS_PER_SECOND;
40009e3c: c2 06 a0 08 ld [ %i2 + 8 ], %g1
40009e40: 05 0e e6 b2 sethi %hi(0x3b9ac800), %g2
40009e44: 84 10 a1 ff or %g2, 0x1ff, %g2 ! 3b9ac9ff <RAM_SIZE+0x3b5ac9ff>
40009e48: 80 a0 40 02 cmp %g1, %g2
40009e4c: 28 80 00 3b bleu,a 40009f38 <sigtimedwait+0x11c>
40009e50: d8 1e 80 00 ldd [ %i2 ], %o4
return NULL;
40009e54: 82 10 20 00 clr %g1
queue_context->Timeout.arg = abstime;
40009e58: c2 27 bf e8 st %g1, [ %fp + -24 ]
queue_context->enqueue_callout =
40009e5c: 03 10 00 1f sethi %hi(0x40007c00), %g1
40009e60: 82 10 61 30 or %g1, 0x130, %g1 ! 40007d30 <_Thread_queue_Add_timeout_monotonic_timespec>
/*
* Initialize local variables.
*/
the_info = ( info ) ? info : &signal_information;
40009e64: 80 a6 60 00 cmp %i1, 0
40009e68: 02 80 00 49 be 40009f8c <sigtimedwait+0x170> <== NEVER TAKEN
40009e6c: c2 27 bf e4 st %g1, [ %fp + -28 ]
executing = _Thread_Executing;
40009e70: fa 01 a0 20 ld [ %g6 + 0x20 ], %i5
executing = _Thread_Get_executing();
api = executing->API_Extensions[ THREAD_API_POSIX ];
40009e74: f8 07 61 5c ld [ %i5 + 0x15c ], %i4
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
40009e78: 91 d0 20 09 ta 9
_ISR_lock_ISR_disable( &queue_context->Lock_context.Lock_context );
40009e7c: c2 27 bf dc st %g1, [ %fp + -36 ]
*/
/* API signals pending? */
_POSIX_signals_Acquire( &queue_context );
if ( *set & api->signals_pending ) {
40009e80: c2 06 00 00 ld [ %i0 ], %g1
40009e84: c4 07 20 6c ld [ %i4 + 0x6c ], %g2
40009e88: 80 88 40 02 btst %g1, %g2
40009e8c: 12 80 00 4b bne 40009fb8 <sigtimedwait+0x19c>
40009e90: 92 10 20 1b mov 0x1b, %o1
return the_info->si_signo;
}
/* Process pending signals? */
if ( *set & _POSIX_signals_Pending ) {
40009e94: 05 10 00 77 sethi %hi(0x4001dc00), %g2
40009e98: c4 00 a2 30 ld [ %g2 + 0x230 ], %g2 ! 4001de30 <_POSIX_signals_Pending>
40009e9c: 80 88 40 02 btst %g1, %g2
40009ea0: 12 80 00 6b bne 4000a04c <sigtimedwait+0x230>
40009ea4: 96 07 bf dc add %fp, -36, %o3
the_info->si_code = SI_USER;
the_info->si_value.sival_int = 0;
return signo;
}
the_info->si_signo = -1;
40009ea8: 84 10 3f ff mov -1, %g2
40009eac: c4 26 40 00 st %g2, [ %i1 ]
executing->Wait.option = *set;
40009eb0: c2 27 60 48 st %g1, [ %i5 + 0x48 ]
queue_context->thread_state = thread_state;
40009eb4: 03 04 00 01 sethi %hi(0x10000400), %g1
executing->Wait.return_argument = the_info;
40009eb8: f2 27 60 40 st %i1, [ %i5 + 0x40 ]
_Thread_queue_Context_set_thread_state(
&queue_context,
STATES_WAITING_FOR_SIGNAL | STATES_INTERRUPTIBLE_BY_SIGNAL
);
_Thread_queue_Enqueue(
40009ebc: 94 10 00 1d mov %i5, %o2
40009ec0: c2 27 bf e0 st %g1, [ %fp + -32 ]
40009ec4: 13 10 00 62 sethi %hi(0x40018800), %o1
40009ec8: 11 10 00 6e sethi %hi(0x4001b800), %o0
40009ecc: 92 12 60 70 or %o1, 0x70, %o1
40009ed0: 7f ff f4 14 call 40006f20 <_Thread_queue_Enqueue>
40009ed4: 90 12 20 48 or %o0, 0x48, %o0
/*
* When the thread is set free by a signal, it is need to eliminate
* the signal.
*/
_POSIX_signals_Clear_signals(
40009ed8: d2 06 40 00 ld [ %i1 ], %o1
40009edc: 90 10 00 1c mov %i4, %o0
40009ee0: 9a 10 20 01 mov 1, %o5
40009ee4: 98 10 20 00 clr %o4
40009ee8: 96 10 20 00 clr %o3
40009eec: 40 00 0a fc call 4000cadc <_POSIX_signals_Clear_signals>
40009ef0: 94 10 00 19 mov %i1, %o2
return _POSIX_Get_by_name_error_table[ error ];
}
RTEMS_INLINE_ROUTINE int _POSIX_Get_error( Status_Control status )
{
return STATUS_GET_POSIX( status );
40009ef4: c2 07 60 4c ld [ %i5 + 0x4c ], %g1
40009ef8: b9 38 60 1f sra %g1, 0x1f, %i4
40009efc: b8 0f 20 ff and %i4, 0xff, %i4
40009f00: b8 07 00 01 add %i4, %g1, %i4
40009f04: b9 3f 20 08 sra %i4, 8, %i4
* was not in our set.
*/
error = _POSIX_Get_error_after_wait( executing );
if (
40009f08: 80 a7 20 04 cmp %i4, 4
40009f0c: 12 80 00 83 bne 4000a118 <sigtimedwait+0x2fc>
40009f10: 82 10 20 01 mov 1, %g1
error != EINTR
|| ( *set & signo_to_mask( the_info->si_signo ) ) == 0
40009f14: fa 06 40 00 ld [ %i1 ], %i5
40009f18: c4 06 00 00 ld [ %i0 ], %g2
40009f1c: 86 07 7f ff add %i5, -1, %g3
40009f20: 83 28 40 03 sll %g1, %g3, %g1
40009f24: 80 88 40 02 btst %g1, %g2
40009f28: 02 80 00 7f be 4000a124 <sigtimedwait+0x308>
40009f2c: 01 00 00 00 nop
rtems_set_errno_and_return_minus_one( error );
}
return the_info->si_signo;
}
40009f30: 81 c7 e0 08 ret
40009f34: 91 e8 00 1d restore %g0, %i5, %o0
return _Watchdog_Is_valid_timespec( ts ) && ts->tv_sec >= 0;
40009f38: 80 a3 20 00 cmp %o4, 0
40009f3c: 06 bf ff c6 bl 40009e54 <sigtimedwait+0x38> <== NEVER TAKEN
40009f40: f8 1f bf c8 ldd [ %fp + -56 ], %i4
sec += (uint64_t) delta->tv_sec;
40009f44: b6 83 40 1d addcc %o5, %i5, %i3
now->tv_nsec += delta->tv_nsec;
40009f48: c6 07 bf d0 ld [ %fp + -48 ], %g3
sec += (uint64_t) delta->tv_sec;
40009f4c: b4 43 00 1c addx %o4, %i4, %i2
now->tv_nsec += delta->tv_nsec;
40009f50: 82 00 40 03 add %g1, %g3, %g1
if ( now->tv_nsec >= WATCHDOG_NANOSECONDS_PER_SECOND ) {
40009f54: 80 a0 40 02 cmp %g1, %g2
40009f58: 34 80 00 63 bg,a 4000a0e4 <sigtimedwait+0x2c8> <== NEVER TAKEN
40009f5c: 05 31 19 4d sethi %hi(0xc4653400), %g2 <== NOT EXECUTED
if ( sec <= INT64_MAX ) {
40009f60: 80 a6 a0 00 cmp %i2, 0
40009f64: 06 80 00 67 bl 4000a100 <sigtimedwait+0x2e4> <== NEVER TAKEN
40009f68: c2 27 bf d0 st %g1, [ %fp + -48 ]
now->tv_sec = sec;
40009f6c: f4 27 bf c8 st %i2, [ %fp + -56 ]
return now;
40009f70: 82 07 bf c8 add %fp, -56, %g1
40009f74: 10 bf ff b9 b 40009e58 <sigtimedwait+0x3c>
40009f78: f6 27 bf cc st %i3, [ %fp + -52 ]
queue_context->enqueue_callout = _Thread_queue_Enqueue_do_nothing_extra;
40009f7c: 82 10 63 08 or %g1, 0x308, %g1
the_info = ( info ) ? info : &signal_information;
40009f80: 80 a6 60 00 cmp %i1, 0
40009f84: 12 bf ff bb bne 40009e70 <sigtimedwait+0x54>
40009f88: c2 27 bf e4 st %g1, [ %fp + -28 ]
40009f8c: fa 01 a0 20 ld [ %g6 + 0x20 ], %i5
api = executing->API_Extensions[ THREAD_API_POSIX ];
40009f90: f8 07 61 5c ld [ %i5 + 0x15c ], %i4
the_info = ( info ) ? info : &signal_information;
40009f94: b2 07 bf bc add %fp, -68, %i1
40009f98: 91 d0 20 09 ta 9
_ISR_lock_ISR_disable( &queue_context->Lock_context.Lock_context );
40009f9c: c2 27 bf dc st %g1, [ %fp + -36 ]
if ( *set & api->signals_pending ) {
40009fa0: c2 06 00 00 ld [ %i0 ], %g1
40009fa4: c4 07 20 6c ld [ %i4 + 0x6c ], %g2
40009fa8: 80 88 40 02 btst %g1, %g2
40009fac: 22 bf ff bb be,a 40009e98 <sigtimedwait+0x7c>
40009fb0: 05 10 00 77 sethi %hi(0x4001dc00), %g2
for ( signo = SIGRTMIN ; signo <= SIGRTMAX ; signo++ ) {
40009fb4: 92 10 20 1b mov 0x1b, %o1
40009fb8: 86 10 20 01 mov 1, %g3
40009fbc: 82 02 7f ff add %o1, -1, %g1
40009fc0: 83 28 c0 01 sll %g3, %g1, %g1
if ( set & signo_to_mask( signo ) ) {
40009fc4: 80 88 40 02 btst %g1, %g2
40009fc8: 32 80 00 12 bne,a 4000a010 <sigtimedwait+0x1f4> <== NEVER TAKEN
40009fcc: d2 26 40 00 st %o1, [ %i1 ] <== NOT EXECUTED
for ( signo = SIGRTMIN ; signo <= SIGRTMAX ; signo++ ) {
40009fd0: 92 02 60 01 inc %o1
40009fd4: 80 a2 60 20 cmp %o1, 0x20
40009fd8: 12 bf ff fa bne 40009fc0 <sigtimedwait+0x1a4>
40009fdc: 82 02 7f ff add %o1, -1, %g1
for ( signo = SIGHUP ; signo <= __SIGLASTNOTRT ; signo++ ) {
40009fe0: 92 10 20 01 mov 1, %o1
40009fe4: 10 80 00 05 b 40009ff8 <sigtimedwait+0x1dc>
40009fe8: 86 10 20 01 mov 1, %g3
40009fec: 80 a2 60 1b cmp %o1, 0x1b
40009ff0: 22 80 00 08 be,a 4000a010 <sigtimedwait+0x1f4> <== NEVER TAKEN
40009ff4: d2 26 40 00 st %o1, [ %i1 ] <== NOT EXECUTED
40009ff8: 82 02 7f ff add %o1, -1, %g1
40009ffc: 83 28 c0 01 sll %g3, %g1, %g1
if ( set & signo_to_mask( signo ) ) {
4000a000: 80 88 40 02 btst %g1, %g2
4000a004: 22 bf ff fa be,a 40009fec <sigtimedwait+0x1d0>
4000a008: 92 02 60 01 inc %o1
the_info->si_signo = _POSIX_signals_Get_lowest( api->signals_pending );
4000a00c: d2 26 40 00 st %o1, [ %i1 ]
_POSIX_signals_Clear_signals(
4000a010: 9a 10 20 00 clr %o5
4000a014: 98 10 20 00 clr %o4
4000a018: 96 10 20 00 clr %o3
4000a01c: 94 10 00 19 mov %i1, %o2
4000a020: 40 00 0a af call 4000cadc <_POSIX_signals_Clear_signals>
4000a024: 90 10 00 1c mov %i4, %o0
register uint32_t _psr __asm__("g1") = psr; /* input to trap handler */
4000a028: c2 07 bf dc ld [ %fp + -36 ], %g1
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
4000a02c: 91 d0 20 0a ta 0xa
4000a030: 01 00 00 00 nop
return the_info->si_signo;
4000a034: fa 06 40 00 ld [ %i1 ], %i5
the_info->si_code = SI_USER;
4000a038: 82 10 20 01 mov 1, %g1
the_info->si_value.sival_int = 0;
4000a03c: c0 26 60 08 clr [ %i1 + 8 ]
the_info->si_code = SI_USER;
4000a040: c2 26 60 04 st %g1, [ %i1 + 4 ]
}
4000a044: 81 c7 e0 08 ret
4000a048: 91 e8 00 1d restore %g0, %i5, %o0
for ( signo = SIGRTMIN ; signo <= SIGRTMAX ; signo++ ) {
4000a04c: ba 10 20 1b mov 0x1b, %i5
4000a050: 86 10 20 01 mov 1, %g3
4000a054: 82 07 7f ff add %i5, -1, %g1
4000a058: 83 28 c0 01 sll %g3, %g1, %g1
if ( set & signo_to_mask( signo ) ) {
4000a05c: 80 88 40 02 btst %g1, %g2
4000a060: 12 80 00 12 bne 4000a0a8 <sigtimedwait+0x28c> <== NEVER TAKEN
4000a064: 9a 10 20 00 clr %o5
for ( signo = SIGRTMIN ; signo <= SIGRTMAX ; signo++ ) {
4000a068: ba 07 60 01 inc %i5
4000a06c: 80 a7 60 20 cmp %i5, 0x20
4000a070: 12 bf ff fa bne 4000a058 <sigtimedwait+0x23c>
4000a074: 82 07 7f ff add %i5, -1, %g1
for ( signo = SIGHUP ; signo <= __SIGLASTNOTRT ; signo++ ) {
4000a078: ba 10 20 01 mov 1, %i5
4000a07c: 10 80 00 05 b 4000a090 <sigtimedwait+0x274>
4000a080: 86 10 20 01 mov 1, %g3
4000a084: 80 a7 60 1b cmp %i5, 0x1b
4000a088: 02 80 00 08 be 4000a0a8 <sigtimedwait+0x28c> <== NEVER TAKEN
4000a08c: 9a 10 20 00 clr %o5
4000a090: 82 07 7f ff add %i5, -1, %g1
4000a094: 83 28 c0 01 sll %g3, %g1, %g1
if ( set & signo_to_mask( signo ) ) {
4000a098: 80 88 40 02 btst %g1, %g2
4000a09c: 22 bf ff fa be,a 4000a084 <sigtimedwait+0x268>
4000a0a0: ba 07 60 01 inc %i5
_POSIX_signals_Clear_signals( api, signo, the_info, true, false, false );
4000a0a4: 9a 10 20 00 clr %o5
4000a0a8: 98 10 20 00 clr %o4
4000a0ac: 96 10 20 01 mov 1, %o3
4000a0b0: 94 10 00 19 mov %i1, %o2
4000a0b4: 92 10 00 1d mov %i5, %o1
4000a0b8: 40 00 0a 89 call 4000cadc <_POSIX_signals_Clear_signals>
4000a0bc: 90 10 00 1c mov %i4, %o0
register uint32_t _psr __asm__("g1") = psr; /* input to trap handler */
4000a0c0: c2 07 bf dc ld [ %fp + -36 ], %g1
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
4000a0c4: 91 d0 20 0a ta 0xa
4000a0c8: 01 00 00 00 nop
the_info->si_code = SI_USER;
4000a0cc: 82 10 20 01 mov 1, %g1 ! 1 <_TLS_Alignment>
the_info->si_signo = signo;
4000a0d0: fa 26 40 00 st %i5, [ %i1 ]
the_info->si_code = SI_USER;
4000a0d4: c2 26 60 04 st %g1, [ %i1 + 4 ]
the_info->si_value.sival_int = 0;
4000a0d8: c0 26 60 08 clr [ %i1 + 8 ]
}
4000a0dc: 81 c7 e0 08 ret
4000a0e0: 91 e8 00 1d restore %g0, %i5, %o0
now->tv_nsec -= WATCHDOG_NANOSECONDS_PER_SECOND;
4000a0e4: 84 10 a2 00 or %g2, 0x200, %g2 <== NOT EXECUTED
4000a0e8: 82 00 40 02 add %g1, %g2, %g1 <== NOT EXECUTED
++sec;
4000a0ec: b6 86 e0 01 inccc %i3 <== NOT EXECUTED
4000a0f0: b4 46 a0 00 addx %i2, 0, %i2 <== NOT EXECUTED
if ( sec <= INT64_MAX ) {
4000a0f4: 80 a6 a0 00 cmp %i2, 0 <== NOT EXECUTED
4000a0f8: 16 bf ff 9d bge 40009f6c <sigtimedwait+0x150> <== NOT EXECUTED
4000a0fc: c2 27 bf d0 st %g1, [ %fp + -48 ] <== NOT EXECUTED
now->tv_sec = INT64_MAX;
4000a100: 05 1f ff ff sethi %hi(0x7ffffc00), %g2 <== NOT EXECUTED
4000a104: 86 10 3f ff mov -1, %g3 <== NOT EXECUTED
4000a108: 84 10 a3 ff or %g2, 0x3ff, %g2 <== NOT EXECUTED
return now;
4000a10c: 82 07 bf c8 add %fp, -56, %g1 <== NOT EXECUTED
now->tv_sec = INT64_MAX;
4000a110: 10 bf ff 52 b 40009e58 <sigtimedwait+0x3c> <== NOT EXECUTED
4000a114: c4 3f bf c8 std %g2, [ %fp + -56 ] <== NOT EXECUTED
if ( error == ETIMEDOUT ) {
4000a118: 80 a7 20 74 cmp %i4, 0x74
4000a11c: 22 80 00 02 be,a 4000a124 <sigtimedwait+0x308>
4000a120: b8 10 20 0b mov 0xb, %i4
rtems_set_errno_and_return_minus_one( error );
4000a124: 40 00 1b 36 call 40010dfc <__errno>
4000a128: ba 10 3f ff mov -1, %i5
4000a12c: 10 bf ff 81 b 40009f30 <sigtimedwait+0x114>
4000a130: f8 22 00 00 st %i4, [ %o0 ]
rtems_set_errno_and_return_minus_one( EINVAL );
4000a134: 40 00 1b 32 call 40010dfc <__errno>
4000a138: ba 10 3f ff mov -1, %i5
4000a13c: 82 10 20 16 mov 0x16, %g1
4000a140: 10 bf ff 7c b 40009f30 <sigtimedwait+0x114>
4000a144: c2 22 00 00 st %g1, [ %o0 ]
4000b284 <sigwait>:
int sigwait(
const sigset_t *__restrict set,
int *__restrict sig
)
{
4000b284: 9d e3 bf a0 save %sp, -96, %sp
int status;
status = sigtimedwait( set, NULL, NULL );
4000b288: 94 10 20 00 clr %o2
4000b28c: 92 10 20 00 clr %o1
4000b290: 7f ff ff 32 call 4000af58 <sigtimedwait>
4000b294: 90 10 00 18 mov %i0, %o0
if ( status != -1 ) {
4000b298: 80 a2 3f ff cmp %o0, -1
4000b29c: 02 80 00 07 be 4000b2b8 <sigwait+0x34>
4000b2a0: 80 a6 60 00 cmp %i1, 0
if ( sig )
4000b2a4: 02 80 00 03 be 4000b2b0 <sigwait+0x2c> <== NEVER TAKEN
4000b2a8: b0 10 20 00 clr %i0
*sig = status;
4000b2ac: d0 26 40 00 st %o0, [ %i1 ]
4000b2b0: 81 c7 e0 08 ret
4000b2b4: 81 e8 00 00 restore
return 0;
}
return errno;
4000b2b8: 40 00 1b 2e call 40011f70 <__errno>
4000b2bc: 01 00 00 00 nop
4000b2c0: f0 02 00 00 ld [ %o0 ], %i0
}
4000b2c4: 81 c7 e0 08 ret
4000b2c8: 81 e8 00 00 restore
40004324 <sysconf>:
*/
long sysconf(
int name
)
{
40004324: 9d e3 bf a0 save %sp, -96, %sp
switch ( name ) {
40004328: 80 a6 20 0a cmp %i0, 0xa
4000432c: 14 80 00 0c bg 4000435c <sysconf+0x38>
40004330: 82 10 00 18 mov %i0, %g1
40004334: 80 a0 60 08 cmp %g1, 8
40004338: 14 80 00 07 bg 40004354 <sysconf+0x30>
4000433c: b0 10 20 01 mov 1, %i0
40004340: 80 a0 60 04 cmp %g1, 4
40004344: 02 80 00 24 be 400043d4 <sysconf+0xb0>
40004348: 80 a0 60 08 cmp %g1, 8
4000434c: 12 80 00 11 bne 40004390 <sysconf+0x6c>
40004350: 31 00 00 04 sethi %hi(0x1000), %i0
return 0;
#endif
default:
rtems_set_errno_and_return_minus_one( EINVAL );
}
}
40004354: 81 c7 e0 08 ret
40004358: 81 e8 00 00 restore
switch ( name ) {
4000435c: 80 a6 20 8c cmp %i0, 0x8c
40004360: 22 80 00 1a be,a 400043c8 <sysconf+0xa4> <== NEVER TAKEN
40004364: 31 00 00 c3 sethi %hi(0x30c00), %i0 <== NOT EXECUTED
40004368: 04 80 00 10 ble 400043a8 <sysconf+0x84>
4000436c: 80 a0 62 03 cmp %g1, 0x203
40004370: 02 bf ff f9 be 40004354 <sysconf+0x30> <== NEVER TAKEN
40004374: b0 10 20 00 clr %i0
rtems_set_errno_and_return_minus_one( EINVAL );
40004378: 40 00 2b f5 call 4000f34c <__errno>
4000437c: b0 10 3f ff mov -1, %i0
40004380: 82 10 20 16 mov 0x16, %g1
40004384: c2 22 00 00 st %g1, [ %o0 ]
40004388: 81 c7 e0 08 ret
4000438c: 81 e8 00 00 restore
switch ( name ) {
40004390: 80 a0 60 02 cmp %g1, 2
return (long) rtems_clock_get_ticks_per_second();
40004394: 03 10 00 42 sethi %hi(0x40010800), %g1
switch ( name ) {
40004398: 12 bf ff f8 bne 40004378 <sysconf+0x54>
4000439c: f0 00 61 4c ld [ %g1 + 0x14c ], %i0 ! 4001094c <_Watchdog_Ticks_per_second>
}
400043a0: 81 c7 e0 08 ret
400043a4: 81 e8 00 00 restore
switch ( name ) {
400043a8: 80 a0 60 33 cmp %g1, 0x33
400043ac: 02 bf ff ea be 40004354 <sysconf+0x30> <== ALWAYS TAKEN
400043b0: b0 10 24 00 mov 0x400, %i0
400043b4: 80 a0 60 4f cmp %g1, 0x4f <== NOT EXECUTED
400043b8: 12 bf ff f0 bne 40004378 <sysconf+0x54> <== NOT EXECUTED
400043bc: b0 10 20 20 mov 0x20, %i0 <== NOT EXECUTED
}
400043c0: 81 c7 e0 08 ret <== NOT EXECUTED
400043c4: 81 e8 00 00 restore <== NOT EXECUTED
return (long) _POSIX_26_VERSION;
400043c8: b0 16 22 78 or %i0, 0x278, %i0 <== NOT EXECUTED
}
400043cc: 81 c7 e0 08 ret <== NOT EXECUTED
400043d0: 81 e8 00 00 restore <== NOT EXECUTED
return rtems_libio_number_iops;
400043d4: 03 10 00 42 sethi %hi(0x40010800), %g1
400043d8: f0 00 60 30 ld [ %g1 + 0x30 ], %i0 ! 40010830 <rtems_libio_number_iops>
400043dc: 81 c7 e0 08 ret
400043e0: 81 e8 00 00 restore
4000c194 <timer_create>:
{
4000c194: 9d e3 bf a0 save %sp, -96, %sp
if ( clock_id != CLOCK_REALTIME )
4000c198: 80 a6 20 01 cmp %i0, 1
4000c19c: 12 80 00 4c bne 4000c2cc <timer_create+0x138>
4000c1a0: 80 a6 a0 00 cmp %i2, 0
if ( !timerid )
4000c1a4: 02 80 00 4a be 4000c2cc <timer_create+0x138>
4000c1a8: 80 a6 60 00 cmp %i1, 0
if (evp != NULL) {
4000c1ac: 02 80 00 36 be 4000c284 <timer_create+0xf0>
4000c1b0: 3b 10 00 5b sethi %hi(0x40016c00), %i5
if ( ( evp->sigev_notify != SIGEV_NONE ) &&
4000c1b4: c2 06 40 00 ld [ %i1 ], %g1
4000c1b8: 82 00 7f ff add %g1, -1, %g1
4000c1bc: 80 a0 60 01 cmp %g1, 1
4000c1c0: 18 80 00 43 bgu 4000c2cc <timer_create+0x138> <== NEVER TAKEN
4000c1c4: 01 00 00 00 nop
if ( !evp->sigev_signo )
4000c1c8: c2 06 60 04 ld [ %i1 + 4 ], %g1
4000c1cc: 80 a0 60 00 cmp %g1, 0
4000c1d0: 02 80 00 3f be 4000c2cc <timer_create+0x138> <== NEVER TAKEN
4000c1d4: 82 00 7f ff add %g1, -1, %g1
if ( !is_valid_signo(evp->sigev_signo) )
4000c1d8: 80 a0 60 1f cmp %g1, 0x1f
4000c1dc: 18 80 00 3c bgu 4000c2cc <timer_create+0x138> <== NEVER TAKEN
4000c1e0: 01 00 00 00 nop
* This function allocates a timer control block from
* the inactive chain of free timer control blocks.
*/
RTEMS_INLINE_ROUTINE POSIX_Timer_Control *_POSIX_Timer_Allocate( void )
{
return (POSIX_Timer_Control *) _Objects_Allocate( &_POSIX_Timer_Information );
4000c1e4: 7f ff ee a5 call 40007c78 <_Objects_Allocate>
4000c1e8: 90 17 60 04 or %i5, 4, %o0
if ( !ptimer ) {
4000c1ec: 80 a2 20 00 cmp %o0, 0
4000c1f0: 02 80 00 2f be 4000c2ac <timer_create+0x118> <== NEVER TAKEN
4000c1f4: 82 10 20 02 mov 2, %g1
ptimer->state = POSIX_TIMER_STATE_CREATE_NEW;
4000c1f8: c2 2a 20 34 stb %g1, [ %o0 + 0x34 ]
ptimer->thread_id = _Thread_Get_executing()->Object.id;
4000c1fc: c2 01 a0 20 ld [ %g6 + 0x20 ], %g1
4000c200: c8 00 60 08 ld [ %g1 + 8 ], %g4
ptimer->inf.sigev_notify = evp->sigev_notify;
4000c204: c6 06 40 00 ld [ %i1 ], %g3
ptimer->inf.sigev_signo = evp->sigev_signo;
4000c208: c4 06 60 04 ld [ %i1 + 4 ], %g2
ptimer->inf.sigev_value = evp->sigev_value;
4000c20c: c2 06 60 08 ld [ %i1 + 8 ], %g1
ptimer->thread_id = _Thread_Get_executing()->Object.id;
4000c210: c8 22 20 30 st %g4, [ %o0 + 0x30 ]
ptimer->inf.sigev_notify = evp->sigev_notify;
4000c214: c6 22 20 38 st %g3, [ %o0 + 0x38 ]
ptimer->inf.sigev_signo = evp->sigev_signo;
4000c218: c4 22 20 3c st %g2, [ %o0 + 0x3c ]
ptimer->inf.sigev_value = evp->sigev_value;
4000c21c: c2 22 20 40 st %g1, [ %o0 + 0x40 ]
RB_COLOR( &the_watchdog->Node.RBTree, Node ) = state;
4000c220: 84 10 20 02 mov 2, %g2
4000c224: c4 22 20 1c st %g2, [ %o0 + 0x1c ]
the_watchdog->routine = routine;
4000c228: 05 10 00 30 sethi %hi(0x4000c000), %g2
4000c22c: 84 10 a2 e4 or %g2, 0x2e4, %g2 ! 4000c2e4 <_POSIX_Timer_TSR>
information->local_table[ index - OBJECTS_INDEX_MINIMUM ] = the_object;
4000c230: c6 02 20 08 ld [ %o0 + 8 ], %g3
4000c234: c4 22 20 20 st %g2, [ %o0 + 0x20 ]
4000c238: ba 17 60 04 or %i5, 4, %i5
4000c23c: c2 12 20 0a lduh [ %o0 + 0xa ], %g1
ptimer->overrun = 0;
4000c240: c0 22 20 74 clr [ %o0 + 0x74 ]
4000c244: 83 28 60 02 sll %g1, 2, %g1
ptimer->timer_data.it_value.tv_sec = 0;
4000c248: c0 22 20 60 clr [ %o0 + 0x60 ]
4000c24c: 82 00 7f fc add %g1, -4, %g1
4000c250: c0 22 20 64 clr [ %o0 + 0x64 ]
return 0;
4000c254: b0 10 20 00 clr %i0
ptimer->timer_data.it_value.tv_nsec = 0;
4000c258: c0 22 20 68 clr [ %o0 + 0x68 ]
ptimer->timer_data.it_interval.tv_sec = 0;
4000c25c: c0 22 20 50 clr [ %o0 + 0x50 ]
4000c260: c0 22 20 54 clr [ %o0 + 0x54 ]
ptimer->timer_data.it_interval.tv_nsec = 0;
4000c264: c0 22 20 58 clr [ %o0 + 0x58 ]
the_object->name.name_u32 = name;
4000c268: c0 22 20 0c clr [ %o0 + 0xc ]
information->local_table[ index - OBJECTS_INDEX_MINIMUM ] = the_object;
4000c26c: c4 07 60 04 ld [ %i5 + 4 ], %g2
*timerid = ptimer->Object.id;
4000c270: c6 26 80 00 st %g3, [ %i2 ]
_RTEMS_Unlock_allocator();
4000c274: 7f ff ea 8b call 40006ca0 <_RTEMS_Unlock_allocator>
4000c278: d0 20 80 01 st %o0, [ %g2 + %g1 ]
}
4000c27c: 81 c7 e0 08 ret
4000c280: 81 e8 00 00 restore
4000c284: 7f ff ee 7d call 40007c78 <_Objects_Allocate>
4000c288: 90 17 60 04 or %i5, 4, %o0
if ( !ptimer ) {
4000c28c: 80 a2 20 00 cmp %o0, 0
4000c290: 02 80 00 07 be 4000c2ac <timer_create+0x118>
4000c294: 82 10 20 02 mov 2, %g1
ptimer->state = POSIX_TIMER_STATE_CREATE_NEW;
4000c298: c2 2a 20 34 stb %g1, [ %o0 + 0x34 ]
ptimer->thread_id = _Thread_Get_executing()->Object.id;
4000c29c: c2 01 a0 20 ld [ %g6 + 0x20 ], %g1
4000c2a0: c2 00 60 08 ld [ %g1 + 8 ], %g1
4000c2a4: 10 bf ff df b 4000c220 <timer_create+0x8c>
4000c2a8: c2 22 20 30 st %g1, [ %o0 + 0x30 ]
4000c2ac: 7f ff ea 7d call 40006ca0 <_RTEMS_Unlock_allocator>
4000c2b0: b0 10 3f ff mov -1, %i0
rtems_set_errno_and_return_minus_one( EAGAIN );
4000c2b4: 40 00 18 81 call 400124b8 <__errno>
4000c2b8: 01 00 00 00 nop
4000c2bc: 82 10 20 0b mov 0xb, %g1 ! b <_TLS_Alignment+0xa>
4000c2c0: c2 22 00 00 st %g1, [ %o0 ]
4000c2c4: 81 c7 e0 08 ret
4000c2c8: 81 e8 00 00 restore
rtems_set_errno_and_return_minus_one( EINVAL );
4000c2cc: 40 00 18 7b call 400124b8 <__errno>
4000c2d0: b0 10 3f ff mov -1, %i0
4000c2d4: 82 10 20 16 mov 0x16, %g1
4000c2d8: c2 22 00 00 st %g1, [ %o0 ]
4000c2dc: 81 c7 e0 08 ret
4000c2e0: 81 e8 00 00 restore
4000a528 <timer_gettime>:
int timer_gettime(
timer_t timerid,
struct itimerspec *value
)
{
4000a528: 9d e3 bf 98 save %sp, -104, %sp
POSIX_Timer_Control *ptimer;
ISR_lock_Context lock_context;
uint64_t now;
uint32_t remaining;
if ( !value )
4000a52c: 80 a6 60 00 cmp %i1, 0
4000a530: 02 80 00 29 be 4000a5d4 <timer_gettime+0xac>
4000a534: 92 07 bf fc add %fp, -4, %o1
4000a538: 15 10 00 8e sethi %hi(0x40023800), %o2
4000a53c: 90 10 00 18 mov %i0, %o0
4000a540: 40 00 06 9b call 4000bfac <_Objects_Get>
4000a544: 94 12 a1 08 or %o2, 0x108, %o2
rtems_set_errno_and_return_minus_one( EINVAL );
ptimer = _POSIX_Timer_Get( timerid, &lock_context );
if ( ptimer != NULL ) {
4000a548: ba 92 20 00 orcc %o0, 0, %i5
4000a54c: 02 80 00 1c be 4000a5bc <timer_gettime+0x94>
4000a550: 03 10 00 9a sethi %hi(0x40026800), %g1
Per_CPU_Control *cpu;
cpu = _POSIX_Timer_Acquire_critical( ptimer, &lock_context );
now = cpu->Watchdog.ticks;
if ( now < ptimer->Timer.expire ) {
4000a554: c6 07 60 28 ld [ %i5 + 0x28 ], %g3
now = cpu->Watchdog.ticks;
4000a558: 82 10 62 00 or %g1, 0x200, %g1
4000a55c: c4 00 60 30 ld [ %g1 + 0x30 ], %g2
if ( now < ptimer->Timer.expire ) {
4000a560: d0 07 60 2c ld [ %i5 + 0x2c ], %o0
4000a564: 80 a0 c0 02 cmp %g3, %g2
4000a568: 08 80 00 0e bleu 4000a5a0 <timer_gettime+0x78> <== ALWAYS TAKEN
4000a56c: c2 00 60 34 ld [ %g1 + 0x34 ], %g1
remaining = (uint32_t) ( ptimer->Timer.expire - now );
4000a570: 90 22 00 01 sub %o0, %g1, %o0 <== NOT EXECUTED
} else {
remaining = 0;
}
_Timespec_From_ticks( remaining, &value->it_value );
4000a574: 40 00 0a 15 call 4000cdc8 <_Timespec_From_ticks>
4000a578: 92 06 60 10 add %i1, 0x10, %o1
value->it_interval = ptimer->timer_data.it_interval;
4000a57c: c4 1f 60 50 ldd [ %i5 + 0x50 ], %g2
4000a580: c4 3e 40 00 std %g2, [ %i1 ]
4000a584: c4 1f 60 58 ldd [ %i5 + 0x58 ], %g2
4000a588: c4 3e 60 08 std %g2, [ %i1 + 8 ]
register uint32_t _psr __asm__("g1") = psr; /* input to trap handler */
4000a58c: c2 07 bf fc ld [ %fp + -4 ], %g1
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
4000a590: 91 d0 20 0a ta 0xa
4000a594: 01 00 00 00 nop
_POSIX_Timer_Release( cpu, &lock_context );
return 0;
4000a598: 81 c7 e0 08 ret
4000a59c: 91 e8 20 00 restore %g0, 0, %o0
if ( now < ptimer->Timer.expire ) {
4000a5a0: 32 bf ff f5 bne,a 4000a574 <timer_gettime+0x4c> <== NEVER TAKEN
4000a5a4: 90 10 20 00 clr %o0 <== NOT EXECUTED
4000a5a8: 80 a2 00 01 cmp %o0, %g1
4000a5ac: 38 bf ff f2 bgu,a 4000a574 <timer_gettime+0x4c> <== ALWAYS TAKEN
4000a5b0: 90 22 00 01 sub %o0, %g1, %o0
remaining = 0;
4000a5b4: 10 bf ff f0 b 4000a574 <timer_gettime+0x4c> <== NOT EXECUTED
4000a5b8: 90 10 20 00 clr %o0 <== NOT EXECUTED
}
rtems_set_errno_and_return_minus_one( EINVAL );
4000a5bc: 40 00 1e 0e call 40011df4 <__errno>
4000a5c0: b0 10 3f ff mov -1, %i0
4000a5c4: 82 10 20 16 mov 0x16, %g1
4000a5c8: c2 22 00 00 st %g1, [ %o0 ]
}
4000a5cc: 81 c7 e0 08 ret
4000a5d0: 81 e8 00 00 restore
rtems_set_errno_and_return_minus_one( EINVAL );
4000a5d4: 40 00 1e 08 call 40011df4 <__errno>
4000a5d8: b0 10 3f ff mov -1, %i0
4000a5dc: 82 10 20 16 mov 0x16, %g1
4000a5e0: c2 22 00 00 st %g1, [ %o0 ]
4000a5e4: 81 c7 e0 08 ret
4000a5e8: 81 e8 00 00 restore
400065fc <timer_settime>:
timer_t timerid,
int flags,
const struct itimerspec *__restrict value,
struct itimerspec *__restrict ovalue
)
{
400065fc: 9d e3 bf 68 save %sp, -152, %sp
POSIX_Timer_Control *ptimer;
ISR_lock_Context lock_context;
uint32_t initial_period;
struct itimerspec normalize;
if ( !value )
40006600: 80 a6 a0 00 cmp %i2, 0
40006604: 02 80 00 80 be 40006804 <timer_settime+0x208> <== NEVER TAKEN
40006608: 01 00 00 00 nop
/*
* First, it verifies if the structure "value" is correct
* if the number of nanoseconds is not correct return EINVAL
*/
if ( !_Timespec_Is_valid( &(value->it_value) ) ) {
4000660c: 40 00 0f 43 call 4000a318 <_Timespec_Is_valid>
40006610: 90 06 a0 10 add %i2, 0x10, %o0
40006614: 80 a2 20 00 cmp %o0, 0
40006618: 02 80 00 7b be 40006804 <timer_settime+0x208>
4000661c: 01 00 00 00 nop
rtems_set_errno_and_return_minus_one( EINVAL );
}
if ( !_Timespec_Is_valid( &(value->it_interval) ) ) {
40006620: 40 00 0f 3e call 4000a318 <_Timespec_Is_valid>
40006624: 90 10 00 1a mov %i2, %o0
40006628: 80 a2 20 00 cmp %o0, 0
4000662c: 02 80 00 76 be 40006804 <timer_settime+0x208> <== NEVER TAKEN
40006630: 01 00 00 00 nop
rtems_set_errno_and_return_minus_one( EINVAL );
}
if ( flags != TIMER_ABSTIME && flags != POSIX_TIMER_RELATIVE ) {
40006634: a0 8e 7f fb andcc %i1, -5, %l0
40006638: 12 80 00 73 bne 40006804 <timer_settime+0x208>
4000663c: 80 a6 60 04 cmp %i1, 4
rtems_set_errno_and_return_minus_one( EINVAL );
}
normalize = *value;
40006640: d4 1e 80 00 ldd [ %i2 ], %o2
40006644: d8 1e a0 08 ldd [ %i2 + 8 ], %o4
40006648: f8 1e a0 10 ldd [ %i2 + 0x10 ], %i4
4000664c: c4 1e a0 18 ldd [ %i2 + 0x18 ], %g2
40006650: d4 3f bf e0 std %o2, [ %fp + -32 ]
40006654: d8 3f bf e8 std %o4, [ %fp + -24 ]
40006658: f8 3f bf f0 std %i4, [ %fp + -16 ]
/* Convert absolute to relative time */
if (flags == TIMER_ABSTIME) {
4000665c: 02 80 00 5d be 400067d0 <timer_settime+0x1d4>
40006660: c4 3f bf f8 std %g2, [ %fp + -8 ]
40006664: 92 07 bf d0 add %fp, -48, %o1
40006668: 15 10 00 65 sethi %hi(0x40019400), %o2
4000666c: 90 10 00 18 mov %i0, %o0
40006670: 40 00 06 52 call 40007fb8 <_Objects_Get>
40006674: 94 12 a1 44 or %o2, 0x144, %o2
* something with the structure of times of the timer: to stop, start
* or start it again
*/
ptimer = _POSIX_Timer_Get( timerid, &lock_context );
if ( ptimer != NULL ) {
40006678: ba 92 20 00 orcc %o0, 0, %i5
4000667c: 02 80 00 67 be 40006818 <timer_settime+0x21c>
40006680: 92 07 60 10 add %i5, 0x10, %o1
Per_CPU_Control *cpu;
cpu = _POSIX_Timer_Acquire_critical( ptimer, &lock_context );
/* Stop the timer */
_Watchdog_Remove(
40006684: 11 10 00 6c sethi %hi(0x4001b000), %o0
40006688: d2 27 bf cc st %o1, [ %fp + -52 ]
4000668c: 40 00 0f b1 call 4000a550 <_Watchdog_Remove>
40006690: 90 12 21 b8 or %o0, 0x1b8, %o0
&cpu->Watchdog.Header[ PER_CPU_WATCHDOG_TICKS ],
&ptimer->Timer
);
/* First, it verifies if the timer must be stopped */
if ( normalize.it_value.tv_sec == 0 && normalize.it_value.tv_nsec == 0 ) {
40006694: c4 07 bf f0 ld [ %fp + -16 ], %g2
40006698: c2 07 bf f4 ld [ %fp + -12 ], %g1
4000669c: 80 90 80 01 orcc %g2, %g1, %g0
400066a0: 12 80 00 20 bne 40006720 <timer_settime+0x124>
400066a4: d2 07 bf cc ld [ %fp + -52 ], %o1
400066a8: c2 07 bf f8 ld [ %fp + -8 ], %g1
400066ac: 80 a0 60 00 cmp %g1, 0
400066b0: 32 80 00 1d bne,a 40006724 <timer_settime+0x128>
400066b4: d2 27 bf cc st %o1, [ %fp + -52 ]
/* The old data of the timer are returned */
if ( ovalue )
400066b8: 80 a6 e0 00 cmp %i3, 0
400066bc: 02 80 00 0a be 400066e4 <timer_settime+0xe8>
400066c0: 82 10 20 04 mov 4, %g1
*ovalue = ptimer->timer_data;
400066c4: c4 1f 60 50 ldd [ %i5 + 0x50 ], %g2
400066c8: c4 3e c0 00 std %g2, [ %i3 ]
400066cc: c4 1f 60 58 ldd [ %i5 + 0x58 ], %g2
400066d0: c4 3e e0 08 std %g2, [ %i3 + 8 ]
400066d4: c4 1f 60 60 ldd [ %i5 + 0x60 ], %g2
400066d8: c4 3e e0 10 std %g2, [ %i3 + 0x10 ]
400066dc: c4 1f 60 68 ldd [ %i5 + 0x68 ], %g2
400066e0: c4 3e e0 18 std %g2, [ %i3 + 0x18 ]
/* The new data are set */
ptimer->timer_data = normalize;
400066e4: c4 1f bf e0 ldd [ %fp + -32 ], %g2
400066e8: c4 3f 60 50 std %g2, [ %i5 + 0x50 ]
400066ec: c4 1f bf e8 ldd [ %fp + -24 ], %g2
400066f0: c4 3f 60 58 std %g2, [ %i5 + 0x58 ]
400066f4: c4 1f bf f0 ldd [ %fp + -16 ], %g2
400066f8: c4 3f 60 60 std %g2, [ %i5 + 0x60 ]
400066fc: c4 1f bf f8 ldd [ %fp + -8 ], %g2
40006700: c4 3f 60 68 std %g2, [ %i5 + 0x68 ]
/* Indicates that the timer is created and stopped */
ptimer->state = POSIX_TIMER_STATE_CREATE_STOP;
40006704: c2 2f 60 34 stb %g1, [ %i5 + 0x34 ]
register uint32_t _psr __asm__("g1") = psr; /* input to trap handler */
40006708: c2 07 bf d0 ld [ %fp + -48 ], %g1
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
4000670c: 91 d0 20 0a ta 0xa
40006710: 01 00 00 00 nop
/* Returns with success */
_POSIX_Timer_Release( cpu, &lock_context );
return 0;
40006714: a0 10 20 00 clr %l0 ! 0 <PROM_START>
_POSIX_Timer_Release( cpu, &lock_context );
return 0;
}
rtems_set_errno_and_return_minus_one( EINVAL );
}
40006718: 81 c7 e0 08 ret
4000671c: 91 e8 00 10 restore %g0, %l0, %o0
ptimer->ticks = _Timespec_To_ticks( &value->it_interval );
40006720: d2 27 bf cc st %o1, [ %fp + -52 ]
40006724: 40 00 0f 42 call 4000a42c <_Timespec_To_ticks>
40006728: 90 10 00 1a mov %i2, %o0
4000672c: d0 27 60 70 st %o0, [ %i5 + 0x70 ]
initial_period = _Timespec_To_ticks( &normalize.it_value );
40006730: 40 00 0f 3f call 4000a42c <_Timespec_To_ticks>
40006734: 90 07 bf f0 add %fp, -16, %o0
ptimer->state = POSIX_TIMER_STATE_CREATE_RUN;
40006738: 82 10 20 03 mov 3, %g1
4000673c: c2 2f 60 34 stb %g1, [ %i5 + 0x34 ]
initial_period = _Timespec_To_ticks( &normalize.it_value );
40006740: b8 10 00 08 mov %o0, %i4
40006744: 7f ff f8 2f call 40004800 <_Timecounter_Nanotime>
40006748: 90 07 60 78 add %i5, 0x78, %o0
cpu->Watchdog.ticks + ticks
4000674c: 03 10 00 6c sethi %hi(0x4001b000), %g1
40006750: 82 10 61 80 or %g1, 0x180, %g1 ! 4001b180 <_Per_CPU_Information>
_Watchdog_Insert(
40006754: d4 18 60 30 ldd [ %g1 + 0x30 ], %o2
40006758: 84 10 00 0a mov %o2, %g2
4000675c: d2 07 bf cc ld [ %fp + -52 ], %o1
40006760: 96 82 c0 1c addcc %o3, %i4, %o3
40006764: 90 00 60 38 add %g1, 0x38, %o0
40006768: 7f ff fc bb call 40005a54 <_Watchdog_Insert>
4000676c: 94 40 a0 00 addx %g2, 0, %o2
if ( ovalue )
40006770: 80 a6 e0 00 cmp %i3, 0
40006774: 02 80 00 0b be 400067a0 <timer_settime+0x1a4>
40006778: c4 1f bf e0 ldd [ %fp + -32 ], %g2
*ovalue = ptimer->timer_data;
4000677c: c4 1f 60 50 ldd [ %i5 + 0x50 ], %g2
40006780: c4 3e c0 00 std %g2, [ %i3 ]
40006784: c4 1f 60 58 ldd [ %i5 + 0x58 ], %g2
40006788: c4 3e e0 08 std %g2, [ %i3 + 8 ]
4000678c: c4 1f 60 60 ldd [ %i5 + 0x60 ], %g2
40006790: c4 3e e0 10 std %g2, [ %i3 + 0x10 ]
40006794: c4 1f 60 68 ldd [ %i5 + 0x68 ], %g2
40006798: c4 3e e0 18 std %g2, [ %i3 + 0x18 ]
ptimer->timer_data = normalize;
4000679c: c4 1f bf e0 ldd [ %fp + -32 ], %g2
400067a0: c4 3f 60 50 std %g2, [ %i5 + 0x50 ]
400067a4: c4 1f bf e8 ldd [ %fp + -24 ], %g2
400067a8: c4 3f 60 58 std %g2, [ %i5 + 0x58 ]
400067ac: c4 1f bf f0 ldd [ %fp + -16 ], %g2
400067b0: c4 3f 60 60 std %g2, [ %i5 + 0x60 ]
400067b4: c4 1f bf f8 ldd [ %fp + -8 ], %g2
400067b8: c4 3f 60 68 std %g2, [ %i5 + 0x68 ]
register uint32_t _psr __asm__("g1") = psr; /* input to trap handler */
400067bc: c2 07 bf d0 ld [ %fp + -48 ], %g1
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
400067c0: 91 d0 20 0a ta 0xa
400067c4: 01 00 00 00 nop
}
400067c8: 81 c7 e0 08 ret
400067cc: 91 e8 00 10 restore %g0, %l0, %o0
400067d0: 7f ff f8 0c call 40004800 <_Timecounter_Nanotime>
400067d4: 90 07 bf d0 add %fp, -48, %o0
if ( _Timespec_Greater_than( &now, &normalize.it_value ) )
400067d8: 92 07 bf d0 add %fp, -48, %o1
400067dc: 40 00 0e df call 4000a358 <_Timespec_Less_than>
400067e0: 90 07 bf f0 add %fp, -16, %o0
400067e4: 80 a2 20 00 cmp %o0, 0
400067e8: 12 80 00 07 bne 40006804 <timer_settime+0x208>
400067ec: 94 07 bf f0 add %fp, -16, %o2
_Timespec_Subtract( &now, &normalize.it_value, &normalize.it_value );
400067f0: 90 07 bf d0 add %fp, -48, %o0
400067f4: 40 00 0e f7 call 4000a3d0 <_Timespec_Subtract>
400067f8: 92 10 00 0a mov %o2, %o1
400067fc: 10 bf ff 9b b 40006668 <timer_settime+0x6c>
40006800: 92 07 bf d0 add %fp, -48, %o1
rtems_set_errno_and_return_minus_one( EINVAL );
40006804: 40 00 38 8f call 40014a40 <__errno>
40006808: a0 10 3f ff mov -1, %l0
4000680c: 82 10 20 16 mov 0x16, %g1
40006810: 10 bf ff ee b 400067c8 <timer_settime+0x1cc>
40006814: c2 22 00 00 st %g1, [ %o0 ]
rtems_set_errno_and_return_minus_one( EINVAL );
40006818: 40 00 38 8a call 40014a40 <__errno>
4000681c: a0 10 3f ff mov -1, %l0
40006820: 82 10 20 16 mov 0x16, %g1
40006824: 10 bf ff e9 b 400067c8 <timer_settime+0x1cc>
40006828: c2 22 00 00 st %g1, [ %o0 ]
40006afc <ualarm>:
useconds_t ualarm(
useconds_t useconds,
useconds_t interval
)
{
40006afc: 9d e3 bf 98 save %sp, -104, %sp
uint32_t us_per_tick = rtems_configuration_get_microseconds_per_tick();
40006b00: 35 10 00 58 sethi %hi(0x40016000), %i2
40006b04: f8 06 a2 08 ld [ %i2 + 0x208 ], %i4 ! 40016208 <_Watchdog_Microseconds_per_tick>
return ( us + us_per_tick - 1 ) / us_per_tick;
40006b08: a4 07 3f ff add %i4, -1, %l2
40006b0c: b0 06 00 12 add %i0, %l2, %i0
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
40006b10: 91 d0 20 09 ta 9
&lock_context
);
cpu = _Watchdog_Get_CPU( the_watchdog );
_Watchdog_Per_CPU_acquire_critical( cpu, &lock_context2 );
now = cpu->Watchdog.ticks;
40006b14: 05 10 00 6e sethi %hi(0x4001b800), %g2
expire = the_watchdog->expire;
40006b18: 37 10 00 65 sethi %hi(0x40019400), %i3
40006b1c: e0 18 a3 f0 ldd [ %g2 + 0x3f0 ], %l0
40006b20: 84 16 e0 30 or %i3, 0x30, %g2
40006b24: c6 00 a0 18 ld [ %g2 + 0x18 ], %g3
if ( now < expire ) {
40006b28: 80 a0 c0 10 cmp %g3, %l0
40006b2c: 18 80 00 15 bgu 40006b80 <ualarm+0x84> <== NEVER TAKEN
40006b30: fa 00 a0 1c ld [ %g2 + 0x1c ], %i5
40006b34: 02 80 00 11 be 40006b78 <ualarm+0x7c> <== ALWAYS TAKEN
40006b38: 80 a7 40 11 cmp %i5, %l1
40006b3c: c2 27 bf fc st %g1, [ %fp + -4 ] <== NOT EXECUTED
_Watchdog_Remove( header, the_watchdog );
40006b40: 92 16 e0 30 or %i3, 0x30, %o1
40006b44: 11 10 00 6e sethi %hi(0x4001b800), %o0
40006b48: 40 00 12 40 call 4000b448 <_Watchdog_Remove>
40006b4c: 90 12 23 f8 or %o0, 0x3f8, %o0 ! 4001bbf8 <_Per_CPU_Information+0x38>
&cpu->Watchdog.Header[ PER_CPU_WATCHDOG_TICKS ],
the_watchdog,
now
);
if ( ticks_initial != 0 ) {
40006b50: c2 07 bf fc ld [ %fp + -4 ], %g1
40006b54: 80 a7 00 18 cmp %i4, %i0
40006b58: 08 80 00 13 bleu 40006ba4 <ualarm+0xa8>
40006b5c: ba 10 20 00 clr %i5
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
40006b60: 91 d0 20 0a ta 0xa
40006b64: 01 00 00 00 nop
_ISR_lock_Release_and_ISR_enable(
&_POSIX_signals_Ualarm_lock,
&lock_context
);
remaining *= rtems_configuration_get_microseconds_per_tick();
40006b68: f0 06 a2 08 ld [ %i2 + 0x208 ], %i0
return remaining;
}
40006b6c: b0 5f 40 18 smul %i5, %i0, %i0
40006b70: 81 c7 e0 08 ret
40006b74: 81 e8 00 00 restore
if ( now < expire ) {
40006b78: 28 bf ff f2 bleu,a 40006b40 <ualarm+0x44>
40006b7c: c2 27 bf fc st %g1, [ %fp + -4 ]
remaining = expire - now;
40006b80: c2 27 bf fc st %g1, [ %fp + -4 ]
_Watchdog_Remove( header, the_watchdog );
40006b84: 92 16 e0 30 or %i3, 0x30, %o1
40006b88: 11 10 00 6e sethi %hi(0x4001b800), %o0
40006b8c: 40 00 12 2f call 4000b448 <_Watchdog_Remove>
40006b90: 90 12 23 f8 or %o0, 0x3f8, %o0 ! 4001bbf8 <_Per_CPU_Information+0x38>
if ( ticks_initial != 0 ) {
40006b94: c2 07 bf fc ld [ %fp + -4 ], %g1
40006b98: 80 a7 00 18 cmp %i4, %i0
40006b9c: 18 bf ff f1 bgu 40006b60 <ualarm+0x64> <== ALWAYS TAKEN
40006ba0: ba 27 40 11 sub %i5, %l1, %i5
_POSIX_signals_Ualarm_interval = ticks_interval;
40006ba4: 05 10 00 6f sethi %hi(0x4001bc00), %g2
return ( us + us_per_tick - 1 ) / us_per_tick;
40006ba8: 81 80 20 00 wr %g0, %y
40006bac: 01 00 00 00 nop
40006bb0: 01 00 00 00 nop
40006bb4: 01 00 00 00 nop
40006bb8: b0 76 00 1c udiv %i0, %i4, %i0
40006bbc: b2 06 40 12 add %i1, %l2, %i1
_Watchdog_Insert(
40006bc0: 96 84 40 18 addcc %l1, %i0, %o3
return ( us + us_per_tick - 1 ) / us_per_tick;
40006bc4: 81 80 20 00 wr %g0, %y
40006bc8: 01 00 00 00 nop
40006bcc: 01 00 00 00 nop
40006bd0: 01 00 00 00 nop
40006bd4: b8 76 40 1c udiv %i1, %i4, %i4
_Watchdog_Insert(
40006bd8: 94 44 20 00 addx %l0, 0, %o2
_POSIX_signals_Ualarm_interval = ticks_interval;
40006bdc: f8 20 a0 20 st %i4, [ %g2 + 0x20 ]
_Watchdog_Insert(
40006be0: 92 16 e0 30 or %i3, 0x30, %o1
40006be4: 7f ff fc ef call 40005fa0 <_Watchdog_Insert>
40006be8: 90 01 a0 38 add %g6, 0x38, %o0
40006bec: c2 07 bf fc ld [ %fp + -4 ], %g1
40006bf0: 91 d0 20 0a ta 0xa
40006bf4: 01 00 00 00 nop
remaining *= rtems_configuration_get_microseconds_per_tick();
40006bf8: f0 06 a2 08 ld [ %i2 + 0x208 ], %i0
}
40006bfc: b0 5f 40 18 smul %i5, %i0, %i0
40006c00: 81 c7 e0 08 ret
40006c04: 81 e8 00 00 restore
40001274 <wait.part.0>:
static void wait(void)
40001274: 9d e3 bf a0 save %sp, -96, %sp
rtems_test_assert(sc == RTEMS_SUCCESSFUL);
40001278: 94 10 20 5c mov 0x5c, %o2
4000127c: 17 10 00 60 sethi %hi(0x40018000), %o3
40001280: 13 10 00 60 sethi %hi(0x40018000), %o1
40001284: 96 12 e0 20 or %o3, 0x20, %o3
40001288: 92 12 60 38 or %o1, 0x38, %o1
4000128c: 11 10 00 60 sethi %hi(0x40018000), %o0
40001290: 40 00 03 81 call 40002094 <__wrap_printf>
40001294: 90 12 20 68 or %o0, 0x68, %o0 ! 40018068 <_rodata_start+0x48>
40001298: 40 00 03 79 call 4000207c <rtems_test_exit>
4000129c: 90 10 20 00 clr %o0
400012a0: 01 00 00 00 nop <== NOT EXECUTED