=============================================================================== 400072e0 <_POSIX_Mutex_Auto_initialization>: #include #include bool _POSIX_Mutex_Auto_initialization( POSIX_Mutex_Control *the_mutex ) { 400072e0: 9d e3 bf a0 save %sp, -96, %sp <== NOT EXECUTED zero |= (unsigned long) the_mutex->Priority_ceiling.Node.RBTree.Node.rbe_right; zero |= (unsigned long) the_mutex->Priority_ceiling.Node.RBTree.Node.rbe_parent; zero |= (unsigned long) the_mutex->Priority_ceiling.Node.RBTree.Node.rbe_color; zero |= (unsigned long) the_mutex->Priority_ceiling.priority; zero |= (unsigned long) (the_mutex->Priority_ceiling.priority >> 32); zero |= (unsigned long) the_mutex->scheduler; 400072e4: f2 06 20 04 ld [ %i0 + 4 ], %i1 <== NOT EXECUTED zero |= (unsigned long) the_mutex->Priority_ceiling.priority; 400072e8: de 06 20 30 ld [ %i0 + 0x30 ], %o7 <== NOT EXECUTED 400072ec: da 06 20 34 ld [ %i0 + 0x34 ], %o5 <== NOT EXECUTED zero |= (unsigned long) the_mutex->scheduler; 400072f0: c4 06 00 00 ld [ %i0 ], %g2 <== NOT EXECUTED 400072f4: d4 06 20 08 ld [ %i0 + 8 ], %o2 <== NOT EXECUTED 400072f8: d6 06 20 18 ld [ %i0 + 0x18 ], %o3 <== NOT EXECUTED 400072fc: f4 06 20 0c ld [ %i0 + 0xc ], %i2 <== NOT EXECUTED 40007300: f6 06 20 10 ld [ %i0 + 0x10 ], %i3 <== NOT EXECUTED 40007304: f8 06 20 14 ld [ %i0 + 0x14 ], %i4 <== NOT EXECUTED 40007308: fa 06 20 20 ld [ %i0 + 0x20 ], %i5 <== NOT EXECUTED 4000730c: c8 06 20 24 ld [ %i0 + 0x24 ], %g4 <== NOT EXECUTED 40007310: c2 06 20 28 ld [ %i0 + 0x28 ], %g1 <== NOT EXECUTED 40007314: d8 06 20 2c ld [ %i0 + 0x2c ], %o4 <== NOT EXECUTED 40007318: c6 06 20 38 ld [ %i0 + 0x38 ], %g3 <== NOT EXECUTED 4000731c: 84 10 80 19 or %g2, %i1, %g2 <== NOT EXECUTED 40007320: 84 10 80 0a or %g2, %o2, %g2 <== NOT EXECUTED 40007324: 84 10 80 0b or %g2, %o3, %g2 <== NOT EXECUTED 40007328: 84 16 80 02 or %i2, %g2, %g2 <== NOT EXECUTED 4000732c: 84 16 c0 02 or %i3, %g2, %g2 <== NOT EXECUTED 40007330: 84 17 00 02 or %i4, %g2, %g2 <== NOT EXECUTED 40007334: 84 17 40 02 or %i5, %g2, %g2 <== NOT EXECUTED 40007338: 84 11 00 02 or %g4, %g2, %g2 <== NOT EXECUTED 4000733c: 82 10 40 02 or %g1, %g2, %g1 <== NOT EXECUTED 40007340: 82 10 40 0c or %g1, %o4, %g1 <== NOT EXECUTED 40007344: 82 10 40 0d or %g1, %o5, %g1 <== NOT EXECUTED 40007348: 82 10 c0 01 or %g3, %g1, %g1 <== NOT EXECUTED if ( zero != 0 ) { 4000734c: 80 90 40 0f orcc %g1, %o7, %g0 <== NOT EXECUTED 40007350: 12 80 00 08 bne 40007370 <_POSIX_Mutex_Auto_initialization+0x90> <== NOT EXECUTED 40007354: b2 10 20 00 clr %i1 <== NOT EXECUTED return false; } flags = (uintptr_t) the_mutex ^ POSIX_MUTEX_MAGIC; 40007358: 03 25 87 04 sethi %hi(0x961c1000), %g1 <== NOT EXECUTED 4000735c: 82 10 63 b8 or %g1, 0x3b8, %g1 ! 961c13b8 <== NOT EXECUTED 40007360: 82 1e 00 01 xor %i0, %g1, %g1 <== NOT EXECUTED flags &= ~POSIX_MUTEX_FLAGS_MASK; 40007364: 82 08 7f f8 and %g1, -8, %g1 <== NOT EXECUTED the_mutex->flags = flags; 40007368: c2 26 00 00 st %g1, [ %i0 ] <== NOT EXECUTED return true; 4000736c: b2 10 20 01 mov 1, %i1 <== NOT EXECUTED } 40007370: b0 0e 60 01 and %i1, 1, %i0 <== NOT EXECUTED 40007374: 81 c7 e0 08 ret <== NOT EXECUTED 40007378: 81 e8 00 00 restore <== NOT EXECUTED =============================================================================== 40013470 <_POSIX_Mutex_Default_attributes>: 40013470: 00 00 00 01 00 00 00 00 7f ff ff ff 00 00 00 00 ................ 40013480: 00 00 00 03 00 00 00 00 ........ =============================================================================== 400070a8 <_POSIX_Mutex_Lock_support>: int _POSIX_Mutex_Lock_support( pthread_mutex_t *mutex, const struct timespec *abstime, Thread_queue_Enqueue_callout enqueue_callout ) { 400070a8: 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 ); 400070ac: 80 a6 20 00 cmp %i0, 0 400070b0: 02 80 00 3f be 400071ac <_POSIX_Mutex_Lock_support+0x104> <== NEVER TAKEN 400070b4: 05 25 87 04 sethi %hi(0x961c1000), %g2 400070b8: fa 06 00 00 ld [ %i0 ], %i5 400070bc: 82 1e 00 1d xor %i0, %i5, %g1 400070c0: 84 10 a3 b8 or %g2, 0x3b8, %g2 400070c4: 82 18 40 02 xor %g1, %g2, %g1 400070c8: 80 88 7f f8 btst -8, %g1 400070cc: 12 80 00 33 bne 40007198 <_POSIX_Mutex_Lock_support+0xf0> <== NEVER TAKEN 400070d0: 01 00 00 00 nop <== NOT EXECUTED __asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS)); 400070d4: 91 d0 20 09 ta 9 <== NOT EXECUTED ) { #if defined( RTEMS_SMP ) context->Lock_context.isr_level = level; #else context->isr_level = level; 400070d8: 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 ) ) { 400070dc: 82 8f 60 03 andcc %i5, 3, %g1 queue_context->enqueue_callout = enqueue_callout; 400070e0: f4 27 bf e4 st %i2, [ %fp + -28 ] queue_context->Timeout.arg = arg; 400070e4: f2 27 bf e8 st %i1, [ %fp + -24 ] 400070e8: 02 80 00 34 be 400071b8 <_POSIX_Mutex_Lock_support+0x110> <== NEVER TAKEN 400070ec: d0 01 a0 20 ld [ %g6 + 0x20 ], %o0 400070f0: 80 a0 60 02 cmp %g1, 2 400070f4: 12 80 00 10 bne 40007134 <_POSIX_Mutex_Lock_support+0x8c> 400070f8: c2 06 20 10 ld [ %i0 + 0x10 ], %g1 { Thread_Control *owner; owner = _POSIX_Mutex_Get_owner( the_mutex ); if ( owner == NULL ) { 400070fc: 80 a0 60 00 cmp %g1, 0 40007100: 02 80 00 43 be 4000720c <_POSIX_Mutex_Lock_support+0x164> <== ALWAYS TAKEN 40007104: 80 a2 00 01 cmp %o0, %g1 executing, queue_context ); } if ( owner == executing ) { 40007108: 02 80 00 18 be 40007168 <_POSIX_Mutex_Lock_support+0xc0> <== NOT EXECUTED 4000710c: 94 10 00 08 mov %o0, %o2 <== NOT EXECUTED status = _POSIX_Mutex_Lock_nested( the_mutex, flags ); _POSIX_Mutex_Release( the_mutex, queue_context ); return status; } return _POSIX_Mutex_Seize_slow( 40007110: 98 07 bf dc add %fp, -36, %o4 <== NOT EXECUTED 40007114: 96 10 00 19 mov %i1, %o3 <== NOT EXECUTED 40007118: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED 4000711c: 13 10 00 4d sethi %hi(0x40013400), %o1 <== NOT EXECUTED 40007120: 7f ff ff ca call 40007048 <_POSIX_Mutex_Seize_slow> <== NOT EXECUTED 40007124: 92 12 61 00 or %o1, 0x100, %o1 ! 40013500 <_Thread_queue_Operations_priority> <== NOT EXECUTED 40007128: 93 3a 60 08 sra %o1, 8, %o1 <== NOT EXECUTED ); break; } return _POSIX_Get_error( status ); } 4000712c: 81 c7 e0 08 ret <== NOT EXECUTED 40007130: 91 e8 00 09 restore %g0, %o1, %o0 <== NOT EXECUTED if ( owner == NULL ) { 40007134: 80 a0 60 00 cmp %g1, 0 40007138: 02 80 00 2e be 400071f0 <_POSIX_Mutex_Lock_support+0x148> <== ALWAYS TAKEN 4000713c: 80 a2 00 01 cmp %o0, %g1 if ( owner == executing ) { 40007140: 02 80 00 0a be 40007168 <_POSIX_Mutex_Lock_support+0xc0> <== NOT EXECUTED 40007144: 94 10 00 08 mov %o0, %o2 <== NOT EXECUTED return _POSIX_Mutex_Seize_slow( 40007148: 98 07 bf dc add %fp, -36, %o4 <== NOT EXECUTED 4000714c: 96 10 00 19 mov %i1, %o3 <== NOT EXECUTED 40007150: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED 40007154: 13 10 00 4d sethi %hi(0x40013400), %o1 <== NOT EXECUTED 40007158: 7f ff ff bc call 40007048 <_POSIX_Mutex_Seize_slow> <== NOT EXECUTED 4000715c: 92 12 60 ec or %o1, 0xec, %o1 ! 400134ec <_Thread_queue_Operations_priority_inherit> <== NOT EXECUTED return _POSIX_Get_error( status ); 40007160: 10 80 00 0c b 40007190 <_POSIX_Mutex_Lock_support+0xe8> <== NOT EXECUTED 40007164: 93 3a 60 08 sra %o1, 8, %o1 <== NOT EXECUTED if ( _POSIX_Mutex_Is_recursive( flags ) ) { 40007168: 80 8f 60 04 btst 4, %i5 <== NOT EXECUTED 4000716c: 02 80 00 06 be 40007184 <_POSIX_Mutex_Lock_support+0xdc> <== NOT EXECUTED 40007170: 92 10 20 2d mov 0x2d, %o1 <== NOT EXECUTED ++the_mutex->Recursive.nest_level; 40007174: c2 06 20 18 ld [ %i0 + 0x18 ], %g1 <== NOT EXECUTED 40007178: 82 00 60 01 inc %g1 <== NOT EXECUTED 4000717c: c2 26 20 18 st %g1, [ %i0 + 0x18 ] <== NOT EXECUTED 40007180: 92 10 20 00 clr %o1 <== NOT EXECUTED register uint32_t _psr __asm__("g1") = psr; /* input to trap handler */ 40007184: c2 07 bf dc ld [ %fp + -36 ], %g1 <== NOT EXECUTED __asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr)); 40007188: 91 d0 20 0a ta 0xa <== NOT EXECUTED 4000718c: 01 00 00 00 nop <== NOT EXECUTED } 40007190: 81 c7 e0 08 ret 40007194: 91 e8 00 09 restore %g0, %o1, %o0 POSIX_MUTEX_VALIDATE_OBJECT( the_mutex, flags ); 40007198: 40 00 00 52 call 400072e0 <_POSIX_Mutex_Auto_initialization> <== NOT EXECUTED 4000719c: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED 400071a0: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED 400071a4: 12 bf ff cc bne 400070d4 <_POSIX_Mutex_Lock_support+0x2c> <== NOT EXECUTED 400071a8: 01 00 00 00 nop <== NOT EXECUTED 400071ac: 92 10 20 16 mov 0x16, %o1 ! 16 <_TLS_Alignment+0x15> <== NOT EXECUTED } 400071b0: 81 c7 e0 08 ret <== NOT EXECUTED 400071b4: 91 e8 00 09 restore %g0, %o1, %o0 <== NOT EXECUTED 400071b8: c2 06 20 10 ld [ %i0 + 0x10 ], %g1 <== NOT EXECUTED if ( owner == NULL ) { 400071bc: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 400071c0: 02 80 00 0c be 400071f0 <_POSIX_Mutex_Lock_support+0x148> <== NOT EXECUTED 400071c4: 80 a2 00 01 cmp %o0, %g1 <== NOT EXECUTED if ( owner == executing ) { 400071c8: 02 bf ff e8 be 40007168 <_POSIX_Mutex_Lock_support+0xc0> <== NOT EXECUTED 400071cc: 94 10 00 08 mov %o0, %o2 <== NOT EXECUTED return _POSIX_Mutex_Seize_slow( 400071d0: 98 07 bf dc add %fp, -36, %o4 <== NOT EXECUTED 400071d4: 96 10 00 19 mov %i1, %o3 <== NOT EXECUTED 400071d8: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED 400071dc: 13 10 00 4d sethi %hi(0x40013400), %o1 <== NOT EXECUTED 400071e0: 7f ff ff 9a call 40007048 <_POSIX_Mutex_Seize_slow> <== NOT EXECUTED 400071e4: 92 12 61 14 or %o1, 0x114, %o1 ! 40013514 <_Thread_queue_Operations_FIFO> <== NOT EXECUTED 400071e8: 10 bf ff ea b 40007190 <_POSIX_Mutex_Lock_support+0xe8> <== NOT EXECUTED 400071ec: 93 3a 60 08 sra %o1, 8, %o1 <== NOT EXECUTED the_mutex->Recursive.Mutex.Queue.Queue.owner = owner; 400071f0: d0 26 20 10 st %o0, [ %i0 + 0x10 ] <== NOT EXECUTED register uint32_t _psr __asm__("g1") = psr; /* input to trap handler */ 400071f4: c2 07 bf dc ld [ %fp + -36 ], %g1 <== NOT EXECUTED __asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr)); 400071f8: 91 d0 20 0a ta 0xa <== NOT EXECUTED 400071fc: 01 00 00 00 nop 40007200: 92 10 20 00 clr %o1 ! 0 40007204: 81 c7 e0 08 ret 40007208: 91 e8 00 09 restore %g0, %o1, %o0 if ( 4000720c: c2 02 20 38 ld [ %o0 + 0x38 ], %g1 queue_context->Priority.update_count = 0; 40007210: c0 27 bf f0 clr [ %fp + -16 ] 40007214: c6 06 20 30 ld [ %i0 + 0x30 ], %g3 40007218: c4 00 60 18 ld [ %g1 + 0x18 ], %g2 4000721c: 80 a0 c0 02 cmp %g3, %g2 40007220: 18 80 00 09 bgu 40007244 <_POSIX_Mutex_Lock_support+0x19c> <== NEVER TAKEN 40007224: 01 00 00 00 nop 40007228: 32 80 00 0c bne,a 40007258 <_POSIX_Mutex_Lock_support+0x1b0> <== NEVER TAKEN 4000722c: d0 26 20 10 st %o0, [ %i0 + 0x10 ] <== NOT EXECUTED 40007230: c4 06 20 34 ld [ %i0 + 0x34 ], %g2 40007234: c2 00 60 1c ld [ %g1 + 0x1c ], %g1 40007238: 80 a0 80 01 cmp %g2, %g1 4000723c: 28 80 00 07 bleu,a 40007258 <_POSIX_Mutex_Lock_support+0x1b0> <== ALWAYS TAKEN 40007240: d0 26 20 10 st %o0, [ %i0 + 0x10 ] register uint32_t _psr __asm__("g1") = psr; /* input to trap handler */ 40007244: c2 07 bf dc ld [ %fp + -36 ], %g1 <== NOT EXECUTED __asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr)); 40007248: 91 d0 20 0a ta 0xa <== NOT EXECUTED 4000724c: 01 00 00 00 nop <== NOT EXECUTED 40007250: 10 bf ff d8 b 400071b0 <_POSIX_Mutex_Lock_support+0x108> <== NOT EXECUTED 40007254: 92 10 20 16 mov 0x16, %o1 ! 16 <_TLS_Alignment+0x15> <== NOT EXECUTED _Thread_Priority_add( 40007258: 92 06 20 20 add %i0, 0x20, %o1 4000725c: 40 00 14 e1 call 4000c5e0 <_Thread_Priority_add> 40007260: 94 07 bf dc add %fp, -36, %o2 const ISR_lock_Context *lock_context ) { uint32_t disable_level; disable_level = cpu_self->thread_dispatch_disable_level; 40007264: c2 01 a0 18 ld [ %g6 + 0x18 ], %g1 <== NOT EXECUTED _Profiling_Thread_dispatch_disable_critical( cpu_self, disable_level, lock_context ); cpu_self->thread_dispatch_disable_level = disable_level + 1; 40007268: 82 00 60 01 inc %g1 <== NOT EXECUTED */ 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 ); 4000726c: ba 10 00 06 mov %g6, %i5 <== NOT EXECUTED cpu_self->thread_dispatch_disable_level = disable_level + 1; 40007270: c2 21 a0 18 st %g1, [ %g6 + 0x18 ] <== NOT EXECUTED register uint32_t _psr __asm__("g1") = psr; /* input to trap handler */ 40007274: c2 07 bf dc ld [ %fp + -36 ], %g1 <== NOT EXECUTED __asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr)); 40007278: 91 d0 20 0a ta 0xa <== NOT EXECUTED 4000727c: 01 00 00 00 nop _Thread_Priority_update( queue_context ); 40007280: 40 00 14 e9 call 4000c624 <_Thread_Priority_update> 40007284: 90 07 bf dc add %fp, -36, %o0 * * @param[in] cpu_self The current processor. */ RTEMS_INLINE_ROUTINE void _Thread_Dispatch_enable( Per_CPU_Control *cpu_self ) { uint32_t disable_level = cpu_self->thread_dispatch_disable_level; 40007288: c2 07 60 18 ld [ %i5 + 0x18 ], %g1 if ( disable_level == 1 ) { 4000728c: 80 a0 60 01 cmp %g1, 1 40007290: 02 80 00 05 be 400072a4 <_POSIX_Mutex_Lock_support+0x1fc> <== ALWAYS TAKEN 40007294: 82 00 7f ff add %g1, -1, %g1 } _ISR_Local_enable( level ); } else { _Assert( disable_level > 0 ); cpu_self->thread_dispatch_disable_level = disable_level - 1; 40007298: 92 10 20 00 clr %o1 <== NOT EXECUTED 4000729c: c2 27 60 18 st %g1, [ %i5 + 0x18 ] <== NOT EXECUTED 400072a0: 30 bf ff bc b,a 40007190 <_POSIX_Mutex_Lock_support+0xe8> <== NOT EXECUTED __asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS)); 400072a4: 91 d0 20 09 ta 9 <== NOT EXECUTED if ( 400072a8: c4 0f 60 1c ldub [ %i5 + 0x1c ], %g2 400072ac: 80 a0 a0 00 cmp %g2, 0 400072b0: 32 80 00 07 bne,a 400072cc <_POSIX_Mutex_Lock_support+0x224> <== NEVER TAKEN 400072b4: 92 10 00 01 mov %g1, %o1 <== NOT EXECUTED cpu_self->thread_dispatch_disable_level = 0; 400072b8: c0 27 60 18 clr [ %i5 + 0x18 ] <== NOT EXECUTED __asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr)); 400072bc: 91 d0 20 0a ta 0xa <== NOT EXECUTED 400072c0: 01 00 00 00 nop 400072c4: 10 bf ff b3 b 40007190 <_POSIX_Mutex_Lock_support+0xe8> 400072c8: 92 10 20 00 clr %o1 ! 0 _Thread_Do_dispatch( cpu_self, level ); 400072cc: c2 27 bf d4 st %g1, [ %fp + -44 ] <== NOT EXECUTED 400072d0: 40 00 15 5c call 4000c840 <_Thread_Do_dispatch> <== NOT EXECUTED 400072d4: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED 400072d8: 10 bf ff f9 b 400072bc <_POSIX_Mutex_Lock_support+0x214> <== NOT EXECUTED 400072dc: c2 07 bf d4 ld [ %fp + -44 ], %g1 <== NOT EXECUTED =============================================================================== 40007048 <_POSIX_Mutex_Seize_slow>: const Thread_queue_Operations *operations, Thread_Control *executing, const struct timespec *abstime, Thread_queue_Context *queue_context ) { 40007048: 9d e3 bf a0 save %sp, -96, %sp <== NOT EXECUTED if ( (uintptr_t) abstime != POSIX_MUTEX_ABSTIME_TRY_LOCK ) { 4000704c: 80 a6 e0 01 cmp %i3, 1 <== NOT EXECUTED 40007050: 02 80 00 0f be 4000708c <_POSIX_Mutex_Seize_slow+0x44> <== NOT EXECUTED 40007054: 82 10 20 01 mov 1, %g1 <== NOT EXECUTED queue_context->thread_state = thread_state; 40007058: c2 27 20 04 st %g1, [ %i4 + 4 ] <== NOT EXECUTED queue_context->deadlock_callout = deadlock_callout; 4000705c: 03 10 00 33 sethi %hi(0x4000cc00), %g1 <== NOT EXECUTED 40007060: 82 10 63 70 or %g1, 0x370, %g1 ! 4000cf70 <_Thread_queue_Deadlock_status> <== NOT EXECUTED 40007064: c2 27 20 20 st %g1, [ %i4 + 0x20 ] <== NOT EXECUTED ); _Thread_queue_Context_set_deadlock_callout( queue_context, _Thread_queue_Deadlock_status ); _Thread_queue_Enqueue( 40007068: 92 10 00 19 mov %i1, %o1 <== NOT EXECUTED 4000706c: 90 06 20 0c add %i0, 0xc, %o0 <== NOT EXECUTED 40007070: 96 10 00 1c mov %i4, %o3 <== NOT EXECUTED 40007074: 94 10 00 1a mov %i2, %o2 <== NOT EXECUTED 40007078: 40 00 17 c6 call 4000cf90 <_Thread_queue_Enqueue> <== NOT EXECUTED 4000707c: b0 10 20 00 clr %i0 <== NOT EXECUTED RTEMS_INLINE_ROUTINE Status_Control _Thread_Wait_get_status( const Thread_Control *the_thread ) { return (Status_Control) the_thread->Wait.return_code; 40007080: f2 06 a0 4c ld [ %i2 + 0x4c ], %i1 <== NOT EXECUTED return _Thread_Wait_get_status( executing ); } else { _POSIX_Mutex_Release( the_mutex, queue_context ); return STATUS_UNAVAILABLE; } } 40007084: 81 c7 e0 08 ret <== NOT EXECUTED 40007088: 81 e8 00 00 restore <== NOT EXECUTED register uint32_t _psr __asm__("g1") = psr; /* input to trap handler */ 4000708c: c2 07 00 00 ld [ %i4 ], %g1 <== NOT EXECUTED __asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr)); 40007090: 91 d0 20 0a ta 0xa <== NOT EXECUTED 40007094: 01 00 00 00 nop <== NOT EXECUTED 40007098: 33 00 00 04 sethi %hi(0x1000), %i1 <== NOT EXECUTED 4000709c: b2 16 60 0d or %i1, 0xd, %i1 ! 100d <_Configuration_Interrupt_stack_size+0xd> <== NOT EXECUTED 400070a0: 81 c7 e0 08 ret <== NOT EXECUTED 400070a4: 91 e8 20 00 restore %g0, 0, %o0 <== NOT EXECUTED =============================================================================== 400075fc <_POSIX_Priority_To_core>: Priority_Control _POSIX_Priority_To_core( const Scheduler_Control *scheduler, int posix_priority, bool *valid ) { 400075fc: 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; 40007600: f8 1e 20 40 ldd [ %i0 + 0x40 ], %i4 core_posix_priority = (Priority_Control) posix_priority; 40007604: 83 3e 60 1f sra %i1, 0x1f, %g1 40007608: 86 10 00 19 mov %i1, %g3 4000760c: 84 10 00 01 mov %g1, %g2 *valid = ( posix_priority >= POSIX_SCHEDULER_MINIMUM_PRIORITY && core_posix_priority < scheduler->maximum_priority ); 40007610: 80 a7 00 01 cmp %i4, %g1 40007614: 18 80 00 05 bgu 40007628 <_POSIX_Priority_To_core+0x2c> <== NEVER TAKEN 40007618: 88 10 20 01 mov 1, %g4 4000761c: 02 80 00 11 be 40007660 <_POSIX_Priority_To_core+0x64> <== ALWAYS TAKEN 40007620: 80 a7 40 19 cmp %i5, %i1 40007624: 88 10 20 00 clr %g4 <== NOT EXECUTED 40007628: 82 20 40 19 sub %g1, %i1, %g1 <== NOT EXECUTED 4000762c: 83 30 60 1f srl %g1, 0x1f, %g1 40007630: 82 08 40 04 and %g1, %g4, %g1 *valid = ( posix_priority >= POSIX_SCHEDULER_MINIMUM_PRIORITY 40007634: c2 2e 80 00 stb %g1, [ %i2 ] core_priority = scheduler->maximum_priority - core_posix_priority; 40007638: b6 a7 40 03 subcc %i5, %g3, %i3 RTEMS_INLINE_ROUTINE Priority_Control _Scheduler_Map_priority( const Scheduler_Control *scheduler, Priority_Control priority ) { return ( *scheduler->Operations.map_priority )( scheduler, priority ); 4000763c: c2 06 20 1c ld [ %i0 + 0x1c ], %g1 40007640: b4 67 00 02 subx %i4, %g2, %i2 40007644: 94 10 00 1b mov %i3, %o2 40007648: 92 10 00 1a mov %i2, %o1 4000764c: 9f c0 40 00 call %g1 40007650: 90 10 00 18 mov %i0, %o0 return _Scheduler_Map_priority( scheduler, core_priority ); } 40007654: b0 10 00 08 mov %o0, %i0 40007658: 81 c7 e0 08 ret 4000765c: 93 e8 00 09 restore %g0, %o1, %o1 && core_posix_priority < scheduler->maximum_priority ); 40007660: 38 bf ff f3 bgu,a 4000762c <_POSIX_Priority_To_core+0x30> <== ALWAYS TAKEN 40007664: 82 20 40 19 sub %g1, %i1, %g1 40007668: 10 bf ff f0 b 40007628 <_POSIX_Priority_To_core+0x2c> <== NOT EXECUTED 4000766c: 88 10 20 00 clr %g4 <== NOT EXECUTED =============================================================================== 40005fac : ISR_Level level; _ISR_Local_disable( level ); #endif executing = _Thread_Executing; 40005fac: c6 01 a0 20 ld [ %g6 + 0x20 ], %g3 <== NOT EXECUTED __asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS)); 40005fb0: 91 d0 20 09 ta 9 <== NOT EXECUTED */ RTEMS_INLINE_ROUTINE RBTree_Node * const *_RBTree_Root_const_reference( const RBTree_Control *the_rbtree ) { return &RB_ROOT( the_rbtree ); 40005fb4: 86 00 e1 60 add %g3, 0x160, %g3 RBTree_Node *parent; link = _RBTree_Root_const_reference( the_rbtree ); parent = NULL; while ( *link != NULL ) { 40005fb8: c4 00 c0 00 ld [ %g3 ], %g2 40005fbc: 80 a0 a0 00 cmp %g2, 0 40005fc0: 02 80 00 0d be 40005ff4 <== ALWAYS TAKEN 40005fc4: 86 00 bf f8 add %g2, -8, %g3 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; 40005fc8: c8 00 e0 18 ld [ %g3 + 0x18 ], %g4 <== NOT EXECUTED parent = *link; if ( ( *equal )( key, parent ) ) { 40005fcc: 80 a2 00 04 cmp %o0, %g4 <== NOT EXECUTED 40005fd0: 22 80 00 0e be,a 40006008 <== NOT EXECUTED 40005fd4: d0 00 e0 20 ld [ %g3 + 0x20 ], %o0 <== NOT EXECUTED return ( *map )( parent ); } else if ( ( *less )( key, parent ) ) { 40005fd8: 1a bf ff f8 bcc 40005fb8 <== NOT EXECUTED 40005fdc: 86 00 a0 04 add %g2, 4, %g3 <== NOT EXECUTED return &RB_LEFT( the_node, Node ); 40005fe0: 86 10 00 02 mov %g2, %g3 <== NOT EXECUTED while ( *link != NULL ) { 40005fe4: c4 00 c0 00 ld [ %g3 ], %g2 <== NOT EXECUTED 40005fe8: 80 a0 a0 00 cmp %g2, 0 <== NOT EXECUTED 40005fec: 12 bf ff f7 bne 40005fc8 <== NOT EXECUTED 40005ff0: 86 00 bf f8 add %g2, -8, %g3 <== NOT EXECUTED key_value_pair = _POSIX_Keys_Key_value_find( key, executing ); if ( key_value_pair != NULL ) { value = key_value_pair->value; } else { value = NULL; 40005ff4: 90 10 20 00 clr %o0 <== NOT EXECUTED __asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr)); 40005ff8: 91 d0 20 0a ta 0xa <== NOT EXECUTED 40005ffc: 01 00 00 00 nop } _POSIX_Keys_Key_value_release( executing, &lock_context ); return value; } 40006000: 81 c3 e0 08 retl 40006004: 01 00 00 00 nop 40006008: 91 d0 20 0a ta 0xa <== NOT EXECUTED 4000600c: 01 00 00 00 nop <== NOT EXECUTED 40006010: 81 c3 e0 08 retl <== NOT EXECUTED 40006014: 01 00 00 00 nop <== NOT EXECUTED =============================================================================== 40005f3c : */ int pthread_key_create( pthread_key_t *key, void (*destructor)( void * ) ) { 40005f3c: 9d e3 bf a0 save %sp, -96, %sp * the inactive chain of free keys control blocks. */ RTEMS_INLINE_ROUTINE POSIX_Keys_Control *_POSIX_Keys_Allocate( void ) { return (POSIX_Keys_Control *) _Objects_Allocate( &_POSIX_Keys_Information ); 40005f40: 3b 10 00 4e sethi %hi(0x40013800), %i5 40005f44: 40 00 0a da call 40008aac <_Objects_Allocate> 40005f48: 90 17 60 d8 or %i5, 0xd8, %o0 ! 400138d8 <_POSIX_Keys_Information> POSIX_Keys_Control *the_key; the_key = _POSIX_Keys_Allocate(); if ( !the_key ) { 40005f4c: 80 a2 20 00 cmp %o0, 0 40005f50: 02 80 00 13 be 40005f9c <== NEVER TAKEN 40005f54: 86 02 20 14 add %o0, 0x14, %g3 #if defined(RTEMS_DEBUG) if ( index > information->maximum ) return; #endif information->local_table[ index ] = the_object; 40005f58: c2 12 20 0a lduh [ %o0 + 0xa ], %g1 tail->previous = head; 40005f5c: c6 22 20 1c st %g3, [ %o0 + 0x1c ] return &the_chain->Tail.Node; 40005f60: 84 02 20 18 add %o0, 0x18, %g2 _Objects_Allocator_unlock(); return EAGAIN; } the_key->destructor = destructor; 40005f64: f2 22 20 10 st %i1, [ %o0 + 0x10 ] 40005f68: ba 17 60 d8 or %i5, 0xd8, %i5 head->next = tail; 40005f6c: c4 22 20 14 st %g2, [ %o0 + 0x14 ] 40005f70: 83 28 60 02 sll %g1, 2, %g1 head->previous = NULL; 40005f74: c0 22 20 18 clr [ %o0 + 0x18 ] Objects_Control *the_object, uint32_t name ) { /* ASSERT: information->is_string == false */ the_object->name.name_u32 = name; 40005f78: c0 22 20 0c clr [ %o0 + 0xc ] information->local_table[ index ] = the_object; 40005f7c: c6 07 60 1c ld [ %i5 + 0x1c ], %g3 40005f80: c4 02 20 08 ld [ %o0 + 8 ], %g2 40005f84: d0 20 c0 01 st %o0, [ %g3 + %g1 ] _Chain_Initialize_empty( &the_key->Key_value_pairs ); _Objects_Open_u32( &_POSIX_Keys_Information, &the_key->Object, 0 ); *key = the_key->Object.id; 40005f88: c4 26 00 00 st %g2, [ %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(); 40005f8c: 40 00 04 68 call 4000712c <_RTEMS_Unlock_allocator> 40005f90: b0 10 20 00 clr %i0 _Objects_Allocator_unlock(); return 0; } 40005f94: 81 c7 e0 08 ret 40005f98: 81 e8 00 00 restore 40005f9c: 40 00 04 64 call 4000712c <_RTEMS_Unlock_allocator> <== NOT EXECUTED 40005fa0: b0 10 20 0b mov 0xb, %i0 <== NOT EXECUTED return EAGAIN; 40005fa4: 81 c7 e0 08 ret <== NOT EXECUTED 40005fa8: 81 e8 00 00 restore <== NOT EXECUTED =============================================================================== 40006e58 : */ int pthread_mutex_destroy( pthread_mutex_t *mutex ) { 40006e58: 9d e3 bf a0 save %sp, -96, %sp unsigned long flags; Thread_queue_Context queue_context; int eno; the_mutex = _POSIX_Mutex_Get( mutex ); POSIX_MUTEX_VALIDATE_OBJECT( the_mutex, flags ); 40006e5c: 80 a6 20 00 cmp %i0, 0 40006e60: 02 80 00 18 be 40006ec0 <== NEVER TAKEN 40006e64: 05 25 87 04 sethi %hi(0x961c1000), %g2 40006e68: c2 06 00 00 ld [ %i0 ], %g1 40006e6c: 82 1e 00 01 xor %i0, %g1, %g1 40006e70: 84 10 a3 b8 or %g2, 0x3b8, %g2 40006e74: 82 18 40 02 xor %g1, %g2, %g1 40006e78: 80 88 7f f8 btst -8, %g1 40006e7c: 12 80 00 0c bne 40006eac <== NEVER TAKEN 40006e80: 01 00 00 00 nop <== NOT EXECUTED __asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS)); 40006e84: 91 d0 20 09 ta 9 <== NOT EXECUTED _POSIX_Mutex_Acquire( the_mutex, &queue_context ); if ( _POSIX_Mutex_Get_owner( the_mutex ) == NULL ) { 40006e88: c4 06 20 10 ld [ %i0 + 0x10 ], %g2 40006e8c: 80 a0 a0 00 cmp %g2, 0 40006e90: 22 80 00 0e be,a 40006ec8 <== ALWAYS TAKEN 40006e94: c4 06 00 00 ld [ %i0 ], %g2 the_mutex->flags = ~the_mutex->flags; eno = 0; } else { eno = EBUSY; 40006e98: b0 10 20 10 mov 0x10, %i0 <== NOT EXECUTED __asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr)); 40006e9c: 91 d0 20 0a ta 0xa <== NOT EXECUTED 40006ea0: 01 00 00 00 nop <== NOT EXECUTED } _POSIX_Mutex_Release( the_mutex, &queue_context ); return eno; } 40006ea4: 81 c7 e0 08 ret <== NOT EXECUTED 40006ea8: 81 e8 00 00 restore <== NOT EXECUTED POSIX_MUTEX_VALIDATE_OBJECT( the_mutex, flags ); 40006eac: 40 00 01 0d call 400072e0 <_POSIX_Mutex_Auto_initialization> <== NOT EXECUTED 40006eb0: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED 40006eb4: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED 40006eb8: 12 bf ff f3 bne 40006e84 <== NOT EXECUTED 40006ebc: 01 00 00 00 nop <== NOT EXECUTED 40006ec0: 81 c7 e0 08 ret <== NOT EXECUTED 40006ec4: 91 e8 20 16 restore %g0, 0x16, %o0 <== NOT EXECUTED the_mutex->flags = ~the_mutex->flags; 40006ec8: 84 38 00 02 xnor %g0, %g2, %g2 <== NOT EXECUTED 40006ecc: c4 26 00 00 st %g2, [ %i0 ] <== NOT EXECUTED eno = 0; 40006ed0: b0 10 20 00 clr %i0 <== NOT EXECUTED 40006ed4: 91 d0 20 0a ta 0xa <== NOT EXECUTED 40006ed8: 01 00 00 00 nop } 40006edc: 81 c7 e0 08 ret 40006ee0: 81 e8 00 00 restore =============================================================================== 40006ee4 : int pthread_mutex_init( pthread_mutex_t *mutex, const pthread_mutexattr_t *attr ) { 40006ee4: 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; 40006ee8: 80 a6 60 00 cmp %i1, 0 40006eec: 02 80 00 0f be 40006f28 <== NEVER TAKEN 40006ef0: ba 10 00 18 mov %i0, %i5 else the_attr = &_POSIX_Mutex_Default_attributes; /* Check for NULL mutex */ if ( !mutex ) 40006ef4: 80 a6 20 00 cmp %i0, 0 40006ef8: 02 80 00 44 be 40007008 <== NEVER TAKEN 40006efc: 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 ) 40006f00: c2 06 40 00 ld [ %i1 ], %g1 40006f04: 80 a0 60 00 cmp %g1, 0 40006f08: 02 80 00 06 be 40006f20 <== NEVER TAKEN 40006f0c: b0 10 20 16 mov 0x16, %i0 return EINVAL; if ( !_POSIX_Is_valid_pshared( the_attr->process_shared ) ) { 40006f10: c2 06 60 04 ld [ %i1 + 4 ], %g1 40006f14: 80 a0 60 01 cmp %g1, 1 40006f18: 28 80 00 16 bleu,a 40006f70 <== ALWAYS TAKEN 40006f1c: c2 06 60 0c ld [ %i1 + 0xc ], %g1 ); the_mutex->Recursive.nest_level = 0; _Priority_Node_initialize( &the_mutex->Priority_ceiling, priority ); the_mutex->scheduler = scheduler; return 0; } 40006f20: 81 c7 e0 08 ret <== NOT EXECUTED 40006f24: 81 e8 00 00 restore <== NOT EXECUTED if ( !mutex ) 40006f28: 80 a6 20 00 cmp %i0, 0 <== NOT EXECUTED 40006f2c: 02 80 00 37 be 40007008 <== NOT EXECUTED 40006f30: 03 25 87 04 sethi %hi(0x961c1000), %g1 <== NOT EXECUTED flags = (uintptr_t) the_mutex ^ POSIX_MUTEX_MAGIC; 40006f34: 82 10 63 b8 or %g1, 0x3b8, %g1 ! 961c13b8 <== NOT EXECUTED 40006f38: 82 1e 00 01 xor %i0, %g1, %g1 <== NOT EXECUTED flags &= ~POSIX_MUTEX_FLAGS_MASK; 40006f3c: 82 08 7f f8 and %g1, -8, %g1 <== NOT EXECUTED the_mutex->flags = flags; 40006f40: c2 26 00 00 st %g1, [ %i0 ] <== NOT EXECUTED scheduler = NULL; 40006f44: 84 10 20 00 clr %g2 <== NOT EXECUTED priority = 0; 40006f48: 90 10 20 00 clr %o0 <== NOT EXECUTED 40006f4c: 92 10 20 00 clr %o1 <== NOT EXECUTED ) { #if defined(RTEMS_SMP) _SMP_ticket_lock_Initialize( &queue->Lock ); #endif queue->heads = NULL; 40006f50: c0 27 60 0c clr [ %i5 + 0xc ] queue->owner = NULL; 40006f54: c0 27 60 10 clr [ %i5 + 0x10 ] queue->name = name; 40006f58: c0 27 60 14 clr [ %i5 + 0x14 ] the_mutex->Recursive.nest_level = 0; 40006f5c: c0 27 60 18 clr [ %i5 + 0x18 ] RTEMS_INLINE_ROUTINE void _Priority_Node_initialize( Priority_Node *node, Priority_Control priority ) { node->priority = priority; 40006f60: d0 3f 60 30 std %o0, [ %i5 + 0x30 ] the_mutex->scheduler = scheduler; 40006f64: c4 27 60 38 st %g2, [ %i5 + 0x38 ] return 0; 40006f68: 81 c7 e0 08 ret 40006f6c: 91 e8 20 00 restore %g0, 0, %o0 switch ( the_attr->protocol ) { 40006f70: 80 a0 60 01 cmp %g1, 1 40006f74: 02 80 00 27 be 40007010 40006f78: 80 a0 60 02 cmp %g1, 2 40006f7c: 02 80 00 27 be 40007018 <== ALWAYS TAKEN 40006f80: 80 a0 60 00 cmp %g1, 0 40006f84: 12 bf ff e7 bne 40006f20 <== NOT EXECUTED 40006f88: 84 10 20 00 clr %g2 <== NOT EXECUTED switch ( the_attr->type ) { 40006f8c: c2 06 60 10 ld [ %i1 + 0x10 ], %g1 40006f90: 80 a0 60 03 cmp %g1, 3 40006f94: 18 bf ff e3 bgu 40006f20 <== NEVER TAKEN 40006f98: b0 10 20 16 mov 0x16, %i0 if ( the_attr->type == PTHREAD_MUTEX_RECURSIVE ) { 40006f9c: 80 a0 60 01 cmp %g1, 1 flags = (uintptr_t) the_mutex ^ POSIX_MUTEX_MAGIC; 40006fa0: 03 25 87 04 sethi %hi(0x961c1000), %g1 40006fa4: 82 10 63 b8 or %g1, 0x3b8, %g1 ! 961c13b8 40006fa8: 82 1f 40 01 xor %i5, %g1, %g1 flags &= ~POSIX_MUTEX_FLAGS_MASK; 40006fac: 82 08 7f f8 and %g1, -8, %g1 if ( the_attr->type == PTHREAD_MUTEX_RECURSIVE ) { 40006fb0: 12 80 00 03 bne 40006fbc <== ALWAYS TAKEN 40006fb4: 82 10 80 01 or %g2, %g1, %g1 flags |= POSIX_MUTEX_RECURSIVE; 40006fb8: 82 10 60 04 or %g1, 4, %g1 <== NOT EXECUTED if ( protocol == POSIX_MUTEX_PRIORITY_CEILING ) { 40006fbc: 80 a0 a0 02 cmp %g2, 2 40006fc0: 12 80 00 18 bne 40007020 40006fc4: c2 27 40 00 st %g1, [ %i5 ] prio_ceiling = the_attr->prio_ceiling; 40006fc8: d2 06 60 08 ld [ %i1 + 8 ], %o1 if ( prio_ceiling == INT_MAX ) { 40006fcc: 03 1f ff ff sethi %hi(0x7ffffc00), %g1 40006fd0: 82 10 63 ff or %g1, 0x3ff, %g1 ! 7fffffff 40006fd4: 80 a2 40 01 cmp %o1, %g1 40006fd8: 12 80 00 05 bne 40006fec <== ALWAYS TAKEN 40006fdc: 39 10 00 4b sethi %hi(0x40012c00), %i4 RTEMS_INLINE_ROUTINE int _POSIX_Priority_Get_maximum( const Scheduler_Control *scheduler ) { _Assert( (int) scheduler->maximum_priority > 1 ); return (int) scheduler->maximum_priority - 1; 40006fe0: 82 17 22 98 or %i4, 0x298, %g1 ! 40012e98 <_Scheduler_Table> <== NOT EXECUTED 40006fe4: d2 00 60 44 ld [ %g1 + 0x44 ], %o1 <== NOT EXECUTED 40006fe8: 92 02 7f ff add %o1, -1, %o1 <== NOT EXECUTED priority = _POSIX_Priority_To_core( scheduler, prio_ceiling, &valid ); 40006fec: 94 07 bf ff add %fp, -1, %o2 40006ff0: 40 00 01 83 call 400075fc <_POSIX_Priority_To_core> 40006ff4: 90 17 22 98 or %i4, 0x298, %o0 if ( !valid ) { 40006ff8: c2 0f bf ff ldub [ %fp + -1 ], %g1 40006ffc: 80 a0 60 00 cmp %g1, 0 40007000: 12 bf ff d4 bne 40006f50 <== ALWAYS TAKEN 40007004: 84 17 22 98 or %i4, 0x298, %g2 return EINVAL; 40007008: 81 c7 e0 08 ret <== NOT EXECUTED 4000700c: 91 e8 20 16 restore %g0, 0x16, %o0 <== NOT EXECUTED protocol = POSIX_MUTEX_PRIORITY_INHERIT; 40007010: 10 bf ff df b 40006f8c 40007014: 84 10 20 01 mov 1, %g2 break; 40007018: 10 bf ff dd b 40006f8c 4000701c: 84 10 20 02 mov 2, %g2 scheduler = NULL; 40007020: 84 10 20 00 clr %g2 priority = 0; 40007024: 90 10 20 00 clr %o0 40007028: 10 bf ff ca b 40006f50 4000702c: 92 10 20 00 clr %o1 =============================================================================== 4000737c : */ int pthread_mutex_unlock( pthread_mutex_t *mutex ) { 4000737c: 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 ); 40007380: 80 a6 20 00 cmp %i0, 0 40007384: 02 80 00 32 be 4000744c <== NEVER TAKEN 40007388: 05 25 87 04 sethi %hi(0x961c1000), %g2 4000738c: fa 06 00 00 ld [ %i0 ], %i5 40007390: 82 1e 00 1d xor %i0, %i5, %g1 40007394: 84 10 a3 b8 or %g2, 0x3b8, %g2 40007398: 82 18 40 02 xor %g1, %g2, %g1 4000739c: 80 88 7f f8 btst -8, %g1 400073a0: 12 80 00 26 bne 40007438 <== NEVER TAKEN 400073a4: 01 00 00 00 nop <== NOT EXECUTED __asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS)); 400073a8: 91 d0 20 09 ta 9 <== NOT EXECUTED 400073ac: c2 27 bf dc st %g1, [ %fp + -36 ] executing = _POSIX_Mutex_Acquire( the_mutex, &queue_context ); switch ( _POSIX_Mutex_Get_protocol( flags ) ) { 400073b0: ba 8f 60 03 andcc %i5, 3, %i5 400073b4: 02 80 00 28 be 40007454 <== NEVER TAKEN 400073b8: d0 01 a0 20 ld [ %g6 + 0x20 ], %o0 400073bc: 80 a7 60 02 cmp %i5, 2 400073c0: 12 80 00 0a bne 400073e8 400073c4: c2 06 20 10 ld [ %i0 + 0x10 ], %g1 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 ) ) { 400073c8: 80 a2 00 01 cmp %o0, %g1 400073cc: 22 80 00 37 be,a 400074a8 <== ALWAYS TAKEN 400073d0: c2 06 20 18 ld [ %i0 + 0x18 ], %g1 register uint32_t _psr __asm__("g1") = psr; /* input to trap handler */ 400073d4: c2 07 bf dc ld [ %fp + -36 ], %g1 <== NOT EXECUTED __asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr)); 400073d8: 91 d0 20 0a ta 0xa <== NOT EXECUTED 400073dc: 01 00 00 00 nop <== NOT EXECUTED 400073e0: 81 c7 e0 08 ret <== NOT EXECUTED 400073e4: 91 e8 20 01 restore %g0, 1, %o0 <== NOT EXECUTED if ( !_POSIX_Mutex_Is_owner( the_mutex, executing ) ) { 400073e8: 80 a2 00 01 cmp %o0, %g1 400073ec: 12 bf ff fa bne 400073d4 <== NEVER TAKEN 400073f0: 01 00 00 00 nop nest_level = the_mutex->Recursive.nest_level; 400073f4: c2 06 20 18 ld [ %i0 + 0x18 ], %g1 if ( nest_level > 0 ) { 400073f8: 80 a0 60 00 cmp %g1, 0 400073fc: 12 80 00 2e bne 400074b4 <== NEVER TAKEN 40007400: 82 00 7f ff add %g1, -1, %g1 the_mutex->Recursive.Mutex.Queue.Queue.owner = owner; 40007404: c0 26 20 10 clr [ %i0 + 0x10 ] heads = the_mutex->Recursive.Mutex.Queue.Queue.heads; 40007408: d2 06 20 0c ld [ %i0 + 0xc ], %o1 if ( heads == NULL ) { 4000740c: 80 a2 60 00 cmp %o1, 0 40007410: 02 80 00 2f be 400074cc <== ALWAYS TAKEN 40007414: 94 10 00 08 mov %o0, %o2 _Thread_queue_Surrender( 40007418: 96 07 bf dc add %fp, -36, %o3 <== NOT EXECUTED 4000741c: 90 06 20 0c add %i0, 0xc, %o0 <== NOT EXECUTED 40007420: 19 10 00 4d sethi %hi(0x40013400), %o4 <== NOT EXECUTED 40007424: b0 10 20 00 clr %i0 <== NOT EXECUTED 40007428: 40 00 17 91 call 4000d26c <_Thread_queue_Surrender> <== NOT EXECUTED 4000742c: 98 13 20 ec or %o4, 0xec, %o4 <== NOT EXECUTED ); break; } return _POSIX_Get_error( status ); } 40007430: 81 c7 e0 08 ret <== NOT EXECUTED 40007434: 81 e8 00 00 restore <== NOT EXECUTED POSIX_MUTEX_VALIDATE_OBJECT( the_mutex, flags ); 40007438: 7f ff ff aa call 400072e0 <_POSIX_Mutex_Auto_initialization> <== NOT EXECUTED 4000743c: 90 10 00 18 mov %i0, %o0 <== NOT EXECUTED 40007440: 80 a2 20 00 cmp %o0, 0 <== NOT EXECUTED 40007444: 12 bf ff d9 bne 400073a8 <== NOT EXECUTED 40007448: 01 00 00 00 nop <== NOT EXECUTED 4000744c: 81 c7 e0 08 ret <== NOT EXECUTED 40007450: 91 e8 20 16 restore %g0, 0x16, %o0 <== NOT EXECUTED if ( !_POSIX_Mutex_Is_owner( the_mutex, executing ) ) { 40007454: c2 06 20 10 ld [ %i0 + 0x10 ], %g1 <== NOT EXECUTED 40007458: 80 a2 00 01 cmp %o0, %g1 <== NOT EXECUTED 4000745c: 12 bf ff de bne 400073d4 <== NOT EXECUTED 40007460: 01 00 00 00 nop <== NOT EXECUTED nest_level = the_mutex->Recursive.nest_level; 40007464: c2 06 20 18 ld [ %i0 + 0x18 ], %g1 <== NOT EXECUTED if ( nest_level > 0 ) { 40007468: 80 a0 60 00 cmp %g1, 0 <== NOT EXECUTED 4000746c: 12 80 00 12 bne 400074b4 <== NOT EXECUTED 40007470: 82 00 7f ff add %g1, -1, %g1 <== NOT EXECUTED the_mutex->Recursive.Mutex.Queue.Queue.owner = owner; 40007474: c0 26 20 10 clr [ %i0 + 0x10 ] <== NOT EXECUTED heads = the_mutex->Recursive.Mutex.Queue.Queue.heads; 40007478: d2 06 20 0c ld [ %i0 + 0xc ], %o1 <== NOT EXECUTED if ( heads == NULL ) { 4000747c: 80 a2 60 00 cmp %o1, 0 <== NOT EXECUTED 40007480: 02 80 00 13 be 400074cc <== NOT EXECUTED 40007484: 94 10 00 08 mov %o0, %o2 <== NOT EXECUTED _Thread_queue_Surrender( 40007488: 96 07 bf dc add %fp, -36, %o3 <== NOT EXECUTED 4000748c: 90 06 20 0c add %i0, 0xc, %o0 <== NOT EXECUTED 40007490: 19 10 00 4d sethi %hi(0x40013400), %o4 <== NOT EXECUTED 40007494: b0 10 20 00 clr %i0 <== NOT EXECUTED 40007498: 40 00 17 75 call 4000d26c <_Thread_queue_Surrender> <== NOT EXECUTED 4000749c: 98 13 21 14 or %o4, 0x114, %o4 <== NOT EXECUTED 400074a0: 81 c7 e0 08 ret <== NOT EXECUTED 400074a4: 81 e8 00 00 restore <== NOT EXECUTED return STATUS_NOT_OWNER; } nest_level = the_mutex->Recursive.nest_level; if ( nest_level > 0 ) { 400074a8: 80 a0 60 00 cmp %g1, 0 400074ac: 02 80 00 0d be 400074e0 <== ALWAYS TAKEN 400074b0: 82 00 7f ff add %g1, -1, %g1 the_mutex->Recursive.nest_level = nest_level - 1; 400074b4: c2 26 20 18 st %g1, [ %i0 + 0x18 ] <== NOT EXECUTED register uint32_t _psr __asm__("g1") = psr; /* input to trap handler */ 400074b8: c2 07 bf dc ld [ %fp + -36 ], %g1 <== NOT EXECUTED __asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr)); 400074bc: 91 d0 20 0a ta 0xa <== NOT EXECUTED 400074c0: 01 00 00 00 nop <== NOT EXECUTED 400074c4: 81 c7 e0 08 ret <== NOT EXECUTED 400074c8: 91 e8 20 00 restore %g0, 0, %o0 <== NOT EXECUTED register uint32_t _psr __asm__("g1") = psr; /* input to trap handler */ 400074cc: c2 07 bf dc ld [ %fp + -36 ], %g1 <== NOT EXECUTED __asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr)); 400074d0: 91 d0 20 0a ta 0xa <== NOT EXECUTED 400074d4: 01 00 00 00 nop 400074d8: 81 c7 e0 08 ret 400074dc: 91 e8 20 00 restore %g0, 0, %o0 400074e0: c0 27 bf f0 clr [ %fp + -16 ] _Thread_Resource_count_decrement( executing ); _Thread_queue_Context_clear_priority_updates( queue_context ); _Thread_Wait_acquire_default_critical( executing, &lock_context ); _Thread_Priority_remove( 400074e4: b6 06 20 20 add %i0, 0x20, %i3 400074e8: 94 07 bf dc add %fp, -36, %o2 400074ec: 40 00 14 42 call 4000c5f4 <_Thread_Priority_remove> 400074f0: 92 10 00 1b mov %i3, %o1 disable_level = cpu_self->thread_dispatch_disable_level; 400074f4: c2 01 a0 18 ld [ %g6 + 0x18 ], %g1 cpu_self->thread_dispatch_disable_level = disable_level + 1; 400074f8: 82 00 60 01 inc %g1 400074fc: 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; 40007500: d0 06 20 0c ld [ %i0 + 0xc ], %o0 if ( heads != NULL ) { 40007504: 80 a2 20 00 cmp %o0, 0 40007508: 02 80 00 2a be 400075b0 <== ALWAYS TAKEN 4000750c: 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 ); 40007510: 39 10 00 4d sethi %hi(0x40013400), %i4 <== NOT EXECUTED 40007514: b8 17 21 00 or %i4, 0x100, %i4 ! 40013500 <_Thread_queue_Operations_priority> <== NOT EXECUTED 40007518: c2 07 20 10 ld [ %i4 + 0x10 ], %g1 <== NOT EXECUTED 4000751c: 9f c0 40 00 call %g1 <== NOT EXECUTED 40007520: 01 00 00 00 nop <== NOT EXECUTED the_mutex->Recursive.Mutex.Queue.Queue.owner = owner; 40007524: d0 26 20 10 st %o0, [ %i0 + 0x10 ] <== NOT EXECUTED new_owner = ( *operations->first )( heads ); 40007528: b4 10 00 08 mov %o0, %i2 <== NOT EXECUTED _POSIX_Mutex_Set_owner( the_mutex, new_owner ); _Thread_Resource_count_increment( new_owner ); _Thread_Priority_add( 4000752c: 94 07 bf dc add %fp, -36, %o2 <== NOT EXECUTED 40007530: 40 00 14 2c call 4000c5e0 <_Thread_Priority_add> <== NOT EXECUTED 40007534: 92 10 00 1b mov %i3, %o1 <== NOT EXECUTED new_owner, &the_mutex->Priority_ceiling, queue_context ); _Thread_queue_Extract_critical( 40007538: 96 07 bf dc add %fp, -36, %o3 <== NOT EXECUTED 4000753c: 94 10 00 1a mov %i2, %o2 <== NOT EXECUTED 40007540: 92 10 00 1c mov %i4, %o1 <== NOT EXECUTED 40007544: 40 00 17 09 call 4000d168 <_Thread_queue_Extract_critical> <== NOT EXECUTED 40007548: 90 06 20 0c add %i0, 0xc, %o0 <== NOT EXECUTED } else { _POSIX_Mutex_Set_owner( the_mutex, NULL ); _POSIX_Mutex_Release( the_mutex, queue_context ); } _Thread_Priority_update( queue_context ); 4000754c: 40 00 14 36 call 4000c624 <_Thread_Priority_update> 40007550: 90 07 bf dc add %fp, -36, %o0 uint32_t disable_level = cpu_self->thread_dispatch_disable_level; 40007554: c2 07 60 18 ld [ %i5 + 0x18 ], %g1 if ( disable_level == 1 ) { 40007558: 80 a0 60 01 cmp %g1, 1 4000755c: 02 80 00 06 be 40007574 <== ALWAYS TAKEN 40007560: 82 00 7f ff add %g1, -1, %g1 cpu_self->thread_dispatch_disable_level = disable_level - 1; 40007564: b0 10 20 00 clr %i0 <== NOT EXECUTED 40007568: c2 27 60 18 st %g1, [ %i5 + 0x18 ] <== NOT EXECUTED 4000756c: 81 c7 e0 08 ret <== NOT EXECUTED 40007570: 81 e8 00 00 restore <== NOT EXECUTED __asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS)); 40007574: 91 d0 20 09 ta 9 <== NOT EXECUTED if ( 40007578: c4 0f 60 1c ldub [ %i5 + 0x1c ], %g2 4000757c: 80 a0 a0 00 cmp %g2, 0 40007580: 12 80 00 07 bne 4000759c <== NEVER TAKEN 40007584: 92 10 00 01 mov %g1, %o1 <== NOT EXECUTED cpu_self->thread_dispatch_disable_level = 0; 40007588: c0 27 60 18 clr [ %i5 + 0x18 ] <== NOT EXECUTED __asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr)); 4000758c: 91 d0 20 0a ta 0xa <== NOT EXECUTED 40007590: 01 00 00 00 nop 40007594: 81 c7 e0 08 ret 40007598: 91 e8 20 00 restore %g0, 0, %o0 _Thread_Do_dispatch( cpu_self, level ); 4000759c: c2 27 bf d4 st %g1, [ %fp + -44 ] <== NOT EXECUTED 400075a0: 40 00 14 a8 call 4000c840 <_Thread_Do_dispatch> <== NOT EXECUTED 400075a4: 90 10 00 1d mov %i5, %o0 <== NOT EXECUTED 400075a8: 10 bf ff f9 b 4000758c <== NOT EXECUTED 400075ac: c2 07 bf d4 ld [ %fp + -44 ], %g1 <== NOT EXECUTED the_mutex->Recursive.Mutex.Queue.Queue.owner = owner; 400075b0: c0 26 20 10 clr [ %i0 + 0x10 ] <== NOT EXECUTED register uint32_t _psr __asm__("g1") = psr; /* input to trap handler */ 400075b4: c2 07 bf dc ld [ %fp + -36 ], %g1 <== NOT EXECUTED __asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr)); 400075b8: 91 d0 20 0a ta 0xa <== NOT EXECUTED 400075bc: 01 00 00 00 nop 400075c0: 30 bf ff e3 b,a 4000754c =============================================================================== 40006d70 : */ int pthread_mutexattr_destroy( pthread_mutexattr_t *attr ) { if ( attr == NULL || !attr->is_initialized ) 40006d70: 82 92 20 00 orcc %o0, 0, %g1 40006d74: 02 80 00 09 be 40006d98 <== NEVER TAKEN 40006d78: 90 10 20 16 mov 0x16, %o0 40006d7c: c4 00 40 00 ld [ %g1 ], %g2 40006d80: 80 a0 a0 00 cmp %g2, 0 40006d84: 02 80 00 05 be 40006d98 <== NEVER TAKEN 40006d88: 01 00 00 00 nop return EINVAL; attr->is_initialized = false; 40006d8c: c0 20 40 00 clr [ %g1 ] return 0; 40006d90: 81 c3 e0 08 retl 40006d94: 90 10 20 00 clr %o0 } 40006d98: 81 c3 e0 08 retl <== NOT EXECUTED 40006d9c: 01 00 00 00 nop <== NOT EXECUTED =============================================================================== 40006da0 : */ int pthread_mutexattr_init( pthread_mutexattr_t *attr ) { if ( attr == NULL ) 40006da0: 82 92 20 00 orcc %o0, 0, %g1 40006da4: 02 80 00 11 be 40006de8 <== NEVER TAKEN 40006da8: 07 10 00 4d sethi %hi(0x40013400), %g3 return EINVAL; *attr = _POSIX_Mutex_Default_attributes; 40006dac: 84 10 e0 70 or %g3, 0x70, %g2 ! 40013470 <_POSIX_Mutex_Default_attributes> 40006db0: d6 00 e0 70 ld [ %g3 + 0x70 ], %o3 40006db4: d8 00 a0 04 ld [ %g2 + 4 ], %o4 40006db8: da 00 a0 08 ld [ %g2 + 8 ], %o5 40006dbc: c8 00 a0 0c ld [ %g2 + 0xc ], %g4 40006dc0: c6 00 a0 10 ld [ %g2 + 0x10 ], %g3 40006dc4: c4 00 a0 14 ld [ %g2 + 0x14 ], %g2 40006dc8: d6 20 40 00 st %o3, [ %g1 ] return 0; 40006dcc: 90 10 20 00 clr %o0 *attr = _POSIX_Mutex_Default_attributes; 40006dd0: d8 20 60 04 st %o4, [ %g1 + 4 ] 40006dd4: da 20 60 08 st %o5, [ %g1 + 8 ] 40006dd8: c8 20 60 0c st %g4, [ %g1 + 0xc ] 40006ddc: c6 20 60 10 st %g3, [ %g1 + 0x10 ] return 0; 40006de0: 81 c3 e0 08 retl 40006de4: c4 20 60 14 st %g2, [ %g1 + 0x14 ] } 40006de8: 81 c3 e0 08 retl <== NOT EXECUTED 40006dec: 90 10 20 16 mov 0x16, %o0 <== NOT EXECUTED =============================================================================== 40006df0 : int pthread_mutexattr_setprioceiling( pthread_mutexattr_t *attr, int prioceiling ) { if ( !attr || !attr->is_initialized ) 40006df0: 82 92 20 00 orcc %o0, 0, %g1 40006df4: 02 80 00 09 be 40006e18 <== NEVER TAKEN 40006df8: 90 10 20 16 mov 0x16, %o0 40006dfc: c4 00 40 00 ld [ %g1 ], %g2 40006e00: 80 a0 a0 00 cmp %g2, 0 40006e04: 02 80 00 05 be 40006e18 <== NEVER TAKEN 40006e08: 01 00 00 00 nop return EINVAL; attr->prio_ceiling = prioceiling; 40006e0c: d2 20 60 08 st %o1, [ %g1 + 8 ] return 0; 40006e10: 81 c3 e0 08 retl 40006e14: 90 10 20 00 clr %o0 } 40006e18: 81 c3 e0 08 retl <== NOT EXECUTED 40006e1c: 01 00 00 00 nop <== NOT EXECUTED =============================================================================== 40006e20 : int pthread_mutexattr_setprotocol( pthread_mutexattr_t *attr, int protocol ) { if ( !attr || !attr->is_initialized ) 40006e20: 82 92 20 00 orcc %o0, 0, %g1 40006e24: 02 80 00 0b be 40006e50 <== NEVER TAKEN 40006e28: 90 10 20 16 mov 0x16, %o0 40006e2c: c4 00 40 00 ld [ %g1 ], %g2 40006e30: 80 a0 a0 00 cmp %g2, 0 40006e34: 02 80 00 07 be 40006e50 <== NEVER TAKEN 40006e38: 80 a2 60 02 cmp %o1, 2 return EINVAL; switch ( protocol ) { 40006e3c: 18 80 00 05 bgu 40006e50 <== NEVER TAKEN 40006e40: 01 00 00 00 nop case PTHREAD_PRIO_NONE: case PTHREAD_PRIO_INHERIT: case PTHREAD_PRIO_PROTECT: attr->protocol = protocol; 40006e44: d2 20 60 0c st %o1, [ %g1 + 0xc ] return 0; 40006e48: 81 c3 e0 08 retl 40006e4c: 90 10 20 00 clr %o0 default: return EINVAL; } } 40006e50: 81 c3 e0 08 retl <== NOT EXECUTED 40006e54: 01 00 00 00 nop <== NOT EXECUTED =============================================================================== 40006ff0 : int pthread_once( pthread_once_t *once_control, void (*init_routine)(void) ) { if ( !once_control || !init_routine ) 40006ff0: 80 a2 20 00 cmp %o0, 0 40006ff4: 02 80 00 07 be 40007010 <== NEVER TAKEN 40006ff8: 80 a2 60 00 cmp %o1, 0 40006ffc: 02 80 00 05 be 40007010 <== NEVER TAKEN 40007000: 01 00 00 00 nop return EINVAL; return _Once( &once_control->_flags, init_routine ); 40007004: 82 13 c0 00 mov %o7, %g1 40007008: 40 00 0a 03 call 40009814 <_Once> 4000700c: 9e 10 40 00 mov %g1, %o7 } 40007010: 81 c3 e0 08 retl <== NOT EXECUTED 40007014: 90 10 20 16 mov 0x16, %o0 <== NOT EXECUTED =============================================================================== 400075d4 : sizeof( POSIX_Spinlock_Control ) == sizeof( pthread_spinlock_t ), POSIX_SPINLOCK_T_SIZE ); int pthread_spin_lock( pthread_spinlock_t *spinlock ) { 400075d4: 84 10 00 08 mov %o0, %g2 <== NOT EXECUTED __asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS)); 400075d8: 91 d0 20 09 ta 9 <== NOT EXECUTED &cpu_self->Lock_stats_context ); #endif the_spinlock->interrupt_state = level; return 0; } 400075dc: 90 10 20 00 clr %o0 400075e0: 81 c3 e0 08 retl 400075e4: c2 20 a0 08 st %g1, [ %g2 + 8 ] =============================================================================== 400075e8 : { POSIX_Spinlock_Control *the_spinlock; ISR_Level level; the_spinlock = _POSIX_Spinlock_Get( lock ); level = the_spinlock->interrupt_state; 400075e8: c2 02 20 08 ld [ %o0 + 8 ], %g1 <== NOT EXECUTED __asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr)); 400075ec: 91 d0 20 0a ta 0xa <== NOT EXECUTED 400075f0: 01 00 00 00 nop &_Per_CPU_Get()->Lock_stats_context ); #endif _ISR_Local_enable( level ); return 0; } 400075f4: 81 c3 e0 08 retl 400075f8: 90 10 20 00 clr %o0 ! 0 =============================================================================== 40007670 : #include int sched_get_priority_max( int policy ) { 40007670: 9d e3 bf a0 save %sp, -96, %sp 40007674: 80 a6 20 04 cmp %i0, 4 40007678: 18 80 00 09 bgu 4000769c <== NEVER TAKEN 4000767c: 82 10 20 01 mov 1, %g1 40007680: b1 28 40 18 sll %g1, %i0, %i0 40007684: 80 8e 20 17 btst 0x17, %i0 40007688: 02 80 00 05 be 4000769c <== NEVER TAKEN 4000768c: 03 10 00 4b sethi %hi(0x40012c00), %g1 40007690: f0 00 62 dc ld [ %g1 + 0x2dc ], %i0 ! 40012edc <_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 ); } 40007694: 81 c7 e0 08 ret 40007698: 91 ee 3f ff restore %i0, -1, %o0 rtems_set_errno_and_return_minus_one( EINVAL ); 4000769c: 40 00 28 5d call 40011810 <__errno> <== NOT EXECUTED 400076a0: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED 400076a4: 82 10 20 16 mov 0x16, %g1 <== NOT EXECUTED 400076a8: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED 400076ac: 81 c7 e0 08 ret <== NOT EXECUTED 400076b0: 81 e8 00 00 restore <== NOT EXECUTED