=============================================================================== 400069b8 <_CORE_message_queue_Broadcast>: ) { Thread_Control *the_thread; uint32_t number_broadcasted; if ( size > the_message_queue->maximum_message_size ) { 400069b8: 01852783 lw a5,24(a0) { 400069bc: fe010113 addi sp,sp,-32 400069c0: 01212823 sw s2,16(sp) 400069c4: 00112e23 sw ra,28(sp) 400069c8: 00812c23 sw s0,24(sp) 400069cc: 00912a23 sw s1,20(sp) 400069d0: 01312623 sw s3,12(sp) 400069d4: 01412423 sw s4,8(sp) 400069d8: 01512223 sw s5,4(sp) 400069dc: 01612023 sw s6,0(sp) 400069e0: 00070913 mv s2,a4 if ( size > the_message_queue->maximum_message_size ) { 400069e4: 0ac7ec63 bltu a5,a2,40006a9c <_CORE_message_queue_Broadcast+0xe4> * * NOTE: This check is critical because threads can block on * send and receive and this ensures that we are broadcasting * the message to threads waiting to receive -- not to send. */ if ( the_message_queue->number_of_pending_messages != 0 ) { 400069e8: 01452a03 lw s4,20(a0) 400069ec: 00050493 mv s1,a0 400069f0: 00060993 mv s3,a2 400069f4: 00058a93 mv s5,a1 400069f8: 00068b13 mv s6,a3 400069fc: 0a0a1a63 bnez s4,40006ab0 <_CORE_message_queue_Broadcast+0xf8> RTEMS_INLINE_ROUTINE Thread_Control *_Thread_queue_First_locked( Thread_queue_Control *the_thread_queue, const Thread_queue_Operations *operations ) { Thread_queue_Heads *heads = the_thread_queue->Queue.heads; 40006a00: 0004a503 lw a0,0(s1) /* * There must be no pending messages if there is a thread waiting to * receive a message. */ the_thread = _Thread_queue_First_locked( 40006a04: 00c4a783 lw a5,12(s1) if ( heads != NULL ) { 40006a08: 04050e63 beqz a0,40006a64 <_CORE_message_queue_Broadcast+0xac> return ( *operations->first )( heads ); 40006a0c: 0107a783 lw a5,16(a5) 40006a10: 000780e7 jalr a5 memcpy(destination, source, size); 40006a14: 000a8593 mv a1,s5 40006a18: 00098613 mv a2,s3 40006a1c: 00050413 mv s0,a0 &the_message_queue->Wait_queue, the_message_queue->operations ); if ( the_thread == NULL ) { 40006a20: 04050263 beqz a0,40006a64 <_CORE_message_queue_Broadcast+0xac> <== NEVER TAKEN return NULL; } *(size_t *) the_thread->Wait.return_argument = size; 40006a24: 04052783 lw a5,64(a0) memcpy(destination, source, size); 40006a28: 04452503 lw a0,68(a0) 0, queue_context ) ) ) { number_broadcasted += 1; 40006a2c: 001a0a13 addi s4,s4,1 *(size_t *) the_thread->Wait.return_argument = size; 40006a30: 0137a023 sw s3,0(a5) the_thread->Wait.count = (uint32_t) submit_type; 40006a34: 02042e23 sw zero,60(s0) memcpy(destination, source, size); 40006a38: 3240b0ef jal ra,40011d5c buffer, the_thread->Wait.return_argument_second.mutable_object, size ); _Thread_queue_Extract_critical( 40006a3c: 00c4a583 lw a1,12(s1) 40006a40: 00090693 mv a3,s2 40006a44: 00040613 mv a2,s0 40006a48: 00048513 mv a0,s1 40006a4c: 18c020ef jal ra,40008bd8 <_Thread_queue_Extract_critical> __asm__ volatile ( 40006a50: 300477f3 csrrci a5,mstatus,8 return mstatus & RISCV_MSTATUS_MIE; 40006a54: 0087f793 andi a5,a5,8 _ISR_lock_ISR_disable( &queue_context->Lock_context.Lock_context ); 40006a58: 00f92023 sw a5,0(s2) if ( the_message_queue->number_of_pending_messages != 0 ) { 40006a5c: 0144a783 lw a5,20(s1) 40006a60: fa0780e3 beqz a5,40006a00 <_CORE_message_queue_Broadcast+0x48> <== ALWAYS TAKEN __asm__ volatile ( "csrrs zero, mstatus, %0" : : "r" ( level ) ); 40006a64: 00092783 lw a5,0(s2) 40006a68: 3007a073 csrs mstatus,a5 } _CORE_message_queue_Release( the_message_queue, queue_context ); *count = number_broadcasted; return STATUS_SUCCESSFUL; 40006a6c: 00000513 li a0,0 *count = number_broadcasted; 40006a70: 014b2023 sw s4,0(s6) } 40006a74: 01c12083 lw ra,28(sp) 40006a78: 01812403 lw s0,24(sp) 40006a7c: 01412483 lw s1,20(sp) 40006a80: 01012903 lw s2,16(sp) 40006a84: 00c12983 lw s3,12(sp) 40006a88: 00812a03 lw s4,8(sp) 40006a8c: 00412a83 lw s5,4(sp) 40006a90: 00012b03 lw s6,0(sp) 40006a94: 02010113 addi sp,sp,32 40006a98: 00008067 ret 40006a9c: 00072783 lw a5,0(a4) 40006aa0: 3007a073 csrs mstatus,a5 return STATUS_MESSAGE_INVALID_SIZE; 40006aa4: 00008537 lui a0,0x8 40006aa8: a0850513 addi a0,a0,-1528 # 7a08 40006aac: fc9ff06f j 40006a74 <_CORE_message_queue_Broadcast+0xbc> number_broadcasted = 0; 40006ab0: 00000a13 li s4,0 40006ab4: fb1ff06f j 40006a64 <_CORE_message_queue_Broadcast+0xac> =============================================================================== 4000d8d0 <_CORE_message_queue_Seize>: void *buffer, size_t *size_p, bool wait, Thread_queue_Context *queue_context ) { 4000d8d0: fe010113 addi sp,sp,-32 4000d8d4: 01312623 sw s3,12(sp) return _Chain_Immutable_head( the_chain )->next; 4000d8d8: 01c52983 lw s3,28(a0) 4000d8dc: 00812c23 sw s0,24(sp) 4000d8e0: 00912a23 sw s1,20(sp) 4000d8e4: 01212823 sw s2,16(sp) 4000d8e8: 00112e23 sw ra,28(sp) return &the_chain->Tail.Node; 4000d8ec: 02050813 addi a6,a0,32 4000d8f0: 00050413 mv s0,a0 4000d8f4: 00058493 mv s1,a1 4000d8f8: 00078913 mv s2,a5 if ( !_Chain_Is_empty(the_chain)) 4000d8fc: 0f098463 beq s3,a6,4000d9e4 <_CORE_message_queue_Seize+0x114> new_first = old_first->next; 4000d900: 0009a703 lw a4,0(s3) CORE_message_queue_Buffer *the_message; the_message = _CORE_message_queue_Get_pending_message( the_message_queue ); if ( the_message != NULL ) { the_message_queue->number_of_pending_messages -= 1; 4000d904: 01452783 lw a5,20(a0) 4000d908: 01c50593 addi a1,a0,28 *size_p = the_message->size; 4000d90c: 0089a503 lw a0,8(s3) head->next = new_first; 4000d910: 00e42e23 sw a4,28(s0) new_first->previous = head; 4000d914: 00b72223 sw a1,4(a4) the_message_queue->number_of_pending_messages -= 1; 4000d918: fff78793 addi a5,a5,-1 # 7fffffff 4000d91c: 00f42a23 sw a5,20(s0) *size_p = the_message->size; 4000d920: 00a6a023 sw a0,0(a3) executing->Wait.count = 4000d924: 00c9a783 lw a5,12(s3) const void *source, void *destination, size_t size ) { memcpy(destination, source, size); 4000d928: 00060513 mv a0,a2 4000d92c: 01098593 addi a1,s3,16 4000d930: 02f4ae23 sw a5,60(s1) 4000d934: 0006a603 lw a2,0(a3) 4000d938: 70d0a0ef jal ra,40018844 Thread_queue_Heads *heads = the_thread_queue->Queue.heads; 4000d93c: 00042503 lw a0,0(s0) * is not, then we can go ahead and free the buffer. * * NOTE: If we note that the queue was not full before this receive, * then we can avoid this dequeue. */ the_thread = _Thread_queue_First_locked( 4000d940: 00c42783 lw a5,12(s0) if ( heads != NULL ) { 4000d944: 06050063 beqz a0,4000d9a4 <_CORE_message_queue_Seize+0xd4> return ( *operations->first )( heads ); 4000d948: 0107a783 lw a5,16(a5) 4000d94c: 000780e7 jalr a5 4000d950: 00050493 mv s1,a0 &the_message_queue->Wait_queue, the_message_queue->operations ); if ( the_thread == NULL ) { 4000d954: 04050863 beqz a0,4000d9a4 <_CORE_message_queue_Seize+0xd4> <== NEVER TAKEN /* * There was a thread waiting to send a message. This code * puts the messages in the message queue on behalf of the * waiting task. */ _CORE_message_queue_Insert_message( 4000d958: 03c52703 lw a4,60(a0) 4000d95c: 04852683 lw a3,72(a0) 4000d960: 04452603 lw a2,68(a0) 4000d964: 00098593 mv a1,s3 4000d968: 00040513 mv a0,s0 4000d96c: 7d4060ef jal ra,40014140 <_CORE_message_queue_Insert_message> the_message, the_thread->Wait.return_argument_second.immutable_object, (size_t) the_thread->Wait.option, (CORE_message_queue_Submit_types) the_thread->Wait.count ); _Thread_queue_Extract_critical( 4000d970: 00c42583 lw a1,12(s0) 4000d974: 00040513 mv a0,s0 4000d978: 00090693 mv a3,s2 4000d97c: 00048613 mv a2,s1 4000d980: 320030ef jal ra,40010ca0 <_Thread_queue_Extract_critical> &the_message_queue->Wait_queue.Queue, the_message_queue->operations, the_thread, queue_context ); return STATUS_SUCCESSFUL; 4000d984: 00000513 li a0,0 the_message_queue->operations, executing, queue_context ); return _Thread_Wait_get_status( executing ); } 4000d988: 01c12083 lw ra,28(sp) 4000d98c: 01812403 lw s0,24(sp) 4000d990: 01412483 lw s1,20(sp) 4000d994: 01012903 lw s2,16(sp) 4000d998: 00c12983 lw s3,12(sp) 4000d99c: 02010113 addi sp,sp,32 4000d9a0: 00008067 ret old_last = tail->previous; 4000d9a4: 03c42783 lw a5,60(s0) return &the_chain->Tail.Node; 4000d9a8: 03840713 addi a4,s0,56 the_node->next = tail; 4000d9ac: 00e9a023 sw a4,0(s3) tail->previous = the_node; 4000d9b0: 03342e23 sw s3,60(s0) old_last->next = the_node; 4000d9b4: 0137a023 sw s3,0(a5) the_node->previous = old_last; 4000d9b8: 00f9a223 sw a5,4(s3) 4000d9bc: 00092783 lw a5,0(s2) 4000d9c0: 3007a073 csrs mstatus,a5 4000d9c4: 01c12083 lw ra,28(sp) 4000d9c8: 01812403 lw s0,24(sp) 4000d9cc: 01412483 lw s1,20(sp) 4000d9d0: 01012903 lw s2,16(sp) 4000d9d4: 00c12983 lw s3,12(sp) return STATUS_SUCCESSFUL; 4000d9d8: 00000513 li a0,0 } 4000d9dc: 02010113 addi sp,sp,32 4000d9e0: 00008067 ret if ( !wait ) { 4000d9e4: 02070663 beqz a4,4000da10 <_CORE_message_queue_Seize+0x140> _Thread_queue_Enqueue( 4000d9e8: 00c52583 lw a1,12(a0) queue_context->thread_state = thread_state; 4000d9ec: 01000793 li a5,16 executing->Wait.return_argument_second.mutable_object = buffer; 4000d9f0: 04c4a223 sw a2,68(s1) executing->Wait.return_argument = size_p; 4000d9f4: 04d4a023 sw a3,64(s1) 4000d9f8: 00f92223 sw a5,4(s2) _Thread_queue_Enqueue( 4000d9fc: 00090693 mv a3,s2 4000da00: 00048613 mv a2,s1 4000da04: 0cc030ef jal ra,40010ad0 <_Thread_queue_Enqueue> return (Status_Control) the_thread->Wait.return_code; 4000da08: 04c4a503 lw a0,76(s1) return _Thread_Wait_get_status( executing ); 4000da0c: f7dff06f j 4000d988 <_CORE_message_queue_Seize+0xb8> 4000da10: 0007a783 lw a5,0(a5) 4000da14: 3007a073 csrs mstatus,a5 return STATUS_UNSATISFIED; 4000da18: 00001537 lui a0,0x1 4000da1c: b0d50513 addi a0,a0,-1267 # b0d 4000da20: f69ff06f j 4000d988 <_CORE_message_queue_Seize+0xb8> =============================================================================== 4000da24 <_CORE_message_queue_Submit>: size_t size, CORE_message_queue_Submit_types submit_type, bool wait, Thread_queue_Context *queue_context ) { 4000da24: fd010113 addi sp,sp,-48 4000da28: 02812423 sw s0,40(sp) 4000da2c: 00050413 mv s0,a0 CORE_message_queue_Buffer *the_message; Thread_Control *the_thread; if ( size > the_message_queue->maximum_message_size ) { 4000da30: 01852503 lw a0,24(a0) { 4000da34: 03212023 sw s2,32(sp) 4000da38: 02112623 sw ra,44(sp) 4000da3c: 02912223 sw s1,36(sp) 4000da40: 01312e23 sw s3,28(sp) 4000da44: 01412c23 sw s4,24(sp) 4000da48: 01512a23 sw s5,20(sp) 4000da4c: 01612823 sw s6,16(sp) 4000da50: 01712623 sw s7,12(sp) 4000da54: 00080913 mv s2,a6 if ( size > the_message_queue->maximum_message_size ) { 4000da58: 0ed56463 bltu a0,a3,4000db40 <_CORE_message_queue_Submit+0x11c> 4000da5c: 00078b13 mv s6,a5 * * NOTE: This check is critical because threads can block on * send and receive and this ensures that we are broadcasting * the message to threads waiting to receive -- not to send. */ if ( the_message_queue->number_of_pending_messages != 0 ) { 4000da60: 01442783 lw a5,20(s0) 4000da64: 00068493 mv s1,a3 4000da68: 00058a93 mv s5,a1 4000da6c: 00060b93 mv s7,a2 4000da70: 00070993 mv s3,a4 4000da74: 08079063 bnez a5,4000daf4 <_CORE_message_queue_Submit+0xd0> Thread_queue_Heads *heads = the_thread_queue->Queue.heads; 4000da78: 00042503 lw a0,0(s0) /* * There must be no pending messages if there is a thread waiting to * receive a message. */ the_thread = _Thread_queue_First_locked( 4000da7c: 00c42783 lw a5,12(s0) if ( heads != NULL ) { 4000da80: 06050a63 beqz a0,4000daf4 <_CORE_message_queue_Submit+0xd0> return ( *operations->first )( heads ); 4000da84: 0107a783 lw a5,16(a5) 4000da88: 000780e7 jalr a5 4000da8c: 00050a13 mv s4,a0 &the_message_queue->Wait_queue, the_message_queue->operations ); if ( the_thread == NULL ) { 4000da90: 06050263 beqz a0,4000daf4 <_CORE_message_queue_Submit+0xd0> <== NEVER TAKEN return NULL; } *(size_t *) the_thread->Wait.return_argument = size; 4000da94: 04052783 lw a5,64(a0) memcpy(destination, source, size); 4000da98: 04452503 lw a0,68(a0) 4000da9c: 000b8593 mv a1,s7 *(size_t *) the_thread->Wait.return_argument = size; 4000daa0: 0097a023 sw s1,0(a5) memcpy(destination, source, size); 4000daa4: 00048613 mv a2,s1 the_thread->Wait.count = (uint32_t) submit_type; 4000daa8: 033a2e23 sw s3,60(s4) memcpy(destination, source, size); 4000daac: 5990a0ef jal ra,40018844 buffer, the_thread->Wait.return_argument_second.mutable_object, size ); _Thread_queue_Extract_critical( 4000dab0: 00c42583 lw a1,12(s0) 4000dab4: 00040513 mv a0,s0 4000dab8: 00090693 mv a3,s2 4000dabc: 000a0613 mv a2,s4 4000dac0: 1e0030ef jal ra,40010ca0 <_Thread_queue_Extract_critical> size, submit_type, queue_context ); if ( the_thread != NULL ) { return STATUS_SUCCESSFUL; 4000dac4: 00000513 li a0,0 executing, queue_context ); return _Thread_Wait_get_status( executing ); #endif } 4000dac8: 02c12083 lw ra,44(sp) 4000dacc: 02812403 lw s0,40(sp) 4000dad0: 02412483 lw s1,36(sp) 4000dad4: 02012903 lw s2,32(sp) 4000dad8: 01c12983 lw s3,28(sp) 4000dadc: 01812a03 lw s4,24(sp) 4000dae0: 01412a83 lw s5,20(sp) 4000dae4: 01012b03 lw s6,16(sp) 4000dae8: 00c12b83 lw s7,12(sp) 4000daec: 03010113 addi sp,sp,48 4000daf0: 00008067 ret return _Chain_Immutable_head( the_chain )->next; 4000daf4: 03442583 lw a1,52(s0) return &the_chain->Tail.Node; 4000daf8: 03840793 addi a5,s0,56 4000dafc: 03440613 addi a2,s0,52 if ( !_Chain_Is_empty(the_chain)) 4000db00: 06f58863 beq a1,a5,4000db70 <_CORE_message_queue_Submit+0x14c> new_first = old_first->next; 4000db04: 0005a783 lw a5,0(a1) _CORE_message_queue_Insert_message( 4000db08: 00098713 mv a4,s3 4000db0c: 00048693 mv a3,s1 head->next = new_first; 4000db10: 02f42a23 sw a5,52(s0) new_first->previous = head; 4000db14: 00c7a223 sw a2,4(a5) 4000db18: 00040513 mv a0,s0 4000db1c: 000b8613 mv a2,s7 4000db20: 620060ef jal ra,40014140 <_CORE_message_queue_Insert_message> if ( 4000db24: 01442703 lw a4,20(s0) 4000db28: 00100793 li a5,1 4000db2c: 02f70463 beq a4,a5,4000db54 <_CORE_message_queue_Submit+0x130> 4000db30: 00092783 lw a5,0(s2) 4000db34: 3007a073 csrs mstatus,a5 return STATUS_SUCCESSFUL; 4000db38: 00000513 li a0,0 } 4000db3c: f8dff06f j 4000dac8 <_CORE_message_queue_Submit+0xa4> 4000db40: 00082783 lw a5,0(a6) 4000db44: 3007a073 csrs mstatus,a5 return STATUS_MESSAGE_INVALID_SIZE; 4000db48: 00008537 lui a0,0x8 4000db4c: a0850513 addi a0,a0,-1528 # 7a08 4000db50: f79ff06f j 4000dac8 <_CORE_message_queue_Submit+0xa4> && the_message_queue->notify_handler != NULL 4000db54: 03042783 lw a5,48(s0) 4000db58: fc078ce3 beqz a5,4000db30 <_CORE_message_queue_Submit+0x10c> ( *the_message_queue->notify_handler )( 4000db5c: 00040513 mv a0,s0 4000db60: 00090593 mv a1,s2 4000db64: 000780e7 jalr a5 return STATUS_SUCCESSFUL; 4000db68: 00000513 li a0,0 ( *the_message_queue->notify_handler )( 4000db6c: f5dff06f j 4000dac8 <_CORE_message_queue_Submit+0xa4> if ( !wait ) { 4000db70: 020b0e63 beqz s6,4000dbac <_CORE_message_queue_Submit+0x188> if ( _ISR_Is_in_progress() ) { 4000db74: 1a0010ef jal ra,4000ed14 <_ISR_Is_in_progress> 4000db78: 04051463 bnez a0,4000dbc0 <_CORE_message_queue_Submit+0x19c> _Thread_queue_Enqueue( 4000db7c: 00c42583 lw a1,12(s0) queue_context->thread_state = thread_state; 4000db80: 01000793 li a5,16 executing->Wait.return_argument_second.immutable_object = buffer; 4000db84: 057aa223 sw s7,68(s5) executing->Wait.option = (uint32_t) size; 4000db88: 049aa423 sw s1,72(s5) executing->Wait.count = submit_type; 4000db8c: 033aae23 sw s3,60(s5) _Thread_queue_Enqueue( 4000db90: 00040513 mv a0,s0 4000db94: 00f92223 sw a5,4(s2) 4000db98: 00090693 mv a3,s2 4000db9c: 000a8613 mv a2,s5 4000dba0: 731020ef jal ra,40010ad0 <_Thread_queue_Enqueue> 4000dba4: 04caa503 lw a0,76(s5) return _Thread_Wait_get_status( executing ); 4000dba8: f21ff06f j 4000dac8 <_CORE_message_queue_Submit+0xa4> 4000dbac: 00092783 lw a5,0(s2) 4000dbb0: 3007a073 csrs mstatus,a5 return STATUS_TOO_MANY; 4000dbb4: 00001537 lui a0,0x1 4000dbb8: b0550513 addi a0,a0,-1275 # b05 4000dbbc: f0dff06f j 4000dac8 <_CORE_message_queue_Submit+0xa4> 4000dbc0: 00092783 lw a5,0(s2) 4000dbc4: 3007a073 csrs mstatus,a5 return STATUS_MESSAGE_QUEUE_WAIT_IN_ISR; 4000dbc8: 00001537 lui a0,0x1 4000dbcc: b0d50513 addi a0,a0,-1267 # b0d 4000dbd0: ef9ff06f j 4000dac8 <_CORE_message_queue_Submit+0xa4> =============================================================================== 40007250 <_Heap_Allocate_aligned_with_boundary>: Heap_Control *heap, uintptr_t alloc_size, uintptr_t alignment, uintptr_t boundary ) { 40007250: ff010113 addi sp,sp,-16 40007254: 00812423 sw s0,8(sp) 40007258: 00112623 sw ra,12(sp) 4000725c: 00050413 mv s0,a0 40007260: 00912223 sw s1,4(sp) 40007264: 01212023 sw s2,0(sp) Heap_Statistics *const stats = &heap->stats; uintptr_t const block_size_floor = alloc_size + HEAP_BLOCK_HEADER_SIZE 40007268: 00458513 addi a0,a1,4 - HEAP_ALLOC_BONUS; uintptr_t const page_size = heap->page_size; 4000726c: 01042e83 lw t4,16(s0) Heap_Block *block = NULL; uintptr_t alloc_begin = 0; uint32_t search_count = 0; bool search_again = false; if ( block_size_floor < alloc_size ) { 40007270: 16b56863 bltu a0,a1,400073e0 <_Heap_Allocate_aligned_with_boundary+0x190> 40007274: 00058893 mv a7,a1 /* Integer overflow occured */ return NULL; } if ( boundary != 0 ) { 40007278: 14069c63 bnez a3,400073d0 <_Heap_Allocate_aligned_with_boundary+0x180> * * @return The first block of the free list. */ RTEMS_INLINE_ROUTINE Heap_Block *_Heap_Free_list_first( Heap_Control *heap ) { return _Heap_Free_list_head(heap)->next; 4000727c: 00842583 lw a1,8(s0) do { Heap_Block *const free_list_tail = _Heap_Free_list_tail( heap ); block = _Heap_Free_list_first( heap ); while ( block != free_list_tail ) { 40007280: 00000493 li s1,0 40007284: 02b40a63 beq s0,a1,400072b8 <_Heap_Allocate_aligned_with_boundary+0x68> uintptr_t alloc_begin = alloc_end - alloc_size; 40007288: 00400e13 li t3,4 uintptr_t const alloc_begin_ceiling = block_end - min_block_size 4000728c: 007e8f13 addi t5,t4,7 uintptr_t alloc_begin = alloc_end - alloc_size; 40007290: 411e0e33 sub t3,t3,a7 uintptr_t const free_size = alloc_block_begin - block_begin; 40007294: ff800f93 li t6,-8 /* * The HEAP_PREV_BLOCK_USED flag is always set in the block size_and_flag * field. Thus the value is about one unit larger than the real block * size. The greater than operator takes this into account. */ if ( block->size_and_flag > block_size_floor ) { 40007298: 0045a783 lw a5,4(a1) ); } } /* Statistics */ ++search_count; 4000729c: 00148493 addi s1,s1,1 if ( block->size_and_flag > block_size_floor ) { 400072a0: 00f57863 bgeu a0,a5,400072b0 <_Heap_Allocate_aligned_with_boundary+0x60> */ RTEMS_INLINE_ROUTINE uintptr_t _Heap_Alloc_area_of_block( const Heap_Block *block ) { return (uintptr_t) block + HEAP_BLOCK_HEADER_SIZE; 400072a4: 00858913 addi s2,a1,8 if ( alignment == 0 ) { 400072a8: 04061263 bnez a2,400072ec <_Heap_Allocate_aligned_with_boundary+0x9c> if ( alloc_begin != 0 ) { 400072ac: 0c091863 bnez s2,4000737c <_Heap_Allocate_aligned_with_boundary+0x12c><== ALWAYS TAKEN break; } block = block->next; 400072b0: 0085a583 lw a1,8(a1) while ( block != free_list_tail ) { 400072b4: feb412e3 bne s0,a1,40007298 <_Heap_Allocate_aligned_with_boundary+0x48> ++stats->allocs; stats->searches += search_count; stats->lifetime_allocated += _Heap_Block_size( block ); } else { /* Statistics */ ++stats->failed_allocs; 400072b8: 05c42783 lw a5,92(s0) 400072bc: 00000513 li a0,0 400072c0: 00178793 addi a5,a5,1 400072c4: 04f42e23 sw a5,92(s0) } /* Statistics */ if ( stats->max_search < search_count ) { 400072c8: 05042783 lw a5,80(s0) 400072cc: 0097f463 bgeu a5,s1,400072d4 <_Heap_Allocate_aligned_with_boundary+0x84> stats->max_search = search_count; 400072d0: 04942823 sw s1,80(s0) } return (void *) alloc_begin; } 400072d4: 00c12083 lw ra,12(sp) 400072d8: 00812403 lw s0,8(sp) 400072dc: 00412483 lw s1,4(sp) 400072e0: 00012903 lw s2,0(sp) 400072e4: 01010113 addi sp,sp,16 400072e8: 00008067 ret * * @return The block size. */ RTEMS_INLINE_ROUTINE uintptr_t _Heap_Block_size( const Heap_Block *block ) { return block->size_and_flag & ~HEAP_PREV_BLOCK_USED; 400072ec: ffe7f793 andi a5,a5,-2 uintptr_t const block_end = block_begin + block_size; 400072f0: 00b78733 add a4,a5,a1 uintptr_t alloc_begin = alloc_end - alloc_size; 400072f4: 00ee07b3 add a5,t3,a4 return value - (value % alignment); 400072f8: 02c7f833 remu a6,a5,a2 400072fc: 01442283 lw t0,20(s0) uintptr_t const alloc_begin_ceiling = block_end - min_block_size 40007300: 405f0333 sub t1,t5,t0 40007304: 00e30733 add a4,t1,a4 40007308: 41078833 sub a6,a5,a6 if ( alloc_begin > alloc_begin_ceiling ) { 4000730c: 01077663 bgeu a4,a6,40007318 <_Heap_Allocate_aligned_with_boundary+0xc8> 40007310: 02c777b3 remu a5,a4,a2 40007314: 40f70833 sub a6,a4,a5 if ( boundary != 0 ) { 40007318: 04068063 beqz a3,40007358 <_Heap_Allocate_aligned_with_boundary+0x108> alloc_end = alloc_begin + alloc_size; 4000731c: 010883b3 add t2,a7,a6 40007320: 02d3f733 remu a4,t2,a3 uintptr_t const boundary_floor = alloc_begin_floor + alloc_size; 40007324: 01288333 add t1,a7,s2 40007328: 40e387b3 sub a5,t2,a4 while ( alloc_begin < boundary_line && boundary_line < alloc_end ) { 4000732c: 02f87663 bgeu a6,a5,40007358 <_Heap_Allocate_aligned_with_boundary+0x108> 40007330: 0277f463 bgeu a5,t2,40007358 <_Heap_Allocate_aligned_with_boundary+0x108> if ( boundary_line < boundary_floor ) { 40007334: f667eee3 bltu a5,t1,400072b0 <_Heap_Allocate_aligned_with_boundary+0x60> alloc_begin = boundary_line - alloc_size; 40007338: 411787b3 sub a5,a5,a7 4000733c: 02c7f833 remu a6,a5,a2 40007340: 41078833 sub a6,a5,a6 alloc_end = alloc_begin + alloc_size; 40007344: 01088733 add a4,a7,a6 40007348: 02d777b3 remu a5,a4,a3 4000734c: 40f707b3 sub a5,a4,a5 while ( alloc_begin < boundary_line && boundary_line < alloc_end ) { 40007350: 00f87463 bgeu a6,a5,40007358 <_Heap_Allocate_aligned_with_boundary+0x108> 40007354: fee7e0e3 bltu a5,a4,40007334 <_Heap_Allocate_aligned_with_boundary+0xe4> if ( alloc_begin >= alloc_begin_floor ) { 40007358: f5286ce3 bltu a6,s2,400072b0 <_Heap_Allocate_aligned_with_boundary+0x60> 4000735c: 03d877b3 remu a5,a6,t4 uintptr_t const free_size = alloc_block_begin - block_begin; 40007360: 40bf8733 sub a4,t6,a1 40007364: 01070733 add a4,a4,a6 40007368: 40f707b3 sub a5,a4,a5 if ( free_size >= min_block_size || free_size == 0 ) { 4000736c: 0057f463 bgeu a5,t0,40007374 <_Heap_Allocate_aligned_with_boundary+0x124> 40007370: f40790e3 bnez a5,400072b0 <_Heap_Allocate_aligned_with_boundary+0x60> 40007374: 00080913 mv s2,a6 if ( alloc_begin != 0 ) { 40007378: f2090ce3 beqz s2,400072b0 <_Heap_Allocate_aligned_with_boundary+0x60><== NEVER TAKEN block = _Heap_Block_allocate( heap, block, alloc_begin, alloc_size ); 4000737c: 00088693 mv a3,a7 40007380: 00090613 mv a2,s2 40007384: 00040513 mv a0,s0 40007388: 36c000ef jal ra,400076f4 <_Heap_Block_allocate> return block->size_and_flag & ~HEAP_PREV_BLOCK_USED; 4000738c: 00452703 lw a4,4(a0) stats->lifetime_allocated += _Heap_Block_size( block ); 40007390: 02842783 lw a5,40(s0) ++stats->allocs; 40007394: 05842603 lw a2,88(s0) stats->searches += search_count; 40007398: 05442683 lw a3,84(s0) stats->lifetime_allocated += _Heap_Block_size( block ); 4000739c: 02c42583 lw a1,44(s0) 400073a0: ffe77713 andi a4,a4,-2 400073a4: 00e78733 add a4,a5,a4 400073a8: 00f737b3 sltu a5,a4,a5 ++stats->allocs; 400073ac: 00160613 addi a2,a2,1 stats->searches += search_count; 400073b0: 009686b3 add a3,a3,s1 stats->lifetime_allocated += _Heap_Block_size( block ); 400073b4: 00b787b3 add a5,a5,a1 ++stats->allocs; 400073b8: 04c42c23 sw a2,88(s0) stats->searches += search_count; 400073bc: 04d42a23 sw a3,84(s0) stats->lifetime_allocated += _Heap_Block_size( block ); 400073c0: 02e42423 sw a4,40(s0) 400073c4: 02f42623 sw a5,44(s0) return (void *) alloc_begin; 400073c8: 00090513 mv a0,s2 400073cc: efdff06f j 400072c8 <_Heap_Allocate_aligned_with_boundary+0x78> if ( boundary < alloc_size ) { 400073d0: 00b6e863 bltu a3,a1,400073e0 <_Heap_Allocate_aligned_with_boundary+0x190> if ( alignment == 0 ) { 400073d4: ea0614e3 bnez a2,4000727c <_Heap_Allocate_aligned_with_boundary+0x2c> alignment = page_size; 400073d8: 000e8613 mv a2,t4 400073dc: ea1ff06f j 4000727c <_Heap_Allocate_aligned_with_boundary+0x2c> } 400073e0: 00c12083 lw ra,12(sp) 400073e4: 00812403 lw s0,8(sp) 400073e8: 00412483 lw s1,4(sp) 400073ec: 00012903 lw s2,0(sp) return NULL; 400073f0: 00000513 li a0,0 } 400073f4: 01010113 addi sp,sp,16 400073f8: 00008067 ret =============================================================================== 4000fc38 <_Heap_Extend>: Heap_Control *heap, void *extend_area_begin_ptr, uintptr_t extend_area_size, uintptr_t unused RTEMS_UNUSED ) { 4000fc38: fc010113 addi sp,sp,-64 4000fc3c: 02812c23 sw s0,56(sp) 4000fc40: 02912a23 sw s1,52(sp) 4000fc44: 03212823 sw s2,48(sp) 4000fc48: 02112e23 sw ra,60(sp) 4000fc4c: 03312623 sw s3,44(sp) 4000fc50: 03412423 sw s4,40(sp) 4000fc54: 03512223 sw s5,36(sp) 4000fc58: 03612023 sw s6,32(sp) 4000fc5c: 01712e23 sw s7,28(sp) 4000fc60: 01812c23 sw s8,24(sp) 4000fc64: 01912a23 sw s9,20(sp) Heap_Block *start_block = first_block; Heap_Block *merge_below_block = NULL; Heap_Block *merge_above_block = NULL; Heap_Block *link_below_block = NULL; Heap_Block *link_above_block = NULL; Heap_Block *extend_first_block = NULL; 4000fc68: 00012423 sw zero,8(sp) Heap_Block *extend_last_block = NULL; 4000fc6c: 00012623 sw zero,12(sp) uintptr_t const page_size = heap->page_size; uintptr_t const min_block_size = heap->min_block_size; uintptr_t const extend_area_begin = (uintptr_t) extend_area_begin_ptr; uintptr_t const extend_area_end = extend_area_begin + extend_area_size; 4000fc70: 00c584b3 add s1,a1,a2 Heap_Block *const first_block = heap->first_block; 4000fc74: 02052903 lw s2,32(a0) { 4000fc78: 00058413 mv s0,a1 uintptr_t const free_size = stats->free_size; uintptr_t extend_first_block_size = 0; uintptr_t extended_size = 0; bool extend_area_ok = false; if ( extend_area_end < extend_area_begin ) { 4000fc7c: 02b4fe63 bgeu s1,a1,4000fcb8 <_Heap_Extend+0x80> return 0; 4000fc80: 00000513 li a0,0 /* Statistics */ stats->size += extended_size; return extended_size; } 4000fc84: 03c12083 lw ra,60(sp) 4000fc88: 03812403 lw s0,56(sp) 4000fc8c: 03412483 lw s1,52(sp) 4000fc90: 03012903 lw s2,48(sp) 4000fc94: 02c12983 lw s3,44(sp) 4000fc98: 02812a03 lw s4,40(sp) 4000fc9c: 02412a83 lw s5,36(sp) 4000fca0: 02012b03 lw s6,32(sp) 4000fca4: 01c12b83 lw s7,28(sp) 4000fca8: 01812c03 lw s8,24(sp) 4000fcac: 01412c83 lw s9,20(sp) 4000fcb0: 04010113 addi sp,sp,64 4000fcb4: 00008067 ret uintptr_t const page_size = heap->page_size; 4000fcb8: 01052a03 lw s4,16(a0) extend_area_ok = _Heap_Get_first_and_last_block( 4000fcbc: 01452683 lw a3,20(a0) 4000fcc0: 00050b93 mv s7,a0 4000fcc4: 00060593 mv a1,a2 4000fcc8: 00c10793 addi a5,sp,12 4000fccc: 00810713 addi a4,sp,8 4000fcd0: 000a0613 mv a2,s4 4000fcd4: 00040513 mv a0,s0 uintptr_t const free_size = stats->free_size; 4000fcd8: 03cba983 lw s3,60(s7) extend_area_ok = _Heap_Get_first_and_last_block( 4000fcdc: 821f70ef jal ra,400074fc <_Heap_Get_first_and_last_block> if (!extend_area_ok ) { 4000fce0: fa0500e3 beqz a0,4000fc80 <_Heap_Extend+0x48> 4000fce4: 00040c93 mv s9,s0 Heap_Block *const first_block = heap->first_block; 4000fce8: 00090793 mv a5,s2 Heap_Block *link_above_block = NULL; 4000fcec: 00000c13 li s8,0 Heap_Block *link_below_block = NULL; 4000fcf0: 00000613 li a2,0 Heap_Block *merge_above_block = NULL; 4000fcf4: 00000a93 li s5,0 Heap_Block *merge_below_block = NULL; 4000fcf8: 00000b13 li s6,0 (uintptr_t) start_block : heap->area_begin; 4000fcfc: 00078593 mv a1,a5 4000fd00: 1d278e63 beq a5,s2,4000fedc <_Heap_Extend+0x2a4> uintptr_t const sub_area_end = start_block->prev_size; 4000fd04: 0007a683 lw a3,0(a5) # 80000000 return value - (value % alignment); 4000fd08: 0346f833 remu a6,a3,s4 - HEAP_BLOCK_HEADER_SIZE); 4000fd0c: ff868713 addi a4,a3,-8 4000fd10: 41070733 sub a4,a4,a6 if ( 4000fd14: 1ad47863 bgeu s0,a3,4000fec4 <_Heap_Extend+0x28c> sub_area_end > extend_area_begin && extend_area_end > sub_area_begin 4000fd18: f695e4e3 bltu a1,s1,4000fc80 <_Heap_Extend+0x48> if ( extend_area_end == sub_area_begin ) { 4000fd1c: 1c958463 beq a1,s1,4000fee4 <_Heap_Extend+0x2ac> } else if ( extend_area_end < sub_area_end ) { 4000fd20: 1ad4f663 bgeu s1,a3,4000fecc <_Heap_Extend+0x294> 4000fd24: 00078613 mv a2,a5 } else if ( sub_area_end < extend_area_begin ) { 4000fd28: 0086f463 bgeu a3,s0,4000fd30 <_Heap_Extend+0xf8> link_above_block = end_block; 4000fd2c: 00070c13 mv s8,a4 return block->size_and_flag & ~HEAP_PREV_BLOCK_USED; 4000fd30: 00472783 lw a5,4(a4) 4000fd34: ffe7f793 andi a5,a5,-2 return (Heap_Block *) ((uintptr_t) block + offset); 4000fd38: 00e787b3 add a5,a5,a4 } while ( start_block != first_block ); 4000fd3c: fcf910e3 bne s2,a5,4000fcfc <_Heap_Extend+0xc4> if ( extend_area_begin < heap->area_begin ) { 4000fd40: 018ba783 lw a5,24(s7) 4000fd44: 1af46463 bltu s0,a5,4000feec <_Heap_Extend+0x2b4> } else if ( heap->area_end < extend_area_end ) { 4000fd48: 01cba783 lw a5,28(s7) 4000fd4c: 0097f463 bgeu a5,s1,4000fd54 <_Heap_Extend+0x11c> heap->area_end = extend_area_end; 4000fd50: 009bae23 sw s1,28(s7) (uintptr_t) extend_last_block - (uintptr_t) extend_first_block; 4000fd54: 00c12703 lw a4,12(sp) 4000fd58: 00812783 lw a5,8(sp) if ( (uintptr_t) extend_first_block < (uintptr_t) heap->first_block ) { 4000fd5c: 020ba583 lw a1,32(s7) extend_first_block_size = 4000fd60: 40f706b3 sub a3,a4,a5 extend_first_block_size | HEAP_PREV_BLOCK_USED; 4000fd64: 0016e513 ori a0,a3,1 extend_first_block->prev_size = extend_area_end; 4000fd68: 0097a023 sw s1,0(a5) extend_first_block->size_and_flag = 4000fd6c: 00a7a223 sw a0,4(a5) extend_last_block->prev_size = extend_first_block_size; 4000fd70: 00d72023 sw a3,0(a4) extend_last_block->size_and_flag = 0; 4000fd74: 00072223 sw zero,4(a4) if ( (uintptr_t) extend_first_block < (uintptr_t) heap->first_block ) { 4000fd78: 16b7fe63 bgeu a5,a1,4000fef4 <_Heap_Extend+0x2bc> heap->first_block = extend_first_block; 4000fd7c: 02fba023 sw a5,32(s7) if ( merge_below_block != NULL ) { 4000fd80: 180b0263 beqz s6,4000ff04 <_Heap_Extend+0x2cc> uintptr_t const page_size = heap->page_size; 4000fd84: 010ba703 lw a4,16(s7) _Heap_Align_up( extend_area_begin + HEAP_BLOCK_HEADER_SIZE, page_size ); 4000fd88: 00840593 addi a1,s0,8 uintptr_t remainder = value % alignment; 4000fd8c: 02e5f7b3 remu a5,a1,a4 if ( remainder != 0 ) { 4000fd90: 00078a63 beqz a5,4000fda4 <_Heap_Extend+0x16c> return value - remainder + alignment; 4000fd94: 00b705b3 add a1,a4,a1 4000fd98: 40f585b3 sub a1,a1,a5 uintptr_t const new_first_block_begin = 4000fd9c: ff858c93 addi s9,a1,-8 Heap_Block *const new_first_block = (Heap_Block *) new_first_block_begin; 4000fda0: 000c8413 mv s0,s9 new_first_block->prev_size = first_block->prev_size; 4000fda4: 000b2683 lw a3,0(s6) ++stats->used_blocks; 4000fda8: 04cba703 lw a4,76(s7) --stats->frees; 4000fdac: 060ba783 lw a5,96(s7) uintptr_t const new_first_block_size = 4000fdb0: 419b0cb3 sub s9,s6,s9 new_first_block->size_and_flag = new_first_block_size | HEAP_PREV_BLOCK_USED; 4000fdb4: 001cec93 ori s9,s9,1 new_first_block->prev_size = first_block->prev_size; 4000fdb8: 00d42023 sw a3,0(s0) new_first_block->size_and_flag = new_first_block_size | HEAP_PREV_BLOCK_USED; 4000fdbc: 01942223 sw s9,4(s0) ++stats->used_blocks; 4000fdc0: 00170713 addi a4,a4,1 --stats->frees; 4000fdc4: fff78793 addi a5,a5,-1 ++stats->used_blocks; 4000fdc8: 04eba623 sw a4,76(s7) --stats->frees; 4000fdcc: 06fba023 sw a5,96(s7) _Heap_Free( heap, (void *) _Heap_Alloc_area_of_block( block ) ); 4000fdd0: 000b8513 mv a0,s7 4000fdd4: 19c000ef jal ra,4000ff70 <_Heap_Free> return _Heap_Free_list_head(heap)->next; 4000fdd8: 008ba783 lw a5,8(s7) Heap_Block *next = block->next; 4000fddc: 0087a703 lw a4,8(a5) Heap_Block *prev = block->prev; 4000fde0: 00c7a683 lw a3,12(a5) prev->next = next; 4000fde4: 00e6a423 sw a4,8(a3) next->prev = prev; 4000fde8: 00d72623 sw a3,12(a4) Heap_Block *prev = block_next->prev; 4000fdec: 00cba703 lw a4,12(s7) new_block->next = block_next; 4000fdf0: 0177a423 sw s7,8(a5) new_block->prev = prev; 4000fdf4: 00e7a623 sw a4,12(a5) prev->next = new_block; 4000fdf8: 00f72423 sw a5,8(a4) block_next->prev = new_block; 4000fdfc: 00fba623 sw a5,12(s7) if ( merge_above_block != NULL ) { 4000fe00: 100a8c63 beqz s5,4000ff18 <_Heap_Extend+0x2e0> return value - (value % alignment); 4000fe04: 010ba783 lw a5,16(s7) 4000fe08: ff848493 addi s1,s1,-8 uintptr_t const last_block_new_size = _Heap_Align_down( 4000fe0c: 41548733 sub a4,s1,s5 4000fe10: 02f776b3 remu a3,a4,a5 (last_block->size_and_flag - last_block_new_size) 4000fe14: 004aa783 lw a5,4(s5) ++stats->used_blocks; 4000fe18: 04cba803 lw a6,76(s7) --stats->frees; 4000fe1c: 060ba603 lw a2,96(s7) (last_block->size_and_flag - last_block_new_size) 4000fe20: 00fa87b3 add a5,s5,a5 4000fe24: 409784b3 sub s1,a5,s1 ++stats->used_blocks; 4000fe28: 00180813 addi a6,a6,1 --stats->frees; 4000fe2c: fff60613 addi a2,a2,-1 _Heap_Free( heap, (void *) _Heap_Alloc_area_of_block( block ) ); 4000fe30: 008a8593 addi a1,s5,8 4000fe34: 000b8513 mv a0,s7 4000fe38: 40d70733 sub a4,a4,a3 (last_block->size_and_flag - last_block_new_size) 4000fe3c: 00d487b3 add a5,s1,a3 | HEAP_PREV_BLOCK_USED; 4000fe40: 0017e793 ori a5,a5,1 new_last_block->size_and_flag = 4000fe44: 00ea86b3 add a3,s5,a4 4000fe48: 00f6a223 sw a5,4(a3) uintptr_t flag = block->size_and_flag & HEAP_PREV_BLOCK_USED; 4000fe4c: 004aa783 lw a5,4(s5) 4000fe50: 0017f793 andi a5,a5,1 block->size_and_flag = size | flag; 4000fe54: 00e7e7b3 or a5,a5,a4 4000fe58: 00faa223 sw a5,4(s5) ++stats->used_blocks; 4000fe5c: 050ba623 sw a6,76(s7) --stats->frees; 4000fe60: 06cba023 sw a2,96(s7) _Heap_Free( heap, (void *) _Heap_Alloc_area_of_block( block ) ); 4000fe64: 10c000ef jal ra,4000ff70 <_Heap_Free> return _Heap_Free_list_head(heap)->next; 4000fe68: 008ba783 lw a5,8(s7) Heap_Block *next = block->next; 4000fe6c: 0087a703 lw a4,8(a5) Heap_Block *prev = block->prev; 4000fe70: 00c7a683 lw a3,12(a5) prev->next = next; 4000fe74: 00e6a423 sw a4,8(a3) next->prev = prev; 4000fe78: 00d72623 sw a3,12(a4) Heap_Block *prev = block_next->prev; 4000fe7c: 00cba703 lw a4,12(s7) new_block->next = block_next; 4000fe80: 0177a423 sw s7,8(a5) new_block->prev = prev; 4000fe84: 00e7a623 sw a4,12(a5) prev->next = new_block; 4000fe88: 00f72423 sw a5,8(a4) block_next->prev = new_block; 4000fe8c: 00fba623 sw a5,12(s7) _Heap_Block_set_size( 4000fe90: 024ba603 lw a2,36(s7) 4000fe94: 020ba703 lw a4,32(s7) extended_size = stats->free_size - free_size; 4000fe98: 03cba783 lw a5,60(s7) uintptr_t flag = block->size_and_flag & HEAP_PREV_BLOCK_USED; 4000fe9c: 00462583 lw a1,4(a2) stats->size += extended_size; 4000fea0: 038ba683 lw a3,56(s7) _Heap_Block_set_size( 4000fea4: 40c70733 sub a4,a4,a2 uintptr_t flag = block->size_and_flag & HEAP_PREV_BLOCK_USED; 4000fea8: 0015f593 andi a1,a1,1 block->size_and_flag = size | flag; 4000feac: 00b76733 or a4,a4,a1 extended_size = stats->free_size - free_size; 4000feb0: 41378533 sub a0,a5,s3 4000feb4: 00e62223 sw a4,4(a2) stats->size += extended_size; 4000feb8: 00a687b3 add a5,a3,a0 4000febc: 02fbac23 sw a5,56(s7) return extended_size; 4000fec0: dc5ff06f j 4000fc84 <_Heap_Extend+0x4c> if ( extend_area_end == sub_area_begin ) { 4000fec4: 00959463 bne a1,s1,4000fecc <_Heap_Extend+0x294> 4000fec8: 00078b13 mv s6,a5 <== NOT EXECUTED if ( sub_area_end == extend_area_begin ) { 4000fecc: e4d41ee3 bne s0,a3,4000fd28 <_Heap_Extend+0xf0> start_block->prev_size = extend_area_end; 4000fed0: 0097a023 sw s1,0(a5) merge_above_block = end_block; 4000fed4: 00070a93 mv s5,a4 4000fed8: e59ff06f j 4000fd30 <_Heap_Extend+0xf8> (uintptr_t) start_block : heap->area_begin; 4000fedc: 018ba583 lw a1,24(s7) 4000fee0: e25ff06f j 4000fd04 <_Heap_Extend+0xcc> if ( extend_area_end == sub_area_begin ) { 4000fee4: 00078b13 mv s6,a5 4000fee8: e41ff06f j 4000fd28 <_Heap_Extend+0xf0> heap->area_begin = extend_area_begin; 4000feec: 008bac23 sw s0,24(s7) 4000fef0: e65ff06f j 4000fd54 <_Heap_Extend+0x11c> } else if ( (uintptr_t) extend_last_block > (uintptr_t) heap->last_block ) { 4000fef4: 024ba783 lw a5,36(s7) 4000fef8: e8e7f4e3 bgeu a5,a4,4000fd80 <_Heap_Extend+0x148> heap->last_block = extend_last_block; 4000fefc: 02eba223 sw a4,36(s7) 4000ff00: e81ff06f j 4000fd80 <_Heap_Extend+0x148> } else if ( link_below_block != NULL ) { 4000ff04: ee060ee3 beqz a2,4000fe00 <_Heap_Extend+0x1c8> (link_begin - last_block_begin) | HEAP_PREV_BLOCK_USED; 4000ff08: 40e60633 sub a2,a2,a4 4000ff0c: 00166613 ori a2,a2,1 last_block->size_and_flag = 4000ff10: 00c72223 sw a2,4(a4) } 4000ff14: eedff06f j 4000fe00 <_Heap_Extend+0x1c8> } else if ( link_above_block != NULL ) { 4000ff18: 020c0663 beqz s8,4000ff44 <_Heap_Extend+0x30c> uintptr_t flag = block->size_and_flag & HEAP_PREV_BLOCK_USED; 4000ff1c: 004c2783 lw a5,4(s8) _Heap_Link_above( 4000ff20: 00c12683 lw a3,12(sp) 4000ff24: 0017f713 andi a4,a5,1 _Heap_Block_set_size( link, first_block_begin - link_begin ); 4000ff28: 00812783 lw a5,8(sp) 4000ff2c: 418787b3 sub a5,a5,s8 block->size_and_flag = size | flag; 4000ff30: 00e7e7b3 or a5,a5,a4 4000ff34: 00fc2223 sw a5,4(s8) last_block->size_and_flag |= HEAP_PREV_BLOCK_USED; 4000ff38: 0046a783 lw a5,4(a3) 4000ff3c: 0017e793 ori a5,a5,1 4000ff40: 00f6a223 sw a5,4(a3) if ( merge_below_block == NULL && merge_above_block == NULL ) { 4000ff44: f40b16e3 bnez s6,4000fe90 <_Heap_Extend+0x258> ++stats->used_blocks; 4000ff48: 04cba703 lw a4,76(s7) --stats->frees; 4000ff4c: 060ba783 lw a5,96(s7) _Heap_Free( heap, (void *) _Heap_Alloc_area_of_block( block ) ); 4000ff50: 00812583 lw a1,8(sp) ++stats->used_blocks; 4000ff54: 00170713 addi a4,a4,1 --stats->frees; 4000ff58: fff78793 addi a5,a5,-1 ++stats->used_blocks; 4000ff5c: 04eba623 sw a4,76(s7) --stats->frees; 4000ff60: 06fba023 sw a5,96(s7) _Heap_Free( heap, (void *) _Heap_Alloc_area_of_block( block ) ); 4000ff64: 00858593 addi a1,a1,8 4000ff68: 000b8513 mv a0,s7 4000ff6c: ef9ff06f j 4000fe64 <_Heap_Extend+0x22c> =============================================================================== 4000ff70 <_Heap_Free>: return do_free; } #endif bool _Heap_Free( Heap_Control *heap, void *alloc_begin_ptr ) { 4000ff70: 00050793 mv a5,a0 /* * If NULL return true so a free on NULL is considered a valid release. This * is a special case that could be handled by the in heap check how-ever that * would result in false being returned which is wrong. */ if ( alloc_begin_ptr == NULL ) { 4000ff74: 14058863 beqz a1,400100c4 <_Heap_Free+0x154> return value - (value % alignment); 4000ff78: 01052603 lw a2,16(a0) - HEAP_BLOCK_HEADER_SIZE); 4000ff7c: ff858713 addi a4,a1,-8 return (uintptr_t) block >= (uintptr_t) heap->first_block 4000ff80: 02052683 lw a3,32(a0) return value - (value % alignment); 4000ff84: 02c5f5b3 remu a1,a1,a2 alloc_begin = (uintptr_t) alloc_begin_ptr; block = _Heap_Block_of_alloc_area( alloc_begin, heap->page_size ); if ( !_Heap_Is_block_in_heap( heap, block ) ) { return false; 4000ff88: 00000513 li a0,0 - HEAP_BLOCK_HEADER_SIZE); 4000ff8c: 40b705b3 sub a1,a4,a1 && (uintptr_t) block <= (uintptr_t) heap->last_block; 4000ff90: 00d5e863 bltu a1,a3,4000ffa0 <_Heap_Free+0x30> 4000ff94: 0247a303 lw t1,36(a5) 4000ff98: 00b37663 bgeu t1,a1,4000ffa4 <_Heap_Free+0x34> 4000ff9c: 00008067 ret ++stats->frees; stats->free_size += block_size; stats->lifetime_freed += block_size; return( true ); } 4000ffa0: 00008067 ret return block->size_and_flag & ~HEAP_PREV_BLOCK_USED; 4000ffa4: 0045a603 lw a2,4(a1) 4000ffa8: ffe67893 andi a7,a2,-2 return (Heap_Block *) ((uintptr_t) block + offset); 4000ffac: 01158733 add a4,a1,a7 && (uintptr_t) block <= (uintptr_t) heap->last_block; 4000ffb0: fed768e3 bltu a4,a3,4000ffa0 <_Heap_Free+0x30> 4000ffb4: 0ae36263 bltu t1,a4,40010058 <_Heap_Free+0xe8> return block->size_and_flag & HEAP_PREV_BLOCK_USED; 4000ffb8: 00472803 lw a6,4(a4) 4000ffbc: 00187513 andi a0,a6,1 if ( !_Heap_Is_prev_used( next_block ) ) { 4000ffc0: 10050663 beqz a0,400100cc <_Heap_Free+0x15c> <== NEVER TAKEN return block->size_and_flag & ~HEAP_PREV_BLOCK_USED; 4000ffc4: ffe87813 andi a6,a6,-2 return block->size_and_flag & HEAP_PREV_BLOCK_USED; 4000ffc8: 00167613 andi a2,a2,1 && !_Heap_Is_prev_used( _Heap_Block_at( next_block, next_block_size )); 4000ffcc: 08e30863 beq t1,a4,4001005c <_Heap_Free+0xec> 4000ffd0: 01070e33 add t3,a4,a6 4000ffd4: 004e2e03 lw t3,4(t3) 4000ffd8: 001e7e13 andi t3,t3,1 4000ffdc: 080e1063 bnez t3,4001005c <_Heap_Free+0xec> 4000ffe0: 00100e13 li t3,1 if ( !_Heap_Is_prev_used( block ) ) { 4000ffe4: 08060063 beqz a2,40010064 <_Heap_Free+0xf4> Heap_Block *next = old_block->next; 4000ffe8: 00872683 lw a3,8(a4) Heap_Block *prev = old_block->prev; 4000ffec: 00c72703 lw a4,12(a4) uintptr_t const size = block_size + next_block_size; 4000fff0: 01088833 add a6,a7,a6 new_block->next = next; 4000fff4: 00d5a423 sw a3,8(a1) new_block->prev = prev; 4000fff8: 00e5a623 sw a4,12(a1) next->prev = new_block; 4000fffc: 00b6a623 sw a1,12(a3) prev->next = new_block; 40010000: 00b72423 sw a1,8(a4) block->size_and_flag = size | HEAP_PREV_BLOCK_USED; 40010004: 00186713 ori a4,a6,1 40010008: 00e5a223 sw a4,4(a1) next_block->prev_size = size; 4001000c: 010585b3 add a1,a1,a6 40010010: 0105a023 sw a6,0(a1) stats->lifetime_freed += block_size; 40010014: 0307a703 lw a4,48(a5) --stats->used_blocks; 40010018: 04c7a583 lw a1,76(a5) ++stats->frees; 4001001c: 0607a603 lw a2,96(a5) stats->free_size += block_size; 40010020: 03c7a683 lw a3,60(a5) stats->lifetime_freed += block_size; 40010024: 0347a303 lw t1,52(a5) 40010028: 01170833 add a6,a4,a7 4001002c: 00e83733 sltu a4,a6,a4 --stats->used_blocks; 40010030: fff58593 addi a1,a1,-1 ++stats->frees; 40010034: 00160613 addi a2,a2,1 stats->free_size += block_size; 40010038: 011688b3 add a7,a3,a7 stats->lifetime_freed += block_size; 4001003c: 00670733 add a4,a4,t1 --stats->used_blocks; 40010040: 04b7a623 sw a1,76(a5) ++stats->frees; 40010044: 06c7a023 sw a2,96(a5) stats->free_size += block_size; 40010048: 0317ae23 sw a7,60(a5) stats->lifetime_freed += block_size; 4001004c: 0307a823 sw a6,48(a5) 40010050: 02e7aa23 sw a4,52(a5) return( true ); 40010054: 00008067 ret 40010058: 00008067 ret if ( !_Heap_Is_prev_used( block ) ) { 4001005c: 00000e13 li t3,0 40010060: 06061863 bnez a2,400100d0 <_Heap_Free+0x160> uintptr_t const prev_size = block->prev_size; 40010064: 0005a603 lw a2,0(a1) return (Heap_Block *) ((uintptr_t) block + offset); 40010068: 40c585b3 sub a1,a1,a2 && (uintptr_t) block <= (uintptr_t) heap->last_block; 4001006c: 04d5e863 bltu a1,a3,400100bc <_Heap_Free+0x14c> 40010070: 04b36663 bltu t1,a1,400100bc <_Heap_Free+0x14c> return block->size_and_flag & HEAP_PREV_BLOCK_USED; 40010074: 0045a683 lw a3,4(a1) 40010078: 0016f693 andi a3,a3,1 if ( !_Heap_Is_prev_used ( prev_block) ) { 4001007c: 04068063 beqz a3,400100bc <_Heap_Free+0x14c> <== NEVER TAKEN uintptr_t const size = block_size + prev_size + next_block_size; 40010080: 01160633 add a2,a2,a7 if ( next_is_free ) { /* coalesce both */ 40010084: 080e0a63 beqz t3,40010118 <_Heap_Free+0x1a8> Heap_Block *next = block->next; 40010088: 00872683 lw a3,8(a4) Heap_Block *prev = block->prev; 4001008c: 00c72303 lw t1,12(a4) stats->free_blocks -= 1; 40010090: 0447a703 lw a4,68(a5) uintptr_t const size = block_size + prev_size + next_block_size; 40010094: 00c80833 add a6,a6,a2 prev->next = next; 40010098: 00d32423 sw a3,8(t1) next->prev = prev; 4001009c: 0066a623 sw t1,12(a3) stats->free_blocks -= 1; 400100a0: fff70713 addi a4,a4,-1 400100a4: 04e7a223 sw a4,68(a5) prev_block->size_and_flag = size | HEAP_PREV_BLOCK_USED; 400100a8: 00186713 ori a4,a6,1 400100ac: 00e5a223 sw a4,4(a1) next_block->prev_size = size; 400100b0: 010585b3 add a1,a1,a6 400100b4: 0105a023 sw a6,0(a1) 400100b8: f5dff06f j 40010014 <_Heap_Free+0xa4> return false; 400100bc: 00000513 li a0,0 <== NOT EXECUTED 400100c0: 00008067 ret <== NOT EXECUTED return true; 400100c4: 00100513 li a0,1 400100c8: 00008067 ret 400100cc: 00008067 ret <== NOT EXECUTED Heap_Block *next = block_before->next; 400100d0: 0087a603 lw a2,8(a5) new_block->prev = block_before; 400100d4: 00f5a623 sw a5,12(a1) block->size_and_flag = block_size | HEAP_PREV_BLOCK_USED; 400100d8: 0018e693 ori a3,a7,1 new_block->next = next; 400100dc: 00c5a423 sw a2,8(a1) block_before->next = new_block; 400100e0: 00b7a423 sw a1,8(a5) next->prev = new_block; 400100e4: 00b62623 sw a1,12(a2) 400100e8: 00d5a223 sw a3,4(a1) next_block->size_and_flag &= ~HEAP_PREV_BLOCK_USED; 400100ec: 00472603 lw a2,4(a4) ++stats->free_blocks; 400100f0: 0447a683 lw a3,68(a5) if ( stats->max_free_blocks < stats->free_blocks ) { 400100f4: 0487a583 lw a1,72(a5) next_block->size_and_flag &= ~HEAP_PREV_BLOCK_USED; 400100f8: ffe67613 andi a2,a2,-2 400100fc: 00c72223 sw a2,4(a4) next_block->prev_size = block_size; 40010100: 01172023 sw a7,0(a4) ++stats->free_blocks; 40010104: 00168713 addi a4,a3,1 40010108: 04e7a223 sw a4,68(a5) if ( stats->max_free_blocks < stats->free_blocks ) { 4001010c: f0e5f4e3 bgeu a1,a4,40010014 <_Heap_Free+0xa4> stats->max_free_blocks = stats->free_blocks; 40010110: 04e7a423 sw a4,72(a5) 40010114: f01ff06f j 40010014 <_Heap_Free+0xa4> prev_block->size_and_flag = size | HEAP_PREV_BLOCK_USED; 40010118: 00166693 ori a3,a2,1 4001011c: 00d5a223 sw a3,4(a1) next_block->size_and_flag &= ~HEAP_PREV_BLOCK_USED; 40010120: 00472683 lw a3,4(a4) next_block->prev_size = size; 40010124: 00c72023 sw a2,0(a4) next_block->size_and_flag &= ~HEAP_PREV_BLOCK_USED; 40010128: ffe6f693 andi a3,a3,-2 4001012c: 00d72223 sw a3,4(a4) next_block->prev_size = size; 40010130: ee5ff06f j 40010014 <_Heap_Free+0xa4> =============================================================================== 400061e0 <_Heap_Greedy_allocate>: Heap_Block *_Heap_Greedy_allocate( Heap_Control *heap, const uintptr_t *block_sizes, size_t block_count ) { 400061e0: fe010113 addi sp,sp,-32 400061e4: 00912a23 sw s1,20(sp) 400061e8: 00112e23 sw ra,28(sp) 400061ec: 00812c23 sw s0,24(sp) 400061f0: 01212823 sw s2,16(sp) 400061f4: 01312623 sw s3,12(sp) 400061f8: 01412423 sw s4,8(sp) 400061fc: 00050493 mv s1,a0 Heap_Block *current; size_t i; _Heap_Protection_free_all_delayed_blocks( heap ); for (i = 0; i < block_count; ++i) { 40006200: 0c060863 beqz a2,400062d0 <_Heap_Greedy_allocate+0xf0> 40006204: 00060993 mv s3,a2 40006208: 00058413 mv s0,a1 4000620c: 00000a13 li s4,0 Heap_Block *allocated_blocks = NULL; 40006210: 00000913 li s2,0 * @retval pointer The starting address of the allocated memory area. * @retval NULL No memory is available of the parameters are inconsistent. */ RTEMS_INLINE_ROUTINE void *_Heap_Allocate( Heap_Control *heap, uintptr_t size ) { return _Heap_Allocate_aligned_with_boundary( heap, size, 0, 0 ); 40006214: 00042583 lw a1,0(s0) 40006218: 00000693 li a3,0 4000621c: 00000613 li a2,0 40006220: 00048513 mv a0,s1 40006224: 0b4050ef jal ra,4000b2d8 <_Heap_Allocate_aligned_with_boundary> uintptr_t alloc_begin, uintptr_t page_size ) { return (Heap_Block *) (_Heap_Align_down( alloc_begin, page_size ) - HEAP_BLOCK_HEADER_SIZE); 40006228: ff850793 addi a5,a0,-8 for (i = 0; i < block_count; ++i) { 4000622c: 001a0a13 addi s4,s4,1 void *next = _Heap_Allocate( heap, block_sizes [i] ); if ( next != NULL ) { 40006230: 00050c63 beqz a0,40006248 <_Heap_Greedy_allocate+0x68> return value - (value % alignment); 40006234: 0104a703 lw a4,16(s1) 40006238: 02e57533 remu a0,a0,a4 - HEAP_BLOCK_HEADER_SIZE); 4000623c: 40a78533 sub a0,a5,a0 Heap_Block *next_block = _Heap_Block_of_alloc_area( (uintptr_t) next, heap->page_size ); next_block->next = allocated_blocks; 40006240: 01252423 sw s2,8(a0) 40006244: 00050913 mv s2,a0 for (i = 0; i < block_count; ++i) { 40006248: 00440413 addi s0,s0,4 4000624c: fd4994e3 bne s3,s4,40006214 <_Heap_Greedy_allocate+0x34> return _Heap_Free_list_head(heap)->next; 40006250: 0084a403 lw s0,8(s1) allocated_blocks = next_block; } } while ( (current = _Heap_Free_list_first( heap )) != free_list_tail ) { 40006254: 06848a63 beq s1,s0,400062c8 <_Heap_Greedy_allocate+0xe8> Heap_Block *blocks = NULL; 40006258: 00000993 li s3,0 * * @return The block size. */ RTEMS_INLINE_ROUTINE uintptr_t _Heap_Block_size( const Heap_Block *block ) { return block->size_and_flag & ~HEAP_PREV_BLOCK_USED; 4000625c: 00442683 lw a3,4(s0) _Heap_Block_allocate( 40006260: 00840613 addi a2,s0,8 40006264: 00040593 mv a1,s0 40006268: ffe6f693 andi a3,a3,-2 4000626c: ff868693 addi a3,a3,-8 40006270: 00048513 mv a0,s1 40006274: 508050ef jal ra,4000b77c <_Heap_Block_allocate> current, _Heap_Alloc_area_of_block( current ), _Heap_Block_size( current ) - HEAP_BLOCK_HEADER_SIZE ); current->next = blocks; 40006278: 01342423 sw s3,8(s0) return &heap->free_list; 4000627c: 00040993 mv s3,s0 return _Heap_Free_list_head(heap)->next; 40006280: 0084a403 lw s0,8(s1) while ( (current = _Heap_Free_list_first( heap )) != free_list_tail ) { 40006284: fc849ce3 bne s1,s0,4000625c <_Heap_Greedy_allocate+0x7c> blocks = current; } while ( allocated_blocks != NULL ) { 40006288: 00090e63 beqz s2,400062a4 <_Heap_Greedy_allocate+0xc4> current = allocated_blocks; allocated_blocks = allocated_blocks->next; 4000628c: 00090593 mv a1,s2 40006290: 00892903 lw s2,8(s2) _Heap_Free( heap, (void *) _Heap_Alloc_area_of_block( current ) ); 40006294: 00858593 addi a1,a1,8 40006298: 00048513 mv a0,s1 4000629c: 161050ef jal ra,4000bbfc <_Heap_Free> while ( allocated_blocks != NULL ) { 400062a0: fe0916e3 bnez s2,4000628c <_Heap_Greedy_allocate+0xac> } return blocks; } 400062a4: 01c12083 lw ra,28(sp) 400062a8: 01812403 lw s0,24(sp) 400062ac: 01412483 lw s1,20(sp) 400062b0: 01012903 lw s2,16(sp) 400062b4: 00812a03 lw s4,8(sp) 400062b8: 00098513 mv a0,s3 400062bc: 00c12983 lw s3,12(sp) 400062c0: 02010113 addi sp,sp,32 400062c4: 00008067 ret Heap_Block *blocks = NULL; 400062c8: 00000993 li s3,0 while ( allocated_blocks != NULL ) { 400062cc: fbdff06f j 40006288 <_Heap_Greedy_allocate+0xa8> 400062d0: 00852403 lw s0,8(a0) Heap_Block *allocated_blocks = NULL; 400062d4: 00000913 li s2,0 Heap_Block *blocks = NULL; 400062d8: 00000993 li s3,0 while ( (current = _Heap_Free_list_first( heap )) != free_list_tail ) { 400062dc: f6a41ee3 bne s0,a0,40006258 <_Heap_Greedy_allocate+0x78> 400062e0: fc5ff06f j 400062a4 <_Heap_Greedy_allocate+0xc4> <== NOT EXECUTED =============================================================================== 40003d84 <_Heap_Greedy_allocate_all_except_largest>: Heap_Block *_Heap_Greedy_allocate_all_except_largest( Heap_Control *heap, uintptr_t *allocatable_size ) { 40003d84: fe010113 addi sp,sp,-32 40003d88: 00812c23 sw s0,24(sp) 40003d8c: 00058413 mv s0,a1 Heap_Information info; _Heap_Get_free_information( heap, &info ); 40003d90: 00410593 addi a1,sp,4 { 40003d94: 00912a23 sw s1,20(sp) 40003d98: 00112e23 sw ra,28(sp) 40003d9c: 00050493 mv s1,a0 _Heap_Get_free_information( heap, &info ); 40003da0: 701040ef jal ra,40008ca0 <_Heap_Get_free_information> if ( info.largest > 0 ) { 40003da4: 00812783 lw a5,8(sp) 40003da8: 00078463 beqz a5,40003db0 <_Heap_Greedy_allocate_all_except_largest+0x2c><== NEVER TAKEN *allocatable_size = info.largest - HEAP_BLOCK_HEADER_SIZE + HEAP_ALLOC_BONUS; 40003dac: ffc78793 addi a5,a5,-4 40003db0: 00f42023 sw a5,0(s0) } else { *allocatable_size = 0; } return _Heap_Greedy_allocate( heap, allocatable_size, 1 ); 40003db4: 00040593 mv a1,s0 40003db8: 00048513 mv a0,s1 40003dbc: 00100613 li a2,1 40003dc0: ec1ff0ef jal ra,40003c80 <_Heap_Greedy_allocate> } 40003dc4: 01c12083 lw ra,28(sp) 40003dc8: 01812403 lw s0,24(sp) 40003dcc: 01412483 lw s1,20(sp) 40003dd0: 02010113 addi sp,sp,32 40003dd4: 00008067 ret =============================================================================== 40007560 <_Heap_Initialize>: { 40007560: fd010113 addi sp,sp,-48 40007564: 02812423 sw s0,40(sp) 40007568: 01512a23 sw s5,20(sp) 4000756c: 01712623 sw s7,12(sp) 40007570: 01812423 sw s8,8(sp) 40007574: 02112623 sw ra,44(sp) 40007578: 02912223 sw s1,36(sp) 4000757c: 03212023 sw s2,32(sp) 40007580: 01312e23 sw s3,28(sp) 40007584: 01412c23 sw s4,24(sp) 40007588: 01612823 sw s6,16(sp) 4000758c: 01912223 sw s9,4(sp) 40007590: 00058413 mv s0,a1 40007594: 00060c13 mv s8,a2 40007598: 00050793 mv a5,a0 uintptr_t const heap_area_begin = (uintptr_t) heap_area_begin_ptr; 4000759c: 00058b93 mv s7,a1 uintptr_t const heap_area_end = heap_area_begin + heap_area_size; 400075a0: 00c58ab3 add s5,a1,a2 if ( page_size == 0 ) { 400075a4: 10068463 beqz a3,400076ac <_Heap_Initialize+0x14c> uintptr_t remainder = value % alignment; 400075a8: 00f6f713 andi a4,a3,15 400075ac: 00068493 mv s1,a3 if ( remainder != 0 ) { 400075b0: 12071463 bnez a4,400076d8 <_Heap_Initialize+0x178> if ( page_size < CPU_ALIGNMENT ) { 400075b4: 00f00713 li a4,15 return 0; 400075b8: 00000913 li s2,0 if ( page_size < CPU_ALIGNMENT ) { 400075bc: 0a977c63 bgeu a4,s1,40007674 <_Heap_Initialize+0x114> uintptr_t remainder = value % alignment; 400075c0: 01000b13 li s6,16 400075c4: 029b7733 remu a4,s6,s1 if ( remainder != 0 ) { 400075c8: 12070263 beqz a4,400076ec <_Heap_Initialize+0x18c> return value - remainder + alignment; 400075cc: 01048b13 addi s6,s1,16 400075d0: 40eb0b33 sub s6,s6,a4 _Heap_Align_up( heap_area_begin + HEAP_BLOCK_HEADER_SIZE, page_size ); 400075d4: 00840713 addi a4,s0,8 uintptr_t remainder = value % alignment; 400075d8: 029776b3 remu a3,a4,s1 if ( remainder != 0 ) { 400075dc: 0e069263 bnez a3,400076c0 <_Heap_Initialize+0x160> <== ALWAYS TAKEN uintptr_t const heap_area_begin = (uintptr_t) heap_area_begin_ptr; 400075e0: 00040713 mv a4,s0 <== NOT EXECUTED 400075e4: 00800993 li s3,8 <== NOT EXECUTED return 0; 400075e8: 00000913 li s2,0 if ( 400075ec: 097ae463 bltu s5,s7,40007674 <_Heap_Initialize+0x114> || heap_area_size <= overhead 400075f0: 0989f263 bgeu s3,s8,40007674 <_Heap_Initialize+0x114> _Heap_Align_down( heap_area_size - overhead, page_size ); 400075f4: 413c0933 sub s2,s8,s3 return value - (value % alignment); 400075f8: 02997cb3 remu s9,s2,s1 400075fc: 41990933 sub s2,s2,s9 || first_block_size < min_block_size 40007600: 0f696263 bltu s2,s6,400076e4 <_Heap_Initialize+0x184> memset(heap, 0, sizeof(*heap)); 40007604: 06800613 li a2,104 40007608: 00000593 li a1,0 4000760c: 00078513 mv a0,a5 return (Heap_Block *) ((uintptr_t) block + offset); 40007610: 00e90a33 add s4,s2,a4 40007614: 76c0d0ef jal ra,40014d80 first_block->size_and_flag = first_block_size | HEAP_PREV_BLOCK_USED; 40007618: 00196713 ori a4,s2,1 4000761c: 00e42223 sw a4,4(s0) first_block->prev_size = heap_area_end; 40007620: 01542023 sw s5,0(s0) first_block->next = _Heap_Free_list_tail( heap ); 40007624: 00a42423 sw a0,8(s0) first_block->prev = _Heap_Free_list_head( heap ); 40007628: 00a42623 sw a0,12(s0) _Heap_Block_set_size( 4000762c: 418989b3 sub s3,s3,s8 heap->page_size = page_size; 40007630: 00952823 sw s1,16(a0) heap->min_block_size = min_block_size; 40007634: 01652a23 sw s6,20(a0) heap->area_begin = heap_area_begin; 40007638: 01752c23 sw s7,24(a0) heap->area_end = heap_area_end; 4000763c: 01552e23 sw s5,28(a0) heap->first_block = first_block; 40007640: 02852023 sw s0,32(a0) heap->last_block = last_block; 40007644: 03452223 sw s4,36(a0) _Heap_Free_list_head( heap )->next = first_block; 40007648: 00852423 sw s0,8(a0) _Heap_Free_list_tail( heap )->prev = first_block; 4000764c: 00852623 sw s0,12(a0) 40007650: 019989b3 add s3,s3,s9 last_block->prev_size = first_block_size; 40007654: 012a2023 sw s2,0(s4) block->size_and_flag = size | flag; 40007658: 013a2223 sw s3,4(s4) stats->free_blocks = 1; 4000765c: 00100713 li a4,1 stats->size = first_block_size; 40007660: 03252c23 sw s2,56(a0) stats->free_size = first_block_size; 40007664: 03252e23 sw s2,60(a0) stats->min_free_size = first_block_size; 40007668: 05252023 sw s2,64(a0) stats->free_blocks = 1; 4000766c: 04e52223 sw a4,68(a0) stats->max_free_blocks = 1; 40007670: 04e52423 sw a4,72(a0) } 40007674: 02c12083 lw ra,44(sp) 40007678: 02812403 lw s0,40(sp) 4000767c: 02412483 lw s1,36(sp) 40007680: 01c12983 lw s3,28(sp) 40007684: 01812a03 lw s4,24(sp) 40007688: 01412a83 lw s5,20(sp) 4000768c: 01012b03 lw s6,16(sp) 40007690: 00c12b83 lw s7,12(sp) 40007694: 00812c03 lw s8,8(sp) 40007698: 00412c83 lw s9,4(sp) 4000769c: 00090513 mv a0,s2 400076a0: 02012903 lw s2,32(sp) 400076a4: 03010113 addi sp,sp,48 400076a8: 00008067 ret page_size = CPU_ALIGNMENT; 400076ac: 01000493 li s1,16 return value; 400076b0: 01000b13 li s6,16 _Heap_Align_up( heap_area_begin + HEAP_BLOCK_HEADER_SIZE, page_size ); 400076b4: 00840713 addi a4,s0,8 uintptr_t remainder = value % alignment; 400076b8: 029776b3 remu a3,a4,s1 if ( remainder != 0 ) { 400076bc: f20682e3 beqz a3,400075e0 <_Heap_Initialize+0x80> <== NEVER TAKEN uintptr_t const first_block_begin = 400076c0: 00940733 add a4,s0,s1 400076c4: 40d70733 sub a4,a4,a3 uintptr_t const overhead = 400076c8: 40870433 sub s0,a4,s0 400076cc: 00840993 addi s3,s0,8 Heap_Block *const first_block = (Heap_Block *) first_block_begin; 400076d0: 00070413 mv s0,a4 return value - remainder + alignment; 400076d4: f15ff06f j 400075e8 <_Heap_Initialize+0x88> 400076d8: 01068493 addi s1,a3,16 400076dc: 40e484b3 sub s1,s1,a4 400076e0: ed5ff06f j 400075b4 <_Heap_Initialize+0x54> return 0; 400076e4: 00000913 li s2,0 400076e8: f8dff06f j 40007674 <_Heap_Initialize+0x114> return value; 400076ec: 01000b13 li s6,16 400076f0: fc5ff06f j 400076b4 <_Heap_Initialize+0x154> =============================================================================== 400078f8 <_Heap_Iterate>: void _Heap_Iterate( Heap_Control *heap, Heap_Block_visitor visitor, void *visitor_arg ) { 400078f8: fe010113 addi sp,sp,-32 400078fc: 00812c23 sw s0,24(sp) 40007900: 01312623 sw s3,12(sp) Heap_Block *current = heap->first_block; 40007904: 02052403 lw s0,32(a0) Heap_Block *end = heap->last_block; 40007908: 02452983 lw s3,36(a0) { 4000790c: 00912a23 sw s1,20(sp) 40007910: 01212823 sw s2,16(sp) 40007914: 00112e23 sw ra,28(sp) 40007918: 00058913 mv s2,a1 4000791c: 00060493 mv s1,a2 while ( !stop && current != end ) { uintptr_t size = _Heap_Block_size( current ); Heap_Block *next = _Heap_Block_at( current, size ); bool used = _Heap_Is_prev_used( next ); stop = (*visitor)( current, size, used, visitor_arg ); 40007920: 00040513 mv a0,s0 40007924: 00048693 mv a3,s1 while ( !stop && current != end ) { 40007928: 02898063 beq s3,s0,40007948 <_Heap_Iterate+0x50> return block->size_and_flag & ~HEAP_PREV_BLOCK_USED; 4000792c: 00442583 lw a1,4(s0) 40007930: ffe5f593 andi a1,a1,-2 return (Heap_Block *) ((uintptr_t) block + offset); 40007934: 00b40433 add s0,s0,a1 return block->size_and_flag & HEAP_PREV_BLOCK_USED; 40007938: 00442603 lw a2,4(s0) stop = (*visitor)( current, size, used, visitor_arg ); 4000793c: 00167613 andi a2,a2,1 40007940: 000900e7 jalr s2 while ( !stop && current != end ) { 40007944: fc050ee3 beqz a0,40007920 <_Heap_Iterate+0x28> <== ALWAYS TAKEN current = next; } } 40007948: 01c12083 lw ra,28(sp) 4000794c: 01812403 lw s0,24(sp) 40007950: 01412483 lw s1,20(sp) 40007954: 01012903 lw s2,16(sp) 40007958: 00c12983 lw s3,12(sp) 4000795c: 02010113 addi sp,sp,32 40007960: 00008067 ret =============================================================================== 40005264 <_Heap_Size_of_alloc_area>: return value - (value % alignment); 40005264: 01052783 lw a5,16(a0) return (uintptr_t) block >= (uintptr_t) heap->first_block 40005268: 02052683 lw a3,32(a0) - HEAP_BLOCK_HEADER_SIZE); 4000526c: ff858713 addi a4,a1,-8 return value - (value % alignment); 40005270: 02f5f7b3 remu a5,a1,a5 - HEAP_BLOCK_HEADER_SIZE); 40005274: 40f70733 sub a4,a4,a5 && (uintptr_t) block <= (uintptr_t) heap->last_block; 40005278: 02d76e63 bltu a4,a3,400052b4 <_Heap_Size_of_alloc_area+0x50> 4000527c: 02452503 lw a0,36(a0) 40005280: 02e56a63 bltu a0,a4,400052b4 <_Heap_Size_of_alloc_area+0x50> return block->size_and_flag & ~HEAP_PREV_BLOCK_USED; 40005284: 00472783 lw a5,4(a4) 40005288: ffe7f793 andi a5,a5,-2 return (Heap_Block *) ((uintptr_t) block + offset); 4000528c: 00e787b3 add a5,a5,a4 && (uintptr_t) block <= (uintptr_t) heap->last_block; 40005290: 02d7e263 bltu a5,a3,400052b4 <_Heap_Size_of_alloc_area+0x50> 40005294: 02f56063 bltu a0,a5,400052b4 <_Heap_Size_of_alloc_area+0x50> return block->size_and_flag & HEAP_PREV_BLOCK_USED; 40005298: 0047a503 lw a0,4(a5) 4000529c: 00157513 andi a0,a0,1 block_size = _Heap_Block_size( block ); next_block = _Heap_Block_at( block, block_size ); if ( !_Heap_Is_block_in_heap( heap, next_block ) || !_Heap_Is_prev_used( next_block ) 400052a0: 00050e63 beqz a0,400052bc <_Heap_Size_of_alloc_area+0x58> <== NEVER TAKEN ) { return false; } *alloc_size = (uintptr_t) next_block + HEAP_ALLOC_BONUS - alloc_begin; 400052a4: 40b787b3 sub a5,a5,a1 400052a8: 00478793 addi a5,a5,4 400052ac: 00f62023 sw a5,0(a2) return true; 400052b0: 00008067 ret return false; 400052b4: 00000513 li a0,0 <== NOT EXECUTED } 400052b8: 00008067 ret <== NOT EXECUTED 400052bc: 00008067 ret <== NOT EXECUTED =============================================================================== 4000a5fc <_IO_Base64>: } int _IO_Base64(IO_Put_char put_char, void *arg, const void *src, size_t srclen, const char *wordbreak, int wordlen) { 4000a5fc: fd010113 addi sp,sp,-48 4000a600: 02812423 sw s0,40(sp) 4000a604: 02912223 sw s1,36(sp) 4000a608: 01312e23 sw s3,28(sp) 4000a60c: 01512a23 sw s5,20(sp) 4000a610: 01712623 sw s7,12(sp) 4000a614: 01912223 sw s9,4(sp) 4000a618: 00078b93 mv s7,a5 4000a61c: 02112623 sw ra,44(sp) 4000a620: 03212023 sw s2,32(sp) 4000a624: 01412c23 sw s4,24(sp) 4000a628: 01612823 sw s6,16(sp) 4000a62c: 01812423 sw s8,8(sp) 4000a630: 00400793 li a5,4 4000a634: 00050493 mv s1,a0 4000a638: 00058c93 mv s9,a1 4000a63c: 00060413 mv s0,a2 4000a640: 00068993 mv s3,a3 4000a644: 00070a93 mv s5,a4 4000a648: 00fbd463 bge s7,a5,4000a650 <_IO_Base64+0x54> 4000a64c: 00400b93 li s7,4 if (wordlen < 4) { wordlen = 4; } while (srclen > 2) { 4000a650: 00200793 li a5,2 4000a654: 00000a13 li s4,0 4000a658: 0b37fe63 bgeu a5,s3,4000a714 <_IO_Base64+0x118> 4000a65c: 4001c937 lui s2,0x4001c 4000a660: 00000b13 li s6,0 4000a664: 0ac90913 addi s2,s2,172 # 4001c0ac 4000a668: 00200c13 li s8,2 _IO_Put(base64[(in[0]>>2)&0x3f], arg, put_char); 4000a66c: 00044783 lbu a5,0(s0) (*put_char)(c, arg); 4000a670: 000c8593 mv a1,s9 ((in[1]>>4)&0x0f)], arg, put_char); _IO_Put(base64[((in[1]<<2)&0x3c)| ((in[2]>>6)&0x03)], arg, put_char); _IO_Put(base64[in[2]&0x3f], arg, put_char); in += 3; srclen -= 3; 4000a674: ffd98993 addi s3,s3,-3 _IO_Put(base64[(in[0]>>2)&0x3f], arg, put_char); 4000a678: 0027d793 srli a5,a5,0x2 4000a67c: 00f907b3 add a5,s2,a5 (*put_char)(c, arg); 4000a680: 0007c503 lbu a0,0(a5) 4000a684: 000480e7 jalr s1 _IO_Put(base64[((in[0]<<4)&0x30)| 4000a688: 00044783 lbu a5,0(s0) ((in[1]>>4)&0x0f)], arg, put_char); 4000a68c: 00144703 lbu a4,1(s0) (*put_char)(c, arg); 4000a690: 000c8593 mv a1,s9 _IO_Put(base64[((in[0]<<4)&0x30)| 4000a694: 00479793 slli a5,a5,0x4 ((in[1]>>4)&0x0f)], arg, put_char); 4000a698: 00475713 srli a4,a4,0x4 _IO_Put(base64[((in[0]<<4)&0x30)| 4000a69c: 0307f793 andi a5,a5,48 4000a6a0: 00e7e7b3 or a5,a5,a4 4000a6a4: 00f907b3 add a5,s2,a5 (*put_char)(c, arg); 4000a6a8: 0007c503 lbu a0,0(a5) 4000a6ac: 000480e7 jalr s1 _IO_Put(base64[((in[1]<<2)&0x3c)| 4000a6b0: 00144803 lbu a6,1(s0) ((in[2]>>6)&0x03)], arg, put_char); 4000a6b4: 00244783 lbu a5,2(s0) (*put_char)(c, arg); 4000a6b8: 000c8593 mv a1,s9 _IO_Put(base64[((in[1]<<2)&0x3c)| 4000a6bc: 00281813 slli a6,a6,0x2 ((in[2]>>6)&0x03)], arg, put_char); 4000a6c0: 0067d793 srli a5,a5,0x6 _IO_Put(base64[((in[1]<<2)&0x3c)| 4000a6c4: 03c87813 andi a6,a6,60 4000a6c8: 00f86833 or a6,a6,a5 4000a6cc: 01090833 add a6,s2,a6 (*put_char)(c, arg); 4000a6d0: 00084503 lbu a0,0(a6) 4000a6d4: 000480e7 jalr s1 _IO_Put(base64[in[2]&0x3f], arg, put_char); 4000a6d8: 00244783 lbu a5,2(s0) (*put_char)(c, arg); 4000a6dc: 000c8593 mv a1,s9 _IO_Put(base64[in[2]&0x3f], arg, put_char); 4000a6e0: 03f7f793 andi a5,a5,63 4000a6e4: 00f907b3 add a5,s2,a5 (*put_char)(c, arg); 4000a6e8: 0007c503 lbu a0,0(a5) 4000a6ec: 000480e7 jalr s1 out += 4; 4000a6f0: 004a0713 addi a4,s4,4 loops++; if (srclen != 0 && 4000a6f4: 08098e63 beqz s3,4000a790 <_IO_Base64+0x194> (int)((loops + 1) * 4) >= wordlen) 4000a6f8: 002b0793 addi a5,s6,2 4000a6fc: 00279793 slli a5,a5,0x2 if (srclen != 0 && 4000a700: 0d77d463 bge a5,s7,4000a7c8 <_IO_Base64+0x1cc> loops++; 4000a704: 001b0b13 addi s6,s6,1 out += 4; 4000a708: 00070a13 mv s4,a4 in += 3; 4000a70c: 00340413 addi s0,s0,3 while (srclen > 2) { 4000a710: f53c6ee3 bltu s8,s3,4000a66c <_IO_Base64+0x70> ++w; ++out; } } } if (srclen == 2) { 4000a714: 00200793 li a5,2 4000a718: 0ef99463 bne s3,a5,4000a800 <_IO_Base64+0x204> _IO_Put(base64[(in[0]>>2)&0x3f], arg, put_char); 4000a71c: 00044783 lbu a5,0(s0) 4000a720: 4001c937 lui s2,0x4001c 4000a724: 0ac90913 addi s2,s2,172 # 4001c0ac 4000a728: 0027d793 srli a5,a5,0x2 4000a72c: 00f907b3 add a5,s2,a5 (*put_char)(c, arg); 4000a730: 0007c503 lbu a0,0(a5) 4000a734: 000c8593 mv a1,s9 4000a738: 000480e7 jalr s1 _IO_Put(base64[((in[0]<<4)&0x30)| 4000a73c: 00044783 lbu a5,0(s0) ((in[1]>>4)&0x0f)], arg, put_char); 4000a740: 00144703 lbu a4,1(s0) (*put_char)(c, arg); 4000a744: 000c8593 mv a1,s9 _IO_Put(base64[((in[0]<<4)&0x30)| 4000a748: 00479793 slli a5,a5,0x4 ((in[1]>>4)&0x0f)], arg, put_char); 4000a74c: 00475713 srli a4,a4,0x4 _IO_Put(base64[((in[0]<<4)&0x30)| 4000a750: 0307f793 andi a5,a5,48 4000a754: 00e7e7b3 or a5,a5,a4 4000a758: 00f907b3 add a5,s2,a5 (*put_char)(c, arg); 4000a75c: 0007c503 lbu a0,0(a5) 4000a760: 000480e7 jalr s1 _IO_Put(base64[((in[1]<<2)&0x3c)], arg, put_char); 4000a764: 00144783 lbu a5,1(s0) (*put_char)(c, arg); 4000a768: 000c8593 mv a1,s9 _IO_Put(base64[((in[1]<<2)&0x3c)], arg, put_char); 4000a76c: 00279793 slli a5,a5,0x2 4000a770: 03c7f793 andi a5,a5,60 4000a774: 00f90933 add s2,s2,a5 (*put_char)(c, arg); 4000a778: 00094503 lbu a0,0(s2) 4000a77c: 000480e7 jalr s1 4000a780: 000c8593 mv a1,s9 4000a784: 03d00513 li a0,61 4000a788: 000480e7 jalr s1 } else if (srclen == 1) { _IO_Put(base64[(in[0]>>2)&0x3f], arg, put_char); _IO_Put(base64[((in[0]<<4)&0x30)], arg, put_char); _IO_Put('=', arg, put_char); _IO_Put('=', arg, put_char); out += 4; 4000a78c: 004a0713 addi a4,s4,4 } return out; } 4000a790: 02c12083 lw ra,44(sp) 4000a794: 02812403 lw s0,40(sp) 4000a798: 02412483 lw s1,36(sp) 4000a79c: 02012903 lw s2,32(sp) 4000a7a0: 01c12983 lw s3,28(sp) 4000a7a4: 01812a03 lw s4,24(sp) 4000a7a8: 01412a83 lw s5,20(sp) 4000a7ac: 01012b03 lw s6,16(sp) 4000a7b0: 00c12b83 lw s7,12(sp) 4000a7b4: 00812c03 lw s8,8(sp) 4000a7b8: 00412c83 lw s9,4(sp) 4000a7bc: 00070513 mv a0,a4 4000a7c0: 03010113 addi sp,sp,48 4000a7c4: 00008067 ret while (*w != '\0') { 4000a7c8: 000ac503 lbu a0,0(s5) # 80000000 4000a7cc: 08050263 beqz a0,4000a850 <_IO_Base64+0x254> <== NEVER TAKEN 4000a7d0: 000a8b13 mv s6,s5 (*put_char)(c, arg); 4000a7d4: 000c8593 mv a1,s9 ++w; 4000a7d8: 001b0b13 addi s6,s6,1 (*put_char)(c, arg); 4000a7dc: 000480e7 jalr s1 while (*w != '\0') { 4000a7e0: 000b4503 lbu a0,0(s6) 4000a7e4: 004b0793 addi a5,s6,4 4000a7e8: 415787b3 sub a5,a5,s5 4000a7ec: 014787b3 add a5,a5,s4 4000a7f0: fe0512e3 bnez a0,4000a7d4 <_IO_Base64+0x1d8> <== NEVER TAKEN ++out; 4000a7f4: 00078a13 mv s4,a5 loops = 0; 4000a7f8: 00000b13 li s6,0 4000a7fc: f11ff06f j 4000a70c <_IO_Base64+0x110> } else if (srclen == 1) { 4000a800: 00100793 li a5,1 4000a804: 04f99c63 bne s3,a5,4000a85c <_IO_Base64+0x260> _IO_Put(base64[(in[0]>>2)&0x3f], arg, put_char); 4000a808: 00044783 lbu a5,0(s0) 4000a80c: 4001c937 lui s2,0x4001c 4000a810: 0ac90913 addi s2,s2,172 # 4001c0ac 4000a814: 0027d793 srli a5,a5,0x2 4000a818: 00f907b3 add a5,s2,a5 (*put_char)(c, arg); 4000a81c: 0007c503 lbu a0,0(a5) 4000a820: 000c8593 mv a1,s9 4000a824: 000480e7 jalr s1 _IO_Put(base64[((in[0]<<4)&0x30)], arg, put_char); 4000a828: 00044783 lbu a5,0(s0) (*put_char)(c, arg); 4000a82c: 000c8593 mv a1,s9 _IO_Put(base64[((in[0]<<4)&0x30)], arg, put_char); 4000a830: 00479793 slli a5,a5,0x4 4000a834: 0307f793 andi a5,a5,48 4000a838: 00f90933 add s2,s2,a5 (*put_char)(c, arg); 4000a83c: 00094503 lbu a0,0(s2) 4000a840: 000480e7 jalr s1 4000a844: 000c8593 mv a1,s9 4000a848: 03d00513 li a0,61 4000a84c: f31ff06f j 4000a77c <_IO_Base64+0x180> out += 4; 4000a850: 00070a13 mv s4,a4 <== NOT EXECUTED loops = 0; 4000a854: 00000b13 li s6,0 <== NOT EXECUTED 4000a858: eb5ff06f j 4000a70c <_IO_Base64+0x110> <== NOT EXECUTED 4000a85c: 000a0713 mv a4,s4 return out; 4000a860: f31ff06f j 4000a790 <_IO_Base64+0x194> =============================================================================== 400079cc <_IO_Vprintf>: return (p); } int _IO_Vprintf(IO_Put_char put_char, void *arg, char const *fmt, va_list ap) { 400079cc: f6010113 addi sp,sp,-160 400079d0: 08812c23 sw s0,152(sp) 400079d4: 08912a23 sw s1,148(sp) 400079d8: 09512223 sw s5,132(sp) 400079dc: 08112e23 sw ra,156(sp) 400079e0: 09212823 sw s2,144(sp) 400079e4: 09312623 sw s3,140(sp) 400079e8: 09412423 sw s4,136(sp) 400079ec: 09612023 sw s6,128(sp) 400079f0: 07712e23 sw s7,124(sp) 400079f4: 07812c23 sw s8,120(sp) 400079f8: 07912a23 sw s9,116(sp) 400079fc: 07a12823 sw s10,112(sp) 40007a00: 07b12623 sw s11,108(sp) 40007a04: 00050413 mv s0,a0 40007a08: 00058493 mv s1,a1 40007a0c: 00068a93 mv s5,a3 char padc; int stop = 0, retval = 0; num = 0; if (fmt == NULL) 40007a10: 10060663 beqz a2,40007b1c <_IO_Vprintf+0x150> <== NEVER TAKEN fmt = "(fmt null)\n"; for (;;) { padc = ' '; width = 0; while ((ch = (u_char)*fmt++) != '%' || stop) { 40007a14: 00064503 lbu a0,0(a2) 40007a18: 00060913 mv s2,a2 40007a1c: 4001fbb7 lui s7,0x4001f 40007a20: d74b8793 addi a5,s7,-652 # 4001ed74 40007a24: 4001fb37 lui s6,0x4001f 40007a28: 00f12823 sw a5,16(sp) 40007a2c: ed4b0793 addi a5,s6,-300 # 4001eed4 40007a30: 00f12a23 sw a5,20(sp) num = (uintptr_t)va_arg(ap, void *); goto number; case 's': p = va_arg(ap, char *); if (p == NULL) p = "(null)"; 40007a34: 4001f7b7 lui a5,0x4001f 40007a38: d6c78793 addi a5,a5,-660 # 4001ed6c for (n = 0; n < dwidth && p[n]; n++) continue; width -= n; if (!ladjust && width > 0) 40007a3c: 00000c93 li s9,0 40007a40: 00000a13 li s4,0 p = "(null)"; 40007a44: 00f12e23 sw a5,28(sp) while ((ch = (u_char)*fmt++) != '%' || stop) { 40007a48: 00090793 mv a5,s2 40007a4c: 412c8cb3 sub s9,s9,s2 40007a50: 02500913 li s2,37 40007a54: 0180006f j 40007a6c <_IO_Vprintf+0xa0> if (ch == '\0') 40007a58: 08050263 beqz a0,40007adc <_IO_Vprintf+0x110> PCHAR(ch); 40007a5c: 00048593 mv a1,s1 40007a60: 000400e7 jalr s0 while ((ch = (u_char)*fmt++) != '%' || stop) { 40007a64: 000c4503 lbu a0,0(s8) 40007a68: 000c0793 mv a5,s8 40007a6c: 00178c13 addi s8,a5,1 40007a70: 01978d33 add s10,a5,s9 40007a74: 000c0b93 mv s7,s8 40007a78: ff2510e3 bne a0,s2,40007a58 <_IO_Vprintf+0x8c> 40007a7c: fe0a10e3 bnez s4,40007a5c <_IO_Vprintf+0x90> <== NEVER TAKEN reswitch: switch (ch = (u_char)*fmt++) { 40007a80: 0017ce83 lbu t4,1(a5) padc = ' '; 40007a84: 02000713 li a4,32 sign = 0; dot = 0; dwidth = 0; upper = 0; 40007a88: 02012623 sw zero,44(sp) cflag = 0; hflag = 0; jflag = 0; tflag = 0; zflag = 0; 40007a8c: 00012c23 sw zero,24(sp) 40007a90: 00000893 li a7,0 40007a94: 00000313 li t1,0 sign = 0; dot = 0; dwidth = 0; upper = 0; 40007a98: 00000e13 li t3,0 lflag = 0; ladjust = 0; sharpflag = 0; neg = 0; 40007a9c: 02012423 sw zero,40(sp) 40007aa0: 02012223 sw zero,36(sp) width = 0; 40007aa4: 02012023 sw zero,32(sp) cflag = 0; hflag = 0; jflag = 0; tflag = 0; zflag = 0; 40007aa8: 00000513 li a0,0 padc = ' '; 40007aac: 02e12c23 sw a4,56(sp) 40007ab0: 05700613 li a2,87 if (ch < '0' || ch > '9') 40007ab4: 00900593 li a1,9 reswitch: switch (ch = (u_char)*fmt++) { 40007ab8: fdde8693 addi a3,t4,-35 40007abc: 0ff6f693 andi a3,a3,255 40007ac0: 001b8913 addi s2,s7,1 40007ac4: 06d66c63 bltu a2,a3,40007b3c <_IO_Vprintf+0x170> 40007ac8: 01012703 lw a4,16(sp) 40007acc: 00269693 slli a3,a3,0x2 40007ad0: 00e686b3 add a3,a3,a4 40007ad4: 0006a683 lw a3,0(a3) 40007ad8: 00068067 jr a3 stop = 1; break; } } #undef PCHAR } 40007adc: 09c12083 lw ra,156(sp) 40007ae0: 09812403 lw s0,152(sp) 40007ae4: 09412483 lw s1,148(sp) 40007ae8: 09012903 lw s2,144(sp) 40007aec: 08c12983 lw s3,140(sp) 40007af0: 08812a03 lw s4,136(sp) 40007af4: 08412a83 lw s5,132(sp) 40007af8: 08012b03 lw s6,128(sp) 40007afc: 07c12b83 lw s7,124(sp) 40007b00: 07812c03 lw s8,120(sp) 40007b04: 07412c83 lw s9,116(sp) 40007b08: 06c12d83 lw s11,108(sp) 40007b0c: 000d0513 mv a0,s10 40007b10: 07012d03 lw s10,112(sp) 40007b14: 0a010113 addi sp,sp,160 40007b18: 00008067 ret fmt = "(fmt null)\n"; 40007b1c: 4001f937 lui s2,0x4001f <== NOT EXECUTED 40007b20: 02800513 li a0,40 <== NOT EXECUTED 40007b24: d6090913 addi s2,s2,-672 # 4001ed60 <== NOT EXECUTED 40007b28: ef5ff06f j 40007a1c <_IO_Vprintf+0x50> <== NOT EXECUTED reswitch: switch (ch = (u_char)*fmt++) { 40007b2c: 001bce83 lbu t4,1(s7) zflag = 1; 40007b30: 00100513 li a0,1 reswitch: switch (ch = (u_char)*fmt++) { 40007b34: 00090b93 mv s7,s2 goto reswitch; 40007b38: f81ff06f j 40007ab8 <_IO_Vprintf+0xec> while (percent < fmt) 40007b3c: 02500513 li a0,37 40007b40: 0127e863 bltu a5,s2,40007b50 <_IO_Vprintf+0x184> 40007b44: 0d10006f j 40008414 <_IO_Vprintf+0xa48> <== NOT EXECUTED PCHAR(*percent++); 40007b48: 000c4503 lbu a0,0(s8) 40007b4c: 001c0c13 addi s8,s8,1 40007b50: 00048593 mv a1,s1 40007b54: 000400e7 jalr s0 while (percent < fmt) 40007b58: ff8918e3 bne s2,s8,40007b48 <_IO_Vprintf+0x17c> PCHAR(*percent++); 40007b5c: 01990cb3 add s9,s2,s9 stop = 1; 40007b60: 00100a13 li s4,1 while ((ch = (u_char)*fmt++) != '%' || stop) { 40007b64: 001bc503 lbu a0,1(s7) 40007b68: ee1ff06f j 40007a48 <_IO_Vprintf+0x7c> n = n * 10 + ch - '0'; 40007b6c: fd0e8f93 addi t6,t4,-48 ch = *fmt; 40007b70: 001bce83 lbu t4,1(s7) if (ch < '0' || ch > '9') 40007b74: fd0e8693 addi a3,t4,-48 ch = *fmt; 40007b78: 000e8f13 mv t5,t4 if (ch < '0' || ch > '9') 40007b7c: 58d5e263 bltu a1,a3,40008100 <_IO_Vprintf+0x734> reswitch: switch (ch = (u_char)*fmt++) { 40007b80: 00090b93 mv s7,s2 n = n * 10 + ch - '0'; 40007b84: 002f9693 slli a3,t6,0x2 40007b88: 01f686b3 add a3,a3,t6 for (n = 0;; ++fmt) { 40007b8c: 001b8b93 addi s7,s7,1 n = n * 10 + ch - '0'; 40007b90: 00169693 slli a3,a3,0x1 40007b94: 01e686b3 add a3,a3,t5 ch = *fmt; 40007b98: 000bcf03 lbu t5,0(s7) n = n * 10 + ch - '0'; 40007b9c: fd068f93 addi t6,a3,-48 if (ch < '0' || ch > '9') 40007ba0: fd0f0693 addi a3,t5,-48 ch = *fmt; 40007ba4: 000f0e93 mv t4,t5 if (ch < '0' || ch > '9') 40007ba8: fcd5fee3 bgeu a1,a3,40007b84 <_IO_Vprintf+0x1b8> if (dot) 40007bac: 680e1063 bnez t3,4000822c <_IO_Vprintf+0x860> 40007bb0: 03f12023 sw t6,32(sp) 40007bb4: f05ff06f j 40007ab8 <_IO_Vprintf+0xec> base = 10; 40007bb8: 00a00793 li a5,10 reswitch: switch (ch = (u_char)*fmt++) { 40007bbc: 00a00c13 li s8,10 40007bc0: 00012623 sw zero,12(sp) base = 10; 40007bc4: 02f12e23 sw a5,60(sp) if (jflag) 40007bc8: 01812783 lw a5,24(sp) 40007bcc: 60078463 beqz a5,400081d4 <_IO_Vprintf+0x808> num = va_arg(ap, intmax_t); 40007bd0: 007a8a93 addi s5,s5,7 40007bd4: ff8afa93 andi s5,s5,-8 40007bd8: 000aa583 lw a1,0(s5) 40007bdc: 004aa683 lw a3,4(s5) 40007be0: 008a8a93 addi s5,s5,8 40007be4: 02b12823 sw a1,48(sp) 40007be8: 02d12a23 sw a3,52(sp) lflag = 0; ladjust = 0; sharpflag = 0; neg = 0; 40007bec: 00012c23 sw zero,24(sp) 40007bf0: 00000793 li a5,0 if (sign && (intmax_t)num < 0) { 40007bf4: 0206d263 bgez a3,40007c18 <_IO_Vprintf+0x24c> num = -(intmax_t)num; 40007bf8: 40b00733 neg a4,a1 40007bfc: 00b03533 snez a0,a1 40007c00: 40d006b3 neg a3,a3 40007c04: 02e12823 sw a4,48(sp) 40007c08: 40a68733 sub a4,a3,a0 40007c0c: 02e12a23 sw a4,52(sp) neg = 1; 40007c10: 00100713 li a4,1 40007c14: 00e12c23 sw a4,24(sp) *++p = hex2ascii_data[upper][num % base]; 40007c18: 01412703 lw a4,20(sp) 40007c1c: 00479793 slli a5,a5,0x4 *p = '\0'; 40007c20: 03012c83 lw s9,48(sp) 40007c24: 03412d83 lw s11,52(sp) *++p = hex2ascii_data[upper][num % base]; 40007c28: 00f707b3 add a5,a4,a5 *p = '\0'; 40007c2c: 04010423 sb zero,72(sp) p = nbuf; 40007c30: 04810993 addi s3,sp,72 *++p = hex2ascii_data[upper][num % base]; 40007c34: 00f12423 sw a5,8(sp) 40007c38: 000c0613 mv a2,s8 40007c3c: 00000693 li a3,0 40007c40: 000c8513 mv a0,s9 40007c44: 000d8593 mv a1,s11 40007c48: 20c0c0ef jal ra,40013e54 <__umoddi3> 40007c4c: 00812783 lw a5,8(sp) } while (num /= base); 40007c50: 000d8593 mv a1,s11 40007c54: 00000693 li a3,0 *++p = hex2ascii_data[upper][num % base]; 40007c58: 00a78533 add a0,a5,a0 40007c5c: 00054b03 lbu s6,0(a0) } while (num /= base); 40007c60: 000c0613 mv a2,s8 40007c64: 000c8513 mv a0,s9 *++p = hex2ascii_data[upper][num % base]; 40007c68: 016980a3 sb s6,1(s3) } while (num /= base); 40007c6c: 5490b0ef jal ra,400139b4 <__udivdi3> 40007c70: 00c12783 lw a5,12(sp) 40007c74: 000d8693 mv a3,s11 40007c78: 000c8e13 mv t3,s9 *++p = hex2ascii_data[upper][num % base]; 40007c7c: 00198993 addi s3,s3,1 } while (num /= base); 40007c80: 00058d93 mv s11,a1 40007c84: 00050c93 mv s9,a0 40007c88: fad798e3 bne a5,a3,40007c38 <_IO_Vprintf+0x26c> 40007c8c: fb8e76e3 bgeu t3,s8,40007c38 <_IO_Vprintf+0x26c> *lenp = p - nbuf; 40007c90: 04810793 addi a5,sp,72 40007c94: 40f98633 sub a2,s3,a5 if (sharpflag && num != 0) { 40007c98: 02812783 lw a5,40(sp) tmp = 0; 40007c9c: 00000693 li a3,0 if (sharpflag && num != 0) { 40007ca0: 02078863 beqz a5,40007cd0 <_IO_Vprintf+0x304> 40007ca4: 03012703 lw a4,48(sp) 40007ca8: 03412583 lw a1,52(sp) 40007cac: 00b765b3 or a1,a4,a1 40007cb0: 02058063 beqz a1,40007cd0 <_IO_Vprintf+0x304> tmp++; 40007cb4: 00078693 mv a3,a5 if (base == 8) 40007cb8: 03c12783 lw a5,60(sp) 40007cbc: 00800593 li a1,8 40007cc0: 00b78863 beq a5,a1,40007cd0 <_IO_Vprintf+0x304> tmp = 0; 40007cc4: ff078693 addi a3,a5,-16 40007cc8: 0016b693 seqz a3,a3 40007ccc: 00169693 slli a3,a3,0x1 tmp++; 40007cd0: 01812783 lw a5,24(sp) 40007cd4: 00f035b3 snez a1,a5 if (!ladjust && padc == '0') 40007cd8: 02412783 lw a5,36(sp) tmp++; 40007cdc: 00b686b3 add a3,a3,a1 if (!ladjust && padc == '0') 40007ce0: 42079463 bnez a5,40008108 <_IO_Vprintf+0x73c> 40007ce4: 03812783 lw a5,56(sp) 40007ce8: 03000593 li a1,48 40007cec: 00b79863 bne a5,a1,40007cfc <_IO_Vprintf+0x330> dwidth = width - tmp; 40007cf0: 02012783 lw a5,32(sp) 40007cf4: 40d787b3 sub a5,a5,a3 40007cf8: 02f12623 sw a5,44(sp) static inline int imax(int a, int b) { return (a > b ? a : b); } 40007cfc: 02c12783 lw a5,44(sp) 40007d00: 00060593 mv a1,a2 40007d04: 00f65463 bge a2,a5,40007d0c <_IO_Vprintf+0x340> 40007d08: 00078593 mv a1,a5 width -= tmp + imax(dwidth, n); 40007d0c: 02012783 lw a5,32(sp) 40007d10: 00d586b3 add a3,a1,a3 while (width-- > 0) 40007d14: fff00c93 li s9,-1 width -= tmp + imax(dwidth, n); 40007d18: 40d786b3 sub a3,a5,a3 dwidth -= n; 40007d1c: 02c12783 lw a5,44(sp) while (width-- > 0) 40007d20: fff68c13 addi s8,a3,-1 40007d24: 01812423 sw s8,8(sp) dwidth -= n; 40007d28: 40c787b3 sub a5,a5,a2 40007d2c: 00078d93 mv s11,a5 while (width-- > 0) 40007d30: 02d05263 blez a3,40007d54 <_IO_Vprintf+0x388> 40007d34: fffc0c13 addi s8,s8,-1 PCHAR(' '); 40007d38: 00048593 mv a1,s1 40007d3c: 02000513 li a0,32 40007d40: 000400e7 jalr s0 while (width-- > 0) 40007d44: ff9c18e3 bne s8,s9,40007d34 <_IO_Vprintf+0x368> PCHAR(' '); 40007d48: 00812783 lw a5,8(sp) 40007d4c: 001d0713 addi a4,s10,1 40007d50: 00f70d33 add s10,a4,a5 if (neg) 40007d54: 01812783 lw a5,24(sp) 40007d58: 00078a63 beqz a5,40007d6c <_IO_Vprintf+0x3a0> PCHAR('-'); 40007d5c: 00048593 mv a1,s1 40007d60: 02d00513 li a0,45 40007d64: 000400e7 jalr s0 40007d68: 001d0d13 addi s10,s10,1 if (sharpflag && num != 0) { 40007d6c: 02812783 lw a5,40(sp) 40007d70: 04078463 beqz a5,40007db8 <_IO_Vprintf+0x3ec> 40007d74: 03012783 lw a5,48(sp) 40007d78: 03412703 lw a4,52(sp) 40007d7c: 00e7e6b3 or a3,a5,a4 40007d80: 02068c63 beqz a3,40007db8 <_IO_Vprintf+0x3ec> if (base == 8) { 40007d84: 03c12783 lw a5,60(sp) 40007d88: 00800693 li a3,8 40007d8c: 48d78663 beq a5,a3,40008218 <_IO_Vprintf+0x84c> } else if (base == 16) { 40007d90: 03c12783 lw a5,60(sp) 40007d94: 01000693 li a3,16 40007d98: 02d79063 bne a5,a3,40007db8 <_IO_Vprintf+0x3ec> PCHAR('0'); 40007d9c: 03000513 li a0,48 40007da0: 00048593 mv a1,s1 40007da4: 000400e7 jalr s0 PCHAR('x'); 40007da8: 00048593 mv a1,s1 40007dac: 07800513 li a0,120 40007db0: 000400e7 jalr s0 40007db4: 002d0d13 addi s10,s10,2 while (dwidth-- > 0) 40007db8: fffd8793 addi a5,s11,-1 40007dbc: 000d8713 mv a4,s11 40007dc0: 00f12423 sw a5,8(sp) 40007dc4: 00078d93 mv s11,a5 40007dc8: fff00c93 li s9,-1 40007dcc: 02e05263 blez a4,40007df0 <_IO_Vprintf+0x424> 40007dd0: fffd8d93 addi s11,s11,-1 PCHAR('0'); 40007dd4: 00048593 mv a1,s1 40007dd8: 03000513 li a0,48 40007ddc: 000400e7 jalr s0 while (dwidth-- > 0) 40007de0: ff9d98e3 bne s11,s9,40007dd0 <_IO_Vprintf+0x404> PCHAR('0'); 40007de4: 00812783 lw a5,8(sp) 40007de8: 001d0713 addi a4,s10,1 40007dec: 00e78d33 add s10,a5,a4 while (*p) 40007df0: 400b0463 beqz s6,400081f8 <_IO_Vprintf+0x82c> <== NEVER TAKEN *++p = hex2ascii_data[upper][num % base]; 40007df4: 00098d93 mv s11,s3 PCHAR(*p--); 40007df8: fffd8d93 addi s11,s11,-1 40007dfc: 000b0513 mv a0,s6 40007e00: 00048593 mv a1,s1 40007e04: 000400e7 jalr s0 while (*p) 40007e08: 000dcb03 lbu s6,0(s11) 40007e0c: 41b98cb3 sub s9,s3,s11 40007e10: 01ac8cb3 add s9,s9,s10 40007e14: fe0b12e3 bnez s6,40007df8 <_IO_Vprintf+0x42c> if (ladjust) 40007e18: 02412783 lw a5,36(sp) 40007e1c: 36079863 bnez a5,4000818c <_IO_Vprintf+0x7c0> while ((ch = (u_char)*fmt++) != '%' || stop) { 40007e20: 001bc503 lbu a0,1(s7) 40007e24: 00000a13 li s4,0 40007e28: c21ff06f j 40007a48 <_IO_Vprintf+0x7c> if (!dot) { 40007e2c: 520e1463 bnez t3,40008354 <_IO_Vprintf+0x988> <== NEVER TAKEN padc = '0'; 40007e30: 03d12c23 sw t4,56(sp) reswitch: switch (ch = (u_char)*fmt++) { 40007e34: 001bce83 lbu t4,1(s7) 40007e38: 00090b93 mv s7,s2 40007e3c: c7dff06f j 40007ab8 <_IO_Vprintf+0xec> 40007e40: 001bce83 lbu t4,1(s7) if (hflag) { 40007e44: 48089863 bnez a7,400082d4 <_IO_Vprintf+0x908> hflag = 1; 40007e48: 00100893 li a7,1 reswitch: switch (ch = (u_char)*fmt++) { 40007e4c: 00090b93 mv s7,s2 40007e50: c69ff06f j 40007ab8 <_IO_Vprintf+0xec> jflag = 1; 40007e54: 00100713 li a4,1 reswitch: switch (ch = (u_char)*fmt++) { 40007e58: 001bce83 lbu t4,1(s7) jflag = 1; 40007e5c: 00e12c23 sw a4,24(sp) reswitch: switch (ch = (u_char)*fmt++) { 40007e60: 00090b93 mv s7,s2 goto reswitch; 40007e64: c55ff06f j 40007ab8 <_IO_Vprintf+0xec> if (lflag) { 40007e68: cc0502e3 beqz a0,40007b2c <_IO_Vprintf+0x160> reswitch: switch (ch = (u_char)*fmt++) { 40007e6c: 001bce83 lbu t4,1(s7) jflag = 1; 40007e70: 00a12c23 sw a0,24(sp) reswitch: switch (ch = (u_char)*fmt++) { 40007e74: 00090b93 mv s7,s2 40007e78: c41ff06f j 40007ab8 <_IO_Vprintf+0xec> base = 8; 40007e7c: 00800713 li a4,8 sign = 0; dot = 0; dwidth = 0; upper = 0; 40007e80: 00000793 li a5,0 reswitch: switch (ch = (u_char)*fmt++) { 40007e84: 00800c13 li s8,8 40007e88: 00012623 sw zero,12(sp) base = 8; 40007e8c: 02e12e23 sw a4,60(sp) if (jflag) 40007e90: 01812703 lw a4,24(sp) 40007e94: 2c070c63 beqz a4,4000816c <_IO_Vprintf+0x7a0> num = va_arg(ap, uintmax_t); 40007e98: 007a8a93 addi s5,s5,7 40007e9c: ff8afa93 andi s5,s5,-8 40007ea0: 000aa703 lw a4,0(s5) lflag = 0; ladjust = 0; sharpflag = 0; neg = 0; 40007ea4: 00012c23 sw zero,24(sp) num = va_arg(ap, uintmax_t); 40007ea8: 008a8a93 addi s5,s5,8 40007eac: 02e12823 sw a4,48(sp) 40007eb0: ffcaa703 lw a4,-4(s5) 40007eb4: 02e12a23 sw a4,52(sp) 40007eb8: d61ff06f j 40007c18 <_IO_Vprintf+0x24c> num = (uintptr_t)va_arg(ap, void *); 40007ebc: 000aa783 lw a5,0(s5) base = 16; 40007ec0: 01000713 li a4,16 num = (uintptr_t)va_arg(ap, void *); 40007ec4: 02012a23 sw zero,52(sp) 40007ec8: 02f12823 sw a5,48(sp) sharpflag = (width == 0); 40007ecc: 02012783 lw a5,32(sp) num = (uintptr_t)va_arg(ap, void *); 40007ed0: 004a8a93 addi s5,s5,4 lflag = 0; ladjust = 0; sharpflag = 0; neg = 0; 40007ed4: 00012c23 sw zero,24(sp) sharpflag = (width == 0); 40007ed8: 0017b793 seqz a5,a5 40007edc: 02f12423 sw a5,40(sp) num = (uintptr_t)va_arg(ap, void *); 40007ee0: 01000c13 li s8,16 sign = 0; dot = 0; dwidth = 0; upper = 0; 40007ee4: 00000793 li a5,0 num = (uintptr_t)va_arg(ap, void *); 40007ee8: 00012623 sw zero,12(sp) base = 16; 40007eec: 02e12e23 sw a4,60(sp) 40007ef0: d29ff06f j 40007c18 <_IO_Vprintf+0x24c> p = va_arg(ap, char *); 40007ef4: 000aa983 lw s3,0(s5) 40007ef8: 004a8b13 addi s6,s5,4 if (p == NULL) 40007efc: 08098063 beqz s3,40007f7c <_IO_Vprintf+0x5b0> if (!dot) 40007f00: 360e1e63 bnez t3,4000827c <_IO_Vprintf+0x8b0> n = strlen (p); 40007f04: 00098513 mv a0,s3 40007f08: 68c0d0ef jal ra,40015594 40007f0c: 00050c93 mv s9,a0 width -= n; 40007f10: 02012783 lw a5,32(sp) 40007f14: 419787b3 sub a5,a5,s9 40007f18: 02f12023 sw a5,32(sp) if (!ladjust && width > 0) 40007f1c: 02412783 lw a5,36(sp) 40007f20: 30079a63 bnez a5,40008234 <_IO_Vprintf+0x868> 40007f24: 02012783 lw a5,32(sp) 40007f28: 4af04663 bgtz a5,400083d4 <_IO_Vprintf+0xa08> while (n--) 40007f2c: fffc8a93 addi s5,s9,-1 40007f30: 4e0c8a63 beqz s9,40008424 <_IO_Vprintf+0xa58> for (n = 0; n < dwidth && p[n]; n++) 40007f34: 00098d93 mv s11,s3 while (n--) 40007f38: 00100c13 li s8,1 PCHAR(*p++); 40007f3c: 000dc503 lbu a0,0(s11) 40007f40: 00048593 mv a1,s1 40007f44: 001d8d93 addi s11,s11,1 40007f48: 000400e7 jalr s0 while (n--) 40007f4c: 41bc07b3 sub a5,s8,s11 40007f50: 00f987b3 add a5,s3,a5 40007f54: 015787b3 add a5,a5,s5 40007f58: fe0792e3 bnez a5,40007f3c <_IO_Vprintf+0x570> if (ladjust && width > 0) 40007f5c: 02412783 lw a5,36(sp) 40007f60: 001d0713 addi a4,s10,1 PCHAR(*p++); 40007f64: 00ea8cb3 add s9,s5,a4 if (ladjust && width > 0) 40007f68: 2c079a63 bnez a5,4000823c <_IO_Vprintf+0x870> while ((ch = (u_char)*fmt++) != '%' || stop) { 40007f6c: 001bc503 lbu a0,1(s7) p = va_arg(ap, char *); 40007f70: 000b0a93 mv s5,s6 40007f74: 00000a13 li s4,0 40007f78: ad1ff06f j 40007a48 <_IO_Vprintf+0x7c> p = "(null)"; 40007f7c: 01c12983 lw s3,28(sp) 40007f80: f81ff06f j 40007f00 <_IO_Vprintf+0x534> ladjust = 1; 40007f84: 00100713 li a4,1 reswitch: switch (ch = (u_char)*fmt++) { 40007f88: 001bce83 lbu t4,1(s7) ladjust = 1; 40007f8c: 02e12223 sw a4,36(sp) reswitch: switch (ch = (u_char)*fmt++) { 40007f90: 00090b93 mv s7,s2 goto reswitch; 40007f94: b25ff06f j 40007ab8 <_IO_Vprintf+0xec> reswitch: switch (ch = (u_char)*fmt++) { 40007f98: 001bce83 lbu t4,1(s7) dot = 1; 40007f9c: 00100e13 li t3,1 reswitch: switch (ch = (u_char)*fmt++) { 40007fa0: 00090b93 mv s7,s2 40007fa4: b15ff06f j 40007ab8 <_IO_Vprintf+0xec> sharpflag = 1; 40007fa8: 00100713 li a4,1 <== NOT EXECUTED reswitch: switch (ch = (u_char)*fmt++) { 40007fac: 001bce83 lbu t4,1(s7) <== NOT EXECUTED sharpflag = 1; 40007fb0: 02e12423 sw a4,40(sp) <== NOT EXECUTED reswitch: switch (ch = (u_char)*fmt++) { 40007fb4: 00090b93 mv s7,s2 <== NOT EXECUTED goto reswitch; 40007fb8: b01ff06f j 40007ab8 <_IO_Vprintf+0xec> <== NOT EXECUTED PCHAR(ch); 40007fbc: 02500513 li a0,37 40007fc0: 00048593 mv a1,s1 40007fc4: 000400e7 jalr s0 while ((ch = (u_char)*fmt++) != '%' || stop) { 40007fc8: 001bc503 lbu a0,1(s7) PCHAR(ch); 40007fcc: 001d0c93 addi s9,s10,1 break; 40007fd0: a79ff06f j 40007a48 <_IO_Vprintf+0x7c> width = va_arg(ap, int); 40007fd4: 000aa703 lw a4,0(s5) 40007fd8: 004a8693 addi a3,s5,4 if (!dot) { 40007fdc: 340e1a63 bnez t3,40008330 <_IO_Vprintf+0x964> <== ALWAYS TAKEN width = va_arg(ap, int); 40007fe0: 02e12023 sw a4,32(sp) <== NOT EXECUTED if (width < 0) { 40007fe4: 3a074c63 bltz a4,4000839c <_IO_Vprintf+0x9d0> <== NOT EXECUTED reswitch: switch (ch = (u_char)*fmt++) { 40007fe8: 001bce83 lbu t4,1(s7) dwidth = va_arg(ap, int); 40007fec: 00068a93 mv s5,a3 reswitch: switch (ch = (u_char)*fmt++) { 40007ff0: 00090b93 mv s7,s2 40007ff4: ac5ff06f j 40007ab8 <_IO_Vprintf+0xec> width -= 1; 40007ff8: 02012783 lw a5,32(sp) width = va_arg(ap, int); 40007ffc: 004a8c13 addi s8,s5,4 PCHAR(ch); 40008000: 001d0c93 addi s9,s10,1 width -= 1; 40008004: fff78993 addi s3,a5,-1 if (!ladjust && width > 0) 40008008: 02412783 lw a5,36(sp) 4000800c: 2c079c63 bnez a5,400082e4 <_IO_Vprintf+0x918> <== NEVER TAKEN 40008010: 35304e63 bgtz s3,4000836c <_IO_Vprintf+0x9a0> <== NEVER TAKEN PCHAR(va_arg(ap, int)); 40008014: 000aa503 lw a0,0(s5) 40008018: 00048593 mv a1,s1 4000801c: 000c0a93 mv s5,s8 40008020: 000400e7 jalr s0 while ((ch = (u_char)*fmt++) != '%' || stop) { 40008024: 001bc503 lbu a0,1(s7) PCHAR(va_arg(ap, int)); 40008028: 00000a13 li s4,0 4000802c: a1dff06f j 40007a48 <_IO_Vprintf+0x7c> if (!width) 40008030: 02012783 lw a5,32(sp) <== NOT EXECUTED up = va_arg(ap, u_char *); 40008034: 000aac03 lw s8,0(s5) <== NOT EXECUTED p = va_arg(ap, char *); 40008038: 004aab03 lw s6,4(s5) <== NOT EXECUTED 4000803c: 008a8993 addi s3,s5,8 <== NOT EXECUTED while(width--) { 40008040: 00f00d93 li s11,15 <== NOT EXECUTED if (!width) 40008044: 00078463 beqz a5,4000804c <_IO_Vprintf+0x680> <== NOT EXECUTED while(width--) { 40008048: fff78d93 addi s11,a5,-1 <== NOT EXECUTED 4000804c: 00300793 li a5,3 <== NOT EXECUTED 40008050: 416787b3 sub a5,a5,s6 <== NOT EXECUTED 40008054: 01bc0db3 add s11,s8,s11 <== NOT EXECUTED 40008058: 00f12423 sw a5,8(sp) <== NOT EXECUTED PCHAR(hex2ascii(*up >> 4)); 4000805c: 000c4783 lbu a5,0(s8) <== NOT EXECUTED return (hex2ascii_data[0][hex]); 40008060: 01412a83 lw s5,20(sp) <== NOT EXECUTED PCHAR(hex2ascii(*up >> 4)); 40008064: 00048593 mv a1,s1 <== NOT EXECUTED 40008068: 0047d793 srli a5,a5,0x4 <== NOT EXECUTED return (hex2ascii_data[0][hex]); 4000806c: 00fa87b3 add a5,s5,a5 <== NOT EXECUTED PCHAR(hex2ascii(*up >> 4)); 40008070: 0007c503 lbu a0,0(a5) <== NOT EXECUTED PCHAR(hex2ascii(*up & 0x0f)); 40008074: 002d0c93 addi s9,s10,2 <== NOT EXECUTED PCHAR(hex2ascii(*up >> 4)); 40008078: 000400e7 jalr s0 <== NOT EXECUTED PCHAR(hex2ascii(*up & 0x0f)); 4000807c: 000c4783 lbu a5,0(s8) <== NOT EXECUTED 40008080: 00048593 mv a1,s1 <== NOT EXECUTED 40008084: 00f7f793 andi a5,a5,15 <== NOT EXECUTED return (hex2ascii_data[0][hex]); 40008088: 00fa87b3 add a5,s5,a5 <== NOT EXECUTED PCHAR(hex2ascii(*up & 0x0f)); 4000808c: 0007c503 lbu a0,0(a5) <== NOT EXECUTED 40008090: 000400e7 jalr s0 <== NOT EXECUTED if (width) 40008094: 0bbc1063 bne s8,s11,40008134 <_IO_Vprintf+0x768> <== NOT EXECUTED while ((ch = (u_char)*fmt++) != '%' || stop) { 40008098: 001bc503 lbu a0,1(s7) <== NOT EXECUTED p = va_arg(ap, char *); 4000809c: 00098a93 mv s5,s3 <== NOT EXECUTED 400080a0: 9a9ff06f j 40007a48 <_IO_Vprintf+0x7c> <== NOT EXECUTED base = 16; 400080a4: 01000713 li a4,16 reswitch: switch (ch = (u_char)*fmt++) { 400080a8: 01000c13 li s8,16 400080ac: 00012623 sw zero,12(sp) upper = 1; 400080b0: 00100793 li a5,1 base = 16; 400080b4: 02e12e23 sw a4,60(sp) 400080b8: dd9ff06f j 40007e90 <_IO_Vprintf+0x4c4> base = 10; 400080bc: 00a00713 li a4,10 sign = 0; dot = 0; dwidth = 0; upper = 0; 400080c0: 00000793 li a5,0 reswitch: switch (ch = (u_char)*fmt++) { 400080c4: 00a00c13 li s8,10 400080c8: 00012623 sw zero,12(sp) base = 10; 400080cc: 02e12e23 sw a4,60(sp) 400080d0: dc1ff06f j 40007e90 <_IO_Vprintf+0x4c4> reswitch: switch (ch = (u_char)*fmt++) { 400080d4: 01000793 li a5,16 <== NOT EXECUTED 400080d8: 01000c13 li s8,16 <== NOT EXECUTED 400080dc: 00012623 sw zero,12(sp) <== NOT EXECUTED 400080e0: 02f12e23 sw a5,60(sp) <== NOT EXECUTED 400080e4: ae5ff06f j 40007bc8 <_IO_Vprintf+0x1fc> <== NOT EXECUTED 400080e8: 01000713 li a4,16 400080ec: 00000793 li a5,0 400080f0: 01000c13 li s8,16 400080f4: 00012623 sw zero,12(sp) 400080f8: 02e12e23 sw a4,60(sp) 400080fc: d95ff06f j 40007e90 <_IO_Vprintf+0x4c4> 40008100: 00090b93 mv s7,s2 40008104: aa9ff06f j 40007bac <_IO_Vprintf+0x1e0> static inline int imax(int a, int b) { return (a > b ? a : b); } 40008108: 02c12783 lw a5,44(sp) 4000810c: 00078593 mv a1,a5 40008110: 00c7d463 bge a5,a2,40008118 <_IO_Vprintf+0x74c> 40008114: 00060593 mv a1,a2 width -= tmp + imax(dwidth, n); 40008118: 02012783 lw a5,32(sp) 4000811c: 00d586b3 add a3,a1,a3 40008120: 40d78c33 sub s8,a5,a3 dwidth -= n; 40008124: 02c12783 lw a5,44(sp) 40008128: 40c787b3 sub a5,a5,a2 4000812c: 00078d93 mv s11,a5 if (!ladjust) 40008130: c25ff06f j 40007d54 <_IO_Vprintf+0x388> for (q=p;*q;q++) 40008134: 000b4503 lbu a0,0(s6) <== NOT EXECUTED 40008138: 02050463 beqz a0,40008160 <_IO_Vprintf+0x794> <== NOT EXECUTED 4000813c: 00812783 lw a5,8(sp) <== NOT EXECUTED 40008140: 000b0a93 mv s5,s6 <== NOT EXECUTED 40008144: 01a78d33 add s10,a5,s10 <== NOT EXECUTED PCHAR(*q); 40008148: 00048593 mv a1,s1 <== NOT EXECUTED 4000814c: 01aa8cb3 add s9,s5,s10 <== NOT EXECUTED 40008150: 000400e7 jalr s0 <== NOT EXECUTED for (q=p;*q;q++) 40008154: 001ac503 lbu a0,1(s5) <== NOT EXECUTED 40008158: 001a8a93 addi s5,s5,1 <== NOT EXECUTED 4000815c: fe0516e3 bnez a0,40008148 <_IO_Vprintf+0x77c> <== NOT EXECUTED up++; 40008160: 001c0c13 addi s8,s8,1 <== NOT EXECUTED 40008164: 000c8d13 mv s10,s9 <== NOT EXECUTED 40008168: ef5ff06f j 4000805c <_IO_Vprintf+0x690> <== NOT EXECUTED width = va_arg(ap, int); 4000816c: 004a8693 addi a3,s5,4 else if (lflag) 40008170: 04051863 bnez a0,400081c0 <_IO_Vprintf+0x7f4> else if (hflag) 40008174: 14088463 beqz a7,400082bc <_IO_Vprintf+0x8f0> <== ALWAYS TAKEN num = (u_short)va_arg(ap, int); 40008178: 000ad703 lhu a4,0(s5) <== NOT EXECUTED 4000817c: 02012a23 sw zero,52(sp) <== NOT EXECUTED 40008180: 00068a93 mv s5,a3 <== NOT EXECUTED 40008184: 02e12823 sw a4,48(sp) <== NOT EXECUTED 40008188: a91ff06f j 40007c18 <_IO_Vprintf+0x24c> <== NOT EXECUTED while (width-- > 0) 4000818c: fffc0d93 addi s11,s8,-1 40008190: 9d805ae3 blez s8,40007b64 <_IO_Vprintf+0x198> 40008194: 000d8993 mv s3,s11 40008198: fff00c13 li s8,-1 4000819c: fff98993 addi s3,s3,-1 PCHAR(' '); 400081a0: 00048593 mv a1,s1 400081a4: 02000513 li a0,32 400081a8: 000400e7 jalr s0 while (width-- > 0) 400081ac: ff8998e3 bne s3,s8,4000819c <_IO_Vprintf+0x7d0> 400081b0: 001c8993 addi s3,s9,1 while ((ch = (u_char)*fmt++) != '%' || stop) { 400081b4: 001bc503 lbu a0,1(s7) PCHAR(' '); 400081b8: 013d8cb3 add s9,s11,s3 400081bc: 88dff06f j 40007a48 <_IO_Vprintf+0x7c> num = va_arg(ap, u_int); 400081c0: 000aa703 lw a4,0(s5) 400081c4: 02012a23 sw zero,52(sp) 400081c8: 00068a93 mv s5,a3 400081cc: 02e12823 sw a4,48(sp) 400081d0: a49ff06f j 40007c18 <_IO_Vprintf+0x24c> width = va_arg(ap, int); 400081d4: 004a8793 addi a5,s5,4 else if (tflag) 400081d8: 02051463 bnez a0,40008200 <_IO_Vprintf+0x834> else if (hflag) 400081dc: 14088e63 beqz a7,40008338 <_IO_Vprintf+0x96c> <== ALWAYS TAKEN num = (short)va_arg(ap, int); 400081e0: 000a9583 lh a1,0(s5) <== NOT EXECUTED 400081e4: 00078a93 mv s5,a5 <== NOT EXECUTED 400081e8: 41f5d693 srai a3,a1,0x1f <== NOT EXECUTED 400081ec: 02b12823 sw a1,48(sp) <== NOT EXECUTED 400081f0: 02d12a23 sw a3,52(sp) <== NOT EXECUTED if (sign && (intmax_t)num < 0) { 400081f4: 9f9ff06f j 40007bec <_IO_Vprintf+0x220> <== NOT EXECUTED while (*p) 400081f8: 000d0c93 mv s9,s10 <== NOT EXECUTED 400081fc: c1dff06f j 40007e18 <_IO_Vprintf+0x44c> <== NOT EXECUTED num = va_arg(ap, int); 40008200: 000aa583 lw a1,0(s5) 40008204: 00078a93 mv s5,a5 40008208: 41f5d693 srai a3,a1,0x1f 4000820c: 02b12823 sw a1,48(sp) 40008210: 02d12a23 sw a3,52(sp) if (sign && (intmax_t)num < 0) { 40008214: 9d9ff06f j 40007bec <_IO_Vprintf+0x220> PCHAR('0'); 40008218: 00048593 mv a1,s1 <== NOT EXECUTED 4000821c: 03000513 li a0,48 <== NOT EXECUTED 40008220: 000400e7 jalr s0 <== NOT EXECUTED 40008224: 001d0d13 addi s10,s10,1 <== NOT EXECUTED 40008228: b91ff06f j 40007db8 <_IO_Vprintf+0x3ec> <== NOT EXECUTED 4000822c: 03f12623 sw t6,44(sp) 40008230: 889ff06f j 40007ab8 <_IO_Vprintf+0xec> while (n--) 40008234: 080c9063 bnez s9,400082b4 <_IO_Vprintf+0x8e8> <== ALWAYS TAKEN 40008238: 000d0c93 mv s9,s10 <== NOT EXECUTED if (ladjust && width > 0) 4000823c: 02012783 lw a5,32(sp) p = va_arg(ap, char *); 40008240: 000b0a93 mv s5,s6 if (ladjust && width > 0) 40008244: 92f050e3 blez a5,40007b64 <_IO_Vprintf+0x198> while (width--) 40008248: fff78c13 addi s8,a5,-1 4000824c: 000c0993 mv s3,s8 40008250: fff00a93 li s5,-1 PCHAR(padc); 40008254: 03812503 lw a0,56(sp) while (width--) 40008258: fff98993 addi s3,s3,-1 PCHAR(padc); 4000825c: 00048593 mv a1,s1 40008260: 000400e7 jalr s0 while (width--) 40008264: ff5998e3 bne s3,s5,40008254 <_IO_Vprintf+0x888> 40008268: 001c8993 addi s3,s9,1 while ((ch = (u_char)*fmt++) != '%' || stop) { 4000826c: 001bc503 lbu a0,1(s7) PCHAR(padc); 40008270: 013c0cb3 add s9,s8,s3 p = va_arg(ap, char *); 40008274: 000b0a93 mv s5,s6 40008278: fd0ff06f j 40007a48 <_IO_Vprintf+0x7c> for (n = 0; n < dwidth && p[n]; n++) 4000827c: 02c12783 lw a5,44(sp) 40008280: 00000c93 li s9,0 40008284: 14f05063 blez a5,400083c4 <_IO_Vprintf+0x9f8> <== NEVER TAKEN 40008288: 019986b3 add a3,s3,s9 4000828c: 0006c683 lbu a3,0(a3) 40008290: c80680e3 beqz a3,40007f10 <_IO_Vprintf+0x544> 40008294: 02c12783 lw a5,44(sp) 40008298: 001c8c93 addi s9,s9,1 4000829c: fefc96e3 bne s9,a5,40008288 <_IO_Vprintf+0x8bc> width -= n; 400082a0: 02012783 lw a5,32(sp) 400082a4: 419787b3 sub a5,a5,s9 400082a8: 02f12023 sw a5,32(sp) if (!ladjust && width > 0) 400082ac: 02412783 lw a5,36(sp) 400082b0: c6078ae3 beqz a5,40007f24 <_IO_Vprintf+0x558> <== ALWAYS TAKEN while (n--) 400082b4: fffc8a93 addi s5,s9,-1 400082b8: c7dff06f j 40007f34 <_IO_Vprintf+0x568> else if (cflag) 400082bc: f00302e3 beqz t1,400081c0 <_IO_Vprintf+0x7f4> num = (u_char)va_arg(ap, int); 400082c0: 000ac703 lbu a4,0(s5) 400082c4: 02012a23 sw zero,52(sp) 400082c8: 00068a93 mv s5,a3 400082cc: 02e12823 sw a4,48(sp) 400082d0: 949ff06f j 40007c18 <_IO_Vprintf+0x24c> cflag = 1; 400082d4: 00088313 mv t1,a7 reswitch: switch (ch = (u_char)*fmt++) { 400082d8: 00090b93 mv s7,s2 hflag = 0; 400082dc: 00000893 li a7,0 400082e0: fd8ff06f j 40007ab8 <_IO_Vprintf+0xec> PCHAR(va_arg(ap, int)); 400082e4: 000aa503 lw a0,0(s5) <== NOT EXECUTED 400082e8: 00048593 mv a1,s1 <== NOT EXECUTED 400082ec: 000c0a93 mv s5,s8 <== NOT EXECUTED 400082f0: 000400e7 jalr s0 <== NOT EXECUTED if (ladjust && width > 0) 400082f4: 873058e3 blez s3,40007b64 <_IO_Vprintf+0x198> <== NOT EXECUTED while (width--) 400082f8: 02012783 lw a5,32(sp) <== NOT EXECUTED 400082fc: fff00993 li s3,-1 <== NOT EXECUTED 40008300: ffe78c93 addi s9,a5,-2 <== NOT EXECUTED 40008304: 000c8a93 mv s5,s9 <== NOT EXECUTED PCHAR(padc); 40008308: 03812503 lw a0,56(sp) <== NOT EXECUTED while (width--) 4000830c: fffa8a93 addi s5,s5,-1 <== NOT EXECUTED PCHAR(padc); 40008310: 00048593 mv a1,s1 <== NOT EXECUTED 40008314: 000400e7 jalr s0 <== NOT EXECUTED while (width--) 40008318: ff3a98e3 bne s5,s3,40008308 <_IO_Vprintf+0x93c> <== NOT EXECUTED PCHAR(padc); 4000831c: 002d0a93 addi s5,s10,2 <== NOT EXECUTED 40008320: 019a8cb3 add s9,s5,s9 <== NOT EXECUTED while ((ch = (u_char)*fmt++) != '%' || stop) { 40008324: 001bc503 lbu a0,1(s7) <== NOT EXECUTED PCHAR(va_arg(ap, int)); 40008328: 000c0a93 mv s5,s8 <== NOT EXECUTED 4000832c: f1cff06f j 40007a48 <_IO_Vprintf+0x7c> <== NOT EXECUTED dwidth = va_arg(ap, int); 40008330: 02e12623 sw a4,44(sp) 40008334: cb5ff06f j 40007fe8 <_IO_Vprintf+0x61c> else if (cflag) 40008338: ec0304e3 beqz t1,40008200 <_IO_Vprintf+0x834> <== ALWAYS TAKEN num = (char)va_arg(ap, int); 4000833c: 000ac703 lbu a4,0(s5) <== NOT EXECUTED 40008340: 02012a23 sw zero,52(sp) <== NOT EXECUTED 40008344: 00078a93 mv s5,a5 <== NOT EXECUTED 40008348: 02e12823 sw a4,48(sp) <== NOT EXECUTED 4000834c: 00000793 li a5,0 <== NOT EXECUTED 40008350: 8c9ff06f j 40007c18 <_IO_Vprintf+0x24c> <== NOT EXECUTED ch = *fmt; 40008354: 001bcf03 lbu t5,1(s7) <== NOT EXECUTED if (ch < '0' || ch > '9') 40008358: fd0f0693 addi a3,t5,-48 <== NOT EXECUTED ch = *fmt; 4000835c: 000f0e93 mv t4,t5 <== NOT EXECUTED if (ch < '0' || ch > '9') 40008360: 0cd5ec63 bltu a1,a3,40008438 <_IO_Vprintf+0xa6c> <== NOT EXECUTED n = n * 10 + ch - '0'; 40008364: 00000f93 li t6,0 <== NOT EXECUTED 40008368: 819ff06f j 40007b80 <_IO_Vprintf+0x1b4> <== NOT EXECUTED while (width--) 4000836c: 02012783 lw a5,32(sp) <== NOT EXECUTED 40008370: fff00b13 li s6,-1 <== NOT EXECUTED 40008374: ffe78a13 addi s4,a5,-2 <== NOT EXECUTED 40008378: 000a0993 mv s3,s4 <== NOT EXECUTED PCHAR(padc); 4000837c: 03812503 lw a0,56(sp) <== NOT EXECUTED while (width--) 40008380: fff98993 addi s3,s3,-1 <== NOT EXECUTED PCHAR(padc); 40008384: 00048593 mv a1,s1 <== NOT EXECUTED 40008388: 000400e7 jalr s0 <== NOT EXECUTED while (width--) 4000838c: ff6998e3 bne s3,s6,4000837c <_IO_Vprintf+0x9b0> <== NOT EXECUTED PCHAR(padc); 40008390: 014c89b3 add s3,s9,s4 <== NOT EXECUTED PCHAR(va_arg(ap, int)); 40008394: 00198c93 addi s9,s3,1 <== NOT EXECUTED 40008398: c7dff06f j 40008014 <_IO_Vprintf+0x648> <== NOT EXECUTED ladjust = !ladjust; 4000839c: 02412703 lw a4,36(sp) <== NOT EXECUTED reswitch: switch (ch = (u_char)*fmt++) { 400083a0: 001bce83 lbu t4,1(s7) <== NOT EXECUTED width = va_arg(ap, int); 400083a4: 00068a93 mv s5,a3 <== NOT EXECUTED 400083a8: 00174713 xori a4,a4,1 <== NOT EXECUTED 400083ac: 02e12223 sw a4,36(sp) <== NOT EXECUTED width = -width; 400083b0: 02012703 lw a4,32(sp) <== NOT EXECUTED reswitch: switch (ch = (u_char)*fmt++) { 400083b4: 00090b93 mv s7,s2 <== NOT EXECUTED width = -width; 400083b8: 40e00733 neg a4,a4 <== NOT EXECUTED 400083bc: 02e12023 sw a4,32(sp) <== NOT EXECUTED 400083c0: ef8ff06f j 40007ab8 <_IO_Vprintf+0xec> <== NOT EXECUTED if (!ladjust && width > 0) 400083c4: 02412783 lw a5,36(sp) <== NOT EXECUTED 400083c8: e60798e3 bnez a5,40008238 <_IO_Vprintf+0x86c> <== NOT EXECUTED 400083cc: 02012783 lw a5,32(sp) <== NOT EXECUTED 400083d0: 04f05a63 blez a5,40008424 <_IO_Vprintf+0xa58> <== NOT EXECUTED while (width--) 400083d4: 02012783 lw a5,32(sp) 400083d8: fff00c13 li s8,-1 400083dc: fff78793 addi a5,a5,-1 400083e0: 02f12023 sw a5,32(sp) 400083e4: 00078d93 mv s11,a5 400083e8: 02012783 lw a5,32(sp) PCHAR(padc); 400083ec: 03812503 lw a0,56(sp) 400083f0: 00048593 mv a1,s1 while (width--) 400083f4: fff78793 addi a5,a5,-1 400083f8: 00078a93 mv s5,a5 400083fc: 02f12023 sw a5,32(sp) PCHAR(padc); 40008400: 000400e7 jalr s0 while (width--) 40008404: ff8a92e3 bne s5,s8,400083e8 <_IO_Vprintf+0xa1c> PCHAR(padc); 40008408: 001d0a93 addi s5,s10,1 4000840c: 01ba8d33 add s10,s5,s11 40008410: b1dff06f j 40007f2c <_IO_Vprintf+0x560> while ((ch = (u_char)*fmt++) != '%' || stop) { 40008414: 001bc503 lbu a0,1(s7) <== NOT EXECUTED while (percent < fmt) 40008418: 000d0c93 mv s9,s10 <== NOT EXECUTED stop = 1; 4000841c: 00100a13 li s4,1 <== NOT EXECUTED 40008420: e28ff06f j 40007a48 <_IO_Vprintf+0x7c> <== NOT EXECUTED while ((ch = (u_char)*fmt++) != '%' || stop) { 40008424: 001bc503 lbu a0,1(s7) p = va_arg(ap, char *); 40008428: 000b0a93 mv s5,s6 if (!ladjust && width > 0) 4000842c: 000d0c93 mv s9,s10 40008430: 00000a13 li s4,0 40008434: e14ff06f j 40007a48 <_IO_Vprintf+0x7c> n = n * 10 + ch - '0'; 40008438: 02012623 sw zero,44(sp) <== NOT EXECUTED reswitch: switch (ch = (u_char)*fmt++) { 4000843c: 00090b93 mv s7,s2 <== NOT EXECUTED 40008440: e78ff06f j 40007ab8 <_IO_Vprintf+0xec> <== NOT EXECUTED =============================================================================== 4000e778 <_Memory_Allocate>: Memory_Area *area; const Memory_Area *end; uintptr_t alignment_mask; area = &information->areas[ 0 ]; end = &information->areas[ information->count ]; 4000e778: 00052703 lw a4,0(a0) area = &information->areas[ 0 ]; 4000e77c: 00452783 lw a5,4(a0) alignment_mask = alignment - 1; 4000e780: fff60813 addi a6,a2,-1 end = &information->areas[ information->count ]; 4000e784: 00171693 slli a3,a4,0x1 4000e788: 00e686b3 add a3,a3,a4 4000e78c: 00269693 slli a3,a3,0x2 4000e790: 00d786b3 add a3,a5,a3 while ( area != end ) { 4000e794: 02d78663 beq a5,a3,4000e7c0 <_Memory_Allocate+0x48> 4000e798: 40c00633 neg a2,a2 uintptr_t alloc_begin; uintptr_t alloc_end; alloc_begin = (uintptr_t) area->free; 4000e79c: 0047a503 lw a0,4(a5) alloc_begin += alignment_mask; 4000e7a0: 00a80533 add a0,a6,a0 alloc_begin &= ~alignment_mask; 4000e7a4: 00c57533 and a0,a0,a2 alloc_end = alloc_begin + size; 4000e7a8: 00b50733 add a4,a0,a1 if ( alloc_begin <= alloc_end && alloc_end <= (uintptr_t) area->end ) { 4000e7ac: 00a76663 bltu a4,a0,4000e7b8 <_Memory_Allocate+0x40> 4000e7b0: 0087a883 lw a7,8(a5) 4000e7b4: 00e8fa63 bgeu a7,a4,4000e7c8 <_Memory_Allocate+0x50> area->free = (void *) alloc_end; return (void *) alloc_begin; } ++area; 4000e7b8: 00c78793 addi a5,a5,12 <== NOT EXECUTED while ( area != end ) { 4000e7bc: fef690e3 bne a3,a5,4000e79c <_Memory_Allocate+0x24> <== NOT EXECUTED } return NULL; 4000e7c0: 00000513 li a0,0 <== NOT EXECUTED } 4000e7c4: 00008067 ret <== NOT EXECUTED area->free = (void *) alloc_end; 4000e7c8: 00e7a223 sw a4,4(a5) return (void *) alloc_begin; 4000e7cc: 00008067 ret =============================================================================== 400083c8 <_Objects_Extend_information>: #include /* for memcpy() */ Objects_Maximum _Objects_Extend_information( Objects_Information *information ) { 400083c8: fb010113 addi sp,sp,-80 400083cc: 03712623 sw s7,44(sp) */ RTEMS_INLINE_ROUTINE Objects_Maximum _Objects_Get_maximum_index( const Objects_Information *information ) { return _Objects_Get_index( information->maximum_id ); 400083d0: 00052b83 lw s7,0(a0) 400083d4: 03512a23 sw s5,52(sp) */ do_extend = true; index_base = extend_count; block = 1; if ( information->object_blocks == NULL ) { 400083d8: 02852783 lw a5,40(a0) return information->objects_per_block; 400083dc: 01255a83 lhu s5,18(a0) { 400083e0: 03912223 sw s9,36(sp) 400083e4: 010b9c93 slli s9,s7,0x10 400083e8: 010cdc93 srli s9,s9,0x10 400083ec: 04812423 sw s0,72(sp) 400083f0: 03412c23 sw s4,56(sp) 400083f4: 03812423 sw s8,40(sp) 400083f8: 03a12023 sw s10,32(sp) 400083fc: 04112623 sw ra,76(sp) 40008400: 04912223 sw s1,68(sp) 40008404: 05212023 sw s2,64(sp) 40008408: 03312e23 sw s3,60(sp) 4000840c: 03612823 sw s6,48(sp) 40008410: 01b12e23 sw s11,28(sp) 40008414: 00050a13 mv s4,a0 RTEMS_INLINE_ROUTINE Objects_Maximum _Objects_Get_index( Objects_Id id ) { return (Objects_Maximum)((id >> OBJECTS_INDEX_START_BIT) & 40008418: 000c8d13 mv s10,s9 new_maximum = (uint32_t) old_maximum + extend_count; 4000841c: 019a8c33 add s8,s5,s9 if ( information->object_blocks == NULL ) { 40008420: 001a9413 slli s0,s5,0x1 40008424: 12078a63 beqz a5,40008558 <_Objects_Extend_information+0x190> block_count = 1; } else { block_count = old_maximum / extend_count; 40008428: 035cdb33 divu s6,s9,s5 for ( ; block < block_count; block++ ) { 4000842c: 00100713 li a4,1 40008430: 23677263 bgeu a4,s6,40008654 <_Objects_Extend_information+0x28c> 40008434: 00478793 addi a5,a5,4 index_base = extend_count; 40008438: 000a8413 mv s0,s5 block = 1; 4000843c: 00100913 li s2,1 40008440: 0100006f j 40008450 <_Objects_Extend_information+0x88> for ( ; block < block_count; block++ ) { 40008444: 00190913 addi s2,s2,1 40008448: 00478793 addi a5,a5,4 4000844c: 0f2b0e63 beq s6,s2,40008548 <_Objects_Extend_information+0x180> if ( information->object_blocks[ block ] == NULL ) { 40008450: 0007a703 lw a4,0(a5) 40008454: 00040993 mv s3,s0 do_extend = false; break; } else index_base += extend_count; 40008458: 01540433 add s0,s0,s5 if ( information->object_blocks[ block ] == NULL ) { 4000845c: fe0714e3 bnez a4,40008444 <_Objects_Extend_information+0x7c> do_extend = false; 40008460: 00000d93 li s11,0 /* * We need to limit the number of objects to the maximum number * representable in the index portion of the object Id. In the * case of 16-bit Ids, this is only 256 object instances. */ if ( new_maximum > OBJECTS_ID_FINAL_INDEX ) { 40008464: 000107b7 lui a5,0x10 40008468: 0cfc7c63 bgeu s8,a5,40008540 <_Objects_Extend_information+0x178> /* * Allocate the name table, and the objects and if it fails either return or * generate a fatal error depending on auto-extending being active. */ object_block_size = extend_count * information->object_size; 4000846c: 014a5503 lhu a0,20(s4) new_object_block = _Workspace_Allocate( object_block_size ); 40008470: 03550533 mul a0,a0,s5 40008474: 7e5020ef jal ra,4000b458 <_Workspace_Allocate> 40008478: 00050493 mv s1,a0 if ( new_object_block == NULL ) { 4000847c: 0c050263 beqz a0,40008540 <_Objects_Extend_information+0x178> <== NEVER TAKEN api_class_and_node = information->maximum_id & ~OBJECTS_INDEX_MASK; 40008480: ffff07b7 lui a5,0xffff0 40008484: 00fbfbb3 and s7,s7,a5 } /* * Do we need to grow the tables? */ if ( do_extend ) { 40008488: 0e0d9263 bnez s11,4000856c <_Objects_Extend_information+0x1a4> } /* * Assign the new object block to the object block table. */ information->object_blocks[ block ] = new_object_block; 4000848c: 028a2683 lw a3,40(s4) information->inactive_per_block[ block ] = information->objects_per_block; 40008490: 024a2703 lw a4,36(s4) 40008494: 012a5603 lhu a2,18(s4) information->object_blocks[ block ] = new_object_block; 40008498: 00291793 slli a5,s2,0x2 4000849c: 00f686b3 add a3,a3,a5 information->inactive_per_block[ block ] = information->objects_per_block; 400084a0: 00191793 slli a5,s2,0x1 400084a4: 00f707b3 add a5,a4,a5 information->object_blocks[ block ] = new_object_block; 400084a8: 0096a023 sw s1,0(a3) information->inactive_per_block[ block ] = information->objects_per_block; 400084ac: 00c79023 sh a2,0(a5) # ffff0000 information->inactive += information->objects_per_block; 400084b0: 010a5783 lhu a5,16(s4) 400084b4: 012a5703 lhu a4,18(s4) 400084b8: 00e787b3 add a5,a5,a4 400084bc: 00fa1823 sh a5,16(s4) /* * Append to inactive chain. */ the_object = new_object_block; for ( index = index_base ; index < index_end ; ++index ) { 400084c0: 0289fa63 bgeu s3,s0,400084f4 <_Objects_Extend_information+0x12c> | ( ( index + OBJECTS_INDEX_MINIMUM ) << OBJECTS_INDEX_START_BIT ); _Chain_Initialize_node( &the_object->Node ); _Chain_Append_unprotected( &information->Inactive, &the_object->Node ); the_object = _Addresses_Add_offset( the_object, information->object_size ); 400084c4: 014a5603 lhu a2,20(s4) return &the_chain->Tail.Node; 400084c8: 01ca0693 addi a3,s4,28 | ( ( index + OBJECTS_INDEX_MINIMUM ) << OBJECTS_INDEX_START_BIT ); 400084cc: 00198993 addi s3,s3,1 old_last = tail->previous; 400084d0: 020a2783 lw a5,32(s4) 400084d4: 0179e733 or a4,s3,s7 the_object->id = api_class_and_node 400084d8: 00e4a423 sw a4,8(s1) the_node->next = tail; 400084dc: 00d4a023 sw a3,0(s1) tail->previous = the_node; 400084e0: 029a2023 sw s1,32(s4) old_last->next = the_node; 400084e4: 0097a023 sw s1,0(a5) the_node->previous = old_last; 400084e8: 00f4a223 sw a5,4(s1) RTEMS_INLINE_ROUTINE void *_Addresses_Add_offset ( const void *base, uintptr_t offset ) { return (void *)((uintptr_t)base + offset); 400084ec: 00c484b3 add s1,s1,a2 for ( index = index_base ; index < index_end ; ++index ) { 400084f0: fc899ee3 bne s3,s0,400084cc <_Objects_Extend_information+0x104> } return block; 400084f4: 01091513 slli a0,s2,0x10 400084f8: 01055513 srli a0,a0,0x10 } 400084fc: 04c12083 lw ra,76(sp) 40008500: 04812403 lw s0,72(sp) 40008504: 04412483 lw s1,68(sp) 40008508: 04012903 lw s2,64(sp) 4000850c: 03c12983 lw s3,60(sp) 40008510: 03812a03 lw s4,56(sp) 40008514: 03412a83 lw s5,52(sp) 40008518: 03012b03 lw s6,48(sp) 4000851c: 02c12b83 lw s7,44(sp) 40008520: 02812c03 lw s8,40(sp) 40008524: 02412c83 lw s9,36(sp) 40008528: 02012d03 lw s10,32(sp) 4000852c: 01c12d83 lw s11,28(sp) 40008530: 05010113 addi sp,sp,80 40008534: 00008067 ret _Workspace_Free( new_object_block ); 40008538: 00048513 mv a0,s1 4000853c: 735020ef jal ra,4000b470 <_Workspace_Free> return 0; 40008540: 00000513 li a0,0 40008544: fb9ff06f j 400084fc <_Objects_Extend_information+0x134> index_base += extend_count; 40008548: 00040993 mv s3,s0 do_extend = true; 4000854c: 00100d93 li s11,1 index_end = index_base + extend_count; 40008550: 008a8433 add s0,s5,s0 40008554: f11ff06f j 40008464 <_Objects_Extend_information+0x9c> index_base = extend_count; 40008558: 000a8993 mv s3,s5 do_extend = true; 4000855c: 00100d93 li s11,1 block = 1; 40008560: 00100913 li s2,1 block_count = 1; 40008564: 00100b13 li s6,1 40008568: efdff06f j 40008464 <_Objects_Extend_information+0x9c> block_count++; 4000856c: 001b0613 addi a2,s6,1 table_size = object_blocks_size 40008570: 00161513 slli a0,a2,0x1 40008574: 00c50533 add a0,a0,a2 40008578: 00151513 slli a0,a0,0x1 local_table_size = new_maximum * sizeof( *local_table ); 4000857c: 002c1d93 slli s11,s8,0x2 object_blocks_size = block_count * sizeof( *object_blocks ); 40008580: 00261613 slli a2,a2,0x2 object_blocks = _Workspace_Allocate( table_size ); 40008584: 01b50533 add a0,a0,s11 object_blocks_size = block_count * sizeof( *object_blocks ); 40008588: 00c12423 sw a2,8(sp) object_blocks = _Workspace_Allocate( table_size ); 4000858c: 6cd020ef jal ra,4000b458 <_Workspace_Allocate> if ( object_blocks == NULL ) { 40008590: 00812603 lw a2,8(sp) object_blocks = _Workspace_Allocate( table_size ); 40008594: 00050793 mv a5,a0 if ( object_blocks == NULL ) { 40008598: fa0500e3 beqz a0,40008538 <_Objects_Extend_information+0x170> 4000859c: 00c50733 add a4,a0,a2 400085a0: 00ed8db3 add s11,s11,a4 if ( old_maximum > extend_count ) { 400085a4: 09aae063 bltu s5,s10,40008624 <_Objects_Extend_information+0x25c> object_blocks[ 0 ] = NULL; 400085a8: 00052023 sw zero,0(a0) inactive_per_block[ 0 ] = 0; 400085ac: 000d9023 sh zero,0(s11) memcpy( 400085b0: 004a2583 lw a1,4(s4) 400085b4: 00070513 mv a0,a4 400085b8: 002c9613 slli a2,s9,0x2 400085bc: 00f12423 sw a5,8(sp) 400085c0: 1a8130ef jal ra,4001b768 for ( index = index_base ; index < index_end ; ++index ) { 400085c4: 00812783 lw a5,8(sp) memcpy( 400085c8: 00050713 mv a4,a0 for ( index = index_base ; index < index_end ; ++index ) { 400085cc: 0289f663 bgeu s3,s0,400085f8 <_Objects_Extend_information+0x230> local_table[ index ] = NULL; 400085d0: 41340633 sub a2,s0,s3 400085d4: 00299513 slli a0,s3,0x2 400085d8: 00a70533 add a0,a4,a0 400085dc: 00261613 slli a2,a2,0x2 400085e0: 00000593 li a1,0 400085e4: 00f12623 sw a5,12(sp) 400085e8: 00e12423 sw a4,8(sp) 400085ec: 2a4130ef jal ra,4001b890 400085f0: 00812703 lw a4,8(sp) 400085f4: 00c12783 lw a5,12(sp) __asm__ volatile ( 400085f8: 300476f3 csrrci a3,mstatus,8 | (new_maximum << OBJECTS_INDEX_START_BIT); 400085fc: 017c6c33 or s8,s8,s7 old_tables = information->object_blocks; 40008600: 028a2503 lw a0,40(s4) information->inactive_per_block = inactive_per_block; 40008604: 03ba2223 sw s11,36(s4) information->object_blocks = object_blocks; 40008608: 02fa2423 sw a5,40(s4) information->local_table = local_table; 4000860c: 00ea2223 sw a4,4(s4) information->maximum_id = api_class_and_node 40008610: 018a2023 sw s8,0(s4) return mstatus & RISCV_MSTATUS_MIE; 40008614: 0086f793 andi a5,a3,8 __asm__ volatile ( "csrrs zero, mstatus, %0" : : "r" ( level ) ); 40008618: 3007a073 csrs mstatus,a5 _Workspace_Free( old_tables ); 4000861c: 655020ef jal ra,4000b470 <_Workspace_Free> block_count++; 40008620: e6dff06f j 4000848c <_Objects_Extend_information+0xc4> memcpy( 40008624: 028a2583 lw a1,40(s4) 40008628: ffc60613 addi a2,a2,-4 4000862c: 00e12623 sw a4,12(sp) 40008630: 00a12423 sw a0,8(sp) 40008634: 134130ef jal ra,4001b768 memcpy( 40008638: 024a2583 lw a1,36(s4) 4000863c: 001b1613 slli a2,s6,0x1 40008640: 000d8513 mv a0,s11 40008644: 124130ef jal ra,4001b768 40008648: 00812783 lw a5,8(sp) 4000864c: 00c12703 lw a4,12(sp) 40008650: f61ff06f j 400085b0 <_Objects_Extend_information+0x1e8> index_base = extend_count; 40008654: 000a8993 mv s3,s5 <== NOT EXECUTED do_extend = true; 40008658: 00100d93 li s11,1 <== NOT EXECUTED block = 1; 4000865c: 00100913 li s2,1 <== NOT EXECUTED 40008660: e05ff06f j 40008464 <_Objects_Extend_information+0x9c> <== NOT EXECUTED =============================================================================== 40008664 <_Objects_Free_unlimited>: old_last = tail->previous; 40008664: 02052703 lw a4,32(a0) return &the_chain->Tail.Node; 40008668: 01c50693 addi a3,a0,28 the_node->next = tail; 4000866c: 00d5a023 sw a3,0(a1) tail->previous = the_node; 40008670: 02b52023 sw a1,32(a0) */ RTEMS_INLINE_ROUTINE Objects_Maximum _Objects_Is_auto_extend( const Objects_Information *information ) { return information->objects_per_block != 0; 40008674: 01255683 lhu a3,18(a0) old_last->next = the_node; 40008678: 00b72023 sw a1,0(a4) the_node->previous = old_last; 4000867c: 00e5a223 sw a4,4(a1) Objects_Control *the_object ) { _Chain_Append_unprotected( &information->Inactive, &the_object->Node ); if ( _Objects_Is_auto_extend( information ) ) { 40008680: 04068a63 beqz a3,400086d4 <_Objects_Free_unlimited+0x70> <== NEVER TAKEN 40008684: 0085a703 lw a4,8(a1) Objects_Maximum objects_per_block; Objects_Maximum block; Objects_Maximum inactive; objects_per_block = information->objects_per_block; block = _Objects_Get_index( the_object->id ) - OBJECTS_INDEX_MINIMUM; 40008688: fff70713 addi a4,a4,-1 4000868c: 01071713 slli a4,a4,0x10 40008690: 01075713 srli a4,a4,0x10 if ( block > objects_per_block ) { 40008694: 04e6f063 bgeu a3,a4,400086d4 <_Objects_Free_unlimited+0x70> block /= objects_per_block; ++information->inactive_per_block[ block ]; 40008698: 02d75733 divu a4,a4,a3 4000869c: 02452603 lw a2,36(a0) /* * Check if the threshold level has been met of * 1.5 x objects_per_block are free. */ if ( inactive > ( objects_per_block + ( objects_per_block >> 1 ) ) ) { 400086a0: 0016d593 srli a1,a3,0x1 400086a4: 00d586b3 add a3,a1,a3 ++information->inactive_per_block[ block ]; 400086a8: 00171713 slli a4,a4,0x1 400086ac: 00e60733 add a4,a2,a4 400086b0: 00075603 lhu a2,0(a4) 400086b4: 00160613 addi a2,a2,1 400086b8: 00c71023 sh a2,0(a4) inactive = information->inactive; 400086bc: 01055703 lhu a4,16(a0) ++inactive; 400086c0: 00170713 addi a4,a4,1 400086c4: 01071713 slli a4,a4,0x10 400086c8: 01075713 srli a4,a4,0x10 information->inactive = inactive; 400086cc: 00e51823 sh a4,16(a0) if ( inactive > ( objects_per_block + ( objects_per_block >> 1 ) ) ) { 400086d0: 00e6c463 blt a3,a4,400086d8 <_Objects_Free_unlimited+0x74> _Objects_Shrink_information( information ); } } } } 400086d4: 00008067 ret _Objects_Shrink_information( information ); 400086d8: 0f40006f j 400087cc <_Objects_Shrink_information> =============================================================================== 40008cc8 <_Objects_Get_information>: ) { Objects_Information *info; int the_class_api_maximum; if ( !the_class ) 40008cc8: 08058263 beqz a1,40008d4c <_Objects_Get_information+0x84> { 40008ccc: ff010113 addi sp,sp,-16 40008cd0: 00812423 sw s0,8(sp) 40008cd4: 00912223 sw s1,4(sp) 40008cd8: 00112623 sw ra,12(sp) 40008cdc: 00058413 mv s0,a1 40008ce0: 00050493 mv s1,a0 /* * This call implicitly validates the_api so we do not call * _Objects_Is_api_valid above here. */ the_class_api_maximum = _Objects_API_maximum_class( the_api ); 40008ce4: 48c070ef jal ra,40010170 <_Objects_API_maximum_class> if ( the_class_api_maximum == 0 ) 40008ce8: 04050663 beqz a0,40008d34 <_Objects_Get_information+0x6c> return NULL; if ( the_class > (uint32_t) the_class_api_maximum ) 40008cec: 04856463 bltu a0,s0,40008d34 <_Objects_Get_information+0x6c> return NULL; if ( !_Objects_Information_table[ the_api ] ) 40008cf0: 4001f7b7 lui a5,0x4001f 40008cf4: 00249513 slli a0,s1,0x2 40008cf8: 08478493 addi s1,a5,132 # 4001f084 <_Objects_Information_table> 40008cfc: 00a48533 add a0,s1,a0 40008d00: 00052783 lw a5,0(a0) 40008d04: 02078863 beqz a5,40008d34 <_Objects_Get_information+0x6c> <== NEVER TAKEN return NULL; info = _Objects_Information_table[ the_api ][ the_class ]; 40008d08: 00241413 slli s0,s0,0x2 40008d0c: 00878433 add s0,a5,s0 40008d10: 00042503 lw a0,0(s0) if ( !info ) 40008d14: 02050063 beqz a0,40008d34 <_Objects_Get_information+0x6c> * In a multprocessing configuration, we may access remote objects. * Thus we may have 0 local instances and still have a valid object * pointer. */ #if !defined(RTEMS_MULTIPROCESSING) if ( _Objects_Get_maximum_index( info ) == 0 ) 40008d18: 00055783 lhu a5,0(a0) 40008d1c: 00078c63 beqz a5,40008d34 <_Objects_Get_information+0x6c> return NULL; #endif return info; } 40008d20: 00c12083 lw ra,12(sp) 40008d24: 00812403 lw s0,8(sp) 40008d28: 00412483 lw s1,4(sp) 40008d2c: 01010113 addi sp,sp,16 40008d30: 00008067 ret 40008d34: 00c12083 lw ra,12(sp) 40008d38: 00812403 lw s0,8(sp) 40008d3c: 00412483 lw s1,4(sp) return NULL; 40008d40: 00000513 li a0,0 } 40008d44: 01010113 addi sp,sp,16 40008d48: 00008067 ret return NULL; 40008d4c: 00000513 li a0,0 } 40008d50: 00008067 ret =============================================================================== 40008984 <_Objects_Get_name_as_string>: const Objects_Information *information; const Objects_Control *the_object; ISR_lock_Context lock_context; Objects_Id tmpId; if ( length == 0 ) 40008984: 0c058863 beqz a1,40008a54 <_Objects_Get_name_as_string+0xd0> { 40008988: fd010113 addi sp,sp,-48 4000898c: 02812423 sw s0,40(sp) 40008990: 02112623 sw ra,44(sp) 40008994: 02912223 sw s1,36(sp) 40008998: 03212023 sw s2,32(sp) 4000899c: 01312e23 sw s3,28(sp) 400089a0: 00060413 mv s0,a2 return NULL; if ( name == NULL ) 400089a4: 08060863 beqz a2,40008a34 <_Objects_Get_name_as_string+0xb0> 400089a8: 00058913 mv s2,a1 400089ac: 00050493 mv s1,a0 return NULL; tmpId = (id == OBJECTS_ID_OF_SELF) ? _Thread_Get_executing()->Object.id : id; 400089b0: 06050463 beqz a0,40008a18 <_Objects_Get_name_as_string+0x94> information = _Objects_Get_information_id( tmpId ); 400089b4: 00048513 mv a0,s1 400089b8: 7ad050ef jal ra,4000e964 <_Objects_Get_information_id> 400089bc: 00050993 mv s3,a0 if ( !information ) 400089c0: 06050a63 beqz a0,40008a34 <_Objects_Get_name_as_string+0xb0> return NULL; the_object = _Objects_Get( tmpId, &lock_context, information ); 400089c4: 00050613 mv a2,a0 400089c8: 00c10593 addi a1,sp,12 400089cc: 00048513 mv a0,s1 400089d0: e79ff0ef jal ra,40008848 <_Objects_Get> if ( the_object == NULL ) { 400089d4: 06050063 beqz a0,40008a34 <_Objects_Get_name_as_string+0xb0> return information->name_length > 0; 400089d8: 0169d583 lhu a1,22(s3) return NULL; } _Objects_Name_to_string( 400089dc: 00c52503 lw a0,12(a0) 400089e0: 00090693 mv a3,s2 400089e4: 00040613 mv a2,s0 400089e8: 00b035b3 snez a1,a1 400089ec: eb1ff0ef jal ra,4000889c <_Objects_Name_to_string> __asm__ volatile ( "csrrs zero, mstatus, %0" : : "r" ( level ) ); 400089f0: 00c12783 lw a5,12(sp) 400089f4: 3007a073 csrs mstatus,a5 length ); _ISR_lock_ISR_enable( &lock_context ); return name; } 400089f8: 02c12083 lw ra,44(sp) return name; 400089fc: 00040513 mv a0,s0 } 40008a00: 02812403 lw s0,40(sp) 40008a04: 02412483 lw s1,36(sp) 40008a08: 02012903 lw s2,32(sp) 40008a0c: 01c12983 lw s3,28(sp) 40008a10: 03010113 addi sp,sp,48 40008a14: 00008067 ret tmpId = (id == OBJECTS_ID_OF_SELF) ? _Thread_Get_executing()->Object.id : id; 40008a18: 400207b7 lui a5,0x40020 40008a1c: f387a783 lw a5,-200(a5) # 4001ff38 <_Per_CPU_Information+0x38> 40008a20: 0087a483 lw s1,8(a5) information = _Objects_Get_information_id( tmpId ); 40008a24: 00048513 mv a0,s1 40008a28: 73d050ef jal ra,4000e964 <_Objects_Get_information_id> 40008a2c: 00050993 mv s3,a0 if ( !information ) 40008a30: f8051ae3 bnez a0,400089c4 <_Objects_Get_name_as_string+0x40> <== ALWAYS TAKEN } 40008a34: 02c12083 lw ra,44(sp) 40008a38: 02812403 lw s0,40(sp) 40008a3c: 02412483 lw s1,36(sp) 40008a40: 02012903 lw s2,32(sp) 40008a44: 01c12983 lw s3,28(sp) return NULL; 40008a48: 00000513 li a0,0 } 40008a4c: 03010113 addi sp,sp,48 40008a50: 00008067 ret return NULL; 40008a54: 00000513 li a0,0 } 40008a58: 00008067 ret =============================================================================== 40008a5c <_Objects_Id_to_name>: Objects_Name_or_id_lookup_errors _Objects_Id_to_name ( Objects_Id id, Objects_Name *name ) { 40008a5c: fe010113 addi sp,sp,-32 40008a60: 00812c23 sw s0,24(sp) 40008a64: 00912a23 sw s1,20(sp) 40008a68: 00112e23 sw ra,28(sp) 40008a6c: 00058493 mv s1,a1 40008a70: 00050413 mv s0,a0 /* * Caller is trusted for name != NULL. */ tmpId = (id == OBJECTS_ID_OF_SELF) ? _Thread_Get_executing()->Object.id : id; 40008a74: 00051863 bnez a0,40008a84 <_Objects_Id_to_name+0x28> 40008a78: 400207b7 lui a5,0x40020 40008a7c: f387a783 lw a5,-200(a5) # 4001ff38 <_Per_CPU_Information+0x38> 40008a80: 0087a403 lw s0,8(a5) information = _Objects_Get_information_id( tmpId ); 40008a84: 00040513 mv a0,s0 40008a88: 6dd050ef jal ra,4000e964 <_Objects_Get_information_id> 40008a8c: 00050613 mv a2,a0 if ( !information ) 40008a90: 04050263 beqz a0,40008ad4 <_Objects_Id_to_name+0x78> return OBJECTS_INVALID_ID; if ( _Objects_Has_string_name( information ) ) 40008a94: 01655783 lhu a5,22(a0) 40008a98: 02079e63 bnez a5,40008ad4 <_Objects_Id_to_name+0x78> <== NEVER TAKEN return OBJECTS_INVALID_ID; the_object = _Objects_Get( 40008a9c: 00c10593 addi a1,sp,12 40008aa0: 00040513 mv a0,s0 40008aa4: da5ff0ef jal ra,40008848 <_Objects_Get> tmpId, &lock_context, information ); if ( !the_object ) 40008aa8: 02050663 beqz a0,40008ad4 <_Objects_Id_to_name+0x78> return OBJECTS_INVALID_ID; *name = the_object->name; 40008aac: 00c52783 lw a5,12(a0) 40008ab0: 00f4a023 sw a5,0(s1) 40008ab4: 00c12783 lw a5,12(sp) 40008ab8: 3007a073 csrs mstatus,a5 _ISR_lock_ISR_enable( &lock_context ); return OBJECTS_NAME_OR_ID_LOOKUP_SUCCESSFUL; } 40008abc: 01c12083 lw ra,28(sp) 40008ac0: 01812403 lw s0,24(sp) 40008ac4: 01412483 lw s1,20(sp) return OBJECTS_NAME_OR_ID_LOOKUP_SUCCESSFUL; 40008ac8: 00000513 li a0,0 } 40008acc: 02010113 addi sp,sp,32 40008ad0: 00008067 ret 40008ad4: 01c12083 lw ra,28(sp) 40008ad8: 01812403 lw s0,24(sp) 40008adc: 01412483 lw s1,20(sp) return OBJECTS_INVALID_ID; 40008ae0: 00300513 li a0,3 } 40008ae4: 02010113 addi sp,sp,32 40008ae8: 00008067 ret =============================================================================== 400145cc <_Objects_Name_to_string>: char lname[ 5 ]; const char *s; char *d; size_t i; if ( is_string ) { 400145cc: 06058463 beqz a1,40014634 <_Objects_Name_to_string+0x68> <== ALWAYS TAKEN } d = buffer; i = 1; if ( s != NULL ) { 400145d0: 00051a63 bnez a0,400145e4 <_Objects_Name_to_string+0x18> <== NOT EXECUTED while ( *s != '\0' ) { if ( i < buffer_size ) { *d = _Objects_Name_char_is_printable(*s) ? *s : '*'; 400145d4: 00000513 li a0,0 <== NOT EXECUTED ++s; ++i; } } if ( buffer_size > 0 ) { 400145d8: 04068c63 beqz a3,40014630 <_Objects_Name_to_string+0x64> <== NOT EXECUTED *d = '\0'; 400145dc: 00060023 sb zero,0(a2) <== NOT EXECUTED } return i - 1; 400145e0: 00008067 ret <== NOT EXECUTED while ( *s != '\0' ) { 400145e4: 00054783 lbu a5,0(a0) <== NOT EXECUTED s = name.name_p; 400145e8: 00050813 mv a6,a0 <== NOT EXECUTED while ( *s != '\0' ) { 400145ec: fe0784e3 beqz a5,400145d4 <_Objects_Name_to_string+0x8> <== NOT EXECUTED 400145f0: 00100513 li a0,1 <== NOT EXECUTED *d = _Objects_Name_char_is_printable(*s) ? *s : '*'; 400145f4: 05e00313 li t1,94 <== NOT EXECUTED 400145f8: 0080006f j 40014600 <_Objects_Name_to_string+0x34> <== NOT EXECUTED ++i; 400145fc: 00058513 mv a0,a1 <== NOT EXECUTED 40014600: 00150593 addi a1,a0,1 <== NOT EXECUTED return uc >= ' ' && uc <= '~'; 40014604: fe078713 addi a4,a5,-32 <== NOT EXECUTED while ( *s != '\0' ) { 40014608: 00b808b3 add a7,a6,a1 <== NOT EXECUTED *d = _Objects_Name_char_is_printable(*s) ? *s : '*'; 4001460c: 0ff77713 andi a4,a4,255 <== NOT EXECUTED if ( i < buffer_size ) { 40014610: 00d57a63 bgeu a0,a3,40014624 <_Objects_Name_to_string+0x58> <== NOT EXECUTED *d = _Objects_Name_char_is_printable(*s) ? *s : '*'; 40014614: 00e37463 bgeu t1,a4,4001461c <_Objects_Name_to_string+0x50> <== NOT EXECUTED 40014618: 02a00793 li a5,42 <== NOT EXECUTED 4001461c: 00f60023 sb a5,0(a2) <== NOT EXECUTED ++d; 40014620: 00160613 addi a2,a2,1 <== NOT EXECUTED while ( *s != '\0' ) { 40014624: fff8c783 lbu a5,-1(a7) <== NOT EXECUTED 40014628: fc079ae3 bnez a5,400145fc <_Objects_Name_to_string+0x30> <== NOT EXECUTED if ( buffer_size > 0 ) { 4001462c: fa0698e3 bnez a3,400145dc <_Objects_Name_to_string+0x10> <== NOT EXECUTED } 40014630: 00008067 ret <== NOT EXECUTED { 40014634: ff010113 addi sp,sp,-16 lname[ 0 ] = (name.name_u32 >> 24) & 0xff; 40014638: 01855793 srli a5,a0,0x18 lname[ 1 ] = (name.name_u32 >> 16) & 0xff; 4001463c: 01055593 srli a1,a0,0x10 lname[ 2 ] = (name.name_u32 >> 8) & 0xff; 40014640: 00855713 srli a4,a0,0x8 lname[ 0 ] = (name.name_u32 >> 24) & 0xff; 40014644: 00f10423 sb a5,8(sp) lname[ 1 ] = (name.name_u32 >> 16) & 0xff; 40014648: 00b104a3 sb a1,9(sp) lname[ 2 ] = (name.name_u32 >> 8) & 0xff; 4001464c: 00e10523 sb a4,10(sp) lname[ 3 ] = (name.name_u32 >> 0) & 0xff; 40014650: 00a105a3 sb a0,11(sp) lname[ 4 ] = '\0'; 40014654: 00010623 sb zero,12(sp) s = lname; 40014658: 00810813 addi a6,sp,8 while ( *s != '\0' ) { 4001465c: 04078863 beqz a5,400146ac <_Objects_Name_to_string+0xe0> 40014660: 00100513 li a0,1 *d = _Objects_Name_char_is_printable(*s) ? *s : '*'; 40014664: 05e00313 li t1,94 40014668: 0080006f j 40014670 <_Objects_Name_to_string+0xa4> ++i; 4001466c: 00058513 mv a0,a1 40014670: 00150593 addi a1,a0,1 return uc >= ' ' && uc <= '~'; 40014674: fe078713 addi a4,a5,-32 while ( *s != '\0' ) { 40014678: 00b808b3 add a7,a6,a1 *d = _Objects_Name_char_is_printable(*s) ? *s : '*'; 4001467c: 0ff77713 andi a4,a4,255 if ( i < buffer_size ) { 40014680: 00d57a63 bgeu a0,a3,40014694 <_Objects_Name_to_string+0xc8> *d = _Objects_Name_char_is_printable(*s) ? *s : '*'; 40014684: 00e37463 bgeu t1,a4,4001468c <_Objects_Name_to_string+0xc0> 40014688: 02a00793 li a5,42 4001468c: 00f60023 sb a5,0(a2) ++d; 40014690: 00160613 addi a2,a2,1 while ( *s != '\0' ) { 40014694: fff8c783 lbu a5,-1(a7) 40014698: fc079ae3 bnez a5,4001466c <_Objects_Name_to_string+0xa0> if ( buffer_size > 0 ) { 4001469c: 00068463 beqz a3,400146a4 <_Objects_Name_to_string+0xd8> *d = '\0'; 400146a0: 00060023 sb zero,0(a2) } 400146a4: 01010113 addi sp,sp,16 400146a8: 00008067 ret *d = _Objects_Name_char_is_printable(*s) ? *s : '*'; 400146ac: 00000513 li a0,0 400146b0: fedff06f j 4001469c <_Objects_Name_to_string+0xd0> =============================================================================== 400043c4 <_Objects_Set_name>: 400043c4: 01655783 lhu a5,22(a0) Status_Control _Objects_Set_name( const Objects_Information *information, Objects_Control *the_object, const char *name ) { 400043c8: fe010113 addi sp,sp,-32 400043cc: 00812c23 sw s0,24(sp) 400043d0: 00912a23 sw s1,20(sp) 400043d4: 00112e23 sw ra,28(sp) 400043d8: 00058493 mv s1,a1 400043dc: 00060413 mv s0,a2 if ( _Objects_Has_string_name( information ) ) { 400043e0: 04078463 beqz a5,40004428 <_Objects_Set_name+0x64> size_t length; char *dup; length = strnlen( name, information->name_length ); 400043e4: 00078593 mv a1,a5 400043e8: 00060513 mv a0,a2 400043ec: 5290a0ef jal ra,4000f114 400043f0: 00050593 mv a1,a0 dup = _Workspace_String_duplicate( name, length ); 400043f4: 00040513 mv a0,s0 400043f8: 748020ef jal ra,40006b40 <_Workspace_String_duplicate> 400043fc: 00050413 mv s0,a0 if ( dup == NULL ) { 40004400: 08050c63 beqz a0,40004498 <_Objects_Set_name+0xd4> <== ALWAYS TAKEN return STATUS_NO_MEMORY; } _Workspace_Free( RTEMS_DECONST( char *, the_object->name.name_p ) ); 40004404: 00c4a503 lw a0,12(s1) <== NOT EXECUTED 40004408: 728020ef jal ra,40006b30 <_Workspace_Free> <== NOT EXECUTED the_object->name.name_u32 = _Objects_Build_name( c[ 0 ], c[ 1 ], c[ 2 ], c[ 3 ] ); } return STATUS_SUCCESSFUL; } 4000440c: 01c12083 lw ra,28(sp) <== NOT EXECUTED the_object->name.name_p = dup; 40004410: 0084a623 sw s0,12(s1) <== NOT EXECUTED } 40004414: 01812403 lw s0,24(sp) <== NOT EXECUTED 40004418: 01412483 lw s1,20(sp) <== NOT EXECUTED return STATUS_SUCCESSFUL; 4000441c: 00000513 li a0,0 <== NOT EXECUTED } 40004420: 02010113 addi sp,sp,32 <== NOT EXECUTED 40004424: 00008067 ret <== NOT EXECUTED memset( c, ' ', sizeof( c ) ); 40004428: 202027b7 lui a5,0x20202 4000442c: 02078793 addi a5,a5,32 # 20202020 40004430: 00f12623 sw a5,12(sp) for ( i = 0; i < 4; ++i ) { 40004434: 01010693 addi a3,sp,16 40004438: 00c10793 addi a5,sp,12 if ( name[ i ] == '\0') { 4000443c: 00064703 lbu a4,0(a2) for ( i = 0; i < 4; ++i ) { 40004440: 00160613 addi a2,a2,1 if ( name[ i ] == '\0') { 40004444: 00070863 beqz a4,40004454 <_Objects_Set_name+0x90> c[ i ] = name[ i ]; 40004448: 00e78023 sb a4,0(a5) for ( i = 0; i < 4; ++i ) { 4000444c: 00178793 addi a5,a5,1 40004450: fef696e3 bne a3,a5,4000443c <_Objects_Set_name+0x78> _Objects_Build_name( c[ 0 ], c[ 1 ], c[ 2 ], c[ 3 ] ); 40004454: 00c14783 lbu a5,12(sp) 40004458: 00d14683 lbu a3,13(sp) 4000445c: 00f14603 lbu a2,15(sp) 40004460: 00e14703 lbu a4,14(sp) 40004464: 01879793 slli a5,a5,0x18 40004468: 01069693 slli a3,a3,0x10 4000446c: 00d7e7b3 or a5,a5,a3 40004470: 00c7e7b3 or a5,a5,a2 40004474: 00871713 slli a4,a4,0x8 40004478: 00e7e7b3 or a5,a5,a4 the_object->name.name_u32 = 4000447c: 00f4a623 sw a5,12(s1) return STATUS_SUCCESSFUL; 40004480: 00000513 li a0,0 } 40004484: 01c12083 lw ra,28(sp) 40004488: 01812403 lw s0,24(sp) 4000448c: 01412483 lw s1,20(sp) 40004490: 02010113 addi sp,sp,32 40004494: 00008067 ret return STATUS_NO_MEMORY; 40004498: 00001537 lui a0,0x1 4000449c: 61a50513 addi a0,a0,1562 # 161a <_ISR_Stack_size+0x61a> 400044a0: fe5ff06f j 40004484 <_Objects_Set_name+0xc0> =============================================================================== 400087cc <_Objects_Shrink_information>: /* * Search the list to find block or chunk with all objects inactive. */ objects_per_block = information->objects_per_block; 400087cc: 01255803 lhu a6,18(a0) block_count = _Objects_Get_maximum_index( information ) / objects_per_block; 400087d0: 00055603 lhu a2,0(a0) for ( block = 1; block < block_count; block++ ) { 400087d4: 00100793 li a5,1 block_count = _Objects_Get_maximum_index( information ) / objects_per_block; 400087d8: 03065633 divu a2,a2,a6 for ( block = 1; block < block_count; block++ ) { 400087dc: 02c7fa63 bgeu a5,a2,40008810 <_Objects_Shrink_information+0x44> 400087e0: 02452783 lw a5,36(a0) 400087e4: 00100593 li a1,1 400087e8: 00278793 addi a5,a5,2 400087ec: 0100006f j 400087fc <_Objects_Shrink_information+0x30> 400087f0: 01069593 slli a1,a3,0x10 400087f4: 0105d593 srli a1,a1,0x10 400087f8: 00b60c63 beq a2,a1,40008810 <_Objects_Shrink_information+0x44> if ( information->inactive_per_block[ block ] == objects_per_block ) { 400087fc: 0007d703 lhu a4,0(a5) for ( block = 1; block < block_count; block++ ) { 40008800: 00158693 addi a3,a1,1 40008804: 00278793 addi a5,a5,2 if ( information->inactive_per_block[ block ] == objects_per_block ) { 40008808: ff0714e3 bne a4,a6,400087f0 <_Objects_Shrink_information+0x24> _Objects_Free_objects_block( information, block ); 4000880c: eedff06f j 400086f8 <_Objects_Free_objects_block> return; } } } 40008810: 00008067 ret <== NOT EXECUTED =============================================================================== 4001021c <_Once>: .Mutex = RTEMS_MUTEX_INITIALIZER( "_Once" ), .State = RTEMS_CONDITION_VARIABLE_INITIALIZER( "_Once" ) }; int _Once( unsigned char *once_state, void ( *init_routine )( void ) ) { 4001021c: fd010113 addi sp,sp,-48 40010220: 02112623 sw ra,44(sp) 40010224: 02812423 sw s0,40(sp) 40010228: 02912223 sw s1,36(sp) 4001022c: 03212023 sw s2,32(sp) 40010230: 01312e23 sw s3,28(sp) 40010234: 01412c23 sw s4,24(sp) 40010238: 01512a23 sw s5,20(sp) _Atomic_Fence( ATOMIC_ORDER_ACQUIRE ); if ( RTEMS_PREDICT_FALSE( *once_state != ONCE_STATE_COMPLETE ) ) { 4001023c: 00054783 lbu a5,0(a0) 40010240: 00200493 li s1,2 40010244: 02979663 bne a5,s1,40010270 <_Once+0x54> _Once_Unlock( thread_life_state ); } return 0; } 40010248: 02c12083 lw ra,44(sp) 4001024c: 02812403 lw s0,40(sp) 40010250: 02412483 lw s1,36(sp) 40010254: 02012903 lw s2,32(sp) 40010258: 01c12983 lw s3,28(sp) 4001025c: 01812a03 lw s4,24(sp) 40010260: 01412a83 lw s5,20(sp) 40010264: 00000513 li a0,0 40010268: 03010113 addi sp,sp,48 4001026c: 00008067 ret 40010270: 00050413 mv s0,a0 Thread_Life_state _Once_Lock( void ) { Thread_Life_state thread_life_state; thread_life_state = _Thread_Set_life_protection( THREAD_LIFE_PROTECTED ); 40010274: 00100513 li a0,1 40010278: 00b12623 sw a1,12(sp) _Mutex_Acquire( mutex ); 4001027c: 40021937 lui s2,0x40021 40010280: ce5fa0ef jal ra,4000af64 <_Thread_Set_life_protection> 40010284: 00050a93 mv s5,a0 40010288: 90890513 addi a0,s2,-1784 # 40020908 <_Once_Information> 4001028c: 805f80ef jal ra,40008a90 <_Mutex_Acquire> if ( *once_state == ONCE_STATE_INIT ) { 40010290: 00044783 lbu a5,0(s0) 40010294: 00c12583 lw a1,12(sp) 40010298: 90890993 addi s3,s2,-1784 4001029c: 02078e63 beqz a5,400102d8 <_Once+0xbc> <== ALWAYS TAKEN while ( *once_state != ONCE_STATE_COMPLETE ) { 400102a0: 400219b7 lui s3,0x40021 <== NOT EXECUTED 400102a4: 91c98993 addi s3,s3,-1764 # 4002091c <_Once_Information+0x14> <== NOT EXECUTED 400102a8: 00200a13 li s4,2 <== NOT EXECUTED 400102ac: 00978c63 beq a5,s1,400102c4 <_Once+0xa8> <== NOT EXECUTED _Condition_Wait( condition_variable, mutex ); 400102b0: 90890593 addi a1,s2,-1784 <== NOT EXECUTED 400102b4: 00098513 mv a0,s3 <== NOT EXECUTED 400102b8: 885ff0ef jal ra,4000fb3c <_Condition_Wait> <== NOT EXECUTED 400102bc: 00044783 lbu a5,0(s0) <== NOT EXECUTED 400102c0: ff4798e3 bne a5,s4,400102b0 <_Once+0x94> <== NOT EXECUTED _Mutex_Release( mutex ); 400102c4: 90890513 addi a0,s2,-1784 400102c8: 839f80ef jal ra,40008b00 <_Mutex_Release> } void _Once_Unlock( Thread_Life_state thread_life_state ) { rtems_mutex_unlock( &_Once_Information.Mutex ); _Thread_Set_life_protection( thread_life_state ); 400102cc: 000a8513 mv a0,s5 400102d0: c95fa0ef jal ra,4000af64 <_Thread_Set_life_protection> } 400102d4: f75ff06f j 40010248 <_Once+0x2c> *once_state = ONCE_STATE_RUNNING; 400102d8: 00100793 li a5,1 400102dc: 00f40023 sb a5,0(s0) 400102e0: 90890513 addi a0,s2,-1784 400102e4: 00b12623 sw a1,12(sp) 400102e8: 819f80ef jal ra,40008b00 <_Mutex_Release> _Thread_Set_life_protection( thread_life_state ); 400102ec: 00100513 li a0,1 400102f0: c75fa0ef jal ra,4000af64 <_Thread_Set_life_protection> ( *init_routine )(); 400102f4: 00c12583 lw a1,12(sp) 400102f8: 000580e7 jalr a1 thread_life_state = _Thread_Set_life_protection( THREAD_LIFE_PROTECTED ); 400102fc: 00100513 li a0,1 40010300: c65fa0ef jal ra,4000af64 <_Thread_Set_life_protection> _Mutex_Acquire( mutex ); 40010304: 90890513 addi a0,s2,-1784 40010308: f88f80ef jal ra,40008a90 <_Mutex_Acquire> *once_state = ONCE_STATE_COMPLETE; 4001030c: 00940023 sb s1,0(s0) _Condition_Broadcast( condition_variable ); 40010310: 01498513 addi a0,s3,20 40010314: 891ff0ef jal ra,4000fba4 <_Condition_Broadcast> } 40010318: fadff06f j 400102c4 <_Once+0xa8> =============================================================================== 4000d908 <_Processor_mask_Copy>: ) { long inclusive = 0; long exclusive = 0; if ( ( dst_size | src_size ) % sizeof( long ) != 0 ) { 4000d908: 00d5e733 or a4,a1,a3 { 4000d90c: 00050793 mv a5,a0 if ( ( dst_size | src_size ) % sizeof( long ) != 0 ) { 4000d910: 00377513 andi a0,a4,3 4000d914: 08051063 bnez a0,4000d994 <_Processor_mask_Copy+0x8c> return PROCESSOR_MASK_COPY_INVALID_SIZE; } while ( dst_size > 0 && src_size > 0 ) { 4000d918: 08058263 beqz a1,4000d99c <_Processor_mask_Copy+0x94> 4000d91c: 06068263 beqz a3,4000d980 <_Processor_mask_Copy+0x78> long inclusive = 0; 4000d920: 00000813 li a6,0 4000d924: 0080006f j 4000d92c <_Processor_mask_Copy+0x24> while ( dst_size > 0 && src_size > 0 ) { 4000d928: 04068c63 beqz a3,4000d980 <_Processor_mask_Copy+0x78> <== ALWAYS TAKEN long bits = *src; 4000d92c: 00062703 lw a4,0(a2) inclusive |= bits; *dst = bits; ++dst; ++src; dst_size -= sizeof( long ); 4000d930: ffc58593 addi a1,a1,-4 src_size -= sizeof( long ); 4000d934: ffc68693 addi a3,a3,-4 *dst = bits; 4000d938: 00e7a023 sw a4,0(a5) inclusive |= bits; 4000d93c: 00e86833 or a6,a6,a4 ++dst; 4000d940: 00478793 addi a5,a5,4 ++src; 4000d944: 00460613 addi a2,a2,4 while ( dst_size > 0 && src_size > 0 ) { 4000d948: fe0590e3 bnez a1,4000d928 <_Processor_mask_Copy+0x20> *dst = 0; ++dst; dst_size -= sizeof( long ); } while ( src_size > 0 ) { 4000d94c: 02068663 beqz a3,4000d978 <_Processor_mask_Copy+0x70> long exclusive = 0; 4000d950: 00000793 li a5,0 4000d954: 00d606b3 add a3,a2,a3 exclusive |= *src; 4000d958: 00062703 lw a4,0(a2) ++src; 4000d95c: 00460613 addi a2,a2,4 exclusive |= *src; 4000d960: 00e7e7b3 or a5,a5,a4 while ( src_size > 0 ) { 4000d964: fed61ae3 bne a2,a3,4000d958 <_Processor_mask_Copy+0x50> src_size -= sizeof( long ); } if ( exclusive != 0 ) { 4000d968: 00078a63 beqz a5,4000d97c <_Processor_mask_Copy+0x74> if ( inclusive != 0 ) { return PROCESSOR_MASK_COPY_PARTIAL_LOSS; } else { return PROCESSOR_MASK_COPY_COMPLETE_LOSS; 4000d96c: 00183513 seqz a0,a6 4000d970: 00150513 addi a0,a0,1 4000d974: 00008067 ret } } return PROCESSOR_MASK_COPY_LOSSLESS; 4000d978: 00000513 li a0,0 } 4000d97c: 00008067 ret 4000d980: 00b785b3 add a1,a5,a1 *dst = 0; 4000d984: 0007a023 sw zero,0(a5) ++dst; 4000d988: 00478793 addi a5,a5,4 while ( dst_size > 0 ) { 4000d98c: feb79ce3 bne a5,a1,4000d984 <_Processor_mask_Copy+0x7c> 4000d990: 00008067 ret return PROCESSOR_MASK_COPY_INVALID_SIZE; 4000d994: 00300513 li a0,3 4000d998: 00008067 ret long inclusive = 0; 4000d99c: 00000813 li a6,0 4000d9a0: fadff06f j 4000d94c <_Processor_mask_Copy+0x44> =============================================================================== 4001031c <_RBTree_Extract>: #include RB_GENERATE_REMOVE_COLOR( RBTree_Control, RBTree_Node, Node, static ) RB_GENERATE_REMOVE( RBTree_Control, RBTree_Node, Node, static ) 4001031c: 0005a683 lw a3,0(a1) 40010320: 0045a783 lw a5,4(a1) 40010324: 1e068463 beqz a3,4001050c <_RBTree_Extract+0x1f0> 40010328: 0a078063 beqz a5,400103c8 <_RBTree_Extract+0xac> 4001032c: 00078693 mv a3,a5 40010330: 0007a783 lw a5,0(a5) 40010334: fe079ce3 bnez a5,4001032c <_RBTree_Extract+0x10> 40010338: 0086a703 lw a4,8(a3) 4001033c: 0046a783 lw a5,4(a3) 40010340: 00c6a603 lw a2,12(a3) 40010344: 00070813 mv a6,a4 40010348: 00078663 beqz a5,40010354 <_RBTree_Extract+0x38> 4001034c: 00e7a423 sw a4,8(a5) 40010350: 0086a803 lw a6,8(a3) 40010354: 26070463 beqz a4,400105bc <_RBTree_Extract+0x2a0> <== NEVER TAKEN 40010358: 00072883 lw a7,0(a4) # 1000 <_ISR_Stack_size> 4001035c: 23168e63 beq a3,a7,40010598 <_RBTree_Extract+0x27c> 40010360: 00f72223 sw a5,4(a4) 40010364: 23058e63 beq a1,a6,400105a0 <_RBTree_Extract+0x284> 40010368: 0085a803 lw a6,8(a1) 4001036c: 0005ae03 lw t3,0(a1) 40010370: 0045a303 lw t1,4(a1) 40010374: 00c5a883 lw a7,12(a1) 40010378: 01c6a023 sw t3,0(a3) 4001037c: 0066a223 sw t1,4(a3) 40010380: 0106a423 sw a6,8(a3) 40010384: 0085a803 lw a6,8(a1) 40010388: 0116a623 sw a7,12(a3) 4001038c: 22080c63 beqz a6,400105c4 <_RBTree_Extract+0x2a8> 40010390: 00082883 lw a7,0(a6) 40010394: 25158263 beq a1,a7,400105d8 <_RBTree_Extract+0x2bc> 40010398: 00d82223 sw a3,4(a6) 4001039c: 0005a803 lw a6,0(a1) 400103a0: 0045a583 lw a1,4(a1) 400103a4: 00d82423 sw a3,8(a6) 400103a8: 00058463 beqz a1,400103b0 <_RBTree_Extract+0x94> 400103ac: 00d5a423 sw a3,8(a1) 400103b0: 00070863 beqz a4,400103c0 <_RBTree_Extract+0xa4> <== NEVER TAKEN 400103b4: 00070693 mv a3,a4 400103b8: 0086a683 lw a3,8(a3) 400103bc: fe069ee3 bnez a3,400103b8 <_RBTree_Extract+0x9c> 400103c0: 02060663 beqz a2,400103ec <_RBTree_Extract+0xd0> ) { _Assert( _RBTree_Find_root( the_node ) == _RBTree_Root( the_rbtree ) ); RB_REMOVE( RBTree_Control, the_rbtree, the_node ); _RBTree_Initialize_node( the_node ); } 400103c4: 00008067 ret RB_GENERATE_REMOVE( RBTree_Control, RBTree_Node, Node, static ) 400103c8: 0085a703 lw a4,8(a1) 400103cc: 00c5a603 lw a2,12(a1) 400103d0: 00068793 mv a5,a3 400103d4: 00e7a423 sw a4,8(a5) 400103d8: 14070263 beqz a4,4001051c <_RBTree_Extract+0x200> 400103dc: 00072683 lw a3,0(a4) 400103e0: 1cd58a63 beq a1,a3,400105b4 <_RBTree_Extract+0x298> 400103e4: 00f72223 sw a5,4(a4) 400103e8: fc061ee3 bnez a2,400103c4 <_RBTree_Extract+0xa8> RB_GENERATE_REMOVE_COLOR( RBTree_Control, RBTree_Node, Node, static ) 400103ec: 00100613 li a2,1 400103f0: 00078663 beqz a5,400103fc <_RBTree_Extract+0xe0> 400103f4: 00c7a683 lw a3,12(a5) 400103f8: 1e069463 bnez a3,400105e0 <_RBTree_Extract+0x2c4> 400103fc: 00052683 lw a3,0(a0) 40010400: 18d78463 beq a5,a3,40010588 <_RBTree_Extract+0x26c> 40010404: 00072683 lw a3,0(a4) 40010408: 04f68063 beq a3,a5,40010448 <_RBTree_Extract+0x12c> 4001040c: 00c6a783 lw a5,12(a3) 40010410: 0ac78a63 beq a5,a2,400104c4 <_RBTree_Extract+0x1a8> 40010414: 0006a783 lw a5,0(a3) 40010418: 00078663 beqz a5,40010424 <_RBTree_Extract+0x108> 4001041c: 00c7a583 lw a1,12(a5) 40010420: 10059e63 bnez a1,4001053c <_RBTree_Extract+0x220> 40010424: 0046a583 lw a1,4(a3) 40010428: 00058663 beqz a1,40010434 <_RBTree_Extract+0x118> 4001042c: 00c5a803 lw a6,12(a1) 40010430: 10081063 bnez a6,40010530 <_RBTree_Extract+0x214> 40010434: 00872583 lw a1,8(a4) 40010438: 00c6a623 sw a2,12(a3) 4001043c: 00070793 mv a5,a4 40010440: 00058713 mv a4,a1 40010444: fadff06f j 400103f0 <_RBTree_Extract+0xd4> 40010448: 00472783 lw a5,4(a4) 4001044c: 00c7a583 lw a1,12(a5) 40010450: 0007a683 lw a3,0(a5) 40010454: 02c58663 beq a1,a2,40010480 <_RBTree_Extract+0x164> 40010458: 00068663 beqz a3,40010464 <_RBTree_Extract+0x148> 4001045c: 00c6a583 lw a1,12(a3) 40010460: 1e059a63 bnez a1,40010654 <_RBTree_Extract+0x338> 40010464: 0047a583 lw a1,4(a5) 40010468: 00058663 beqz a1,40010474 <_RBTree_Extract+0x158> 4001046c: 00c5a683 lw a3,12(a1) 40010470: 1e069a63 bnez a3,40010664 <_RBTree_Extract+0x348> 40010474: 00872583 lw a1,8(a4) 40010478: 00c7a623 sw a2,12(a5) 4001047c: fc1ff06f j 4001043c <_RBTree_Extract+0x120> 40010480: 0007a623 sw zero,12(a5) 40010484: 00c72623 sw a2,12(a4) 40010488: 00d72223 sw a3,4(a4) 4001048c: 00068463 beqz a3,40010494 <_RBTree_Extract+0x178> <== NEVER TAKEN 40010490: 00e6a423 sw a4,8(a3) 40010494: 00872583 lw a1,8(a4) 40010498: 00b7a423 sw a1,8(a5) 4001049c: 10058663 beqz a1,400105a8 <_RBTree_Extract+0x28c> 400104a0: 0005a803 lw a6,0(a1) 400104a4: 13070463 beq a4,a6,400105cc <_RBTree_Extract+0x2b0> 400104a8: 00f5a223 sw a5,4(a1) 400104ac: 00472583 lw a1,4(a4) 400104b0: 00e7a023 sw a4,0(a5) 400104b4: 0005a683 lw a3,0(a1) 400104b8: 00f72423 sw a5,8(a4) 400104bc: 00058793 mv a5,a1 400104c0: f99ff06f j 40010458 <_RBTree_Extract+0x13c> 400104c4: 0046a783 lw a5,4(a3) 400104c8: 0006a623 sw zero,12(a3) 400104cc: 00c72623 sw a2,12(a4) 400104d0: 00f72023 sw a5,0(a4) 400104d4: 00078463 beqz a5,400104dc <_RBTree_Extract+0x1c0> <== NEVER TAKEN 400104d8: 00e7a423 sw a4,8(a5) 400104dc: 00872583 lw a1,8(a4) 400104e0: 00b6a423 sw a1,8(a3) 400104e4: 02058063 beqz a1,40010504 <_RBTree_Extract+0x1e8> 400104e8: 0005a803 lw a6,0(a1) 400104ec: 03070c63 beq a4,a6,40010524 <_RBTree_Extract+0x208> 400104f0: 00d5a223 sw a3,4(a1) 400104f4: 00e6a223 sw a4,4(a3) 400104f8: 00d72423 sw a3,8(a4) 400104fc: 00078693 mv a3,a5 40010500: f15ff06f j 40010414 <_RBTree_Extract+0xf8> 40010504: 00d52023 sw a3,0(a0) 40010508: fedff06f j 400104f4 <_RBTree_Extract+0x1d8> RB_GENERATE_REMOVE( RBTree_Control, RBTree_Node, Node, static ) 4001050c: 0085a703 lw a4,8(a1) 40010510: 00c5a603 lw a2,12(a1) 40010514: ec0790e3 bnez a5,400103d4 <_RBTree_Extract+0xb8> 40010518: ec0712e3 bnez a4,400103dc <_RBTree_Extract+0xc0> 4001051c: 00f52023 sw a5,0(a0) 40010520: ea1ff06f j 400103c0 <_RBTree_Extract+0xa4> RB_GENERATE_REMOVE_COLOR( RBTree_Control, RBTree_Node, Node, static ) 40010524: 00d5a023 sw a3,0(a1) 40010528: 00072783 lw a5,0(a4) 4001052c: fc9ff06f j 400104f4 <_RBTree_Extract+0x1d8> 40010530: 0a078c63 beqz a5,400105e8 <_RBTree_Extract+0x2cc> 40010534: 00c7a603 lw a2,12(a5) 40010538: 0a060863 beqz a2,400105e8 <_RBTree_Extract+0x2cc> <== ALWAYS TAKEN 4001053c: 00c72583 lw a1,12(a4) 40010540: 00072603 lw a2,0(a4) 40010544: 00b6a623 sw a1,12(a3) 40010548: 00072623 sw zero,12(a4) 4001054c: 0007a623 sw zero,12(a5) 40010550: 00462783 lw a5,4(a2) 40010554: 00f72023 sw a5,0(a4) 40010558: 00078463 beqz a5,40010560 <_RBTree_Extract+0x244> 4001055c: 00e7a423 sw a4,8(a5) 40010560: 00872783 lw a5,8(a4) 40010564: 00f62423 sw a5,8(a2) 40010568: 0e078063 beqz a5,40010648 <_RBTree_Extract+0x32c> 4001056c: 00872683 lw a3,8(a4) 40010570: 0006a683 lw a3,0(a3) 40010574: 18d70c63 beq a4,a3,4001070c <_RBTree_Extract+0x3f0> 40010578: 00052683 lw a3,0(a0) 4001057c: 00c7a223 sw a2,4(a5) 40010580: 00e62223 sw a4,4(a2) 40010584: 00c72423 sw a2,8(a4) 40010588: 00068663 beqz a3,40010594 <_RBTree_Extract+0x278> 4001058c: 0006a623 sw zero,12(a3) } 40010590: 00008067 ret 40010594: 00008067 ret RB_GENERATE_REMOVE( RBTree_Control, RBTree_Node, Node, static ) 40010598: 00f72023 sw a5,0(a4) 4001059c: dd0596e3 bne a1,a6,40010368 <_RBTree_Extract+0x4c> 400105a0: 00068713 mv a4,a3 400105a4: dc5ff06f j 40010368 <_RBTree_Extract+0x4c> RB_GENERATE_REMOVE_COLOR( RBTree_Control, RBTree_Node, Node, static ) 400105a8: 00f52023 sw a5,0(a0) 400105ac: 00068593 mv a1,a3 400105b0: f01ff06f j 400104b0 <_RBTree_Extract+0x194> RB_GENERATE_REMOVE( RBTree_Control, RBTree_Node, Node, static ) 400105b4: 00f72023 sw a5,0(a4) 400105b8: e09ff06f j 400103c0 <_RBTree_Extract+0xa4> 400105bc: 00f52023 sw a5,0(a0) <== NOT EXECUTED 400105c0: da5ff06f j 40010364 <_RBTree_Extract+0x48> <== NOT EXECUTED 400105c4: 00d52023 sw a3,0(a0) 400105c8: dd5ff06f j 4001039c <_RBTree_Extract+0x80> RB_GENERATE_REMOVE_COLOR( RBTree_Control, RBTree_Node, Node, static ) 400105cc: 00f5a023 sw a5,0(a1) 400105d0: 00068593 mv a1,a3 400105d4: eddff06f j 400104b0 <_RBTree_Extract+0x194> RB_GENERATE_REMOVE( RBTree_Control, RBTree_Node, Node, static ) 400105d8: 00d82023 sw a3,0(a6) 400105dc: dc1ff06f j 4001039c <_RBTree_Extract+0x80> 400105e0: 00078693 mv a3,a5 400105e4: fa9ff06f j 4001058c <_RBTree_Extract+0x270> RB_GENERATE_REMOVE_COLOR( RBTree_Control, RBTree_Node, Node, static ) 400105e8: 0005a783 lw a5,0(a1) 400105ec: 0005a623 sw zero,12(a1) 400105f0: 00100613 li a2,1 400105f4: 00c6a623 sw a2,12(a3) 400105f8: 00f6a223 sw a5,4(a3) 400105fc: 00078463 beqz a5,40010604 <_RBTree_Extract+0x2e8> 40010600: 00d7a423 sw a3,8(a5) 40010604: 0086a783 lw a5,8(a3) 40010608: 00f5a423 sw a5,8(a1) 4001060c: 02078a63 beqz a5,40010640 <_RBTree_Extract+0x324> <== NEVER TAKEN 40010610: 0007a603 lw a2,0(a5) 40010614: 10c68263 beq a3,a2,40010718 <_RBTree_Extract+0x3fc> 40010618: 00b7a223 sw a1,4(a5) <== NOT EXECUTED 4001061c: 00d5a023 sw a3,0(a1) 40010620: 00072603 lw a2,0(a4) 40010624: 00c72803 lw a6,12(a4) 40010628: 00b6a423 sw a1,8(a3) 4001062c: 00062783 lw a5,0(a2) 40010630: 01062623 sw a6,12(a2) 40010634: 00072623 sw zero,12(a4) 40010638: f0078ce3 beqz a5,40010550 <_RBTree_Extract+0x234> <== NEVER TAKEN 4001063c: f11ff06f j 4001054c <_RBTree_Extract+0x230> 40010640: 00b52023 sw a1,0(a0) <== NOT EXECUTED 40010644: fd9ff06f j 4001061c <_RBTree_Extract+0x300> <== NOT EXECUTED 40010648: 00c52023 sw a2,0(a0) 4001064c: 00060693 mv a3,a2 40010650: f31ff06f j 40010580 <_RBTree_Extract+0x264> 40010654: 0047a583 lw a1,4(a5) 40010658: 04058e63 beqz a1,400106b4 <_RBTree_Extract+0x398> 4001065c: 00c5a603 lw a2,12(a1) 40010660: 04060a63 beqz a2,400106b4 <_RBTree_Extract+0x398> 40010664: 00c72683 lw a3,12(a4) 40010668: 00472603 lw a2,4(a4) 4001066c: 00d7a623 sw a3,12(a5) 40010670: 00072623 sw zero,12(a4) 40010674: 0005a623 sw zero,12(a1) 40010678: 00062783 lw a5,0(a2) 4001067c: 00f72223 sw a5,4(a4) 40010680: 00078463 beqz a5,40010688 <_RBTree_Extract+0x36c> 40010684: 00e7a423 sw a4,8(a5) 40010688: 00872783 lw a5,8(a4) 4001068c: 00f62423 sw a5,8(a2) 40010690: 08078863 beqz a5,40010720 <_RBTree_Extract+0x404> 40010694: 0007a683 lw a3,0(a5) 40010698: 08d70a63 beq a4,a3,4001072c <_RBTree_Extract+0x410> 4001069c: 00052683 lw a3,0(a0) 400106a0: 00c7a223 sw a2,4(a5) 400106a4: 00e62023 sw a4,0(a2) 400106a8: 00c72423 sw a2,8(a4) 400106ac: ee0690e3 bnez a3,4001058c <_RBTree_Extract+0x270> <== ALWAYS TAKEN 400106b0: ee5ff06f j 40010594 <_RBTree_Extract+0x278> <== NOT EXECUTED 400106b4: 0046a603 lw a2,4(a3) 400106b8: 0006a623 sw zero,12(a3) 400106bc: 00100593 li a1,1 400106c0: 00b7a623 sw a1,12(a5) 400106c4: 00c7a023 sw a2,0(a5) 400106c8: 00060463 beqz a2,400106d0 <_RBTree_Extract+0x3b4> 400106cc: 00f62423 sw a5,8(a2) 400106d0: 0087a603 lw a2,8(a5) 400106d4: 00c6a423 sw a2,8(a3) 400106d8: 06060063 beqz a2,40010738 <_RBTree_Extract+0x41c> <== NEVER TAKEN 400106dc: 00062583 lw a1,0(a2) 400106e0: 06b78063 beq a5,a1,40010740 <_RBTree_Extract+0x424> 400106e4: 00d62223 sw a3,4(a2) 400106e8: 00f6a223 sw a5,4(a3) 400106ec: 00472603 lw a2,4(a4) 400106f0: 00c72803 lw a6,12(a4) 400106f4: 00d7a423 sw a3,8(a5) 400106f8: 00462583 lw a1,4(a2) 400106fc: 01062623 sw a6,12(a2) 40010700: 00072623 sw zero,12(a4) 40010704: f6058ae3 beqz a1,40010678 <_RBTree_Extract+0x35c> <== NEVER TAKEN 40010708: f6dff06f j 40010674 <_RBTree_Extract+0x358> 4001070c: 00052683 lw a3,0(a0) 40010710: 00c7a023 sw a2,0(a5) 40010714: e6dff06f j 40010580 <_RBTree_Extract+0x264> 40010718: 00b7a023 sw a1,0(a5) 4001071c: f01ff06f j 4001061c <_RBTree_Extract+0x300> 40010720: 00c52023 sw a2,0(a0) 40010724: 00060693 mv a3,a2 40010728: f7dff06f j 400106a4 <_RBTree_Extract+0x388> 4001072c: 00052683 lw a3,0(a0) 40010730: 00c7a023 sw a2,0(a5) 40010734: f71ff06f j 400106a4 <_RBTree_Extract+0x388> 40010738: 00d52023 sw a3,0(a0) <== NOT EXECUTED 4001073c: fadff06f j 400106e8 <_RBTree_Extract+0x3cc> <== NOT EXECUTED 40010740: 00d62023 sw a3,0(a2) <== NOT EXECUTED 40010744: fa5ff06f j 400106e8 <_RBTree_Extract+0x3cc> <== NOT EXECUTED =============================================================================== 40010748 <_RBTree_Insert_color>: #include "config.h" #endif #include RB_GENERATE_INSERT_COLOR( RBTree_Control, RBTree_Node, Node, static inline ) 40010748: 0085a783 lw a5,8(a1) 4001074c: 00100613 li a2,1 40010750: 06079063 bnez a5,400107b0 <_RBTree_Insert_color+0x68> 40010754: 0cc0006f j 40010820 <_RBTree_Insert_color+0xd8> 40010758: 00068663 beqz a3,40010764 <_RBTree_Insert_color+0x1c> 4001075c: 00c6a803 lw a6,12(a3) 40010760: 10c80a63 beq a6,a2,40010874 <_RBTree_Insert_color+0x12c> 40010764: 0007a683 lw a3,0(a5) 40010768: 0cb68263 beq a3,a1,4001082c <_RBTree_Insert_color+0xe4> 4001076c: 00472683 lw a3,4(a4) 40010770: 0007a623 sw zero,12(a5) 40010774: 00c72623 sw a2,12(a4) 40010778: 0006a783 lw a5,0(a3) 4001077c: 00f72223 sw a5,4(a4) 40010780: 00078463 beqz a5,40010788 <_RBTree_Insert_color+0x40> 40010784: 00e7a423 sw a4,8(a5) 40010788: 00872783 lw a5,8(a4) 4001078c: 00f6a423 sw a5,8(a3) 40010790: 0c078e63 beqz a5,4001086c <_RBTree_Insert_color+0x124> 40010794: 0007a803 lw a6,0(a5) 40010798: 0f070863 beq a4,a6,40010888 <_RBTree_Insert_color+0x140> 4001079c: 00d7a223 sw a3,4(a5) 400107a0: 00e6a023 sw a4,0(a3) 400107a4: 00d72423 sw a3,8(a4) 400107a8: 0085a783 lw a5,8(a1) 400107ac: 06078a63 beqz a5,40010820 <_RBTree_Insert_color+0xd8> 400107b0: 00c7a703 lw a4,12(a5) 400107b4: 06c71663 bne a4,a2,40010820 <_RBTree_Insert_color+0xd8> 400107b8: 0087a703 lw a4,8(a5) 400107bc: 00072683 lw a3,0(a4) 400107c0: f8f69ce3 bne a3,a5,40010758 <_RBTree_Insert_color+0x10> 400107c4: 00472683 lw a3,4(a4) 400107c8: 00068663 beqz a3,400107d4 <_RBTree_Insert_color+0x8c> 400107cc: 00c6a803 lw a6,12(a3) 400107d0: 0ac80263 beq a6,a2,40010874 <_RBTree_Insert_color+0x12c> 400107d4: 0047a803 lw a6,4(a5) 400107d8: 00078693 mv a3,a5 400107dc: 0ab80a63 beq a6,a1,40010890 <_RBTree_Insert_color+0x148> 400107e0: 0046a803 lw a6,4(a3) 400107e4: 0007a623 sw zero,12(a5) 400107e8: 00c72623 sw a2,12(a4) 400107ec: 01072023 sw a6,0(a4) 400107f0: 00080463 beqz a6,400107f8 <_RBTree_Insert_color+0xb0> 400107f4: 00e82423 sw a4,8(a6) 400107f8: 00872783 lw a5,8(a4) 400107fc: 00f6a423 sw a5,8(a3) 40010800: 0c078a63 beqz a5,400108d4 <_RBTree_Insert_color+0x18c> 40010804: 0007a803 lw a6,0(a5) 40010808: 0d070a63 beq a4,a6,400108dc <_RBTree_Insert_color+0x194> 4001080c: 00d7a223 sw a3,4(a5) 40010810: 00e6a223 sw a4,4(a3) 40010814: 00d72423 sw a3,8(a4) 40010818: 0085a783 lw a5,8(a1) 4001081c: f8079ae3 bnez a5,400107b0 <_RBTree_Insert_color+0x68> <== ALWAYS TAKEN 40010820: 00052783 lw a5,0(a0) 40010824: 0007a623 sw zero,12(a5) RBTree_Control *the_rbtree, RBTree_Node *the_node ) { RBTree_Control_RB_INSERT_COLOR( the_rbtree, the_node ); } 40010828: 00008067 ret RB_GENERATE_INSERT_COLOR( RBTree_Control, RBTree_Node, Node, static inline ) 4001082c: 0045a683 lw a3,4(a1) 40010830: 00d7a023 sw a3,0(a5) 40010834: 0a068c63 beqz a3,400108ec <_RBTree_Insert_color+0x1a4> 40010838: 00f6a423 sw a5,8(a3) 4001083c: 0087a683 lw a3,8(a5) 40010840: 00d5a423 sw a3,8(a1) 40010844: 0a068063 beqz a3,400108e4 <_RBTree_Insert_color+0x19c> <== NEVER TAKEN 40010848: 0006a803 lw a6,0(a3) 4001084c: 0af80863 beq a6,a5,400108fc <_RBTree_Insert_color+0x1b4> 40010850: 00b6a223 sw a1,4(a3) 40010854: 00f5a223 sw a5,4(a1) 40010858: 00058693 mv a3,a1 4001085c: 00b7a423 sw a1,8(a5) 40010860: 00078593 mv a1,a5 40010864: 00068793 mv a5,a3 40010868: f05ff06f j 4001076c <_RBTree_Insert_color+0x24> 4001086c: 00d52023 sw a3,0(a0) 40010870: f31ff06f j 400107a0 <_RBTree_Insert_color+0x58> 40010874: 0006a623 sw zero,12(a3) 40010878: 0007a623 sw zero,12(a5) 4001087c: 00c72623 sw a2,12(a4) 40010880: 00070593 mv a1,a4 40010884: f25ff06f j 400107a8 <_RBTree_Insert_color+0x60> 40010888: 00d7a023 sw a3,0(a5) 4001088c: f15ff06f j 400107a0 <_RBTree_Insert_color+0x58> 40010890: 0005a683 lw a3,0(a1) 40010894: 00d7a223 sw a3,4(a5) 40010898: 06068663 beqz a3,40010904 <_RBTree_Insert_color+0x1bc> 4001089c: 00f6a423 sw a5,8(a3) 400108a0: 0087a683 lw a3,8(a5) 400108a4: 00d5a423 sw a3,8(a1) 400108a8: 06068663 beqz a3,40010914 <_RBTree_Insert_color+0x1cc> <== NEVER TAKEN 400108ac: 0006a803 lw a6,0(a3) 400108b0: 04f80e63 beq a6,a5,4001090c <_RBTree_Insert_color+0x1c4> 400108b4: 00b6a223 sw a1,4(a3) <== NOT EXECUTED 400108b8: 00f5a023 sw a5,0(a1) 400108bc: 00058813 mv a6,a1 400108c0: 00072683 lw a3,0(a4) 400108c4: 00b7a423 sw a1,8(a5) 400108c8: 00078593 mv a1,a5 400108cc: 00080793 mv a5,a6 400108d0: f11ff06f j 400107e0 <_RBTree_Insert_color+0x98> 400108d4: 00d52023 sw a3,0(a0) 400108d8: f39ff06f j 40010810 <_RBTree_Insert_color+0xc8> 400108dc: 00d7a023 sw a3,0(a5) 400108e0: f31ff06f j 40010810 <_RBTree_Insert_color+0xc8> 400108e4: 00b52023 sw a1,0(a0) <== NOT EXECUTED 400108e8: f6dff06f j 40010854 <_RBTree_Insert_color+0x10c> <== NOT EXECUTED 400108ec: 00070693 mv a3,a4 400108f0: 0006a803 lw a6,0(a3) 400108f4: 00e5a423 sw a4,8(a1) 400108f8: f4f81ce3 bne a6,a5,40010850 <_RBTree_Insert_color+0x108> 400108fc: 00b6a023 sw a1,0(a3) <== NOT EXECUTED 40010900: f55ff06f j 40010854 <_RBTree_Insert_color+0x10c> <== NOT EXECUTED 40010904: 00e5a423 sw a4,8(a1) 40010908: 00070693 mv a3,a4 4001090c: 00b6a023 sw a1,0(a3) 40010910: fa9ff06f j 400108b8 <_RBTree_Insert_color+0x170> 40010914: 00b52023 sw a1,0(a0) <== NOT EXECUTED 40010918: fa1ff06f j 400108b8 <_RBTree_Insert_color+0x170> <== NOT EXECUTED =============================================================================== 4000540c <_RBTree_Iterate>: void _RBTree_Iterate( const RBTree_Control *rbtree, RBTree_Visitor visitor, void *visitor_arg ) { 4000540c: fe010113 addi sp,sp,-32 40005410: 00812c23 sw s0,24(sp) 40005414: 01212823 sw s2,16(sp) 40005418: 01312623 sw s3,12(sp) 4000541c: 00112e23 sw ra,28(sp) 40005420: 00912a23 sw s1,20(sp) 40005424: 00058993 mv s3,a1 40005428: 00060913 mv s2,a2 const RBTree_Node *current = _RBTree_Minimum( rbtree ); 4000542c: 048000ef jal ra,40005474 <_RBTree_Minimum> 40005430: 00050413 mv s0,a0 bool stop = false; while ( !stop && current != NULL ) { stop = ( *visitor )( current, visitor_arg ); 40005434: 00090593 mv a1,s2 40005438: 00040513 mv a0,s0 while ( !stop && current != NULL ) { 4000543c: 00040e63 beqz s0,40005458 <_RBTree_Iterate+0x4c> stop = ( *visitor )( current, visitor_arg ); 40005440: 000980e7 jalr s3 40005444: 00050493 mv s1,a0 current = _RBTree_Successor( current ); 40005448: 00040513 mv a0,s0 4000544c: 048000ef jal ra,40005494 <_RBTree_Successor> 40005450: 00050413 mv s0,a0 while ( !stop && current != NULL ) { 40005454: fe0480e3 beqz s1,40005434 <_RBTree_Iterate+0x28> <== ALWAYS TAKEN } } 40005458: 01c12083 lw ra,28(sp) 4000545c: 01812403 lw s0,24(sp) 40005460: 01412483 lw s1,20(sp) 40005464: 01012903 lw s2,16(sp) 40005468: 00c12983 lw s3,12(sp) 4000546c: 02010113 addi sp,sp,32 40005470: 00008067 ret =============================================================================== 4000e7fc <_SMP_barrier_Wait>: SMP_barrier_Control *control, SMP_barrier_State *state, unsigned int count ) { unsigned int sense = ~state->sense; 4000e7fc: 0005a683 lw a3,0(a1) { 4000e800: 00050713 mv a4,a0 unsigned int sense = ~state->sense; 4000e804: fff6c693 not a3,a3 unsigned int previous_value; bool performed_release; state->sense = sense; 4000e808: 00d5a023 sw a3,0(a1) __asm__ volatile ( 4000e80c: 300475f3 csrrci a1,mstatus,8 *obj = val + arg; 4000e810: 00052783 lw a5,0(a0) 4000e814: 00178793 addi a5,a5,1 4000e818: 00f52023 sw a5,0(a0) return mstatus & RISCV_MSTATUS_MIE; 4000e81c: 0085f593 andi a1,a1,8 __asm__ volatile ( "csrrs zero, mstatus, %0" : : "r" ( level ) ); 4000e820: 3005a073 csrs mstatus,a1 &control->value, 1U, ATOMIC_ORDER_RELAXED ); if ( previous_value + 1U == count ) { 4000e824: 00f60a63 beq a2,a5,4000e838 <_SMP_barrier_Wait+0x3c> val = *obj; 4000e828: 00472783 lw a5,4(a4) <== NOT EXECUTED _Atomic_Store_uint( &control->value, 0U, ATOMIC_ORDER_RELAXED ); _Atomic_Store_uint( &control->sense, sense, ATOMIC_ORDER_RELEASE ); performed_release = true; } else { while ( 4000e82c: fef69ee3 bne a3,a5,4000e828 <_SMP_barrier_Wait+0x2c> <== NOT EXECUTED _Atomic_Load_uint( &control->sense, ATOMIC_ORDER_ACQUIRE ) != sense ) { /* Wait */ } performed_release = false; 4000e830: 00000513 li a0,0 <== NOT EXECUTED } return performed_release; } 4000e834: 00008067 ret <== NOT EXECUTED *obj = desired; 4000e838: 00052023 sw zero,0(a0) performed_release = true; 4000e83c: 00100513 li a0,1 4000e840: 00d72223 sw a3,4(a4) 4000e844: 00008067 ret =============================================================================== 400057a4 <_Scheduler_CBS_Attach_thread>: Scheduler_CBS_Server *server; ISR_lock_Context lock_context; Thread_Control *the_thread; Scheduler_CBS_Node *node; if ( server_id >= _Scheduler_CBS_Maximum_servers ) { 400057a4: 400147b7 lui a5,0x40014 400057a8: d507a783 lw a5,-688(a5) # 40013d50 <_Scheduler_CBS_Maximum_servers> 400057ac: 0cf57263 bgeu a0,a5,40005870 <_Scheduler_CBS_Attach_thread+0xcc> { 400057b0: fe010113 addi sp,sp,-32 400057b4: 00812c23 sw s0,24(sp) return SCHEDULER_CBS_ERROR_INVALID_PARAMETER; } server = &_Scheduler_CBS_Server_list[ server_id ]; 400057b8: 40015437 lui s0,0x40015 400057bc: 00551513 slli a0,a0,0x5 400057c0: 3e840413 addi s0,s0,1000 # 400153e8 <_Scheduler_CBS_Server_list> 400057c4: 00850433 add s0,a0,s0 if ( !server->initialized ) { 400057c8: 01c44783 lbu a5,28(s0) { 400057cc: 00112e23 sw ra,28(sp) 400057d0: 00912a23 sw s1,20(sp) if ( !server->initialized ) { 400057d4: 08078a63 beqz a5,40005868 <_Scheduler_CBS_Attach_thread+0xc4> return SCHEDULER_CBS_ERROR_NOSERVER; } if ( server->task_id != -1 ) { 400057d8: 00042703 lw a4,0(s0) 400057dc: fff00793 li a5,-1 400057e0: 06f71463 bne a4,a5,40005848 <_Scheduler_CBS_Attach_thread+0xa4> return SCHEDULER_CBS_ERROR_FULL; } the_thread = _Thread_Get( task_id, &lock_context ); 400057e4: 00058493 mv s1,a1 400057e8: 00048513 mv a0,s1 400057ec: 00c10593 addi a1,sp,12 400057f0: 6bc010ef jal ra,40006eac <_Thread_Get> if ( the_thread == NULL ) { 400057f4: 06050663 beqz a0,40005860 <_Scheduler_CBS_Attach_thread+0xbc> return the_thread->Scheduler.nodes; 400057f8: 03852783 lw a5,56(a0) return SCHEDULER_CBS_ERROR_INVALID_PARAMETER; } node = _Scheduler_CBS_Thread_get_node( the_thread ); if ( node->cbs_server != NULL ) { 400057fc: 0507a703 lw a4,80(a5) 40005800: 04071863 bnez a4,40005850 <_Scheduler_CBS_Attach_thread+0xac> <== NEVER TAKEN _ISR_lock_ISR_enable( &lock_context ); return SCHEDULER_CBS_ERROR_FULL; } node->cbs_server = server; 40005804: 0487a823 sw s0,80(a5) server->task_id = task_id; the_thread->budget_callout = _Scheduler_CBS_Budget_callout; 40005808: 400067b7 lui a5,0x40006 server->task_id = task_id; 4000580c: 00942023 sw s1,0(s0) the_thread->budget_callout = _Scheduler_CBS_Budget_callout; 40005810: 87878793 addi a5,a5,-1928 # 40005878 <_Scheduler_CBS_Budget_callout> 40005814: 08f52a23 sw a5,148(a0) the_thread->budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_CALLOUT; 40005818: 00300793 li a5,3 4000581c: 08f52823 sw a5,144(a0) the_thread->is_preemptible = true; 40005820: 00100793 li a5,1 40005824: 08f504a3 sb a5,137(a0) __asm__ volatile ( "csrrs zero, mstatus, %0" : : "r" ( level ) ); 40005828: 00c12783 lw a5,12(sp) 4000582c: 3007a073 csrs mstatus,a5 _ISR_lock_ISR_enable( &lock_context ); return SCHEDULER_CBS_OK; 40005830: 00000513 li a0,0 } 40005834: 01c12083 lw ra,28(sp) 40005838: 01812403 lw s0,24(sp) 4000583c: 01412483 lw s1,20(sp) 40005840: 02010113 addi sp,sp,32 40005844: 00008067 ret return SCHEDULER_CBS_ERROR_FULL; 40005848: fe600513 li a0,-26 4000584c: fe9ff06f j 40005834 <_Scheduler_CBS_Attach_thread+0x90> 40005850: 00c12783 lw a5,12(sp) <== NOT EXECUTED 40005854: 3007a073 csrs mstatus,a5 <== NOT EXECUTED return SCHEDULER_CBS_ERROR_FULL; 40005858: fe600513 li a0,-26 <== NOT EXECUTED 4000585c: fd9ff06f j 40005834 <_Scheduler_CBS_Attach_thread+0x90> <== NOT EXECUTED return SCHEDULER_CBS_ERROR_INVALID_PARAMETER; 40005860: fee00513 li a0,-18 40005864: fd1ff06f j 40005834 <_Scheduler_CBS_Attach_thread+0x90> return SCHEDULER_CBS_ERROR_NOSERVER; 40005868: fe700513 li a0,-25 4000586c: fc9ff06f j 40005834 <_Scheduler_CBS_Attach_thread+0x90> return SCHEDULER_CBS_ERROR_INVALID_PARAMETER; 40005870: fee00513 li a0,-18 } 40005874: 00008067 ret =============================================================================== 40005878 <_Scheduler_CBS_Budget_callout>: #include void _Scheduler_CBS_Budget_callout( Thread_Control *the_thread ) { 40005878: fc010113 addi sp,sp,-64 4000587c: 02812c23 sw s0,56(sp) 40005880: 03852403 lw s0,56(a0) 40005884: 00050593 mv a1,a0 node = _Scheduler_CBS_Thread_get_node( the_thread ); /* Put violating task to background until the end of period. */ _Thread_queue_Context_clear_priority_updates( &queue_context ); _Scheduler_CBS_Cancel_job( 40005888: 00c10693 addi a3,sp,12 4000588c: 05442603 lw a2,84(s0) 40005890: 00000513 li a0,0 { 40005894: 02112e23 sw ra,60(sp) queue_context->Priority.update_count = 0; 40005898: 02012023 sw zero,32(sp) _Scheduler_CBS_Cancel_job( 4000589c: 588000ef jal ra,40005e24 <_Scheduler_CBS_Cancel_job> NULL, the_thread, node->deadline_node, &queue_context ); _Thread_Priority_update( &queue_context ); 400058a0: 00c10513 addi a0,sp,12 400058a4: 2fc010ef jal ra,40006ba0 <_Thread_Priority_update> /* Invoke callback function if any. */ if ( node->cbs_server->cbs_budget_overrun ) { 400058a8: 05042783 lw a5,80(s0) 400058ac: 0187a703 lw a4,24(a5) 400058b0: 02070063 beqz a4,400058d0 <_Scheduler_CBS_Budget_callout+0x58> <== NEVER TAKEN _Scheduler_CBS_Get_server_id( 400058b4: 0007a503 lw a0,0(a5) 400058b8: 00810593 addi a1,sp,8 400058bc: 4d8000ef jal ra,40005d94 <_Scheduler_CBS_Get_server_id> node->cbs_server->task_id, &server_id ); node->cbs_server->cbs_budget_overrun( server_id ); 400058c0: 05042783 lw a5,80(s0) 400058c4: 00812503 lw a0,8(sp) 400058c8: 0187a783 lw a5,24(a5) 400058cc: 000780e7 jalr a5 } } 400058d0: 03c12083 lw ra,60(sp) 400058d4: 03812403 lw s0,56(sp) 400058d8: 04010113 addi sp,sp,64 400058dc: 00008067 ret =============================================================================== 400058e8 <_Scheduler_CBS_Cleanup>: #include #include int _Scheduler_CBS_Cleanup (void) { 400058e8: ff010113 addi sp,sp,-16 unsigned int i; for ( i = 0; i<_Scheduler_CBS_Maximum_servers; i++ ) { 400058ec: 400147b7 lui a5,0x40014 { 400058f0: 01212023 sw s2,0(sp) for ( i = 0; i<_Scheduler_CBS_Maximum_servers; i++ ) { 400058f4: d507a903 lw s2,-688(a5) # 40013d50 <_Scheduler_CBS_Maximum_servers> { 400058f8: 00112623 sw ra,12(sp) 400058fc: 00812423 sw s0,8(sp) 40005900: 00912223 sw s1,4(sp) for ( i = 0; i<_Scheduler_CBS_Maximum_servers; i++ ) { 40005904: 02090c63 beqz s2,4000593c <_Scheduler_CBS_Cleanup+0x54> <== NEVER TAKEN 40005908: 400154b7 lui s1,0x40015 4000590c: 40448493 addi s1,s1,1028 # 40015404 <_Scheduler_CBS_Server_list+0x1c> 40005910: 00000413 li s0,0 40005914: 00c0006f j 40005920 <_Scheduler_CBS_Cleanup+0x38> 40005918: 00140413 addi s0,s0,1 4000591c: 03240063 beq s0,s2,4000593c <_Scheduler_CBS_Cleanup+0x54> if ( _Scheduler_CBS_Server_list[ i ].initialized ) 40005920: 0004c783 lbu a5,0(s1) for ( i = 0; i<_Scheduler_CBS_Maximum_servers; i++ ) { 40005924: 02048493 addi s1,s1,32 if ( _Scheduler_CBS_Server_list[ i ].initialized ) 40005928: fe0788e3 beqz a5,40005918 <_Scheduler_CBS_Cleanup+0x30> _Scheduler_CBS_Destroy_server( i ); 4000592c: 00040513 mv a0,s0 for ( i = 0; i<_Scheduler_CBS_Maximum_servers; i++ ) { 40005930: 00140413 addi s0,s0,1 _Scheduler_CBS_Destroy_server( i ); 40005934: 0e0000ef jal ra,40005a14 <_Scheduler_CBS_Destroy_server> for ( i = 0; i<_Scheduler_CBS_Maximum_servers; i++ ) { 40005938: ff2414e3 bne s0,s2,40005920 <_Scheduler_CBS_Cleanup+0x38> } return SCHEDULER_CBS_OK; } 4000593c: 00c12083 lw ra,12(sp) 40005940: 00812403 lw s0,8(sp) 40005944: 00412483 lw s1,4(sp) 40005948: 00012903 lw s2,0(sp) 4000594c: 00000513 li a0,0 40005950: 01010113 addi sp,sp,16 40005954: 00008067 ret =============================================================================== 40005958 <_Scheduler_CBS_Create_server>: ) { unsigned int i; Scheduler_CBS_Server *the_server; if ( params->budget <= 0 || 40005958: 00c52783 lw a5,12(a0) 4000595c: 08f05a63 blez a5,400059f0 <_Scheduler_CBS_Create_server+0x98> <== ALWAYS TAKEN 40005960: 00452783 lw a5,4(a0) 40005964: 0af05063 blez a5,40005a04 <_Scheduler_CBS_Create_server+0xac> <== ALWAYS TAKEN params->deadline <= 0 || params->budget >= SCHEDULER_EDF_PRIO_MSB || params->deadline >= SCHEDULER_EDF_PRIO_MSB ) return SCHEDULER_CBS_ERROR_INVALID_PARAMETER; for ( i = 0; i<_Scheduler_CBS_Maximum_servers; i++ ) { 40005968: 400147b7 lui a5,0x40014 4000596c: d507a803 lw a6,-688(a5) # 40013d50 <_Scheduler_CBS_Maximum_servers> 40005970: 06080c63 beqz a6,400059e8 <_Scheduler_CBS_Create_server+0x90> <== NEVER TAKEN 40005974: 400157b7 lui a5,0x40015 40005978: 40478793 addi a5,a5,1028 # 40015404 <_Scheduler_CBS_Server_list+0x1c> 4000597c: 00000713 li a4,0 40005980: 00c0006f j 4000598c <_Scheduler_CBS_Create_server+0x34> 40005984: 00170713 addi a4,a4,1 40005988: 06e80063 beq a6,a4,400059e8 <_Scheduler_CBS_Create_server+0x90> if ( !_Scheduler_CBS_Server_list[i].initialized ) 4000598c: 0007c683 lbu a3,0(a5) for ( i = 0; i<_Scheduler_CBS_Maximum_servers; i++ ) { 40005990: 02078793 addi a5,a5,32 if ( !_Scheduler_CBS_Server_list[i].initialized ) 40005994: fe0698e3 bnez a3,40005984 <_Scheduler_CBS_Create_server+0x2c> if ( i == _Scheduler_CBS_Maximum_servers ) return SCHEDULER_CBS_ERROR_FULL; *server_id = i; the_server = &_Scheduler_CBS_Server_list[*server_id]; the_server->parameters = *params; 40005998: 400156b7 lui a3,0x40015 4000599c: 00052303 lw t1,0(a0) 400059a0: 00452883 lw a7,4(a0) 400059a4: 00852803 lw a6,8(a0) 400059a8: 00571793 slli a5,a4,0x5 400059ac: 00c52503 lw a0,12(a0) *server_id = i; 400059b0: 00e62023 sw a4,0(a2) the_server->parameters = *params; 400059b4: 3e868713 addi a4,a3,1000 # 400153e8 <_Scheduler_CBS_Server_list> 400059b8: 00e787b3 add a5,a5,a4 the_server->task_id = -1; 400059bc: fff00713 li a4,-1 400059c0: 00e7a023 sw a4,0(a5) the_server->cbs_budget_overrun = budget_overrun_callback; the_server->initialized = true; 400059c4: 00100713 li a4,1 the_server->parameters = *params; 400059c8: 00a7aa23 sw a0,20(a5) 400059cc: 0067a423 sw t1,8(a5) 400059d0: 0117a623 sw a7,12(a5) 400059d4: 0107a823 sw a6,16(a5) the_server->cbs_budget_overrun = budget_overrun_callback; 400059d8: 00b7ac23 sw a1,24(a5) the_server->initialized = true; 400059dc: 00e78e23 sb a4,28(a5) return SCHEDULER_CBS_OK; 400059e0: 00000513 li a0,0 400059e4: 00008067 ret return SCHEDULER_CBS_ERROR_FULL; 400059e8: fe600513 li a0,-26 } 400059ec: 00008067 ret if ( params->budget <= 0 || 400059f0: 00079663 bnez a5,400059fc <_Scheduler_CBS_Create_server+0xa4> 400059f4: 00852783 lw a5,8(a0) 400059f8: f60794e3 bnez a5,40005960 <_Scheduler_CBS_Create_server+0x8> <== ALWAYS TAKEN return SCHEDULER_CBS_ERROR_INVALID_PARAMETER; 400059fc: fee00513 li a0,-18 40005a00: 00008067 ret if ( params->budget <= 0 || 40005a04: fe079ce3 bnez a5,400059fc <_Scheduler_CBS_Create_server+0xa4> 40005a08: 00052783 lw a5,0(a0) 40005a0c: f4079ee3 bnez a5,40005968 <_Scheduler_CBS_Create_server+0x10> <== ALWAYS TAKEN 40005a10: fedff06f j 400059fc <_Scheduler_CBS_Create_server+0xa4> <== NOT EXECUTED =============================================================================== 40005cc8 <_Scheduler_CBS_Get_remaining_budget>: { Scheduler_CBS_Server *server; ISR_lock_Context lock_context; Thread_Control *the_thread; if ( server_id >= _Scheduler_CBS_Maximum_servers ) { 40005cc8: 400147b7 lui a5,0x40014 40005ccc: d507a783 lw a5,-688(a5) # 40013d50 <_Scheduler_CBS_Maximum_servers> 40005cd0: 0af57a63 bgeu a0,a5,40005d84 <_Scheduler_CBS_Get_remaining_budget+0xbc> return SCHEDULER_CBS_ERROR_INVALID_PARAMETER; } server = &_Scheduler_CBS_Server_list[ server_id ]; if ( !server->initialized ) { 40005cd4: 400157b7 lui a5,0x40015 40005cd8: 00551513 slli a0,a0,0x5 40005cdc: 3e878793 addi a5,a5,1000 # 400153e8 <_Scheduler_CBS_Server_list> 40005ce0: 00a787b3 add a5,a5,a0 40005ce4: 01c7c703 lbu a4,28(a5) 40005ce8: 0a070263 beqz a4,40005d8c <_Scheduler_CBS_Get_remaining_budget+0xc4> return SCHEDULER_CBS_ERROR_NOSERVER; } if ( server->task_id == -1 ) { 40005cec: 0007a503 lw a0,0(a5) { 40005cf0: fe010113 addi sp,sp,-32 40005cf4: 00812c23 sw s0,24(sp) 40005cf8: 00112e23 sw ra,28(sp) if ( server->task_id == -1 ) { 40005cfc: fff00713 li a4,-1 40005d00: 00058413 mv s0,a1 40005d04: 02e50c63 beq a0,a4,40005d3c <_Scheduler_CBS_Get_remaining_budget+0x74> *remaining_budget = server->parameters.budget; return SCHEDULER_CBS_OK; } the_thread = _Thread_Get( server->task_id, &lock_context ); 40005d08: 00c10593 addi a1,sp,12 40005d0c: 1a0010ef jal ra,40006eac <_Thread_Get> if ( the_thread != NULL ) { 40005d10: 04050863 beqz a0,40005d60 <_Scheduler_CBS_Get_remaining_budget+0x98> *remaining_budget = the_thread->cpu_time_budget; 40005d14: 08c52783 lw a5,140(a0) 40005d18: 00042223 sw zero,4(s0) 40005d1c: 00f42023 sw a5,0(s0) 40005d20: 00c12783 lw a5,12(sp) 40005d24: 3007a073 csrs mstatus,a5 } else { *remaining_budget = 0; } return SCHEDULER_CBS_OK; } 40005d28: 01c12083 lw ra,28(sp) 40005d2c: 01812403 lw s0,24(sp) <== NOT EXECUTED return SCHEDULER_CBS_OK; 40005d30: 00000513 li a0,0 } 40005d34: 02010113 addi sp,sp,32 <== NOT EXECUTED 40005d38: 00008067 ret *remaining_budget = server->parameters.budget; 40005d3c: 0107a703 lw a4,16(a5) 40005d40: 0147a783 lw a5,20(a5) } 40005d44: 01c12083 lw ra,28(sp) 40005d48: 01812403 lw s0,24(sp) *remaining_budget = server->parameters.budget; 40005d4c: 00e5a023 sw a4,0(a1) 40005d50: 00f5a223 sw a5,4(a1) return SCHEDULER_CBS_OK; 40005d54: 00000513 li a0,0 } 40005d58: 02010113 addi sp,sp,32 40005d5c: 00008067 ret *remaining_budget = 0; 40005d60: 00000793 li a5,0 40005d64: 00000813 li a6,0 } 40005d68: 01c12083 lw ra,28(sp) *remaining_budget = 0; 40005d6c: 00f42023 sw a5,0(s0) 40005d70: 01042223 sw a6,4(s0) } 40005d74: 01812403 lw s0,24(sp) return SCHEDULER_CBS_OK; 40005d78: 00000513 li a0,0 } 40005d7c: 02010113 addi sp,sp,32 40005d80: 00008067 ret return SCHEDULER_CBS_ERROR_INVALID_PARAMETER; 40005d84: fee00513 li a0,-18 40005d88: 00008067 ret return SCHEDULER_CBS_ERROR_NOSERVER; 40005d8c: fe700513 li a0,-25 } 40005d90: 00008067 ret =============================================================================== 40005d94 <_Scheduler_CBS_Get_server_id>: rtems_id task_id, Scheduler_CBS_Server_id *server_id ) { unsigned int i; for ( i = 0; i<_Scheduler_CBS_Maximum_servers; i++ ) { 40005d94: 400147b7 lui a5,0x40014 40005d98: d507a603 lw a2,-688(a5) # 40013d50 <_Scheduler_CBS_Maximum_servers> 40005d9c: 02060663 beqz a2,40005dc8 <_Scheduler_CBS_Get_server_id+0x34> <== NEVER TAKEN 40005da0: 400157b7 lui a5,0x40015 40005da4: 3e878793 addi a5,a5,1000 # 400153e8 <_Scheduler_CBS_Server_list> 40005da8: 00000713 li a4,0 if ( _Scheduler_CBS_Server_list[i].initialized && 40005dac: 01c7c683 lbu a3,28(a5) 40005db0: 00068663 beqz a3,40005dbc <_Scheduler_CBS_Get_server_id+0x28> 40005db4: 0007a683 lw a3,0(a5) 40005db8: 00a68c63 beq a3,a0,40005dd0 <_Scheduler_CBS_Get_server_id+0x3c> for ( i = 0; i<_Scheduler_CBS_Maximum_servers; i++ ) { 40005dbc: 00170713 addi a4,a4,1 40005dc0: 02078793 addi a5,a5,32 40005dc4: fec714e3 bne a4,a2,40005dac <_Scheduler_CBS_Get_server_id+0x18> _Scheduler_CBS_Server_list[i].task_id == task_id ) { *server_id = i; return SCHEDULER_CBS_OK; } } return SCHEDULER_CBS_ERROR_NOSERVER; 40005dc8: fe700513 li a0,-25 } 40005dcc: 00008067 ret *server_id = i; 40005dd0: 00e5a023 sw a4,0(a1) return SCHEDULER_CBS_OK; 40005dd4: 00000513 li a0,0 40005dd8: 00008067 ret =============================================================================== 40005e3c <_Scheduler_CBS_Set_parameters>: int _Scheduler_CBS_Set_parameters ( Scheduler_CBS_Server_id server_id, Scheduler_CBS_Parameters *params ) { if ( server_id >= _Scheduler_CBS_Maximum_servers ) 40005e3c: 400147b7 lui a5,0x40014 40005e40: d507a783 lw a5,-688(a5) # 40013d50 <_Scheduler_CBS_Maximum_servers> 40005e44: 06f57063 bgeu a0,a5,40005ea4 <_Scheduler_CBS_Set_parameters+0x68> return SCHEDULER_CBS_ERROR_INVALID_PARAMETER; if ( params->budget <= 0 || 40005e48: 00c5a783 lw a5,12(a1) 40005e4c: 04f05663 blez a5,40005e98 <_Scheduler_CBS_Set_parameters+0x5c> <== ALWAYS TAKEN 40005e50: 0045a783 lw a5,4(a1) 40005e54: 06f05063 blez a5,40005eb4 <_Scheduler_CBS_Set_parameters+0x78> <== ALWAYS TAKEN params->deadline <= 0 || params->budget >= SCHEDULER_EDF_PRIO_MSB || params->deadline >= SCHEDULER_EDF_PRIO_MSB ) return SCHEDULER_CBS_ERROR_INVALID_PARAMETER; if ( !_Scheduler_CBS_Server_list[server_id].initialized ) 40005e58: 400157b7 lui a5,0x40015 40005e5c: 00551513 slli a0,a0,0x5 40005e60: 3e878793 addi a5,a5,1000 # 400153e8 <_Scheduler_CBS_Server_list> 40005e64: 00a787b3 add a5,a5,a0 40005e68: 01c7c703 lbu a4,28(a5) 40005e6c: 04070063 beqz a4,40005eac <_Scheduler_CBS_Set_parameters+0x70> return SCHEDULER_CBS_ERROR_NOSERVER; _Scheduler_CBS_Server_list[server_id].parameters = *params; 40005e70: 0005a803 lw a6,0(a1) 40005e74: 0045a603 lw a2,4(a1) 40005e78: 0085a683 lw a3,8(a1) 40005e7c: 00c5a703 lw a4,12(a1) return SCHEDULER_CBS_OK; 40005e80: 00000513 li a0,0 _Scheduler_CBS_Server_list[server_id].parameters = *params; 40005e84: 0107a423 sw a6,8(a5) 40005e88: 00c7a623 sw a2,12(a5) 40005e8c: 00d7a823 sw a3,16(a5) 40005e90: 00e7aa23 sw a4,20(a5) return SCHEDULER_CBS_OK; 40005e94: 00008067 ret if ( params->budget <= 0 || 40005e98: 00079663 bnez a5,40005ea4 <_Scheduler_CBS_Set_parameters+0x68> 40005e9c: 0085a783 lw a5,8(a1) 40005ea0: fa0798e3 bnez a5,40005e50 <_Scheduler_CBS_Set_parameters+0x14> <== ALWAYS TAKEN return SCHEDULER_CBS_ERROR_INVALID_PARAMETER; 40005ea4: fee00513 li a0,-18 40005ea8: 00008067 ret return SCHEDULER_CBS_ERROR_NOSERVER; 40005eac: fe700513 li a0,-25 } 40005eb0: 00008067 ret if ( params->budget <= 0 || 40005eb4: fe0798e3 bnez a5,40005ea4 <_Scheduler_CBS_Set_parameters+0x68> 40005eb8: 0005a783 lw a5,0(a1) 40005ebc: f8079ee3 bnez a5,40005e58 <_Scheduler_CBS_Set_parameters+0x1c> <== ALWAYS TAKEN 40005ec0: fe5ff06f j 40005ea4 <_Scheduler_CBS_Set_parameters+0x68> <== NOT EXECUTED =============================================================================== 40005420 <_Scheduler_EDF_Schedule>: first = _RBTree_Minimum( &context->Ready ); 40005420: 00052503 lw a0,0(a0) void _Scheduler_EDF_Schedule( const Scheduler_Control *scheduler, Thread_Control *the_thread ) { 40005424: fe010113 addi sp,sp,-32 40005428: 00812c23 sw s0,24(sp) Thread_Control *heir = _Thread_Heir; 4000542c: 40015437 lui s0,0x40015 40005430: 00912a23 sw s1,20(sp) 40005434: 01212823 sw s2,16(sp) 40005438: 00112e23 sw ra,28(sp) 4000543c: 01312623 sw s3,12(sp) 40005440: 01412423 sw s4,8(sp) 40005444: b4040413 addi s0,s0,-1216 # 40014b40 <_Per_CPU_Information> 40005448: 0a9040ef jal ra,40009cf0 <_RBTree_Minimum> _Scheduler_Update_heir( node->Base.owner, force_dispatch ); 4000544c: fc852903 lw s2,-56(a0) 40005450: 03c42483 lw s1,60(s0) if ( heir != new_heir && ( heir->is_preemptible || force_dispatch ) ) { 40005454: 00990663 beq s2,s1,40005460 <_Scheduler_EDF_Schedule+0x40> 40005458: 0894c783 lbu a5,137(s1) <== NOT EXECUTED 4000545c: 02079263 bnez a5,40005480 <_Scheduler_EDF_Schedule+0x60> <== NOT EXECUTED _Scheduler_EDF_Schedule_body( scheduler, the_thread, false ); } 40005460: 01c12083 lw ra,28(sp) 40005464: 01812403 lw s0,24(sp) 40005468: 01412483 lw s1,20(sp) 4000546c: 01012903 lw s2,16(sp) 40005470: 00c12983 lw s3,12(sp) 40005474: 00812a03 lw s4,8(sp) 40005478: 02010113 addi sp,sp,32 4000547c: 00008067 ret 40005480: 04042983 lw s3,64(s0) <== NOT EXECUTED 40005484: 04442a03 lw s4,68(s0) <== NOT EXECUTED 40005488: d2cff0ef jal ra,400049b4 <_Timecounter_Sbinuptime> <== NOT EXECUTED 4000548c: 04a42023 sw a0,64(s0) <== NOT EXECUTED 40005490: 04b42223 sw a1,68(s0) <== NOT EXECUTED 40005494: 0984a703 lw a4,152(s1) <== NOT EXECUTED 40005498: 09c4a683 lw a3,156(s1) <== NOT EXECUTED *_result = *_end - *_start; 4000549c: 413507b3 sub a5,a0,s3 <== NOT EXECUTED 400054a0: 00f53533 sltu a0,a0,a5 <== NOT EXECUTED 400054a4: 414585b3 sub a1,a1,s4 <== NOT EXECUTED *_time += *_add; 400054a8: 00f707b3 add a5,a4,a5 <== NOT EXECUTED *_result = *_end - *_start; 400054ac: 40a585b3 sub a1,a1,a0 <== NOT EXECUTED *_time += *_add; 400054b0: 00e7b733 sltu a4,a5,a4 <== NOT EXECUTED 400054b4: 00b685b3 add a1,a3,a1 <== NOT EXECUTED 400054b8: 00b705b3 add a1,a4,a1 <== NOT EXECUTED 400054bc: 08f4ac23 sw a5,152(s1) <== NOT EXECUTED 400054c0: 08b4ae23 sw a1,156(s1) <== NOT EXECUTED _Thread_Dispatch_necessary = true; 400054c4: 00100793 li a5,1 <== NOT EXECUTED _Thread_Heir = new_heir; 400054c8: 03242e23 sw s2,60(s0) <== NOT EXECUTED 400054cc: 01c12083 lw ra,28(sp) <== NOT EXECUTED _Thread_Dispatch_necessary = true; 400054d0: 02f40a23 sb a5,52(s0) <== NOT EXECUTED 400054d4: 01812403 lw s0,24(sp) <== NOT EXECUTED 400054d8: 01412483 lw s1,20(sp) <== NOT EXECUTED 400054dc: 01012903 lw s2,16(sp) <== NOT EXECUTED 400054e0: 00c12983 lw s3,12(sp) <== NOT EXECUTED 400054e4: 00812a03 lw s4,8(sp) <== NOT EXECUTED 400054e8: 02010113 addi sp,sp,32 <== NOT EXECUTED 400054ec: 00008067 ret <== NOT EXECUTED =============================================================================== 400054f0 <_Scheduler_EDF_Unblock>: return scheduler->context; 400054f0: 00052503 lw a0,0(a0) void _Scheduler_EDF_Unblock( const Scheduler_Control *scheduler, Thread_Control *the_thread, Scheduler_Node *node ) { 400054f4: fe010113 addi sp,sp,-32 Priority_Control insert_priority; context = _Scheduler_EDF_Get_context( scheduler ); the_node = _Scheduler_EDF_Node_downcast( node ); priority = _Scheduler_Node_get_priority( &the_node->Base ); priority = SCHEDULER_PRIORITY_PURIFY( priority ); 400054f8: 03062803 lw a6,48(a2) { 400054fc: 00812c23 sw s0,24(sp) priority = SCHEDULER_PRIORITY_PURIFY( priority ); 40005500: 03462403 lw s0,52(a2) while ( *link != NULL ) { 40005504: 00052783 lw a5,0(a0) { 40005508: 01212823 sw s2,16(sp) 4000550c: 01312623 sw s3,12(sp) 40005510: 00112e23 sw ra,28(sp) 40005514: 00912a23 sw s1,20(sp) 40005518: 01412423 sw s4,8(sp) priority = SCHEDULER_PRIORITY_PURIFY( priority ); 4000551c: ffe87993 andi s3,a6,-2 insert_priority = SCHEDULER_PRIORITY_APPEND( priority ); the_node->priority = priority; 40005520: 05362423 sw s3,72(a2) 40005524: 04862623 sw s0,76(a2) { 40005528: 00058913 mv s2,a1 _RBTree_Insert_inline( 4000552c: 00186813 ori a6,a6,1 40005530: 03860593 addi a1,a2,56 40005534: 10078463 beqz a5,4000563c <_Scheduler_EDF_Unblock+0x14c> if ( ( *less )( key, parent ) ) { 40005538: 0147a703 lw a4,20(a5) return &RB_RIGHT( the_node, Node ); 4000553c: 00478693 addi a3,a5,4 if ( ( *less )( key, parent ) ) { 40005540: 00876863 bltu a4,s0,40005550 <_Scheduler_EDF_Unblock+0x60> 40005544: 00871e63 bne a4,s0,40005560 <_Scheduler_EDF_Unblock+0x70> 40005548: 0107a703 lw a4,16(a5) 4000554c: 01077a63 bgeu a4,a6,40005560 <_Scheduler_EDF_Unblock+0x70> while ( *link != NULL ) { 40005550: 0006a703 lw a4,0(a3) 40005554: 00070c63 beqz a4,4000556c <_Scheduler_EDF_Unblock+0x7c> 40005558: 00070793 mv a5,a4 4000555c: fddff06f j 40005538 <_Scheduler_EDF_Unblock+0x48> return &RB_LEFT( the_node, Node ); 40005560: 00078693 mv a3,a5 while ( *link != NULL ) { 40005564: 0006a703 lw a4,0(a3) 40005568: fe0718e3 bnez a4,40005558 <_Scheduler_EDF_Unblock+0x68> RB_SET( child, parent, Node ); 4000556c: 04f62023 sw a5,64(a2) 40005570: 00100793 li a5,1 40005574: 04f62223 sw a5,68(a2) 40005578: 02062e23 sw zero,60(a2) 4000557c: 02062c23 sw zero,56(a2) * a context switch. * Pseudo-ISR case: * Even if the thread isn't preemptible, if the new heir is * a pseudo-ISR system task, we need to do a context switch. */ if ( priority < _Thread_Get_priority( _Thread_Heir ) ) { 40005580: 400154b7 lui s1,0x40015 *link = child; 40005584: 00b6a023 sw a1,0(a3) 40005588: b4048493 addi s1,s1,-1216 # 40014b40 <_Per_CPU_Information> _RBTree_Insert_color( the_rbtree, the_node ); 4000558c: 590040ef jal ra,40009b1c <_RBTree_Insert_color> 40005590: 03c4aa03 lw s4,60(s1) */ RTEMS_INLINE_ROUTINE Priority_Control _Priority_Get_priority( const Priority_Aggregation *aggregation ) { return aggregation->Node.priority; 40005594: 038a2703 lw a4,56(s4) 40005598: 01c72783 lw a5,28(a4) 4000559c: 02f46863 bltu s0,a5,400055cc <_Scheduler_EDF_Unblock+0xdc> 400055a0: 02878263 beq a5,s0,400055c4 <_Scheduler_EDF_Unblock+0xd4> _Scheduler_Update_heir( the_thread, priority == ( SCHEDULER_EDF_PRIO_MSB | PRIORITY_PSEUDO_ISR ) ); } } 400055a4: 01c12083 lw ra,28(sp) 400055a8: 01812403 lw s0,24(sp) 400055ac: 01412483 lw s1,20(sp) 400055b0: 01012903 lw s2,16(sp) 400055b4: 00c12983 lw s3,12(sp) 400055b8: 00812a03 lw s4,8(sp) 400055bc: 02010113 addi sp,sp,32 400055c0: 00008067 ret if ( priority < _Thread_Get_priority( _Thread_Heir ) ) { 400055c4: 01872783 lw a5,24(a4) 400055c8: fcf9fee3 bgeu s3,a5,400055a4 <_Scheduler_EDF_Unblock+0xb4> if ( heir != new_heir && ( heir->is_preemptible || force_dispatch ) ) { 400055cc: fd2a0ce3 beq s4,s2,400055a4 <_Scheduler_EDF_Unblock+0xb4> _Scheduler_Update_heir( 400055d0: 800007b7 lui a5,0x80000 400055d4: 0087c433 xor s0,a5,s0 400055d8: 0089e9b3 or s3,s3,s0 400055dc: 00098663 beqz s3,400055e8 <_Scheduler_EDF_Unblock+0xf8> <== NEVER TAKEN 400055e0: 089a4783 lbu a5,137(s4) 400055e4: fc0780e3 beqz a5,400055a4 <_Scheduler_EDF_Unblock+0xb4> 400055e8: 0404a403 lw s0,64(s1) 400055ec: 0444a983 lw s3,68(s1) 400055f0: bc4ff0ef jal ra,400049b4 <_Timecounter_Sbinuptime> 400055f4: 04a4a023 sw a0,64(s1) 400055f8: 04b4a223 sw a1,68(s1) 400055fc: 098a2683 lw a3,152(s4) 40005600: 09ca2603 lw a2,156(s4) *_result = *_end - *_start; 40005604: 40850733 sub a4,a0,s0 40005608: 00e53533 sltu a0,a0,a4 4000560c: 413587b3 sub a5,a1,s3 *_time += *_add; 40005610: 00e68733 add a4,a3,a4 *_result = *_end - *_start; 40005614: 40a787b3 sub a5,a5,a0 *_time += *_add; 40005618: 00d736b3 sltu a3,a4,a3 4000561c: 00f607b3 add a5,a2,a5 40005620: 00f687b3 add a5,a3,a5 40005624: 08fa2e23 sw a5,156(s4) 40005628: 08ea2c23 sw a4,152(s4) _Thread_Dispatch_necessary = true; 4000562c: 00100793 li a5,1 _Thread_Heir = new_heir; 40005630: 0324ae23 sw s2,60(s1) _Thread_Dispatch_necessary = true; 40005634: 02f48a23 sb a5,52(s1) } 40005638: f6dff06f j 400055a4 <_Scheduler_EDF_Unblock+0xb4> link = _RBTree_Root_reference( the_rbtree ); 4000563c: 00050693 mv a3,a0 40005640: f2dff06f j 4000556c <_Scheduler_EDF_Unblock+0x7c> =============================================================================== 40005378 <_Scheduler_EDF_Unmap_priority>: Priority_Control _Scheduler_EDF_Unmap_priority( const Scheduler_Control *scheduler, Priority_Control priority ) { return SCHEDULER_PRIORITY_UNMAP( priority & ~SCHEDULER_EDF_PRIO_MSB ); 40005378: 01f61513 slli a0,a2,0x1f <== NOT EXECUTED 4000537c: 0015d593 srli a1,a1,0x1 <== NOT EXECUTED 40005380: 00161613 slli a2,a2,0x1 <== NOT EXECUTED } 40005384: 00b56533 or a0,a0,a1 <== NOT EXECUTED 40005388: 00265593 srli a1,a2,0x2 <== NOT EXECUTED 4000538c: 00008067 ret <== NOT EXECUTED =============================================================================== 400051d4 <_Scheduler_EDF_Update_priority>: Scheduler_EDF_Context *context; Scheduler_EDF_Node *the_node; Priority_Control priority; Priority_Control insert_priority; if ( !_Thread_Is_ready( the_thread ) ) { 400051d4: 01c5a783 lw a5,28(a1) 400051d8: 10079863 bnez a5,400052e8 <_Scheduler_EDF_Update_priority+0x114> { 400051dc: fe010113 addi sp,sp,-32 400051e0: 01312623 sw s3,12(sp) do { seq = _SMP_sequence_lock_Read_begin( &node->Priority.Lock ); #endif priority = node->Priority.value; 400051e4: 03062983 lw s3,48(a2) the_node = _Scheduler_EDF_Node_downcast( node ); insert_priority = _Scheduler_Node_get_priority( &the_node->Base ); priority = SCHEDULER_PRIORITY_PURIFY( insert_priority ); if ( priority == the_node->priority ) { 400051e8: 04862703 lw a4,72(a2) { 400051ec: 00812c23 sw s0,24(sp) 400051f0: 00912a23 sw s1,20(sp) 400051f4: 01212823 sw s2,16(sp) 400051f8: 00112e23 sw ra,28(sp) 400051fc: 01412423 sw s4,8(sp) 40005200: 01512223 sw s5,4(sp) priority = SCHEDULER_PRIORITY_PURIFY( insert_priority ); 40005204: ffe9f793 andi a5,s3,-2 40005208: 03462483 lw s1,52(a2) 4000520c: 00050913 mv s2,a0 40005210: 00060413 mv s0,a2 if ( priority == the_node->priority ) { 40005214: 0cf70463 beq a4,a5,400052dc <_Scheduler_EDF_Update_priority+0x108> return scheduler->context; 40005218: 00092a03 lw s4,0(s2) _RBTree_Extract( &context->Ready, &node->Node ); 4000521c: 03840a93 addi s5,s0,56 /* Nothing to do */ return; } the_node->priority = priority; 40005220: 04f42423 sw a5,72(s0) 40005224: 04942623 sw s1,76(s0) 40005228: 000a8593 mv a1,s5 4000522c: 000a0513 mv a0,s4 40005230: 4c0040ef jal ra,400096f0 <_RBTree_Extract> link = _RBTree_Root_reference( the_rbtree ); parent = NULL; is_new_minimum = true; while ( *link != NULL ) { 40005234: 000a2783 lw a5,0(s4) 40005238: 10078263 beqz a5,4000533c <_Scheduler_EDF_Update_priority+0x168><== NEVER TAKEN parent = *link; if ( ( *less )( key, parent ) ) { 4000523c: 0147a703 lw a4,20(a5) return &RB_RIGHT( the_node, Node ); 40005240: 00478693 addi a3,a5,4 if ( ( *less )( key, parent ) ) { 40005244: 00976863 bltu a4,s1,40005254 <_Scheduler_EDF_Update_priority+0x80> 40005248: 00971e63 bne a4,s1,40005264 <_Scheduler_EDF_Update_priority+0x90> 4000524c: 0107a703 lw a4,16(a5) 40005250: 01377a63 bgeu a4,s3,40005264 <_Scheduler_EDF_Update_priority+0x90> while ( *link != NULL ) { 40005254: 0006a703 lw a4,0(a3) 40005258: 00070c63 beqz a4,40005270 <_Scheduler_EDF_Update_priority+0x9c> <== NEVER TAKEN 4000525c: 00070793 mv a5,a4 40005260: fddff06f j 4000523c <_Scheduler_EDF_Update_priority+0x68> return &RB_LEFT( the_node, Node ); 40005264: 00078693 mv a3,a5 while ( *link != NULL ) { 40005268: 0006a703 lw a4,0(a3) 4000526c: fe0718e3 bnez a4,4000525c <_Scheduler_EDF_Update_priority+0x88> RB_SET( child, parent, Node ); 40005270: 00100993 li s3,1 40005274: 04f42023 sw a5,64(s0) 40005278: 02042e23 sw zero,60(s0) 4000527c: 02042c23 sw zero,56(s0) 40005280: 05342223 sw s3,68(s0) is_new_minimum = false; } } _RBTree_Add_child( the_node, parent, link ); _RBTree_Insert_color( the_rbtree, the_node ); 40005284: 000a8593 mv a1,s5 40005288: 000a0513 mv a0,s4 *link = child; 4000528c: 0156a023 sw s5,0(a3) _RBTree_Insert_color( the_rbtree, the_node ); 40005290: 08d040ef jal ra,40009b1c <_RBTree_Insert_color> first = _RBTree_Minimum( &context->Ready ); 40005294: 00092503 lw a0,0(s2) Thread_Control *heir = _Thread_Heir; 40005298: 40015437 lui s0,0x40015 4000529c: b4040413 addi s0,s0,-1216 # 40014b40 <_Per_CPU_Information> 400052a0: 251040ef jal ra,40009cf0 <_RBTree_Minimum> _Scheduler_Update_heir( node->Base.owner, force_dispatch ); 400052a4: fc852903 lw s2,-56(a0) 400052a8: 03c42483 lw s1,60(s0) if ( heir != new_heir && ( heir->is_preemptible || force_dispatch ) ) { 400052ac: 00990663 beq s2,s1,400052b8 <_Scheduler_EDF_Update_priority+0xe4> 400052b0: 0894c783 lbu a5,137(s1) 400052b4: 02079c63 bnez a5,400052ec <_Scheduler_EDF_Update_priority+0x118><== ALWAYS TAKEN context = _Scheduler_EDF_Get_context( scheduler ); _Scheduler_EDF_Extract( context, the_node ); _Scheduler_EDF_Enqueue( context, the_node, insert_priority ); _Scheduler_EDF_Schedule_body( scheduler, the_thread, false ); } 400052b8: 01c12083 lw ra,28(sp) 400052bc: 01812403 lw s0,24(sp) 400052c0: 01412483 lw s1,20(sp) 400052c4: 01012903 lw s2,16(sp) 400052c8: 00c12983 lw s3,12(sp) 400052cc: 00812a03 lw s4,8(sp) 400052d0: 00412a83 lw s5,4(sp) 400052d4: 02010113 addi sp,sp,32 400052d8: 00008067 ret if ( priority == the_node->priority ) { 400052dc: 04c62703 lw a4,76(a2) <== NOT EXECUTED 400052e0: f2971ce3 bne a4,s1,40005218 <_Scheduler_EDF_Update_priority+0x44> <== NOT EXECUTED 400052e4: fd5ff06f j 400052b8 <_Scheduler_EDF_Update_priority+0xe4> <== NOT EXECUTED 400052e8: 00008067 ret 400052ec: 04042a03 lw s4,64(s0) 400052f0: 04442a83 lw s5,68(s0) 400052f4: ec0ff0ef jal ra,400049b4 <_Timecounter_Sbinuptime> 400052f8: 04a42023 sw a0,64(s0) 400052fc: 04b42223 sw a1,68(s0) 40005300: 0984a703 lw a4,152(s1) 40005304: 09c4a683 lw a3,156(s1) *_result = *_end - *_start; 40005308: 414507b3 sub a5,a0,s4 4000530c: 00f53533 sltu a0,a0,a5 40005310: 415585b3 sub a1,a1,s5 *_time += *_add; 40005314: 00f707b3 add a5,a4,a5 *_result = *_end - *_start; 40005318: 40a585b3 sub a1,a1,a0 *_time += *_add; 4000531c: 00e7b733 sltu a4,a5,a4 40005320: 00b685b3 add a1,a3,a1 40005324: 00b70733 add a4,a4,a1 40005328: 08f4ac23 sw a5,152(s1) 4000532c: 08e4ae23 sw a4,156(s1) _Thread_Heir = new_heir; 40005330: 03242e23 sw s2,60(s0) _Thread_Dispatch_necessary = true; 40005334: 03340a23 sb s3,52(s0) 40005338: f81ff06f j 400052b8 <_Scheduler_EDF_Update_priority+0xe4> link = _RBTree_Root_reference( the_rbtree ); 4000533c: 000a0693 mv a3,s4 <== NOT EXECUTED 40005340: f31ff06f j 40005270 <_Scheduler_EDF_Update_priority+0x9c> <== NOT EXECUTED =============================================================================== 40005644 <_Scheduler_EDF_Yield>: void _Scheduler_EDF_Yield( const Scheduler_Control *scheduler, Thread_Control *the_thread, Scheduler_Node *node ) { 40005644: fe010113 addi sp,sp,-32 40005648: 01312623 sw s3,12(sp) return scheduler->context; 4000564c: 00052983 lw s3,0(a0) 40005650: 01412423 sw s4,8(sp) _RBTree_Extract( &context->Ready, &node->Node ); 40005654: 03860a13 addi s4,a2,56 40005658: 01212823 sw s2,16(sp) 4000565c: 000a0593 mv a1,s4 40005660: 00050913 mv s2,a0 40005664: 00098513 mv a0,s3 40005668: 00812c23 sw s0,24(sp) 4000566c: 00112e23 sw ra,28(sp) 40005670: 00060413 mv s0,a2 40005674: 00912a23 sw s1,20(sp) 40005678: 01512223 sw s5,4(sp) 4000567c: 074040ef jal ra,400096f0 <_RBTree_Extract> while ( *link != NULL ) { 40005680: 0009a783 lw a5,0(s3) context = _Scheduler_EDF_Get_context( scheduler ); the_node = _Scheduler_EDF_Node_downcast( node ); _Scheduler_EDF_Extract( context, the_node ); _Scheduler_EDF_Enqueue( context, the_node, the_node->priority ); 40005684: 04842603 lw a2,72(s0) 40005688: 04c42803 lw a6,76(s0) 4000568c: 0e078463 beqz a5,40005774 <_Scheduler_EDF_Yield+0x130> <== NEVER TAKEN if ( ( *less )( key, parent ) ) { 40005690: 0147a703 lw a4,20(a5) # 80000014 return &RB_RIGHT( the_node, Node ); 40005694: 00478693 addi a3,a5,4 if ( ( *less )( key, parent ) ) { 40005698: 01076863 bltu a4,a6,400056a8 <_Scheduler_EDF_Yield+0x64> 4000569c: 01071e63 bne a4,a6,400056b8 <_Scheduler_EDF_Yield+0x74> 400056a0: 0107a703 lw a4,16(a5) 400056a4: 00c77a63 bgeu a4,a2,400056b8 <_Scheduler_EDF_Yield+0x74> while ( *link != NULL ) { 400056a8: 0006a703 lw a4,0(a3) 400056ac: 00070c63 beqz a4,400056c4 <_Scheduler_EDF_Yield+0x80> 400056b0: 00070793 mv a5,a4 400056b4: fddff06f j 40005690 <_Scheduler_EDF_Yield+0x4c> return &RB_LEFT( the_node, Node ); 400056b8: 00078693 mv a3,a5 while ( *link != NULL ) { 400056bc: 0006a703 lw a4,0(a3) 400056c0: fe0718e3 bnez a4,400056b0 <_Scheduler_EDF_Yield+0x6c> <== ALWAYS TAKEN RB_SET( child, parent, Node ); 400056c4: 00100493 li s1,1 400056c8: 04f42023 sw a5,64(s0) 400056cc: 02042e23 sw zero,60(s0) 400056d0: 02042c23 sw zero,56(s0) 400056d4: 04942223 sw s1,68(s0) _RBTree_Insert_color( the_rbtree, the_node ); 400056d8: 000a0593 mv a1,s4 400056dc: 00098513 mv a0,s3 *link = child; 400056e0: 0146a023 sw s4,0(a3) _RBTree_Insert_color( the_rbtree, the_node ); 400056e4: 438040ef jal ra,40009b1c <_RBTree_Insert_color> first = _RBTree_Minimum( &context->Ready ); 400056e8: 00092503 lw a0,0(s2) Thread_Control *heir = _Thread_Heir; 400056ec: 40015437 lui s0,0x40015 400056f0: b4040413 addi s0,s0,-1216 # 40014b40 <_Per_CPU_Information> 400056f4: 5fc040ef jal ra,40009cf0 <_RBTree_Minimum> _Scheduler_Update_heir( node->Base.owner, force_dispatch ); 400056f8: fc852a03 lw s4,-56(a0) 400056fc: 03c42983 lw s3,60(s0) if ( heir != new_heir && ( heir->is_preemptible || force_dispatch ) ) { 40005700: 053a0863 beq s4,s3,40005750 <_Scheduler_EDF_Yield+0x10c> 40005704: 04042903 lw s2,64(s0) 40005708: 04442a83 lw s5,68(s0) 4000570c: aa8ff0ef jal ra,400049b4 <_Timecounter_Sbinuptime> 40005710: 04a42023 sw a0,64(s0) 40005714: 04b42223 sw a1,68(s0) 40005718: 0989a703 lw a4,152(s3) 4000571c: 09c9a683 lw a3,156(s3) *_result = *_end - *_start; 40005720: 412507b3 sub a5,a0,s2 40005724: 00f53533 sltu a0,a0,a5 40005728: 415585b3 sub a1,a1,s5 *_time += *_add; 4000572c: 00f707b3 add a5,a4,a5 *_result = *_end - *_start; 40005730: 40a585b3 sub a1,a1,a0 *_time += *_add; 40005734: 00e7b733 sltu a4,a5,a4 40005738: 00b685b3 add a1,a3,a1 4000573c: 00b705b3 add a1,a4,a1 40005740: 08f9ac23 sw a5,152(s3) 40005744: 08b9ae23 sw a1,156(s3) _Thread_Heir = new_heir; 40005748: 03442e23 sw s4,60(s0) _Thread_Dispatch_necessary = true; 4000574c: 02940a23 sb s1,52(s0) _Scheduler_EDF_Schedule_body( scheduler, the_thread, true ); } 40005750: 01c12083 lw ra,28(sp) 40005754: 01812403 lw s0,24(sp) 40005758: 01412483 lw s1,20(sp) 4000575c: 01012903 lw s2,16(sp) 40005760: 00c12983 lw s3,12(sp) 40005764: 00812a03 lw s4,8(sp) 40005768: 00412a83 lw s5,4(sp) 4000576c: 02010113 addi sp,sp,32 40005770: 00008067 ret link = _RBTree_Root_reference( the_rbtree ); 40005774: 00098693 mv a3,s3 <== NOT EXECUTED 40005778: f4dff06f j 400056c4 <_Scheduler_EDF_Yield+0x80> <== NOT EXECUTED =============================================================================== 40008f08 <_Scheduler_default_Tick>: /* * If the thread is not preemptible or is not ready, then * just return. */ if ( !executing->is_preemptible ) 40008f08: 0895c783 lbu a5,137(a1) <== NOT EXECUTED 40008f0c: 00078e63 beqz a5,40008f28 <_Scheduler_default_Tick+0x20> <== NOT EXECUTED return; if ( !_States_Is_ready( executing->current_state ) ) 40008f10: 01c5a783 lw a5,28(a1) <== NOT EXECUTED 40008f14: 00079a63 bnez a5,40008f28 <_Scheduler_default_Tick+0x20> <== NOT EXECUTED /* * The cpu budget algorithm determines what happens next. */ switch ( executing->budget_algorithm ) { 40008f18: 0905a783 lw a5,144(a1) <== NOT EXECUTED 40008f1c: 00200713 li a4,2 <== NOT EXECUTED 40008f20: 00f76663 bltu a4,a5,40008f2c <_Scheduler_default_Tick+0x24> <== NOT EXECUTED 40008f24: 02079663 bnez a5,40008f50 <_Scheduler_default_Tick+0x48> <== NOT EXECUTED 40008f28: 00008067 ret <== NOT EXECUTED 40008f2c: 00300713 li a4,3 <== NOT EXECUTED 40008f30: 04e79e63 bne a5,a4,40008f8c <_Scheduler_default_Tick+0x84> <== NOT EXECUTED } break; #if defined(RTEMS_SCORE_THREAD_ENABLE_SCHEDULER_CALLOUT) case THREAD_CPU_BUDGET_ALGORITHM_CALLOUT: if ( --executing->cpu_time_budget == 0 ) 40008f34: 08c5a783 lw a5,140(a1) <== NOT EXECUTED 40008f38: fff78793 addi a5,a5,-1 <== NOT EXECUTED 40008f3c: 08f5a623 sw a5,140(a1) <== NOT EXECUTED 40008f40: fe0794e3 bnez a5,40008f28 <_Scheduler_default_Tick+0x20> <== NOT EXECUTED (*executing->budget_callout)( executing ); 40008f44: 0945a783 lw a5,148(a1) <== NOT EXECUTED 40008f48: 00058513 mv a0,a1 <== NOT EXECUTED 40008f4c: 00078067 jr a5 <== NOT EXECUTED if ( (int)(--executing->cpu_time_budget) <= 0 ) { 40008f50: 08c5a783 lw a5,140(a1) <== NOT EXECUTED 40008f54: fff78793 addi a5,a5,-1 <== NOT EXECUTED 40008f58: 08f5a623 sw a5,140(a1) <== NOT EXECUTED 40008f5c: fcf046e3 bgtz a5,40008f28 <_Scheduler_default_Tick+0x20> <== NOT EXECUTED { 40008f60: fe010113 addi sp,sp,-32 <== NOT EXECUTED _Thread_Yield( executing ); 40008f64: 00058513 mv a0,a1 <== NOT EXECUTED { 40008f68: 00112e23 sw ra,28(sp) <== NOT EXECUTED _Thread_Yield( executing ); 40008f6c: 00b12623 sw a1,12(sp) <== NOT EXECUTED 40008f70: 31c020ef jal ra,4000b28c <_Thread_Yield> <== NOT EXECUTED executing->cpu_time_budget = 40008f74: 00c12583 lw a1,12(sp) <== NOT EXECUTED 40008f78: 8b01a783 lw a5,-1872(gp) # 40020cf0 <_Watchdog_Ticks_per_timeslice><== NOT EXECUTED break; #endif } } 40008f7c: 01c12083 lw ra,28(sp) <== NOT EXECUTED executing->cpu_time_budget = 40008f80: 08f5a623 sw a5,140(a1) <== NOT EXECUTED } 40008f84: 02010113 addi sp,sp,32 <== NOT EXECUTED 40008f88: 00008067 ret <== NOT EXECUTED 40008f8c: 00008067 ret <== NOT EXECUTED =============================================================================== 4000941c <_Scheduler_priority_Schedule>: void _Scheduler_priority_Schedule( const Scheduler_Control *scheduler, Thread_Control *the_thread ) { 4000941c: fe010113 addi sp,sp,-32 40009420: 00912a23 sw s1,20(sp) 40009424: 00052483 lw s1,0(a0) 40009428: 00112e23 sw ra,28(sp) 4000942c: 00812c23 sw s0,24(sp) bit_number = (unsigned int) __builtin_clz( value ) 40009430: 0004d503 lhu a0,0(s1) 40009434: 01212823 sw s2,16(sp) 40009438: 01312623 sw s3,12(sp) 4000943c: 01412423 sw s4,8(sp) 40009440: 355090ef jal ra,40012f94 <__clzsi2> 40009444: ff050413 addi s0,a0,-16 minor = _Bitfield_Find_first_bit( bit_map->bit_map[ major ] ); 40009448: 00141793 slli a5,s0,0x1 4000944c: 00f487b3 add a5,s1,a5 bit_number = (unsigned int) __builtin_clz( value ) 40009450: 0027d503 lhu a0,2(a5) return (_Priority_Bits_index( major ) << 4) + 40009454: 00441413 slli s0,s0,0x4 bit_number = (unsigned int) __builtin_clz( value ) 40009458: 33d090ef jal ra,40012f94 <__clzsi2> 4000945c: 00850533 add a0,a0,s0 40009460: ff050513 addi a0,a0,-16 return _Chain_Immutable_head( the_chain )->next; 40009464: 00151793 slli a5,a0,0x1 40009468: 00a78533 add a0,a5,a0 4000946c: 00251513 slli a0,a0,0x2 Thread_Control *heir = _Thread_Heir; 40009470: 40023437 lui s0,0x40023 40009474: 00a484b3 add s1,s1,a0 40009478: f8040413 addi s0,s0,-128 # 40022f80 <_Per_CPU_Information> 4000947c: 0244a903 lw s2,36(s1) 40009480: 03c42483 lw s1,60(s0) if ( heir != new_heir && ( heir->is_preemptible || force_dispatch ) ) { 40009484: 01248663 beq s1,s2,40009490 <_Scheduler_priority_Schedule+0x74> 40009488: 0894c783 lbu a5,137(s1) 4000948c: 02079263 bnez a5,400094b0 <_Scheduler_priority_Schedule+0x94> <== ALWAYS TAKEN _Scheduler_priority_Schedule_body( scheduler, the_thread, false ); } 40009490: 01c12083 lw ra,28(sp) 40009494: 01812403 lw s0,24(sp) 40009498: 01412483 lw s1,20(sp) 4000949c: 01012903 lw s2,16(sp) 400094a0: 00c12983 lw s3,12(sp) 400094a4: 00812a03 lw s4,8(sp) 400094a8: 02010113 addi sp,sp,32 400094ac: 00008067 ret 400094b0: 04042983 lw s3,64(s0) 400094b4: 04442a03 lw s4,68(s0) 400094b8: a7cff0ef jal ra,40008734 <_Timecounter_Sbinuptime> 400094bc: 04a42023 sw a0,64(s0) 400094c0: 04b42223 sw a1,68(s0) 400094c4: 0984a703 lw a4,152(s1) 400094c8: 09c4a683 lw a3,156(s1) *_result = *_end - *_start; 400094cc: 413507b3 sub a5,a0,s3 400094d0: 00f53533 sltu a0,a0,a5 400094d4: 414585b3 sub a1,a1,s4 *_time += *_add; 400094d8: 00f707b3 add a5,a4,a5 *_result = *_end - *_start; 400094dc: 40a585b3 sub a1,a1,a0 *_time += *_add; 400094e0: 00e7b733 sltu a4,a5,a4 400094e4: 00b685b3 add a1,a3,a1 400094e8: 00b705b3 add a1,a4,a1 400094ec: 08f4ac23 sw a5,152(s1) 400094f0: 08b4ae23 sw a1,156(s1) _Thread_Dispatch_necessary = true; 400094f4: 00100793 li a5,1 _Thread_Heir = new_heir; 400094f8: 03242e23 sw s2,60(s0) 400094fc: 01c12083 lw ra,28(sp) _Thread_Dispatch_necessary = true; 40009500: 02f40a23 sb a5,52(s0) 40009504: 01812403 lw s0,24(sp) 40009508: 01412483 lw s1,20(sp) 4000950c: 01012903 lw s2,16(sp) 40009510: 00c12983 lw s3,12(sp) 40009514: 00812a03 lw s4,8(sp) 40009518: 02010113 addi sp,sp,32 4000951c: 00008067 ret =============================================================================== 40009520 <_Scheduler_priority_Unblock>: do { seq = _SMP_sequence_lock_Read_begin( &node->Priority.Lock ); #endif priority = node->Priority.value; 40009520: 03062883 lw a7,48(a2) context = _Scheduler_priority_Get_context( scheduler ); the_node = _Scheduler_priority_Node_downcast( node ); priority = (unsigned int ) _Scheduler_Node_get_priority( &the_node->Base ); unmapped_priority = SCHEDULER_PRIORITY_UNMAP( priority ); if ( unmapped_priority != the_node->Ready_queue.current_priority ) { 40009524: 03862783 lw a5,56(a2) { 40009528: fe010113 addi sp,sp,-32 4000952c: 00812c23 sw s0,24(sp) 40009530: 00112e23 sw ra,28(sp) 40009534: 00912a23 sw s1,20(sp) 40009538: 01212823 sw s2,16(sp) 4000953c: 01312623 sw s3,12(sp) 40009540: 01412423 sw s4,8(sp) unmapped_priority = SCHEDULER_PRIORITY_UNMAP( priority ); 40009544: 0018d813 srli a6,a7,0x1 return scheduler->context; 40009548: 00052503 lw a0,0(a0) { 4000954c: 00058413 mv s0,a1 if ( unmapped_priority != the_node->Ready_queue.current_priority ) { 40009550: 0f079463 bne a5,a6,40009638 <_Scheduler_priority_Unblock+0x118> Chain_Control *ready_chain = ready_queue->ready_chain; 40009554: 03c62703 lw a4,60(a2) *bit_map_info->minor |= bit_map_info->ready_minor; 40009558: 04062683 lw a3,64(a2) 4000955c: 04665783 lhu a5,70(a2) old_last = tail->previous; 40009560: 00872583 lw a1,8(a4) return &the_chain->Tail.Node; 40009564: 00470813 addi a6,a4,4 * a context switch. * Pseudo-ISR case: * Even if the thread isn't preemptible, if the new heir is * a pseudo-ISR system task, we need to do a context switch. */ if ( priority < _Thread_Get_priority( _Thread_Heir ) ) { 40009568: 400234b7 lui s1,0x40023 the_node->next = tail; 4000956c: 01042023 sw a6,0(s0) 40009570: f8048493 addi s1,s1,-128 # 40022f80 <_Per_CPU_Information> 40009574: 0006d803 lhu a6,0(a3) 40009578: 03c4a903 lw s2,60(s1) tail->previous = the_node; 4000957c: 00872423 sw s0,8(a4) old_last->next = the_node; 40009580: 0085a023 sw s0,0(a1) the_node->previous = old_last; 40009584: 00b42223 sw a1,4(s0) 40009588: 0107e7b3 or a5,a5,a6 4000958c: 00f69023 sh a5,0(a3) */ RTEMS_INLINE_ROUTINE Priority_Control _Priority_Get_priority( const Priority_Aggregation *aggregation ) { return aggregation->Node.priority; 40009590: 03892703 lw a4,56(s2) bit_map->major_bit_map |= bit_map_info->ready_major; 40009594: 00055783 lhu a5,0(a0) 40009598: 04465603 lhu a2,68(a2) 4000959c: 01c72683 lw a3,28(a4) 400095a0: 00c7e7b3 or a5,a5,a2 400095a4: 00f51023 sh a5,0(a0) 400095a8: 02069663 bnez a3,400095d4 <_Scheduler_priority_Unblock+0xb4> <== NEVER TAKEN 400095ac: 01872783 lw a5,24(a4) 400095b0: 02f8e263 bltu a7,a5,400095d4 <_Scheduler_priority_Unblock+0xb4> _Scheduler_Update_heir( the_thread, priority == PRIORITY_PSEUDO_ISR ); } } 400095b4: 01c12083 lw ra,28(sp) 400095b8: 01812403 lw s0,24(sp) 400095bc: 01412483 lw s1,20(sp) 400095c0: 01012903 lw s2,16(sp) 400095c4: 00c12983 lw s3,12(sp) 400095c8: 00812a03 lw s4,8(sp) 400095cc: 02010113 addi sp,sp,32 400095d0: 00008067 ret if ( heir != new_heir && ( heir->is_preemptible || force_dispatch ) ) { 400095d4: fe8900e3 beq s2,s0,400095b4 <_Scheduler_priority_Unblock+0x94> 400095d8: 00088663 beqz a7,400095e4 <_Scheduler_priority_Unblock+0xc4> 400095dc: 08994783 lbu a5,137(s2) 400095e0: fc078ae3 beqz a5,400095b4 <_Scheduler_priority_Unblock+0x94> 400095e4: 0404a983 lw s3,64(s1) 400095e8: 0444aa03 lw s4,68(s1) 400095ec: 948ff0ef jal ra,40008734 <_Timecounter_Sbinuptime> 400095f0: 04a4a023 sw a0,64(s1) 400095f4: 04b4a223 sw a1,68(s1) 400095f8: 09892703 lw a4,152(s2) 400095fc: 09c92683 lw a3,156(s2) *_result = *_end - *_start; 40009600: 413507b3 sub a5,a0,s3 40009604: 00f53533 sltu a0,a0,a5 40009608: 414585b3 sub a1,a1,s4 *_time += *_add; 4000960c: 00f707b3 add a5,a4,a5 *_result = *_end - *_start; 40009610: 40a585b3 sub a1,a1,a0 *_time += *_add; 40009614: 00e7b733 sltu a4,a5,a4 40009618: 00b685b3 add a1,a3,a1 4000961c: 00b705b3 add a1,a4,a1 40009620: 08f92c23 sw a5,152(s2) 40009624: 08b92e23 sw a1,156(s2) _Thread_Dispatch_necessary = true; 40009628: 00100793 li a5,1 _Thread_Heir = new_heir; 4000962c: 0284ae23 sw s0,60(s1) _Thread_Dispatch_necessary = true; 40009630: 02f48a23 sb a5,52(s1) 40009634: f81ff06f j 400095b4 <_Scheduler_priority_Unblock+0x94> return the_priority / 16; 40009638: 0058d593 srli a1,a7,0x5 return (Priority_bit_map_Word) ( 0x8000u >> bit_number ); 4000963c: 000087b7 lui a5,0x8 return the_priority % 16; 40009640: 00f87713 andi a4,a6,15 bit_map_info->minor = &bit_map->bit_map[ _Priority_Bits_index( major ) ]; 40009644: 00158693 addi a3,a1,1 ready_queue->ready_chain = &ready_queues[ new_priority ]; 40009648: 00181313 slli t1,a6,0x1 return (Priority_bit_map_Word) ( 0x8000u >> bit_number ); 4000964c: 00b7d5b3 srl a1,a5,a1 40009650: 00e7d7b3 srl a5,a5,a4 40009654: 01030333 add t1,t1,a6 40009658: 01059593 slli a1,a1,0x10 4000965c: 01079793 slli a5,a5,0x10 40009660: 0105d593 srli a1,a1,0x10 40009664: 0107d793 srli a5,a5,0x10 40009668: 00231313 slli t1,t1,0x2 _Scheduler_priority_Ready_queue_update( 4000966c: 02450713 addi a4,a0,36 bit_map_info->minor = &bit_map->bit_map[ _Priority_Bits_index( major ) ]; 40009670: 00169693 slli a3,a3,0x1 40009674: 00670733 add a4,a4,t1 40009678: 00d506b3 add a3,a0,a3 bit_map_info->block_major = (Priority_bit_map_Word) ~mask; 4000967c: fff5ce13 not t3,a1 bit_map_info->block_minor = (Priority_bit_map_Word) ~mask; 40009680: fff7c313 not t1,a5 ready_queue->current_priority = new_priority; 40009684: 03062c23 sw a6,56(a2) ready_queue->ready_chain = &ready_queues[ new_priority ]; 40009688: 02e62e23 sw a4,60(a2) bit_map_info->minor = &bit_map->bit_map[ _Priority_Bits_index( major ) ]; 4000968c: 04d62023 sw a3,64(a2) bit_map_info->ready_major = mask; 40009690: 04b61223 sh a1,68(a2) bit_map_info->block_major = (Priority_bit_map_Word) ~mask; 40009694: 05c61423 sh t3,72(a2) bit_map_info->ready_minor = mask; 40009698: 04f61323 sh a5,70(a2) bit_map_info->block_minor = (Priority_bit_map_Word) ~mask; 4000969c: 04661523 sh t1,74(a2) _Priority_bit_map_Initialize_information( bit_map, &ready_queue->Priority_map, new_priority ); } 400096a0: ec1ff06f j 40009560 <_Scheduler_priority_Unblock+0x40> =============================================================================== 400050d8 <_Scheduler_simple_Schedule>: void _Scheduler_simple_Schedule( const Scheduler_Control *scheduler, Thread_Control *the_thread ) { 400050d8: fe010113 addi sp,sp,-32 <== NOT EXECUTED return _Chain_Immutable_head( the_chain )->next; 400050dc: 00052783 lw a5,0(a0) <== NOT EXECUTED 400050e0: 00812c23 sw s0,24(sp) <== NOT EXECUTED Thread_Control *heir = _Thread_Heir; 400050e4: 40014437 lui s0,0x40014 <== NOT EXECUTED 400050e8: 28040413 addi s0,s0,640 # 40014280 <_Per_CPU_Information> <== NOT EXECUTED 400050ec: 00912a23 sw s1,20(sp) <== NOT EXECUTED 400050f0: 01212823 sw s2,16(sp) <== NOT EXECUTED 400050f4: 03c42483 lw s1,60(s0) <== NOT EXECUTED 400050f8: 0007a903 lw s2,0(a5) <== NOT EXECUTED 400050fc: 00112e23 sw ra,28(sp) <== NOT EXECUTED 40005100: 01312623 sw s3,12(sp) <== NOT EXECUTED 40005104: 01412423 sw s4,8(sp) <== NOT EXECUTED if ( heir != new_heir && ( heir->is_preemptible || force_dispatch ) ) { 40005108: 00990663 beq s2,s1,40005114 <_Scheduler_simple_Schedule+0x3c> <== NOT EXECUTED 4000510c: 0894c783 lbu a5,137(s1) <== NOT EXECUTED 40005110: 02079263 bnez a5,40005134 <_Scheduler_simple_Schedule+0x5c> <== NOT EXECUTED _Scheduler_simple_Schedule_body( scheduler, the_thread, false ); } 40005114: 01c12083 lw ra,28(sp) <== NOT EXECUTED 40005118: 01812403 lw s0,24(sp) <== NOT EXECUTED 4000511c: 01412483 lw s1,20(sp) <== NOT EXECUTED 40005120: 01012903 lw s2,16(sp) <== NOT EXECUTED 40005124: 00c12983 lw s3,12(sp) <== NOT EXECUTED 40005128: 00812a03 lw s4,8(sp) <== NOT EXECUTED 4000512c: 02010113 addi sp,sp,32 <== NOT EXECUTED 40005130: 00008067 ret <== NOT EXECUTED 40005134: 04042983 lw s3,64(s0) <== NOT EXECUTED 40005138: 04442a03 lw s4,68(s0) <== NOT EXECUTED 4000513c: f34ff0ef jal ra,40004870 <_Timecounter_Sbinuptime> <== NOT EXECUTED 40005140: 04a42023 sw a0,64(s0) <== NOT EXECUTED 40005144: 04b42223 sw a1,68(s0) <== NOT EXECUTED 40005148: 0984a703 lw a4,152(s1) <== NOT EXECUTED 4000514c: 09c4a683 lw a3,156(s1) <== NOT EXECUTED *_result = *_end - *_start; 40005150: 413507b3 sub a5,a0,s3 <== NOT EXECUTED 40005154: 00f53533 sltu a0,a0,a5 <== NOT EXECUTED 40005158: 414585b3 sub a1,a1,s4 <== NOT EXECUTED *_time += *_add; 4000515c: 00f707b3 add a5,a4,a5 <== NOT EXECUTED *_result = *_end - *_start; 40005160: 40a585b3 sub a1,a1,a0 <== NOT EXECUTED *_time += *_add; 40005164: 00e7b733 sltu a4,a5,a4 <== NOT EXECUTED 40005168: 00b685b3 add a1,a3,a1 <== NOT EXECUTED 4000516c: 00b705b3 add a1,a4,a1 <== NOT EXECUTED 40005170: 08f4ac23 sw a5,152(s1) <== NOT EXECUTED 40005174: 08b4ae23 sw a1,156(s1) <== NOT EXECUTED _Thread_Dispatch_necessary = true; 40005178: 00100793 li a5,1 <== NOT EXECUTED _Thread_Heir = new_heir; 4000517c: 03242e23 sw s2,60(s0) <== NOT EXECUTED 40005180: 01c12083 lw ra,28(sp) <== NOT EXECUTED _Thread_Dispatch_necessary = true; 40005184: 02f40a23 sb a5,52(s0) <== NOT EXECUTED 40005188: 01812403 lw s0,24(sp) <== NOT EXECUTED 4000518c: 01412483 lw s1,20(sp) <== NOT EXECUTED 40005190: 01012903 lw s2,16(sp) <== NOT EXECUTED 40005194: 00c12983 lw s3,12(sp) <== NOT EXECUTED 40005198: 00812a03 lw s4,8(sp) <== NOT EXECUTED 4000519c: 02010113 addi sp,sp,32 <== NOT EXECUTED 400051a0: 00008067 ret <== NOT EXECUTED =============================================================================== 400051a4 <_Scheduler_simple_Unblock>: return scheduler->context; 400051a4: 00052603 lw a2,0(a0) 400051a8: 0385a703 lw a4,56(a1) void _Scheduler_simple_Unblock( const Scheduler_Control *scheduler, Thread_Control *the_thread, Scheduler_Node *node ) { 400051ac: fe010113 addi sp,sp,-32 400051b0: 00062783 lw a5,0(a2) 400051b4: 00812c23 sw s0,24(sp) 400051b8: 00058413 mv s0,a1 400051bc: 01872583 lw a1,24(a4) 400051c0: 00112e23 sw ra,28(sp) 400051c4: 00912a23 sw s1,20(sp) 400051c8: 01212823 sw s2,16(sp) 400051cc: 01312623 sw s3,12(sp) 400051d0: 01412423 sw s4,8(sp) return &the_chain->Tail.Node; 400051d4: 00460613 addi a2,a2,4 while ( next != tail && !( *order )( left, next ) ) { 400051d8: 0015e513 ori a0,a1,1 400051dc: 02f60063 beq a2,a5,400051fc <_Scheduler_simple_Unblock+0x58> 400051e0: 0387a703 lw a4,56(a5) 400051e4: 01c72683 lw a3,28(a4) 400051e8: 00069a63 bnez a3,400051fc <_Scheduler_simple_Unblock+0x58> <== NEVER TAKEN 400051ec: 01872703 lw a4,24(a4) 400051f0: 00a77663 bgeu a4,a0,400051fc <_Scheduler_simple_Unblock+0x58> return the_node->next; 400051f4: 0007a783 lw a5,0(a5) while ( next != tail && !( *order )( left, next ) ) { 400051f8: fef614e3 bne a2,a5,400051e0 <_Scheduler_simple_Unblock+0x3c> * a context switch. * Pseudo-ISR case: * Even if the thread isn't preemptible, if the new heir is * a pseudo-ISR system task, we need to do a context switch. */ if ( priority < _Thread_Get_priority( _Thread_Heir ) ) { 400051fc: 400144b7 lui s1,0x40014 40005200: 28048493 addi s1,s1,640 # 40014280 <_Per_CPU_Information> 40005204: 03c4a903 lw s2,60(s1) return the_node->previous; 40005208: 0047a783 lw a5,4(a5) 4000520c: 03892683 lw a3,56(s2) before_node = after_node->next; 40005210: 0007a703 lw a4,0(a5) the_node->previous = after_node; 40005214: 00f42223 sw a5,4(s0) after_node->next = the_node; 40005218: 0087a023 sw s0,0(a5) 4000521c: 01c6a783 lw a5,28(a3) the_node->next = before_node; 40005220: 00e42023 sw a4,0(s0) before_node->previous = the_node; 40005224: 00872223 sw s0,4(a4) 40005228: 02079663 bnez a5,40005254 <_Scheduler_simple_Unblock+0xb0> <== NEVER TAKEN 4000522c: 0186a783 lw a5,24(a3) 40005230: 02f5e263 bltu a1,a5,40005254 <_Scheduler_simple_Unblock+0xb0> _Scheduler_Update_heir( the_thread, priority == PRIORITY_PSEUDO_ISR ); } } 40005234: 01c12083 lw ra,28(sp) 40005238: 01812403 lw s0,24(sp) 4000523c: 01412483 lw s1,20(sp) 40005240: 01012903 lw s2,16(sp) 40005244: 00c12983 lw s3,12(sp) 40005248: 00812a03 lw s4,8(sp) 4000524c: 02010113 addi sp,sp,32 40005250: 00008067 ret if ( heir != new_heir && ( heir->is_preemptible || force_dispatch ) ) { 40005254: fe8900e3 beq s2,s0,40005234 <_Scheduler_simple_Unblock+0x90> 40005258: 00058663 beqz a1,40005264 <_Scheduler_simple_Unblock+0xc0> 4000525c: 08994783 lbu a5,137(s2) 40005260: fc078ae3 beqz a5,40005234 <_Scheduler_simple_Unblock+0x90> 40005264: 0404a983 lw s3,64(s1) 40005268: 0444aa03 lw s4,68(s1) 4000526c: e04ff0ef jal ra,40004870 <_Timecounter_Sbinuptime> 40005270: 04a4a023 sw a0,64(s1) 40005274: 04b4a223 sw a1,68(s1) 40005278: 09892683 lw a3,152(s2) 4000527c: 09c92603 lw a2,156(s2) *_result = *_end - *_start; 40005280: 41350733 sub a4,a0,s3 40005284: 00e53533 sltu a0,a0,a4 40005288: 414587b3 sub a5,a1,s4 *_time += *_add; 4000528c: 00e68733 add a4,a3,a4 *_result = *_end - *_start; 40005290: 40a787b3 sub a5,a5,a0 *_time += *_add; 40005294: 00d736b3 sltu a3,a4,a3 40005298: 00f607b3 add a5,a2,a5 4000529c: 00f687b3 add a5,a3,a5 400052a0: 08f92e23 sw a5,156(s2) 400052a4: 08e92c23 sw a4,152(s2) _Thread_Dispatch_necessary = true; 400052a8: 00100793 li a5,1 _Thread_Heir = new_heir; 400052ac: 0284ae23 sw s0,60(s1) _Thread_Dispatch_necessary = true; 400052b0: 02f48a23 sb a5,52(s1) 400052b4: f81ff06f j 40005234 <_Scheduler_simple_Unblock+0x90> =============================================================================== 40004fa8 <_Scheduler_simple_Update_priority>: ) { Scheduler_simple_Context *context; unsigned int new_priority; if ( !_Thread_Is_ready( the_thread ) ) { 40004fa8: 01c5a783 lw a5,28(a1) 40004fac: 00078463 beqz a5,40004fb4 <_Scheduler_simple_Update_priority+0xc><== ALWAYS TAKEN 40004fb0: 00008067 ret <== NOT EXECUTED previous = the_node->previous; 40004fb4: 0045a783 lw a5,4(a1) next = the_node->next; 40004fb8: 0005a703 lw a4,0(a1) { 40004fbc: fe010113 addi sp,sp,-32 40004fc0: 00052503 lw a0,0(a0) 40004fc4: 00112e23 sw ra,28(sp) 40004fc8: 00812c23 sw s0,24(sp) 40004fcc: 00912a23 sw s1,20(sp) 40004fd0: 01212823 sw s2,16(sp) 40004fd4: 01312623 sw s3,12(sp) 40004fd8: 01412423 sw s4,8(sp) do { seq = _SMP_sequence_lock_Read_begin( &node->Priority.Lock ); #endif priority = node->Priority.value; 40004fdc: 03062803 lw a6,48(a2) next->previous = previous; 40004fe0: 00f72223 sw a5,4(a4) previous->next = next; 40004fe4: 00e7a023 sw a4,0(a5) return _Chain_Immutable_head( the_chain )->next; 40004fe8: 00052783 lw a5,0(a0) return &the_chain->Tail.Node; 40004fec: 00450613 addi a2,a0,4 ) { const Chain_Node *tail = _Chain_Immutable_tail( the_chain ); Chain_Node *next = _Chain_First( the_chain ); while ( next != tail && !( *order )( left, next ) ) { 40004ff0: 00f61c63 bne a2,a5,40005008 <_Scheduler_simple_Update_priority+0x60> 40004ff4: 0200006f j 40005014 <_Scheduler_simple_Update_priority+0x6c> <== NOT EXECUTED 40004ff8: 01872703 lw a4,24(a4) 40004ffc: 01077c63 bgeu a4,a6,40005014 <_Scheduler_simple_Update_priority+0x6c> return the_node->next; 40005000: 0007a783 lw a5,0(a5) while ( next != tail && !( *order )( left, next ) ) { 40005004: 00f60863 beq a2,a5,40005014 <_Scheduler_simple_Update_priority+0x6c> return aggregation->Node.priority; 40005008: 0387a703 lw a4,56(a5) 4000500c: 01c72683 lw a3,28(a4) 40005010: fe0684e3 beqz a3,40004ff8 <_Scheduler_simple_Update_priority+0x50><== ALWAYS TAKEN return the_node->previous; 40005014: 0047a783 lw a5,4(a5) Thread_Control *heir = _Thread_Heir; 40005018: 40014437 lui s0,0x40014 4000501c: 28040413 addi s0,s0,640 # 40014280 <_Per_CPU_Information> before_node = after_node->next; 40005020: 0007a703 lw a4,0(a5) the_node->previous = after_node; 40005024: 00f5a223 sw a5,4(a1) after_node->next = the_node; 40005028: 00b7a023 sw a1,0(a5) the_node->next = before_node; 4000502c: 00e5a023 sw a4,0(a1) return _Chain_Immutable_head( the_chain )->next; 40005030: 00052903 lw s2,0(a0) 40005034: 03c42483 lw s1,60(s0) before_node->previous = the_node; 40005038: 00b72223 sw a1,4(a4) if ( heir != new_heir && ( heir->is_preemptible || force_dispatch ) ) { 4000503c: 00990663 beq s2,s1,40005048 <_Scheduler_simple_Update_priority+0xa0> 40005040: 0894c783 lbu a5,137(s1) 40005044: 02079263 bnez a5,40005068 <_Scheduler_simple_Update_priority+0xc0><== NEVER TAKEN new_priority = (unsigned int ) _Scheduler_Node_get_priority( node ); _Scheduler_simple_Extract( scheduler, the_thread, node ); _Scheduler_simple_Insert( &context->Ready, the_thread, new_priority ); _Scheduler_simple_Schedule_body( scheduler, the_thread, false ); } 40005048: 01c12083 lw ra,28(sp) 4000504c: 01812403 lw s0,24(sp) 40005050: 01412483 lw s1,20(sp) 40005054: 01012903 lw s2,16(sp) 40005058: 00c12983 lw s3,12(sp) 4000505c: 00812a03 lw s4,8(sp) 40005060: 02010113 addi sp,sp,32 40005064: 00008067 ret 40005068: 04042983 lw s3,64(s0) <== NOT EXECUTED 4000506c: 04442a03 lw s4,68(s0) <== NOT EXECUTED 40005070: 801ff0ef jal ra,40004870 <_Timecounter_Sbinuptime> <== NOT EXECUTED 40005074: 04a42023 sw a0,64(s0) <== NOT EXECUTED 40005078: 04b42223 sw a1,68(s0) <== NOT EXECUTED 4000507c: 0984a703 lw a4,152(s1) <== NOT EXECUTED 40005080: 09c4a683 lw a3,156(s1) <== NOT EXECUTED *_result = *_end - *_start; 40005084: 413507b3 sub a5,a0,s3 <== NOT EXECUTED 40005088: 00f53533 sltu a0,a0,a5 <== NOT EXECUTED 4000508c: 414585b3 sub a1,a1,s4 <== NOT EXECUTED *_time += *_add; 40005090: 00f707b3 add a5,a4,a5 <== NOT EXECUTED *_result = *_end - *_start; 40005094: 40a585b3 sub a1,a1,a0 <== NOT EXECUTED *_time += *_add; 40005098: 00e7b733 sltu a4,a5,a4 <== NOT EXECUTED 4000509c: 00b685b3 add a1,a3,a1 <== NOT EXECUTED 400050a0: 00b70733 add a4,a4,a1 <== NOT EXECUTED 400050a4: 08f4ac23 sw a5,152(s1) <== NOT EXECUTED 400050a8: 08e4ae23 sw a4,156(s1) <== NOT EXECUTED _Thread_Dispatch_necessary = true; 400050ac: 00100793 li a5,1 <== NOT EXECUTED _Thread_Heir = new_heir; 400050b0: 03242e23 sw s2,60(s0) <== NOT EXECUTED 400050b4: 01c12083 lw ra,28(sp) <== NOT EXECUTED _Thread_Dispatch_necessary = true; 400050b8: 02f40a23 sb a5,52(s0) <== NOT EXECUTED 400050bc: 01812403 lw s0,24(sp) <== NOT EXECUTED 400050c0: 01412483 lw s1,20(sp) <== NOT EXECUTED 400050c4: 01012903 lw s2,16(sp) <== NOT EXECUTED 400050c8: 00c12983 lw s3,12(sp) <== NOT EXECUTED 400050cc: 00812a03 lw s4,8(sp) <== NOT EXECUTED 400050d0: 02010113 addi sp,sp,32 <== NOT EXECUTED 400050d4: 00008067 ret <== NOT EXECUTED =============================================================================== 400052b8 <_Scheduler_simple_Yield>: next = the_node->next; 400052b8: 0005a703 lw a4,0(a1) previous = the_node->previous; 400052bc: 0045a783 lw a5,4(a1) void _Scheduler_simple_Yield( const Scheduler_Control *scheduler, Thread_Control *the_thread, Scheduler_Node *node ) { 400052c0: fe010113 addi sp,sp,-32 return scheduler->context; 400052c4: 00052503 lw a0,0(a0) 400052c8: 0385a683 lw a3,56(a1) 400052cc: 00112e23 sw ra,28(sp) 400052d0: 00812c23 sw s0,24(sp) 400052d4: 00912a23 sw s1,20(sp) 400052d8: 01212823 sw s2,16(sp) 400052dc: 01312623 sw s3,12(sp) 400052e0: 01412423 sw s4,8(sp) next->previous = previous; 400052e4: 00f72223 sw a5,4(a4) previous->next = next; 400052e8: 00e7a023 sw a4,0(a5) return _Chain_Immutable_head( the_chain )->next; 400052ec: 00052783 lw a5,0(a0) context = _Scheduler_simple_Get_context( scheduler ); (void) node; _Chain_Extract_unprotected( &the_thread->Object.Node ); insert_priority = (unsigned int) _Thread_Get_priority( the_thread ); 400052f0: 0186a703 lw a4,24(a3) return &the_chain->Tail.Node; 400052f4: 00450613 addi a2,a0,4 while ( next != tail && !( *order )( left, next ) ) { 400052f8: 00176813 ori a6,a4,1 400052fc: 02f60063 beq a2,a5,4000531c <_Scheduler_simple_Yield+0x64> 40005300: 0387a703 lw a4,56(a5) 40005304: 01c72683 lw a3,28(a4) 40005308: 00069a63 bnez a3,4000531c <_Scheduler_simple_Yield+0x64> <== NEVER TAKEN 4000530c: 01872703 lw a4,24(a4) 40005310: 01077663 bgeu a4,a6,4000531c <_Scheduler_simple_Yield+0x64> return the_node->next; 40005314: 0007a783 lw a5,0(a5) while ( next != tail && !( *order )( left, next ) ) { 40005318: fef614e3 bne a2,a5,40005300 <_Scheduler_simple_Yield+0x48> return the_node->previous; 4000531c: 0047a783 lw a5,4(a5) Thread_Control *heir = _Thread_Heir; 40005320: 40014437 lui s0,0x40014 40005324: 28040413 addi s0,s0,640 # 40014280 <_Per_CPU_Information> before_node = after_node->next; 40005328: 0007a703 lw a4,0(a5) the_node->previous = after_node; 4000532c: 00f5a223 sw a5,4(a1) after_node->next = the_node; 40005330: 00b7a023 sw a1,0(a5) the_node->next = before_node; 40005334: 00e5a023 sw a4,0(a1) return _Chain_Immutable_head( the_chain )->next; 40005338: 00052903 lw s2,0(a0) 4000533c: 03c42483 lw s1,60(s0) before_node->previous = the_node; 40005340: 00b72223 sw a1,4(a4) if ( heir != new_heir && ( heir->is_preemptible || force_dispatch ) ) { 40005344: 00990663 beq s2,s1,40005350 <_Scheduler_simple_Yield+0x98> 40005348: 0894c783 lbu a5,137(s1) 4000534c: 02079263 bnez a5,40005370 <_Scheduler_simple_Yield+0xb8> <== NEVER TAKEN insert_priority = SCHEDULER_PRIORITY_APPEND( insert_priority ); _Scheduler_simple_Insert( &context->Ready, the_thread, insert_priority ); _Scheduler_simple_Schedule_body( scheduler, the_thread, false ); } 40005350: 01c12083 lw ra,28(sp) 40005354: 01812403 lw s0,24(sp) 40005358: 01412483 lw s1,20(sp) 4000535c: 01012903 lw s2,16(sp) 40005360: 00c12983 lw s3,12(sp) 40005364: 00812a03 lw s4,8(sp) 40005368: 02010113 addi sp,sp,32 4000536c: 00008067 ret 40005370: 04042983 lw s3,64(s0) <== NOT EXECUTED 40005374: 04442a03 lw s4,68(s0) <== NOT EXECUTED 40005378: cf8ff0ef jal ra,40004870 <_Timecounter_Sbinuptime> <== NOT EXECUTED 4000537c: 04a42023 sw a0,64(s0) <== NOT EXECUTED 40005380: 04b42223 sw a1,68(s0) <== NOT EXECUTED 40005384: 0984a703 lw a4,152(s1) <== NOT EXECUTED 40005388: 09c4a683 lw a3,156(s1) <== NOT EXECUTED *_result = *_end - *_start; 4000538c: 413507b3 sub a5,a0,s3 <== NOT EXECUTED 40005390: 00f53533 sltu a0,a0,a5 <== NOT EXECUTED 40005394: 414585b3 sub a1,a1,s4 <== NOT EXECUTED *_time += *_add; 40005398: 00f707b3 add a5,a4,a5 <== NOT EXECUTED *_result = *_end - *_start; 4000539c: 40a585b3 sub a1,a1,a0 <== NOT EXECUTED *_time += *_add; 400053a0: 00e7b733 sltu a4,a5,a4 <== NOT EXECUTED 400053a4: 00b685b3 add a1,a3,a1 <== NOT EXECUTED 400053a8: 00b70733 add a4,a4,a1 <== NOT EXECUTED 400053ac: 08f4ac23 sw a5,152(s1) <== NOT EXECUTED 400053b0: 08e4ae23 sw a4,156(s1) <== NOT EXECUTED _Thread_Dispatch_necessary = true; 400053b4: 00100793 li a5,1 <== NOT EXECUTED _Thread_Heir = new_heir; 400053b8: 03242e23 sw s2,60(s0) <== NOT EXECUTED 400053bc: 01c12083 lw ra,28(sp) <== NOT EXECUTED _Thread_Dispatch_necessary = true; 400053c0: 02f40a23 sb a5,52(s0) <== NOT EXECUTED 400053c4: 01812403 lw s0,24(sp) <== NOT EXECUTED 400053c8: 01412483 lw s1,20(sp) <== NOT EXECUTED 400053cc: 01012903 lw s2,16(sp) <== NOT EXECUTED 400053d0: 00c12983 lw s3,12(sp) <== NOT EXECUTED 400053d4: 00812a03 lw s4,8(sp) <== NOT EXECUTED 400053d8: 02010113 addi sp,sp,32 <== NOT EXECUTED 400053dc: 00008067 ret <== NOT EXECUTED =============================================================================== 40011414 <_Stack_Allocate>: #include #include void *_Stack_Allocate( size_t stack_size ) { return ( *rtems_configuration_get_stack_allocate_hook() )( stack_size ); 40011414: 8bc1a783 lw a5,-1860(gp) # 40020cfc <_Stack_Allocator_allocate> 40011418: 00078067 jr a5 =============================================================================== 4001141c <_Stack_Free>: #include #include void _Stack_Free( void *stack_area ) { ( *rtems_configuration_get_stack_free_hook() )( stack_area ); 4001141c: 8c81a783 lw a5,-1848(gp) # 40020d08 <_Stack_Allocator_free> <== NOT EXECUTED 40011420: 00078067 jr a5 <== NOT EXECUTED =============================================================================== 40011448 <_TLS_Get_allocation_size>: /* * We must be careful with using _TLS_Size here since this could lead GCC to * assume that this symbol is not 0 and the tests for 0 will be optimized * away. */ size = (uintptr_t) _TLS_Size; 40011448: 00000513 li a0,0 uintptr_t allocation_size; uintptr_t alignment; size = _TLS_Get_size(); if ( size == 0 ) { 4001144c: 04050c63 beqz a0,400114a4 <_TLS_Get_allocation_size+0x5c> <== ALWAYS TAKEN return 0; } allocation_size = _TLS_Allocation_size; 40011450: 94818713 addi a4,gp,-1720 # 40020d88 <_TLS_Allocation_size> <== NOT EXECUTED 40011454: 00072783 lw a5,0(a4) <== NOT EXECUTED if ( allocation_size == 0 ) { 40011458: 04079463 bnez a5,400114a0 <_TLS_Get_allocation_size+0x58> <== NOT EXECUTED */ static inline uintptr_t _TLS_Heap_align_up( uintptr_t val ) { uintptr_t msk = CPU_HEAP_ALIGNMENT - 1; return (val + msk) & ~msk; 4001145c: 01000793 li a5,16 <== NOT EXECUTED 40011460: 00f50513 addi a0,a0,15 <== NOT EXECUTED 40011464: ff07f793 andi a5,a5,-16 <== NOT EXECUTED /* * The stack allocator does not support aligned allocations. Allocate * enough to do the alignment manually. */ if ( alignment > CPU_HEAP_ALIGNMENT ) { 40011468: 01000613 li a2,16 <== NOT EXECUTED 4001146c: ff057693 andi a3,a0,-16 <== NOT EXECUTED 40011470: 00f67463 bgeu a2,a5,40011478 <_TLS_Get_allocation_size+0x30> <== NOT EXECUTED allocation_size += alignment; 40011474: 00f686b3 add a3,a3,a5 <== NOT EXECUTED static inline uintptr_t _TLS_Get_thread_control_block_area_size( uintptr_t alignment ) { return alignment <= sizeof(TLS_Thread_control_block) ? sizeof(TLS_Thread_control_block) : alignment; 40011478: 00800613 li a2,8 <== NOT EXECUTED 4001147c: 02c7e663 bltu a5,a2,400114a8 <_TLS_Get_allocation_size+0x60> <== NOT EXECUTED #ifndef __i386__ allocation_size += sizeof(TLS_Dynamic_thread_vector); #endif if ( _Thread_Maximum_TLS_size != 0 ) { 40011480: 87c1a603 lw a2,-1924(gp) # 40020cbc <_Thread_Maximum_TLS_size> <== NOT EXECUTED allocation_size += sizeof(TLS_Dynamic_thread_vector); 40011484: 00878513 addi a0,a5,8 <== NOT EXECUTED 40011488: 00d50533 add a0,a0,a3 <== NOT EXECUTED if ( _Thread_Maximum_TLS_size != 0 ) { 4001148c: 00060663 beqz a2,40011498 <_TLS_Get_allocation_size+0x50> <== NOT EXECUTED if ( allocation_size <= _Thread_Maximum_TLS_size ) { 40011490: 02a66863 bltu a2,a0,400114c0 <_TLS_Get_allocation_size+0x78> <== NOT EXECUTED 40011494: 00060513 mv a0,a2 <== NOT EXECUTED } else { _Internal_error( INTERNAL_ERROR_TOO_LARGE_TLS_SIZE ); } } _TLS_Allocation_size = allocation_size; 40011498: 00a72023 sw a0,0(a4) <== NOT EXECUTED 4001149c: 00008067 ret <== NOT EXECUTED 400114a0: 00078513 mv a0,a5 <== NOT EXECUTED } return allocation_size; } 400114a4: 00008067 ret <== NOT EXECUTED if ( _Thread_Maximum_TLS_size != 0 ) { 400114a8: 87c1a603 lw a2,-1924(gp) # 40020cbc <_Thread_Maximum_TLS_size> <== NOT EXECUTED 400114ac: 00800793 li a5,8 allocation_size += sizeof(TLS_Dynamic_thread_vector); 400114b0: 00878513 addi a0,a5,8 <== NOT EXECUTED 400114b4: 00d50533 add a0,a0,a3 <== NOT EXECUTED if ( _Thread_Maximum_TLS_size != 0 ) { 400114b8: fe0600e3 beqz a2,40011498 <_TLS_Get_allocation_size+0x50> <== NOT EXECUTED 400114bc: fd5ff06f j 40011490 <_TLS_Get_allocation_size+0x48> <== NOT EXECUTED { 400114c0: ff010113 addi sp,sp,-16 <== NOT EXECUTED _Internal_error( INTERNAL_ERROR_TOO_LARGE_TLS_SIZE ); 400114c4: 02900513 li a0,41 <== NOT EXECUTED { 400114c8: 00112623 sw ra,12(sp) <== NOT EXECUTED _Internal_error( INTERNAL_ERROR_TOO_LARGE_TLS_SIZE ); 400114cc: cecf60ef jal ra,400079b8 <_Internal_error> <== NOT EXECUTED =============================================================================== 40004f7c <_TOD_Set>: Status_Control _TOD_Set( const struct timespec *tod, ISR_lock_Context *lock_context ) { 40004f7c: fd010113 addi sp,sp,-48 40004f80: 03212023 sw s2,32(sp) 40004f84: 02112623 sw ra,44(sp) 40004f88: 02812423 sw s0,40(sp) 40004f8c: 02912223 sw s1,36(sp) 40004f90: 00058913 mv s2,a1 && (unsigned long) ts->tv_nsec < WATCHDOG_NANOSECONDS_PER_SECOND; 40004f94: 00050c63 beqz a0,40004fac <_TOD_Set+0x30> <== NEVER TAKEN 40004f98: 00852703 lw a4,8(a0) 40004f9c: 3b9ad7b7 lui a5,0x3b9ad 40004fa0: 9ff78793 addi a5,a5,-1537 # 3b9ac9ff 40004fa4: 00050413 mv s0,a0 40004fa8: 02e7f863 bgeu a5,a4,40004fd8 <_TOD_Set+0x5c> return STATUS_INVALID_NUMBER; 40004fac: 000014b7 lui s1,0x1 40004fb0: 60a48493 addi s1,s1,1546 # 160a <_ISR_Stack_size+0x60a> 40004fb4: 00092783 lw a5,0(s2) 40004fb8: 3007a073 csrs mstatus,a5 } _TOD.is_set = true; return STATUS_SUCCESSFUL; } 40004fbc: 02c12083 lw ra,44(sp) 40004fc0: 02812403 lw s0,40(sp) 40004fc4: 02012903 lw s2,32(sp) 40004fc8: 00048513 mv a0,s1 40004fcc: 02412483 lw s1,36(sp) 40004fd0: 03010113 addi sp,sp,48 40004fd4: 00008067 ret if ( tod->tv_sec < TOD_SECONDS_1970_THROUGH_1988 ) { 40004fd8: 00052783 lw a5,0(a0) 40004fdc: 00452683 lw a3,4(a0) 40004fe0: de252637 lui a2,0xde252 40004fe4: b0060713 addi a4,a2,-1280 # de251b00 40004fe8: 00e78733 add a4,a5,a4 40004fec: fff68693 addi a3,a3,-1 40004ff0: 00f737b3 sltu a5,a4,a5 40004ff4: 00d787b3 add a5,a5,a3 40004ff8: 00300693 li a3,3 40004ffc: faf6e8e3 bltu a3,a5,40004fac <_TOD_Set+0x30> 40005000: 0cd78c63 beq a5,a3,400050d8 <_TOD_Set+0x15c> return _TOD_Hook_Run( TOD_ACTION_SET_CLOCK, tod ); 40005004: 00040593 mv a1,s0 40005008: 00000513 li a0,0 4000500c: 345040ef jal ra,40009b50 <_TOD_Hook_Run> 40005010: 00050493 mv s1,a0 if ( status != STATUS_SUCCESSFUL ) { 40005014: fa0510e3 bnez a0,40004fb4 <_TOD_Set+0x38> _bt->frac = _ts->tv_nsec * (uint64_t)18446744073LL; 40005018: 00842703 lw a4,8(s0) 4000501c: 4b8306b7 lui a3,0x4b830 40005020: a0968693 addi a3,a3,-1527 # 4b82fa09 40005024: 41f75793 srai a5,a4,0x1f 40005028: 02d787b3 mul a5,a5,a3 4000502c: 00271313 slli t1,a4,0x2 _bt->sec = _ts->tv_sec; 40005030: 00042803 lw a6,0(s0) 40005034: 00442883 lw a7,4(s0) _Timecounter_Set_clock( &tod_as_bintime, lock_context ); 40005038: 01010513 addi a0,sp,16 4000503c: 00090593 mv a1,s2 40005040: 01012823 sw a6,16(sp) 40005044: 01112a23 sw a7,20(sp) _bt->frac = _ts->tv_nsec * (uint64_t)18446744073LL; 40005048: 02d73633 mulhu a2,a4,a3 4000504c: 006787b3 add a5,a5,t1 40005050: 02d70733 mul a4,a4,a3 40005054: 00c787b3 add a5,a5,a2 40005058: 00f12e23 sw a5,28(sp) 4000505c: 00e12c23 sw a4,24(sp) 40005060: 00d000ef jal ra,4000586c <_Timecounter_Set_clock> ticks = (uint64_t) ts->tv_sec; 40005064: 00042703 lw a4,0(s0) 40005068: 00442503 lw a0,4(s0) ticks |= (uint32_t) ts->tv_nsec; 4000506c: 00842803 lw a6,8(s0) __asm__ volatile ( 40005070: 300477f3 csrrci a5,mstatus,8 return mstatus & RISCV_MSTATUS_MIE; 40005074: 0087f793 andi a5,a5,8 _ISR_lock_ISR_disable_and_acquire( &cpu->Watchdog.Lock, &lock_context ); 40005078: 00f12623 sw a5,12(sp) return (Watchdog_Control *) header->first; 4000507c: 400177b7 lui a5,0x40017 40005080: d9c7a583 lw a1,-612(a5) # 40016d9c <_Per_CPU_Information+0x5c> if ( first != NULL ) { 40005084: 02058463 beqz a1,400050ac <_TOD_Set+0x130> ticks <<= WATCHDOG_BITS_FOR_1E9_NANOSECONDS; 40005088: 00275693 srli a3,a4,0x2 4000508c: 01e51513 slli a0,a0,0x1e 40005090: 01e71613 slli a2,a4,0x1e _Watchdog_Tickle( 40005094: 00a6e6b3 or a3,a3,a0 40005098: 40017537 lui a0,0x40017 4000509c: 00c10713 addi a4,sp,12 400050a0: 00c86633 or a2,a6,a2 400050a4: d9850513 addi a0,a0,-616 # 40016d98 <_Per_CPU_Information+0x58> 400050a8: 2d4030ef jal ra,4000837c <_Watchdog_Do_tickle> __asm__ volatile ( "csrrs zero, mstatus, %0" : : "r" ( level ) ); 400050ac: 00c12783 lw a5,12(sp) 400050b0: 3007a073 csrs mstatus,a5 } 400050b4: 02c12083 lw ra,44(sp) 400050b8: 02812403 lw s0,40(sp) _TOD.is_set = true; 400050bc: 00100713 li a4,1 400050c0: 8ce18823 sb a4,-1840(gp) # 400144c0 <_TOD> } 400050c4: 02012903 lw s2,32(sp) 400050c8: 00048513 mv a0,s1 400050cc: 02412483 lw s1,36(sp) 400050d0: 03010113 addi sp,sp,48 400050d4: 00008067 ret if ( tod->tv_sec < TOD_SECONDS_1970_THROUGH_1988 ) { 400050d8: aff60613 addi a2,a2,-1281 400050dc: f2e674e3 bgeu a2,a4,40005004 <_TOD_Set+0x88> 400050e0: ecdff06f j 40004fac <_TOD_Set+0x30> =============================================================================== 40007964 <_Terminate>: void _Terminate( Internal_errors_Source the_source, Internal_errors_t the_error ) { 40007964: fe010113 addi sp,sp,-32 40007968: 00812c23 sw s0,24(sp) 4000796c: 00058413 mv s0,a1 Internal_errors_t error ) { User_extensions_Fatal_context ctx = { source, error }; _User_extensions_Iterate( 40007970: 4000b5b7 lui a1,0x4000b 40007974: 00912a23 sw s1,20(sp) 40007978: 3e458593 addi a1,a1,996 # 4000b3e4 <_User_extensions_Fatal_visitor> 4000797c: 00050493 mv s1,a0 40007980: 00000613 li a2,0 40007984: 00810513 addi a0,sp,8 40007988: 00112e23 sw ra,28(sp) User_extensions_Fatal_context ctx = { source, error }; 4000798c: 00912423 sw s1,8(sp) 40007990: 00812623 sw s0,12(sp) _User_extensions_Iterate( 40007994: 27d030ef jal ra,4000b410 <_User_extensions_Iterate> _User_extensions_Fatal( the_source, the_error ); _Internal_errors_What_happened.the_source = the_source; 40007998: 92c18793 addi a5,gp,-1748 # 40020d6c <_Internal_errors_What_happened> 4000799c: 0097a023 sw s1,0(a5) _Internal_errors_What_happened.the_error = the_error; 400079a0: 0087a223 sw s0,4(a5) _System_state_Current = state; 400079a4: 00300713 li a4,3 _System_state_Set( SYSTEM_STATE_TERMINATED ); _SMP_Request_shutdown(); _CPU_Fatal_halt( the_source, the_error ); 400079a8: 00040593 mv a1,s0 400079ac: 00048513 mv a0,s1 400079b0: 92e1aa23 sw a4,-1740(gp) # 40020d74 <_System_state_Current> 400079b4: 6780a0ef jal ra,4001202c <_CPU_Fatal_halt> =============================================================================== 40009158 <_Thread_Allocate_unlimited>: return _Chain_Immutable_head( the_chain )->next; 40009158: 01852783 lw a5,24(a0) } } } Objects_Control *_Thread_Allocate_unlimited( Objects_Information *information ) { 4000915c: fe010113 addi sp,sp,-32 40009160: 00812c23 sw s0,24(sp) 40009164: 00912a23 sw s1,20(sp) 40009168: 01212823 sw s2,16(sp) 4000916c: 00112e23 sw ra,28(sp) 40009170: 01312623 sw s3,12(sp) return &the_chain->Tail.Node; 40009174: 01c50493 addi s1,a0,28 40009178: 00050413 mv s0,a0 4000917c: 01850913 addi s2,a0,24 if ( !_Chain_Is_empty(the_chain)) 40009180: 06978863 beq a5,s1,400091f0 <_Thread_Allocate_unlimited+0x98> new_first = old_first->next; 40009184: 0007a703 lw a4,0(a5) Objects_Maximum objects_per_block; Objects_Maximum block; _Assert( _Objects_Is_auto_extend( information ) ); objects_per_block = information->objects_per_block; 40009188: 01245683 lhu a3,18(s0) head->next = new_first; 4000918c: 00e42c23 sw a4,24(s0) new_first->previous = head; 40009190: 01272223 sw s2,4(a4) 40009194: 0087a703 lw a4,8(a5) block = _Objects_Get_index( the_object->id ) - OBJECTS_INDEX_MINIMUM; 40009198: fff70713 addi a4,a4,-1 4000919c: 01071713 slli a4,a4,0x10 400091a0: 01075713 srli a4,a4,0x10 if ( block > objects_per_block ) { 400091a4: 02e6f663 bgeu a3,a4,400091d0 <_Thread_Allocate_unlimited+0x78> block /= objects_per_block; information->inactive_per_block[ block ]--; 400091a8: 02d75733 divu a4,a4,a3 400091ac: 02442683 lw a3,36(s0) 400091b0: 00171713 slli a4,a4,0x1 400091b4: 00e68733 add a4,a3,a4 400091b8: 00075683 lhu a3,0(a4) 400091bc: fff68693 addi a3,a3,-1 400091c0: 00d71023 sh a3,0(a4) information->inactive--; 400091c4: 01045703 lhu a4,16(s0) 400091c8: fff70713 addi a4,a4,-1 400091cc: 00e41823 sh a4,16(s0) return _Objects_Allocate_with_extend( information, _Thread_Extend_information ); } 400091d0: 01c12083 lw ra,28(sp) 400091d4: 01812403 lw s0,24(sp) 400091d8: 01412483 lw s1,20(sp) 400091dc: 01012903 lw s2,16(sp) 400091e0: 00c12983 lw s3,12(sp) 400091e4: 00078513 mv a0,a5 400091e8: 02010113 addi sp,sp,32 400091ec: 00008067 ret block = _Objects_Extend_information( &information->Objects ); 400091f0: 9d8ff0ef jal ra,400083c8 <_Objects_Extend_information> 400091f4: 00050993 mv s3,a0 if ( block > 0 ) { 400091f8: 00051a63 bnez a0,4000920c <_Thread_Allocate_unlimited+0xb4> <== ALWAYS TAKEN return _Chain_Immutable_head( the_chain )->next; 400091fc: 01842783 lw a5,24(s0) if ( !_Chain_Is_empty(the_chain)) 40009200: f8f492e3 bne s1,a5,40009184 <_Thread_Allocate_unlimited+0x2c> return NULL; 40009204: 00000793 li a5,0 <== NOT EXECUTED 40009208: fc9ff06f j 400091d0 <_Thread_Allocate_unlimited+0x78> <== NOT EXECUTED new_heads = _Freechain_Extend( 4000920c: 01245603 lhu a2,18(s0) 40009210: 4000b5b7 lui a1,0x4000b 40009214: 04800693 li a3,72 40009218: 45858593 addi a1,a1,1112 # 4000b458 <_Workspace_Allocate> 4000921c: 03040513 addi a0,s0,48 40009220: 7f1080ef jal ra,40012210 <_Freechain_Extend> if ( new_heads == NULL ) { 40009224: fc051ce3 bnez a0,400091fc <_Thread_Allocate_unlimited+0xa4> <== ALWAYS TAKEN _Objects_Free_objects_block( &information->Objects, block ); 40009228: 00098593 mv a1,s3 <== NOT EXECUTED 4000922c: 00040513 mv a0,s0 <== NOT EXECUTED 40009230: cc8ff0ef jal ra,400086f8 <_Objects_Free_objects_block> <== NOT EXECUTED 40009234: fc9ff06f j 400091fc <_Thread_Allocate_unlimited+0xa4> <== NOT EXECUTED =============================================================================== 4000acd4 <_Thread_Cancel>: void _Thread_Cancel( Thread_Control *the_thread, Thread_Control *executing, void *exit_value ) { 4000acd4: fe010113 addi sp,sp,-32 4000acd8: 00812c23 sw s0,24(sp) 4000acdc: 00112e23 sw ra,28(sp) 4000ace0: 00912a23 sw s1,20(sp) 4000ace4: 01212823 sw s2,16(sp) 4000ace8: 01412623 sw s4,12(sp) 4000acec: 01512423 sw s5,8(sp) 4000acf0: 00050413 mv s0,a0 __asm__ volatile ( 4000acf4: 300477f3 csrrci a5,mstatus,8 return mstatus & RISCV_MSTATUS_MIE; 4000acf8: 0087f493 andi s1,a5,8 previous = the_thread->Life.state; 4000acfc: 1ac52783 lw a5,428(a0) the_thread->Life.exit_value = exit_value; 4000ad00: 1ac52a23 sw a2,436(a0) state |= set; 4000ad04: 0047e713 ori a4,a5,4 the_thread->Life.state = state; 4000ad08: 1ae52623 sw a4,428(a0) if ( 4000ad0c: 0097f793 andi a5,a5,9 4000ad10: 08079a63 bnez a5,4000ada4 <_Thread_Cancel+0xd0> the_thread->budget_callout = the_thread->Start.budget_callout; 4000ad14: 0b452783 lw a5,180(a0) the_thread->budget_algorithm = the_thread->Start.budget_algorithm; 4000ad18: 0b052683 lw a3,176(a0) the_thread->is_preemptible = the_thread->Start.is_preemptible; 4000ad1c: 0ac54603 lbu a2,172(a0) the_thread->budget_callout = the_thread->Start.budget_callout; 4000ad20: 08f52a23 sw a5,148(a0) action->handler = handler; 4000ad24: 4000b7b7 lui a5,0x4000b 4000ad28: a5c78793 addi a5,a5,-1444 # 4000aa5c <_Thread_Life_action_handler> if ( _Chain_Is_node_off_chain( the_node ) ) { 4000ad2c: 1a052703 lw a4,416(a0) cpu_self->dispatch_necessary = true; 4000ad30: 40023937 lui s2,0x40023 the_thread->budget_algorithm = the_thread->Start.budget_algorithm; 4000ad34: 08d52823 sw a3,144(a0) 4000ad38: 1af52423 sw a5,424(a0) the_thread->is_preemptible = the_thread->Start.is_preemptible; 4000ad3c: 08c504a3 sb a2,137(a0) 4000ad40: f8090793 addi a5,s2,-128 # 40022f80 <_Per_CPU_Information> 4000ad44: 00100693 li a3,1 4000ad48: 02d78a23 sb a3,52(a5) 4000ad4c: 10070c63 beqz a4,4000ae64 <_Thread_Cancel+0x190> disable_level = cpu_self->thread_dispatch_disable_level; 4000ad50: 0307a703 lw a4,48(a5) return aggregation->Node.priority; 4000ad54: 0385a683 lw a3,56(a1) cpu_self->thread_dispatch_disable_level = disable_level + 1; 4000ad58: 00170713 addi a4,a4,1 4000ad5c: 02e7a823 sw a4,48(a5) ); cpu_self = _Thread_Dispatch_disable_critical( &lock_context ); priority = _Thread_Get_priority( executing ); if ( _States_Is_dormant( the_thread->current_state ) ) { 4000ad60: 01c42783 lw a5,28(s0) 4000ad64: 0186aa03 lw s4,24(a3) 4000ad68: 01c6aa83 lw s5,28(a3) 4000ad6c: 0c07ca63 bltz a5,4000ae40 <_Thread_Cancel+0x16c> pending_requests = the_thread->Life.pending_life_change_requests; 4000ad70: 1b042783 lw a5,432(s0) the_thread->Life.pending_life_change_requests = pending_requests + 1; 4000ad74: 00178713 addi a4,a5,1 4000ad78: 1ae42823 sw a4,432(s0) if ( pending_requests == 0 ) { 4000ad7c: 10078a63 beqz a5,4000ae90 <_Thread_Cancel+0x1bc> <== ALWAYS TAKEN __asm__ volatile ( "csrrs zero, mstatus, %0" : : "r" ( level ) ); 4000ad80: 3004a073 csrs mstatus,s1 _Thread_queue_Extract_with_proxy( the_thread ); 4000ad84: 00040513 mv a0,s0 4000ad88: 4f8060ef jal ra,40011280 <_Thread_queue_Extract_with_proxy> __asm__ volatile ( 4000ad8c: 300474f3 csrrci s1,mstatus,8 4000ad90: 06042503 lw a0,96(s0) 4000ad94: 06840593 addi a1,s0,104 4000ad98: 079000ef jal ra,4000b610 <_Watchdog_Remove> return mstatus & RISCV_MSTATUS_MIE; 4000ad9c: 0084f493 andi s1,s1,8 4000ada0: 0480006f j 4000ade8 <_Thread_Cancel+0x114> disable_level = cpu_self->thread_dispatch_disable_level; 4000ada4: 40023937 lui s2,0x40023 4000ada8: f8090713 addi a4,s2,-128 # 40022f80 <_Per_CPU_Information> 4000adac: 03072783 lw a5,48(a4) cpu_self->thread_dispatch_disable_level = disable_level + 1; 4000adb0: 00178793 addi a5,a5,1 4000adb4: 02f72823 sw a5,48(a4) if ( _States_Is_dormant( the_thread->current_state ) ) { 4000adb8: 01c52783 lw a5,28(a0) 4000adbc: 0807c263 bltz a5,4000ae40 <_Thread_Cancel+0x16c> <== NEVER TAKEN pending_requests = the_thread->Life.pending_life_change_requests; 4000adc0: 1b042783 lw a5,432(s0) 4000adc4: 0385a683 lw a3,56(a1) the_thread->Life.pending_life_change_requests = pending_requests + 1; 4000adc8: 00178713 addi a4,a5,1 4000adcc: 0186aa03 lw s4,24(a3) 4000add0: 01c6aa83 lw s5,28(a3) 4000add4: 1ae42823 sw a4,432(s0) if ( pending_requests == 0 ) { 4000add8: 0a078663 beqz a5,4000ae84 <_Thread_Cancel+0x1b0> <== ALWAYS TAKEN _Thread_State_release( the_thread, &lock_context ); _Thread_Finalize_life_change( the_thread, priority ); } else { _Thread_Add_life_change_request( the_thread ); _Thread_Clear_state_locked( the_thread, STATES_SUSPENDED ); 4000addc: 000085b7 lui a1,0x8 4000ade0: 00040513 mv a0,s0 4000ade4: 004060ef jal ra,40010de8 <_Thread_Clear_state_locked> __asm__ volatile ( "csrrs zero, mstatus, %0" : : "r" ( level ) ); 4000ade8: 3004a073 csrs mstatus,s1 _Thread_State_release( the_thread, &lock_context ); _Thread_Raise_real_priority( the_thread, priority ); 4000adec: 000a0593 mv a1,s4 4000adf0: 000a8613 mv a2,s5 4000adf4: 00040513 mv a0,s0 4000adf8: b61ff0ef jal ra,4000a958 <_Thread_Raise_real_priority> __asm__ volatile ( 4000adfc: 300474f3 csrrci s1,mstatus,8 return mstatus & RISCV_MSTATUS_MIE; 4000ae00: 0084f493 andi s1,s1,8 pending_requests = the_thread->Life.pending_life_change_requests; 4000ae04: 1b042783 lw a5,432(s0) if ( pending_requests == 1 ) { 4000ae08: 00100713 li a4,1 the_thread->Life.pending_life_change_requests = pending_requests - 1; 4000ae0c: fff78693 addi a3,a5,-1 4000ae10: 1ad42823 sw a3,432(s0) if ( pending_requests == 1 ) { 4000ae14: 02e78e63 beq a5,a4,4000ae50 <_Thread_Cancel+0x17c> __asm__ volatile ( "csrrs zero, mstatus, %0" : : "r" ( level ) ); 4000ae18: 3004a073 csrs mstatus,s1 _Thread_Remove_life_change_request( the_thread ); } _Thread_Dispatch_enable( cpu_self ); } 4000ae1c: 01812403 lw s0,24(sp) 4000ae20: 01c12083 lw ra,28(sp) 4000ae24: 01412483 lw s1,20(sp) 4000ae28: 00c12a03 lw s4,12(sp) 4000ae2c: 00812a83 lw s5,8(sp) _Thread_Dispatch_enable( cpu_self ); 4000ae30: f8090513 addi a0,s2,-128 } 4000ae34: 01012903 lw s2,16(sp) 4000ae38: 02010113 addi sp,sp,32 _Thread_Dispatch_enable( cpu_self ); 4000ae3c: af1fe06f j 4000992c <_Thread_Dispatch_enable> 4000ae40: 3004a073 csrs mstatus,s1 _Thread_Make_zombie( the_thread ); 4000ae44: 00040513 mv a0,s0 4000ae48: a51ff0ef jal ra,4000a898 <_Thread_Make_zombie> 4000ae4c: fd1ff06f j 4000ae1c <_Thread_Cancel+0x148> _Thread_Clear_state_locked( 4000ae50: 300285b7 lui a1,0x30028 4000ae54: 30c58593 addi a1,a1,780 # 3002830c 4000ae58: 00040513 mv a0,s0 4000ae5c: 78d050ef jal ra,40010de8 <_Thread_Clear_state_locked> 4000ae60: fb9ff06f j 4000ae18 <_Thread_Cancel+0x144> old_last = tail->previous; 4000ae64: 0e052683 lw a3,224(a0) _Chain_Append_if_is_off_chain_unprotected( 4000ae68: 1a050713 addi a4,a0,416 return &the_chain->Tail.Node; 4000ae6c: 0dc50613 addi a2,a0,220 the_node->next = tail; 4000ae70: 1ac52023 sw a2,416(a0) tail->previous = the_node; 4000ae74: 0ee52023 sw a4,224(a0) old_last->next = the_node; 4000ae78: 00e6a023 sw a4,0(a3) the_node->previous = old_last; 4000ae7c: 1ad52223 sw a3,420(a0) } 4000ae80: ed1ff06f j 4000ad50 <_Thread_Cancel+0x7c> _Thread_Set_state_locked( the_thread, STATES_LIFE_IS_CHANGING ); 4000ae84: 000205b7 lui a1,0x20 4000ae88: 1a0000ef jal ra,4000b028 <_Thread_Set_state_locked> 4000ae8c: f51ff06f j 4000addc <_Thread_Cancel+0x108> 4000ae90: 000205b7 lui a1,0x20 4000ae94: 00040513 mv a0,s0 4000ae98: 190000ef jal ra,4000b028 <_Thread_Set_state_locked> 4000ae9c: ee5ff06f j 4000ad80 <_Thread_Cancel+0xac> =============================================================================== 40008cac <_Thread_Change_life>: Thread_Life_state _Thread_Change_life( Thread_Life_state clear, Thread_Life_state set, Thread_Life_state ignore ) { 40008cac: ff010113 addi sp,sp,-16 40008cb0: 00112623 sw ra,12(sp) 40008cb4: 00812423 sw s0,8(sp) __asm__ volatile ( 40008cb8: 30047873 csrrci a6,mstatus,8 return mstatus & RISCV_MSTATUS_MIE; 40008cbc: 00887813 andi a6,a6,8 40008cc0: 400178b7 lui a7,0x40017 40008cc4: 30088693 addi a3,a7,768 # 40017300 <_Per_CPU_Information> 40008cc8: 0386a703 lw a4,56(a3) state &= ~clear; 40008ccc: fff54513 not a0,a0 state &= ~ignore; 40008cd0: fff64613 not a2,a2 previous = the_thread->Life.state; 40008cd4: 1ac72403 lw s0,428(a4) state &= ~clear; 40008cd8: 008577b3 and a5,a0,s0 state |= set; 40008cdc: 00f5e7b3 or a5,a1,a5 state &= ~ignore; 40008ce0: 00f67633 and a2,a2,a5 the_thread->Life.state = state; 40008ce4: 1af72623 sw a5,428(a4) & ( THREAD_LIFE_PROTECTED | THREAD_LIFE_CHANGE_DEFERRED ) ) == 0; 40008ce8: 00967793 andi a5,a2,9 if ( 40008cec: 04079063 bnez a5,40008d2c <_Thread_Change_life+0x80> & ( THREAD_LIFE_RESTARTING | THREAD_LIFE_TERMINATING ) ) != 0; 40008cf0: 00667613 andi a2,a2,6 && _Thread_Is_life_changing( state ) 40008cf4: 02060c63 beqz a2,40008d2c <_Thread_Change_life+0x80> the_thread->budget_callout = the_thread->Start.budget_callout; 40008cf8: 0b472783 lw a5,180(a4) the_thread->is_preemptible = the_thread->Start.is_preemptible; 40008cfc: 0ac74503 lbu a0,172(a4) the_thread->budget_algorithm = the_thread->Start.budget_algorithm; 40008d00: 0b072583 lw a1,176(a4) the_thread->budget_callout = the_thread->Start.budget_callout; 40008d04: 08f72a23 sw a5,148(a4) action->handler = handler; 40008d08: 400087b7 lui a5,0x40008 40008d0c: 7cc78793 addi a5,a5,1996 # 400087cc <_Thread_Life_action_handler> if ( _Chain_Is_node_off_chain( the_node ) ) { 40008d10: 1a072603 lw a2,416(a4) 40008d14: 1af72423 sw a5,424(a4) the_thread->is_preemptible = the_thread->Start.is_preemptible; 40008d18: 08a704a3 sb a0,137(a4) the_thread->budget_algorithm = the_thread->Start.budget_algorithm; 40008d1c: 08b72823 sw a1,144(a4) 40008d20: 00100793 li a5,1 40008d24: 02f68a23 sb a5,52(a3) 40008d28: 02060863 beqz a2,40008d58 <_Thread_Change_life+0xac> <== ALWAYS TAKEN disable_level = cpu_self->thread_dispatch_disable_level; 40008d2c: 0306a783 lw a5,48(a3) cpu_self->thread_dispatch_disable_level = disable_level + 1; 40008d30: 00178793 addi a5,a5,1 40008d34: 02f6a823 sw a5,48(a3) __asm__ volatile ( "csrrs zero, mstatus, %0" : : "r" ( level ) ); 40008d38: 30082073 csrs mstatus,a6 previous = _Thread_Change_life_locked( executing, clear, set, ignore ); cpu_self = _Thread_Dispatch_disable_critical( &lock_context ); _Thread_State_release( executing, &lock_context ); _Thread_Dispatch_enable( cpu_self ); 40008d3c: 30088513 addi a0,a7,768 40008d40: cc8fe0ef jal ra,40007208 <_Thread_Dispatch_enable> return previous; } 40008d44: 00c12083 lw ra,12(sp) 40008d48: 00040513 mv a0,s0 40008d4c: 00812403 lw s0,8(sp) 40008d50: 01010113 addi sp,sp,16 40008d54: 00008067 ret old_last = tail->previous; 40008d58: 0e072783 lw a5,224(a4) _Chain_Append_if_is_off_chain_unprotected( 40008d5c: 1a070613 addi a2,a4,416 return &the_chain->Tail.Node; 40008d60: 0dc70593 addi a1,a4,220 the_node->next = tail; 40008d64: 1ab72023 sw a1,416(a4) tail->previous = the_node; 40008d68: 0ec72023 sw a2,224(a4) old_last->next = the_node; 40008d6c: 00c7a023 sw a2,0(a5) the_node->previous = old_last; 40008d70: 1af72223 sw a5,420(a4) } 40008d74: fb9ff06f j 40008d2c <_Thread_Change_life+0x80> =============================================================================== 40010de8 <_Thread_Clear_state_locked>: States_Control _Thread_Clear_state_locked( Thread_Control *the_thread, States_Control state ) { 40010de8: ff010113 addi sp,sp,-16 40010dec: 00812423 sw s0,8(sp) States_Control previous_state; _Assert( state != 0 ); _Assert( _Thread_State_is_owner( the_thread ) ); previous_state = the_thread->current_state; 40010df0: 01c52403 lw s0,28(a0) { 40010df4: 00112623 sw ra,12(sp) if ( ( previous_state & state ) != 0 ) { 40010df8: 00b477b3 and a5,s0,a1 40010dfc: 02078863 beqz a5,40010e2c <_Thread_Clear_state_locked+0x44> RTEMS_INLINE_ROUTINE States_Control _States_Clear ( States_Control states_to_clear, States_Control current_state ) { return (current_state & ~states_to_clear); 40010e00: fff5c593 not a1,a1 40010e04: 0085f5b3 and a1,a1,s0 States_Control next_state; next_state = _States_Clear( state, previous_state ); the_thread->current_state = next_state; 40010e08: 00b52e23 sw a1,28(a0) if ( _States_Is_ready( next_state ) ) { 40010e0c: 02059063 bnez a1,40010e2c <_Thread_Clear_state_locked+0x44> <== NEVER TAKEN ( *scheduler->Operations.unblock )( scheduler, the_thread, scheduler_node ); 40010e10: 4001e7b7 lui a5,0x4001e 40010e14: 37078713 addi a4,a5,880 # 4001e370 <_Scheduler_Table> 40010e18: 03852603 lw a2,56(a0) 40010e1c: 01472703 lw a4,20(a4) 40010e20: 00050593 mv a1,a0 40010e24: 37078513 addi a0,a5,880 40010e28: 000700e7 jalr a4 _Scheduler_Unblock( the_thread ); } } return previous_state; } 40010e2c: 00c12083 lw ra,12(sp) 40010e30: 00040513 mv a0,s0 40010e34: 00812403 lw s0,8(sp) 40010e38: 01010113 addi sp,sp,16 40010e3c: 00008067 ret =============================================================================== 40010eac <_Thread_Create_idle>: Thread_Configuration config; Thread_Control *idle; bool ok; memset( &config, 0, sizeof( config ) ); config.scheduler = _Scheduler_Get_by_CPU( cpu ); 40010eac: 4001e537 lui a0,0x4001e 40010eb0: 37050793 addi a5,a0,880 # 4001e370 <_Scheduler_Table> _Scheduler_Start_idle( config.scheduler, idle, cpu ); _User_extensions_Thread_start( idle ); } void _Thread_Create_idle( void ) { 40010eb4: fc010113 addi sp,sp,-64 return ( *scheduler->Operations.map_priority )( scheduler, priority ); 40010eb8: 0447a603 lw a2,68(a5) 40010ebc: 01c7a703 lw a4,28(a5) 40010ec0: 0407a583 lw a1,64(a5) 40010ec4: 03212823 sw s2,48(sp) 40010ec8: 00100913 li s2,1 40010ecc: 02112e23 sw ra,60(sp) 40010ed0: 02812c23 sw s0,56(sp) 40010ed4: 02912a23 sw s1,52(sp) 40010ed8: 9321aa23 sw s2,-1740(gp) # 40020d74 <_System_state_Current> config.scheduler = _Scheduler_Get_by_CPU( cpu ); 40010edc: 00f12023 sw a5,0(sp) memset( &config, 0, sizeof( config ) ); 40010ee0: 00012223 sw zero,4(sp) 40010ee4: 00012423 sw zero,8(sp) 40010ee8: 00012623 sw zero,12(sp) 40010eec: 00012823 sw zero,16(sp) 40010ef0: 00012a23 sw zero,20(sp) 40010ef4: 00012c23 sw zero,24(sp) 40010ef8: 00012e23 sw zero,28(sp) 40010efc: 02012023 sw zero,32(sp) 40010f00: 02012223 sw zero,36(sp) 40010f04: 02012423 sw zero,40(sp) 40010f08: 02012623 sw zero,44(sp) 40010f0c: 37050513 addi a0,a0,880 40010f10: 000700e7 jalr a4 return ( *information->allocate )( information ); 40010f14: 400204b7 lui s1,0x40020 config.stack_size = _Thread_Idle_stack_size 40010f18: 8741a683 lw a3,-1932(gp) # 40020cb4 <_Thread_Idle_stack_size> 40010f1c: 68448793 addi a5,s1,1668 # 40020684 <_Thread_Information> 40010f20: 0087a703 lw a4,8(a5) config.name.name_u32 = _Objects_Build_name( 'I', 'D', 'L', 'E' ); 40010f24: 494457b7 lui a5,0x49445 40010f28: c4578793 addi a5,a5,-955 # 49444c45 40010f2c: 02f12023 sw a5,32(sp) config.is_fp = CPU_IDLE_TASK_IS_FP; 40010f30: 10000793 li a5,256 40010f34: 02f11423 sh a5,40(sp) config.stack_area = &_Thread_Idle_stacks[ 40010f38: 400247b7 lui a5,0x40024 40010f3c: a4078793 addi a5,a5,-1472 # 40023a40 <_Thread_Idle_stacks> config.stack_size = _Thread_Idle_stack_size 40010f40: 00d12423 sw a3,8(sp) config.stack_area = &_Thread_Idle_stacks[ 40010f44: 00f12223 sw a5,4(sp) config.priority = _Scheduler_Map_priority( 40010f48: 00a12823 sw a0,16(sp) 40010f4c: 00b12a23 sw a1,20(sp) config.budget_algorithm = THREAD_CPU_BUDGET_ALGORITHM_NONE; 40010f50: 00012c23 sw zero,24(sp) 40010f54: 68448513 addi a0,s1,1668 40010f58: 000700e7 jalr a4 40010f5c: 00050413 mv s0,a0 ok = _Thread_Initialize( &_Thread_Information, idle, &config ); 40010f60: 00010613 mv a2,sp 40010f64: 00050593 mv a1,a0 40010f68: 68448513 addi a0,s1,1668 40010f6c: 084000ef jal ra,40010ff0 <_Thread_Initialize> cpu->executing = idle; 40010f70: 400234b7 lui s1,0x40023 idle->Start.Entry.Kinds.Idle.entry = _Thread_Idle_body; 40010f74: 8c41a703 lw a4,-1852(gp) # 40020d04 <_Thread_Idle_body> cpu->executing = idle; 40010f78: f8048793 addi a5,s1,-128 # 40022f80 <_Per_CPU_Information> 40010f7c: 0287ac23 sw s0,56(a5) cpu->heir = 40010f80: 0287ae23 sw s0,60(a5) idle->Start.Entry.adaptor = _Thread_Entry_adaptor_idle; 40010f84: 400117b7 lui a5,0x40011 40010f88: fe478793 addi a5,a5,-28 # 40010fe4 <_Thread_Entry_adaptor_idle> idle->Start.Entry.Kinds.Idle.entry = _Thread_Idle_body; 40010f8c: 0ae42223 sw a4,164(s0) _Thread_Load_environment( idle ); 40010f90: 00040513 mv a0,s0 idle->is_idle = true; 40010f94: 09240423 sb s2,136(s0) idle->Start.Entry.adaptor = _Thread_Entry_adaptor_idle; 40010f98: 0af42023 sw a5,160(s0) _Thread_Load_environment( idle ); 40010f9c: 2a8000ef jal ra,40011244 <_Thread_Load_environment> _Scheduler_Start_idle( config.scheduler, idle, cpu ); 40010fa0: 00012503 lw a0,0(sp) ( *scheduler->Operations.start_idle )( scheduler, the_thread, cpu ); 40010fa4: f8048613 addi a2,s1,-128 40010fa8: 00040593 mv a1,s0 40010fac: 03852783 lw a5,56(a0) idle->current_state = STATES_READY; 40010fb0: 00042e23 sw zero,28(s0) 40010fb4: 000780e7 jalr a5 40010fb8: 4000b5b7 lui a1,0x4000b 40010fbc: 00040513 mv a0,s0 40010fc0: 00000613 li a2,0 40010fc4: 3a458593 addi a1,a1,932 # 4000b3a4 <_User_extensions_Thread_start_visitor> 40010fc8: c48fa0ef jal ra,4000b410 <_User_extensions_Iterate> if ( _Per_CPU_Is_processor_online( cpu ) ) { _Thread_Create_idle_for_CPU( cpu ); } } } 40010fcc: 03c12083 lw ra,60(sp) 40010fd0: 03812403 lw s0,56(sp) 40010fd4: 03412483 lw s1,52(sp) 40010fd8: 03012903 lw s2,48(sp) 40010fdc: 04010113 addi sp,sp,64 40010fe0: 00008067 ret =============================================================================== 4000992c <_Thread_Dispatch_enable>: } void _Thread_Dispatch_enable( Per_CPU_Control *cpu_self ) { uint32_t disable_level = cpu_self->thread_dispatch_disable_level; 4000992c: 03052783 lw a5,48(a0) if ( disable_level == 1 ) { 40009930: 00100713 li a4,1 40009934: 00e78863 beq a5,a4,40009944 <_Thread_Dispatch_enable+0x18> _Profiling_Thread_dispatch_enable( cpu_self, 0 ); _ISR_Local_enable( level ); } } else { _Assert( disable_level > 0 ); cpu_self->thread_dispatch_disable_level = disable_level - 1; 40009938: fff78793 addi a5,a5,-1 4000993c: 02f52823 sw a5,48(a0) } } 40009940: 00008067 ret 40009944: 300475f3 csrrci a1,mstatus,8 return mstatus & RISCV_MSTATUS_MIE; 40009948: 0085f593 andi a1,a1,8 cpu_self->dispatch_necessary 4000994c: 03454783 lbu a5,52(a0) 40009950: 0ff7f793 andi a5,a5,255 if ( 40009954: 00079463 bnez a5,4000995c <_Thread_Dispatch_enable+0x30> || !_ISR_Is_enabled( level ) 40009958: 00059463 bnez a1,40009960 <_Thread_Dispatch_enable+0x34> <== ALWAYS TAKEN _Thread_Do_dispatch( cpu_self, level ); 4000995c: e5dff06f j 400097b8 <_Thread_Do_dispatch> cpu_self->thread_dispatch_disable_level = 0; 40009960: 02052823 sw zero,48(a0) __asm__ volatile ( "csrrs zero, mstatus, %0" : : "r" ( level ) ); 40009964: 3005a073 csrs mstatus,a1 } 40009968: 00008067 ret =============================================================================== 400097b8 <_Thread_Do_dispatch>: _Thread_State_release( executing, &lock_context ); } void _Thread_Do_dispatch( Per_CPU_Control *cpu_self, ISR_Level level ) { 400097b8: fc010113 addi sp,sp,-64 400097bc: 02112e23 sw ra,60(sp) 400097c0: 02812c23 sw s0,56(sp) 400097c4: 02912a23 sw s1,52(sp) 400097c8: 03212823 sw s2,48(sp) 400097cc: 03312623 sw s3,44(sp) 400097d0: 03412423 sw s4,40(sp) 400097d4: 03512223 sw s5,36(sp) 400097d8: 03612023 sw s6,32(sp) 400097dc: 01712e23 sw s7,28(sp) riscv_interrupt_disable(); \ } while(0) RTEMS_INLINE_ROUTINE bool _CPU_ISR_Is_enabled( unsigned long level ) { return ( level & RISCV_MSTATUS_MIE ) != 0; 400097e0: 0085f793 andi a5,a1,8 Thread_Control *executing; _Assert( cpu_self->thread_dispatch_disable_level == 1 ); #if defined(RTEMS_SCORE_ROBUST_THREAD_DISPATCH) if ( 400097e4: 10078c63 beqz a5,400098fc <_Thread_Do_dispatch+0x144> <== NEVER TAKEN ) { _Internal_error( INTERNAL_ERROR_BAD_THREAD_DISPATCH_ENVIRONMENT ); } #endif executing = cpu_self->executing; 400097e8: 03852903 lw s2,56(a0) return _Chain_Immutable_head( the_chain )->next; 400097ec: 40021ab7 lui s5,0x40021 /* * Since heir and executing are not the same, we need to do a real * context switch. */ if ( heir->budget_algorithm == THREAD_CPU_BUDGET_ALGORITHM_RESET_TIMESLICE ) heir->cpu_time_budget = rtems_configuration_get_ticks_per_timeslice(); 400097f0: 8b01ab83 lw s7,-1872(gp) # 40020cf0 <_Watchdog_Ticks_per_timeslice> 400097f4: 8d8a8a93 addi s5,s5,-1832 # 400208d8 <_User_extensions_Switches_list> * stack or non-volatile registers reflect the old execution environment. */ cpu_self = _Per_CPU_Get(); _ISR_Local_disable( level ); } while ( cpu_self->dispatch_necessary ); 400097f8: 40023a37 lui s4,0x40023 if ( node != tail ) { 400097fc: 004a8993 addi s3,s5,4 _Context_Switch( &executing->Registers, &heir->Registers ); 40009800: 0e890b13 addi s6,s2,232 } while ( cpu_self->dispatch_necessary ); 40009804: f80a0a13 addi s4,s4,-128 # 40022f80 <_Per_CPU_Information> heir = cpu_self->heir; 40009808: 03c52483 lw s1,60(a0) cpu_self->dispatch_necessary = false; 4000980c: 02050a23 sb zero,52(a0) cpu_self->executing = heir; 40009810: 02952c23 sw s1,56(a0) if ( heir == executing ) 40009814: 04990e63 beq s2,s1,40009870 <_Thread_Do_dispatch+0xb8> if ( heir->budget_algorithm == THREAD_CPU_BUDGET_ALGORITHM_RESET_TIMESLICE ) 40009818: 0904a703 lw a4,144(s1) 4000981c: 00100793 li a5,1 <== NOT EXECUTED 40009820: 00f71463 bne a4,a5,40009828 <_Thread_Do_dispatch+0x70> <== NOT EXECUTED heir->cpu_time_budget = rtems_configuration_get_ticks_per_timeslice(); 40009824: 0974a623 sw s7,140(s1) <== NOT EXECUTED __asm__ volatile ( "csrrs zero, mstatus, %0" : : "r" ( level ) ); 40009828: 3005a073 csrs mstatus,a1 <== NOT EXECUTED 4000982c: 000aa403 lw s0,0(s5) <== NOT EXECUTED 40009830: 01340e63 beq s0,s3,4000984c <_Thread_Do_dispatch+0x94> <== NOT EXECUTED (*extension->thread_switch)( executing, heir ); 40009834: 00842783 lw a5,8(s0) <== NOT EXECUTED return the_node->next; 40009838: 00042403 lw s0,0(s0) <== NOT EXECUTED 4000983c: 00048593 mv a1,s1 <== NOT EXECUTED 40009840: 00090513 mv a0,s2 <== NOT EXECUTED 40009844: 000780e7 jalr a5 <== NOT EXECUTED while ( node != tail ) { 40009848: ff3416e3 bne s0,s3,40009834 <_Thread_Do_dispatch+0x7c> <== NOT EXECUTED _Context_Switch( &executing->Registers, &heir->Registers ); 4000984c: 0e848593 addi a1,s1,232 <== NOT EXECUTED 40009850: 000b0513 mv a0,s6 <== NOT EXECUTED 40009854: 42c020ef jal ra,4000bc80 <_CPU_Context_switch> <== NOT EXECUTED __asm__ volatile ( 40009858: 300475f3 csrrci a1,mstatus,8 <== NOT EXECUTED return mstatus & RISCV_MSTATUS_MIE; 4000985c: 0085f593 andi a1,a1,8 <== NOT EXECUTED } while ( cpu_self->dispatch_necessary ); 40009860: 034a4783 lbu a5,52(s4) <== NOT EXECUTED cpu_self = _Per_CPU_Get(); 40009864: 000a0513 mv a0,s4 <== NOT EXECUTED } while ( cpu_self->dispatch_necessary ); 40009868: 0ff7f793 andi a5,a5,255 <== NOT EXECUTED 4000986c: f8079ee3 bnez a5,40009808 <_Thread_Do_dispatch+0x50> <== NOT EXECUTED post_switch: _Assert( cpu_self->thread_dispatch_disable_level == 1 ); cpu_self->thread_dispatch_disable_level = 0; 40009870: 02052823 sw zero,48(a0) <== NOT EXECUTED __asm__ volatile ( "csrrs zero, mstatus, %0" : : "r" ( level ) ); 40009874: 3005a073 csrs mstatus,a1 __asm__ volatile ( 40009878: 300477f3 csrrci a5,mstatus,8 return mstatus & RISCV_MSTATUS_MIE; 4000987c: 0087f793 andi a5,a5,8 _ISR_lock_ISR_disable( lock_context ); 40009880: 00f12623 sw a5,12(sp) return _Chain_Immutable_head( the_chain )->next; 40009884: 0d892583 lw a1,216(s2) return &the_chain->Tail.Node; 40009888: 0dc90413 addi s0,s2,220 4000988c: 0d890493 addi s1,s2,216 if ( !_Chain_Is_empty(the_chain)) 40009890: 02858c63 beq a1,s0,400098c8 <_Thread_Do_dispatch+0x110> new_first = old_first->next; 40009894: 0005a783 lw a5,0(a1) ( *action->handler )( executing, action, &lock_context ); 40009898: 00c10613 addi a2,sp,12 <== NOT EXECUTED 4000989c: 00090513 mv a0,s2 <== NOT EXECUTED head->next = new_first; 400098a0: 0cf92c23 sw a5,216(s2) <== NOT EXECUTED new_first->previous = head; 400098a4: 0097a223 sw s1,4(a5) <== NOT EXECUTED 400098a8: 0085a783 lw a5,8(a1) <== NOT EXECUTED node->next = NULL; 400098ac: 0005a023 sw zero,0(a1) <== NOT EXECUTED 400098b0: 000780e7 jalr a5 <== NOT EXECUTED __asm__ volatile ( 400098b4: 300477f3 csrrci a5,mstatus,8 <== NOT EXECUTED return mstatus & RISCV_MSTATUS_MIE; 400098b8: 0087f793 andi a5,a5,8 <== NOT EXECUTED 400098bc: 00f12623 sw a5,12(sp) <== NOT EXECUTED return _Chain_Immutable_head( the_chain )->next; 400098c0: 0d892583 lw a1,216(s2) <== NOT EXECUTED if ( !_Chain_Is_empty(the_chain)) 400098c4: fcb418e3 bne s0,a1,40009894 <_Thread_Do_dispatch+0xdc> <== NOT EXECUTED __asm__ volatile ( "csrrs zero, mstatus, %0" : : "r" ( level ) ); 400098c8: 00c12783 lw a5,12(sp) <== NOT EXECUTED 400098cc: 3007a073 csrs mstatus,a5 _Profiling_Thread_dispatch_enable( cpu_self, 0 ); _ISR_Local_enable( level ); _Thread_Run_post_switch_actions( executing ); } 400098d0: 03c12083 lw ra,60(sp) 400098d4: 03812403 lw s0,56(sp) 400098d8: 03412483 lw s1,52(sp) 400098dc: 03012903 lw s2,48(sp) 400098e0: 02c12983 lw s3,44(sp) 400098e4: 02812a03 lw s4,40(sp) 400098e8: 02412a83 lw s5,36(sp) 400098ec: 02012b03 lw s6,32(sp) 400098f0: 01c12b83 lw s7,28(sp) 400098f4: 04010113 addi sp,sp,64 400098f8: 00008067 ret _Internal_error( INTERNAL_ERROR_BAD_THREAD_DISPATCH_ENVIRONMENT ); 400098fc: 01f00513 li a0,31 40009900: 8b8fe0ef jal ra,400079b8 <_Internal_error> <== NOT EXECUTED =============================================================================== 4000aee0 <_Thread_Exit>: __asm__ volatile ( 4000aee0: 300477f3 csrrci a5,mstatus,8 return mstatus & RISCV_MSTATUS_MIE; 4000aee4: 0087f793 andi a5,a5,8 state |= set; 4000aee8: 1ac52703 lw a4,428(a0) the_thread->Life.exit_value = exit_value; 4000aeec: 1ac52a23 sw a2,436(a0) state |= set; 4000aef0: 00e5e5b3 or a1,a1,a4 the_thread->Life.state = state; 4000aef4: 1ab52623 sw a1,428(a0) & ( THREAD_LIFE_RESTARTING | THREAD_LIFE_TERMINATING ) ) != 0; 4000aef8: 0065f593 andi a1,a1,6 && _Thread_Is_life_changing( state ) 4000aefc: 04058063 beqz a1,4000af3c <_Thread_Exit+0x5c> <== NEVER TAKEN the_thread->budget_callout = the_thread->Start.budget_callout; 4000af00: 0b452703 lw a4,180(a0) the_thread->budget_algorithm = the_thread->Start.budget_algorithm; 4000af04: 0b052603 lw a2,176(a0) the_thread->is_preemptible = the_thread->Start.is_preemptible; 4000af08: 0ac54583 lbu a1,172(a0) the_thread->budget_callout = the_thread->Start.budget_callout; 4000af0c: 08e52a23 sw a4,148(a0) action->handler = handler; 4000af10: 4000b737 lui a4,0x4000b 4000af14: a5c70713 addi a4,a4,-1444 # 4000aa5c <_Thread_Life_action_handler> 4000af18: 1ae52423 sw a4,424(a0) if ( _Chain_Is_node_off_chain( the_node ) ) { 4000af1c: 1a052683 lw a3,416(a0) cpu_self->dispatch_necessary = true; 4000af20: 40023737 lui a4,0x40023 the_thread->budget_algorithm = the_thread->Start.budget_algorithm; 4000af24: 08c52823 sw a2,144(a0) the_thread->is_preemptible = the_thread->Start.is_preemptible; 4000af28: 08b504a3 sb a1,137(a0) 4000af2c: f8070713 addi a4,a4,-128 # 40022f80 <_Per_CPU_Information> 4000af30: 00100613 li a2,1 4000af34: 02c70a23 sb a2,52(a4) 4000af38: 00068663 beqz a3,4000af44 <_Thread_Exit+0x64> <== ALWAYS TAKEN __asm__ volatile ( "csrrs zero, mstatus, %0" : : "r" ( level ) ); 4000af3c: 3007a073 csrs mstatus,a5 0, set, THREAD_LIFE_PROTECTED | THREAD_LIFE_CHANGE_DEFERRED ); _Thread_State_release( executing, &lock_context ); } 4000af40: 00008067 ret old_last = tail->previous; 4000af44: 0e052703 lw a4,224(a0) _Chain_Append_if_is_off_chain_unprotected( 4000af48: 1a050693 addi a3,a0,416 return &the_chain->Tail.Node; 4000af4c: 0dc50613 addi a2,a0,220 the_node->next = tail; 4000af50: 1ac52023 sw a2,416(a0) tail->previous = the_node; 4000af54: 0ed52023 sw a3,224(a0) old_last->next = the_node; 4000af58: 00d72023 sw a3,0(a4) the_node->previous = old_last; 4000af5c: 1ae52223 sw a4,420(a0) } 4000af60: fddff06f j 4000af3c <_Thread_Exit+0x5c> =============================================================================== 4001434c <_Thread_Get_name>: size_t buffer_size ) { const char *name; name = the_thread->Join_queue.Queue.name; 4001434c: 01852703 lw a4,24(a0) { 40014350: 00058793 mv a5,a1 40014354: 00060693 mv a3,a2 if ( name != NULL && name[ 0 ] != '\0' ) { 40014358: 00070663 beqz a4,40014364 <_Thread_Get_name+0x18> <== NEVER TAKEN 4001435c: 00074583 lbu a1,0(a4) 40014360: 00059a63 bnez a1,40014374 <_Thread_Get_name+0x28> return strlcpy( buffer, name, buffer_size ); } else { return _Objects_Name_to_string( 40014364: 00c52503 lw a0,12(a0) 40014368: 00078613 mv a2,a5 4001436c: 00000593 li a1,0 40014370: 25c0006f j 400145cc <_Objects_Name_to_string> return strlcpy( buffer, name, buffer_size ); 40014374: 00070593 mv a1,a4 40014378: 00078513 mv a0,a5 4001437c: 1980106f j 40015514 =============================================================================== 400099d8 <_Thread_Handler>: 400099d8: 40023537 lui a0,0x40023 } #endif } void _Thread_Handler( void ) { 400099dc: ff010113 addi sp,sp,-16 400099e0: f8050793 addi a5,a0,-128 # 40022f80 <_Per_CPU_Information> 400099e4: 00812423 sw s0,8(sp) 400099e8: 0387a403 lw s0,56(a5) 400099ec: 00112623 sw ra,12(sp) /* * have to put level into a register for those cpu's that use * inline asm here */ level = executing->Start.isr_level; 400099f0: 0b842783 lw a5,184(s0) } RTEMS_INLINE_ROUTINE void _CPU_ISR_Set_level( uint32_t level ) { if ( ( level & CPU_MODES_INTERRUPT_MASK) == 0 ) { 400099f4: 0017f793 andi a5,a5,1 400099f8: 06079263 bnez a5,40009a5c <_Thread_Handler+0x84> <== NEVER TAKEN __asm__ volatile ( 400099fc: 30046073 csrsi mstatus,8 __asm__ volatile ( 40009a00: 300475f3 csrrci a1,mstatus,8 * Make sure we lose no thread dispatch necessary update and execute the * post-switch actions. As a side-effect change the thread dispatch level * from one to zero. Do not use _Thread_Enable_dispatch() since there is no * valid thread dispatch necessary indicator in this context. */ _Thread_Do_dispatch( cpu_self, level ); 40009a04: 0085f593 andi a1,a1,8 40009a08: f8050513 addi a0,a0,-128 40009a0c: dadff0ef jal ra,400097b8 <_Thread_Do_dispatch> _User_extensions_Iterate( 40009a10: 4000b5b7 lui a1,0x4000b 40009a14: 00000613 li a2,0 40009a18: 3c458593 addi a1,a1,964 # 4000b3c4 <_User_extensions_Thread_begin_visitor> 40009a1c: 00040513 mv a0,s0 40009a20: 1f1010ef jal ra,4000b410 <_User_extensions_Iterate> if ( executing->Object.id == _Thread_Global_constructor ) { 40009a24: 93818793 addi a5,gp,-1736 # 40020d78 <_Thread_Global_constructor> 40009a28: 00842683 lw a3,8(s0) 40009a2c: 0007a703 lw a4,0(a5) 40009a30: 02e68a63 beq a3,a4,40009a64 <_Thread_Handler+0x8c> /* * RTEMS supports multiple APIs and each API can define a different * thread/task prototype. The following code supports invoking the * user thread entry point using the prototype expected. */ ( *executing->Start.Entry.adaptor )( executing ); 40009a34: 0a042783 lw a5,160(s0) 40009a38: 00040513 mv a0,s0 40009a3c: 000780e7 jalr a5 _User_extensions_Iterate( 40009a40: 4000b5b7 lui a1,0x4000b 40009a44: 00040513 mv a0,s0 <== NOT EXECUTED 40009a48: 00000613 li a2,0 <== NOT EXECUTED 40009a4c: 3d458593 addi a1,a1,980 # 4000b3d4 <_User_extensions_Thread_exitted_visitor><== NOT EXECUTED 40009a50: 1c1010ef jal ra,4000b410 <_User_extensions_Iterate> <== NOT EXECUTED * able to fit in a (void *). */ _User_extensions_Thread_exitted( executing ); _Internal_error( INTERNAL_ERROR_THREAD_EXITTED ); 40009a54: 00500513 li a0,5 <== NOT EXECUTED 40009a58: f61fd0ef jal ra,400079b8 <_Internal_error> <== NOT EXECUTED "csrrs zero, mstatus, " RTEMS_XSTRING( RISCV_MSTATUS_MIE ) ); } else { __asm__ volatile ( 40009a5c: 30047073 csrci mstatus,8 <== NOT EXECUTED 40009a60: fa1ff06f j 40009a00 <_Thread_Handler+0x28> <== NOT EXECUTED _Thread_Global_constructor = 0; 40009a64: 0007a023 sw zero,0(a5) <== NOT EXECUTED INIT_NAME(); 40009a68: 0140b0ef jal ra,40014a7c <__libc_init_array> 40009a6c: fc9ff06f j 40009a34 <_Thread_Handler+0x5c> =============================================================================== 40010ff0 <_Thread_Initialize>: Per_CPU_Control *cpu = _Per_CPU_Get_by_index( 0 ); memset( &the_thread->Join_queue, 0, information->Objects.object_size - offsetof( Thread_Control, Join_queue ) 40010ff0: 01455783 lhu a5,20(a0) { 40010ff4: fd010113 addi sp,sp,-48 40010ff8: 02812423 sw s0,40(sp) 40010ffc: 00058413 mv s0,a1 40011000: 02912223 sw s1,36(sp) 40011004: 03212023 sw s2,32(sp) 40011008: 00060493 mv s1,a2 4001100c: 00050913 mv s2,a0 memset( 40011010: ff078613 addi a2,a5,-16 40011014: 00000593 li a1,0 40011018: 01040513 addi a0,s0,16 { 4001101c: 02112623 sw ra,44(sp) 40011020: 01312e23 sw s3,28(sp) 40011024: 01412c23 sw s4,24(sp) memset( 40011028: 559030ef jal ra,40014d80 ); for ( i = 0 ; i < _Thread_Control_add_on_count ; ++i ) { 4001102c: 8701a603 lw a2,-1936(gp) # 40020cb0 <_Thread_Control_add_on_count> 40011030: 02060863 beqz a2,40011060 <_Thread_Initialize+0x70> 40011034: 4001e7b7 lui a5,0x4001e 40011038: 3c078793 addi a5,a5,960 # 4001e3c0 <_Thread_Control_add_ons> 4001103c: 00000593 li a1,0 const Thread_Control_add_on *add_on = &_Thread_Control_add_ons[ i ]; *(void **) ( (char *) the_thread + add_on->destination_offset ) = 40011040: 0007a703 lw a4,0(a5) (char *) the_thread + add_on->source_offset; 40011044: 0047a683 lw a3,4(a5) for ( i = 0 ; i < _Thread_Control_add_on_count ; ++i ) { 40011048: 00158593 addi a1,a1,1 *(void **) ( (char *) the_thread + add_on->destination_offset ) = 4001104c: 00e40733 add a4,s0,a4 (char *) the_thread + add_on->source_offset; 40011050: 00d406b3 add a3,s0,a3 *(void **) ( (char *) the_thread + add_on->destination_offset ) = 40011054: 00d72023 sw a3,0(a4) for ( i = 0 ; i < _Thread_Control_add_on_count ; ++i ) { 40011058: 00878793 addi a5,a5,8 4001105c: fec592e3 bne a1,a2,40011040 <_Thread_Initialize+0x50> } /* Set everything to perform the error case clean up */ the_thread->Start.stack_free = config->stack_free; 40011060: 00c4a783 lw a5,12(s1) goto failed; } #endif #if defined(RTEMS_SMP) || CPU_ENABLE_ROBUST_THREAD_DISPATCH == TRUE if ( 40011064: 0244a703 lw a4,36(s1) the_thread->Start.stack_free = config->stack_free; 40011068: 0cf42423 sw a5,200(s0) if ( 4001106c: 02070863 beqz a4,4001109c <_Thread_Initialize+0xac> #if defined(RTEMS_SMP) || CPU_ENABLE_ROBUST_THREAD_DISPATCH == TRUE failed: #endif ( *the_thread->Start.stack_free )( the_thread->Start.Initial_stack.area ); 40011070: 0d042503 lw a0,208(s0) 40011074: 000780e7 jalr a5 <== NOT EXECUTED return false; 40011078: 00000513 li a0,0 <== NOT EXECUTED } 4001107c: 02c12083 lw ra,44(sp) <== NOT EXECUTED 40011080: 02812403 lw s0,40(sp) 40011084: 02412483 lw s1,36(sp) 40011088: 02012903 lw s2,32(sp) 4001108c: 01c12983 lw s3,28(sp) 40011090: 01812a03 lw s4,24(sp) 40011094: 03010113 addi sp,sp,48 40011098: 00008067 ret stack_begin = config->stack_area; 4001109c: 0044aa03 lw s4,4(s1) stack_end = stack_begin + config->stack_size; 400110a0: 0084a983 lw s3,8(s1) 400110a4: 013a09b3 add s3,s4,s3 tls_size = _TLS_Get_allocation_size(); 400110a8: 3a0000ef jal ra,40011448 <_TLS_Get_allocation_size> if ( tls_size > 0 ) { 400110ac: 02050063 beqz a0,400110cc <_Thread_Initialize+0xdc> tls_align = (uintptr_t) _TLS_Alignment; 400110b0: 00100793 li a5,1 ( ( (uintptr_t) stack_end + tls_align - 1 ) & ~( tls_align - 1 ) ); 400110b4: fff78713 addi a4,a5,-1 <== NOT EXECUTED stack_end -= tls_size; 400110b8: 40a989b3 sub s3,s3,a0 <== NOT EXECUTED ( ( (uintptr_t) stack_end + tls_align - 1 ) & ~( tls_align - 1 ) ); 400110bc: 00e98733 add a4,s3,a4 <== NOT EXECUTED 400110c0: 40f007b3 neg a5,a5 <== NOT EXECUTED 400110c4: 00f777b3 and a5,a4,a5 <== NOT EXECUTED the_thread->Start.tls_area = (void *) 400110c8: 0cf42a23 sw a5,212(s0) <== NOT EXECUTED old_first = head->next; 400110cc: 03092783 lw a5,48(s2) <== NOT EXECUTED stack_end - stack_begin 400110d0: 414989b3 sub s3,s3,s4 the_stack->area = starting_address; 400110d4: 0d442823 sw s4,208(s0) new_first = old_first->next; 400110d8: 0007a703 lw a4,0(a5) the_stack->size = size; 400110dc: 0d342623 sw s3,204(s0) return &the_chain->Head.Node; 400110e0: 03090a13 addi s4,s2,48 head->next = new_first; 400110e4: 02e92823 sw a4,48(s2) new_first->previous = head; 400110e8: 01472223 sw s4,4(a4) the_thread->is_fp = config->is_fp; 400110ec: 0284c803 lbu a6,40(s1) the_thread->Start.isr_level = config->isr_level; 400110f0: 0244a503 lw a0,36(s1) the_thread->Start.is_preemptible = config->is_preemptible; 400110f4: 0294c583 lbu a1,41(s1) the_thread->Start.budget_algorithm = config->budget_algorithm; 400110f8: 0184a683 lw a3,24(s1) the_thread->Start.budget_callout = config->budget_callout; 400110fc: 01c4a603 lw a2,28(s1) return &the_chain->Tail.Node; 40011100: 03078713 addi a4,a5,48 the_thread->Wait.spare_heads = _Freechain_Pop( 40011104: 04f42e23 sw a5,92(s0) 40011108: 03478893 addi a7,a5,52 tail->previous = head; 4001110c: 02e7ac23 sw a4,56(a5) head->next = tail; 40011110: 0317a823 sw a7,48(a5) head->previous = NULL; 40011114: 0207aa23 sw zero,52(a5) timer->header = &cpu->Watchdog.Header[ PER_CPU_WATCHDOG_TICKS ]; 40011118: 400237b7 lui a5,0x40023 RB_COLOR( &the_watchdog->Node.RBTree, Node ) = state; 4001111c: 00200713 li a4,2 40011120: fd078793 addi a5,a5,-48 # 40022fd0 <_Per_CPU_Information+0x50> the_thread->is_fp = config->is_fp; 40011124: 09040523 sb a6,138(s0) the_thread->Start.isr_level = config->isr_level; 40011128: 0aa42c23 sw a0,184(s0) the_thread->Start.is_preemptible = config->is_preemptible; 4001112c: 0ab40623 sb a1,172(s0) the_thread->Start.budget_algorithm = config->budget_algorithm; 40011130: 0ad42823 sw a3,176(s0) the_thread->Start.budget_callout = config->budget_callout; 40011134: 0ac42a23 sw a2,180(s0) 40011138: 06f42023 sw a5,96(s0) 4001113c: 06e42a23 sw a4,116(s0) switch ( config->budget_algorithm ) { 40011140: 00e69663 bne a3,a4,4001114c <_Thread_Initialize+0x15c> the_thread->cpu_time_budget = 40011144: 8b01a783 lw a5,-1872(gp) # 40020cf0 <_Watchdog_Ticks_per_timeslice> 40011148: 08f42623 sw a5,140(s0) <== NOT EXECUTED config->scheduler, 4001114c: 0004a503 lw a0,0(s1) <== NOT EXECUTED return the_thread->Scheduler.nodes; 40011150: 03842983 lw s3,56(s0) <== NOT EXECUTED ( *scheduler->Operations.node_initialize )( 40011154: 0104a683 lw a3,16(s1) 40011158: 02452783 lw a5,36(a0) 4001115c: 0144a703 lw a4,20(s1) 40011160: 00040613 mv a2,s0 40011164: 00098593 mv a1,s3 40011168: 000780e7 jalr a5 _Priority_Node_initialize( &the_thread->Real_priority, config->priority ); 4001116c: 0104a603 lw a2,16(s1) 40011170: 0144a683 lw a3,20(s1) node->priority = priority; 40011174: 0204a503 lw a0,32(s1) information->local_table[ index - OBJECTS_INDEX_MINIMUM ] = the_object; 40011178: 00492783 lw a5,4(s2) 4001117c: 00845703 lhu a4,8(s0) 40011180: 02c42823 sw a2,48(s0) 40011184: 02d42a23 sw a3,52(s0) _RBTree_Initialize_one( &aggregation->Contributors, &node->Node.RBTree ); 40011188: 02040593 addi a1,s0,32 node->priority = priority; 4001118c: 00c9ac23 sw a2,24(s3) RB_ROOT( the_rbtree ) = the_node; 40011190: 02b9a023 sw a1,32(s3) 40011194: 00d9ae23 sw a3,28(s3) the_thread->current_state = STATES_DORMANT; 40011198: 800005b7 lui a1,0x80000 4001119c: 00b42e23 sw a1,28(s0) the_thread->Wait.operations = &_Thread_queue_Operations_default; 400111a0: 4001f5b7 lui a1,0x4001f 400111a4: 00271713 slli a4,a4,0x2 return &the_chain->Tail.Node; 400111a8: 0d840813 addi a6,s0,216 400111ac: 0dc40893 addi a7,s0,220 400111b0: f1058593 addi a1,a1,-240 # 4001ef10 <_Thread_queue_Operations_default> 400111b4: 04b42c23 sw a1,88(s0) the_thread->Start.initial_priority = config->priority; 400111b8: 0cc42023 sw a2,192(s0) the_object->name = name; 400111bc: 00a42623 sw a0,12(s0) information->local_table[ index - OBJECTS_INDEX_MINIMUM ] = the_object; 400111c0: 00e787b3 add a5,a5,a4 RB_PARENT( the_node, Node ) = NULL; 400111c4: 02042423 sw zero,40(s0) RB_LEFT( the_node, Node ) = NULL; 400111c8: 02042023 sw zero,32(s0) RB_RIGHT( the_node, Node ) = NULL; 400111cc: 02042223 sw zero,36(s0) RB_COLOR( the_node, Node ) = RB_BLACK; 400111d0: 02042623 sw zero,44(s0) 400111d4: 0cd42223 sw a3,196(s0) RB_INIT( the_rbtree ); 400111d8: 18042e23 sw zero,412(s0) head->next = tail; 400111dc: 0d142c23 sw a7,216(s0) head->previous = NULL; 400111e0: 0c042e23 sw zero,220(s0) tail->previous = head; 400111e4: 0f042023 sw a6,224(s0) _User_extensions_Iterate( 400111e8: 4000b5b7 lui a1,0x4000b 400111ec: fe87ae23 sw s0,-4(a5) 400111f0: 00810513 addi a0,sp,8 User_extensions_Thread_create_context ctx = { created, true }; 400111f4: 00100793 li a5,1 _User_extensions_Iterate( 400111f8: 00000613 li a2,0 400111fc: 35058593 addi a1,a1,848 # 4000b350 <_User_extensions_Thread_create_visitor> User_extensions_Thread_create_context ctx = { created, true }; 40011200: 00812423 sw s0,8(sp) 40011204: 00f10623 sb a5,12(sp) _User_extensions_Iterate( 40011208: a08fa0ef jal ra,4000b410 <_User_extensions_Iterate> return ctx.ok; 4001120c: 00c14503 lbu a0,12(sp) if ( extension_status ) 40011210: e60516e3 bnez a0,4001107c <_Thread_Initialize+0x8c> _Scheduler_Node_destroy( config->scheduler, scheduler_node ); 40011214: 0004a503 lw a0,0(s1) ( *scheduler->Operations.node_destroy )( scheduler, node ); 40011218: 00098593 mv a1,s3 4001121c: 02852783 lw a5,40(a0) <== NOT EXECUTED 40011220: 000780e7 jalr a5 <== NOT EXECUTED the_thread->Wait.spare_heads 40011224: 05c42703 lw a4,92(s0) <== NOT EXECUTED before_node = after_node->next; 40011228: 03092683 lw a3,48(s2) <== NOT EXECUTED ( *the_thread->Start.stack_free )( the_thread->Start.Initial_stack.area ); 4001122c: 0c842783 lw a5,200(s0) <== NOT EXECUTED the_node->previous = after_node; 40011230: 01472223 sw s4,4(a4) <== NOT EXECUTED after_node->next = the_node; 40011234: 02e92823 sw a4,48(s2) <== NOT EXECUTED the_node->next = before_node; 40011238: 00d72023 sw a3,0(a4) <== NOT EXECUTED before_node->previous = the_node; 4001123c: 00e6a223 sw a4,4(a3) <== NOT EXECUTED void *node ) { _Chain_Initialize_node( node ); _Chain_Prepend_unprotected( &freechain->Free, node ); } 40011240: e31ff06f j 40011070 <_Thread_Initialize+0x80> <== NOT EXECUTED =============================================================================== 40009f98 <_Thread_Iterate>: void _Thread_Iterate( Thread_Visitor visitor, void *arg ) { 40009f98: fd010113 addi sp,sp,-48 40009f9c: 01412c23 sw s4,24(sp) 40009fa0: 4001ba37 lui s4,0x4001b 40009fa4: 01512a23 sw s5,20(sp) 40009fa8: 5e4a0a13 addi s4,s4,1508 # 4001b5e4 <_Objects_Information_table> 40009fac: 00010ab7 lui s5,0x10 40009fb0: 01312e23 sw s3,28(sp) 40009fb4: 01612823 sw s6,16(sp) 40009fb8: 01712623 sw s7,12(sp) 40009fbc: 02112623 sw ra,44(sp) 40009fc0: 02812423 sw s0,40(sp) 40009fc4: 02912223 sw s1,36(sp) 40009fc8: 03212023 sw s2,32(sp) 40009fcc: 00050993 mv s3,a0 40009fd0: 00058b93 mv s7,a1 40009fd4: 00ca0b13 addi s6,s4,12 40009fd8: fffa8a93 addi s5,s5,-1 # ffff const Objects_Information *information; Objects_Maximum maximum; Objects_Maximum index; _Assert( _Objects_Information_table[ api_index ] != NULL ); information = _Objects_Information_table[ api_index ][ 1 ]; 40009fdc: 004a2783 lw a5,4(s4) 40009fe0: 0047a903 lw s2,4(a5) if ( information == NULL ) { 40009fe4: 04090263 beqz s2,4000a028 <_Thread_Iterate+0x90> return _Objects_Get_index( information->maximum_id ); 40009fe8: 00092483 lw s1,0(s2) continue; } maximum = _Objects_Get_maximum_index( information ); for ( index = 0 ; index < maximum ; ++index ) { 40009fec: 01049793 slli a5,s1,0x10 40009ff0: 0107d793 srli a5,a5,0x10 40009ff4: 02078a63 beqz a5,4000a028 <_Thread_Iterate+0x90> <== NEVER TAKEN 40009ff8: 0154f4b3 and s1,s1,s5 40009ffc: 00249493 slli s1,s1,0x2 4000a000: 00000413 li s0,0 Thread_Control *the_thread; the_thread = (Thread_Control *) information->local_table[ index ]; 4000a004: 00492783 lw a5,4(s2) if ( the_thread != NULL ) { bool done; done = (* visitor )( the_thread, arg ); 4000a008: 000b8593 mv a1,s7 the_thread = (Thread_Control *) information->local_table[ index ]; 4000a00c: 008787b3 add a5,a5,s0 4000a010: 0007a503 lw a0,0(a5) for ( index = 0 ; index < maximum ; ++index ) { 4000a014: 00440413 addi s0,s0,4 if ( the_thread != NULL ) { 4000a018: 00050663 beqz a0,4000a024 <_Thread_Iterate+0x8c> done = (* visitor )( the_thread, arg ); 4000a01c: 000980e7 jalr s3 if ( done ) { 4000a020: 00051863 bnez a0,4000a030 <_Thread_Iterate+0x98> <== NEVER TAKEN for ( index = 0 ; index < maximum ; ++index ) { 4000a024: fe8490e3 bne s1,s0,4000a004 <_Thread_Iterate+0x6c> for ( api_index = 1 ; api_index <= OBJECTS_APIS_LAST ; ++api_index ) { 4000a028: 004a0a13 addi s4,s4,4 4000a02c: fb4b18e3 bne s6,s4,40009fdc <_Thread_Iterate+0x44> return; } } } } } 4000a030: 02c12083 lw ra,44(sp) 4000a034: 02812403 lw s0,40(sp) 4000a038: 02412483 lw s1,36(sp) 4000a03c: 02012903 lw s2,32(sp) 4000a040: 01c12983 lw s3,28(sp) 4000a044: 01812a03 lw s4,24(sp) 4000a048: 01412a83 lw s5,20(sp) 4000a04c: 01012b03 lw s6,16(sp) 4000a050: 00c12b83 lw s7,12(sp) 4000a054: 03010113 addi sp,sp,48 4000a058: 00008067 ret =============================================================================== 4000ab9c <_Thread_Kill_zombies>: { 4000ab9c: fe010113 addi sp,sp,-32 4000aba0: 00112e23 sw ra,28(sp) 4000aba4: 00812c23 sw s0,24(sp) 4000aba8: 00912a23 sw s1,20(sp) 4000abac: 01212823 sw s2,16(sp) 4000abb0: 01312623 sw s3,12(sp) 4000abb4: 01412423 sw s4,8(sp) 4000abb8: 01512223 sw s5,4(sp) 4000abbc: 01612023 sw s6,0(sp) __asm__ volatile ( 4000abc0: 300477f3 csrrci a5,mstatus,8 return mstatus & RISCV_MSTATUS_MIE; 4000abc4: 0087f793 andi a5,a5,8 return _Chain_Immutable_head( the_chain )->next; 4000abc8: 40021937 lui s2,0x40021 4000abcc: 8e490913 addi s2,s2,-1820 # 400208e4 <_Thread_Zombies> 4000abd0: 00092403 lw s0,0(s2) if ( !_Chain_Is_empty(the_chain)) 4000abd4: 00490993 addi s3,s2,4 4000abd8: 0d340863 beq s0,s3,4000aca8 <_Thread_Kill_zombies+0x10c> new_first = old_first->next; 4000abdc: 00042703 lw a4,0(s0) head->next = new_first; 4000abe0: 4001ea37 lui s4,0x4001e 4000abe4: 4000bb37 lui s6,0x4000b 4000abe8: 00e92023 sw a4,0(s2) new_first->previous = head; 4000abec: 01272223 sw s2,4(a4) while ( the_thread != NULL ) { 4000abf0: 370a0a93 addi s5,s4,880 # 4001e370 <_Scheduler_Table> __asm__ volatile ( "csrrs zero, mstatus, %0" : : "r" ( level ) ); 4000abf4: 3007a073 csrs mstatus,a5 _Objects_Get_information_id( the_thread->Object.id ); 4000abf8: 00842503 lw a0,8(s0) 4000abfc: 5bc050ef jal ra,400101b8 <_Objects_Get_information_id> 4000ac00: 00050493 mv s1,a0 _User_extensions_Iterate( 4000ac04: 00100613 li a2,1 4000ac08: 394b0593 addi a1,s6,916 # 4000b394 <_User_extensions_Thread_delete_visitor> 4000ac0c: 00040513 mv a0,s0 4000ac10: 001000ef jal ra,4000b410 <_User_extensions_Iterate> __asm__ volatile ( 4000ac14: 30047673 csrrci a2,mstatus,8 return mstatus & RISCV_MSTATUS_MIE; 4000ac18: 00867613 andi a2,a2,8 iter = the_thread->last_user_extensions_iterator; 4000ac1c: 1c842783 lw a5,456(s0) while ( iter != NULL ) { 4000ac20: 00078e63 beqz a5,4000ac3c <_Thread_Kill_zombies+0xa0> next = the_node->next; 4000ac24: 0007a683 lw a3,0(a5) previous = the_node->previous; 4000ac28: 0047a703 lw a4,4(a5) iter = iter->previous; 4000ac2c: 0107a783 lw a5,16(a5) next->previous = previous; 4000ac30: 00e6a223 sw a4,4(a3) previous->next = next; 4000ac34: 00d72023 sw a3,0(a4) while ( iter != NULL ) { 4000ac38: fe0796e3 bnez a5,4000ac24 <_Thread_Kill_zombies+0x88> <== NEVER TAKEN __asm__ volatile ( "csrrs zero, mstatus, %0" : : "r" ( level ) ); 4000ac3c: 30062073 csrs mstatus,a2 ( *scheduler->Operations.node_destroy )( scheduler, node ); 4000ac40: 03842583 lw a1,56(s0) 4000ac44: 028aa783 lw a5,40(s5) 4000ac48: 370a0513 addi a0,s4,880 4000ac4c: 000780e7 jalr a5 the_thread->Wait.spare_heads 4000ac50: 05c42783 lw a5,92(s0) before_node = after_node->next; 4000ac54: 0304a703 lw a4,48(s1) return &the_chain->Head.Node; 4000ac58: 03048693 addi a3,s1,48 the_node->previous = after_node; 4000ac5c: 00d7a223 sw a3,4(a5) ( *the_thread->Start.stack_free )( the_thread->Start.Initial_stack.area ); 4000ac60: 0d042503 lw a0,208(s0) 4000ac64: 0c842683 lw a3,200(s0) after_node->next = the_node; 4000ac68: 02f4a823 sw a5,48(s1) the_node->next = before_node; 4000ac6c: 00e7a023 sw a4,0(a5) before_node->previous = the_node; 4000ac70: 00f72223 sw a5,4(a4) 4000ac74: 000680e7 jalr a3 Objects_Control *the_object ) { _Assert( _Objects_Allocator_is_owner() ); _Assert( information->deallocate != NULL ); ( *information->deallocate )( information, the_object ); 4000ac78: 00c4a783 lw a5,12(s1) 4000ac7c: 00040593 mv a1,s0 4000ac80: 00048513 mv a0,s1 4000ac84: 000780e7 jalr a5 __asm__ volatile ( 4000ac88: 300477f3 csrrci a5,mstatus,8 return mstatus & RISCV_MSTATUS_MIE; 4000ac8c: 0087f793 andi a5,a5,8 return _Chain_Immutable_head( the_chain )->next; 4000ac90: 00092403 lw s0,0(s2) if ( !_Chain_Is_empty(the_chain)) 4000ac94: 01340a63 beq s0,s3,4000aca8 <_Thread_Kill_zombies+0x10c> new_first = old_first->next; 4000ac98: 00042703 lw a4,0(s0) head->next = new_first; 4000ac9c: 00e92023 sw a4,0(s2) new_first->previous = head; 4000aca0: 01272223 sw s2,4(a4) while ( the_thread != NULL ) { 4000aca4: f51ff06f j 4000abf4 <_Thread_Kill_zombies+0x58> __asm__ volatile ( "csrrs zero, mstatus, %0" : : "r" ( level ) ); 4000aca8: 3007a073 csrs mstatus,a5 } 4000acac: 01c12083 lw ra,28(sp) 4000acb0: 01812403 lw s0,24(sp) 4000acb4: 01412483 lw s1,20(sp) 4000acb8: 01012903 lw s2,16(sp) 4000acbc: 00c12983 lw s3,12(sp) 4000acc0: 00812a03 lw s4,8(sp) 4000acc4: 00412a83 lw s5,4(sp) 4000acc8: 00012b03 lw s6,0(sp) 4000accc: 02010113 addi sp,sp,32 4000acd0: 00008067 ret =============================================================================== 4000c670 <_Thread_Priority_add>: return the_thread->Scheduler.nodes; 4000c670: 03852783 lw a5,56(a0) void _Thread_Priority_add( Thread_Control *the_thread, Priority_Node *priority_node, Thread_queue_Context *queue_context ) { 4000c674: ff010113 addi sp,sp,-16 4000c678: 00912223 sw s1,4(sp) queue = the_thread->Wait.queue; 4000c67c: 05452483 lw s1,84(a0) { 4000c680: 00812423 sw s0,8(sp) 4000c684: 00112623 sw ra,12(sp) 4000c688: 01212023 sw s2,0(sp) 4000c68c: 00060413 mv s0,a2 _Thread_Priority_do_perform_actions( 4000c690: 05852603 lw a2,88(a0) _Priority_Actions_initialize_one( 4000c694: 00878793 addi a5,a5,8 aggregation->Action.node = node; 4000c698: 00b7ae23 sw a1,28(a5) aggregation->Action.type = type; 4000c69c: 0207a023 sw zero,32(a5) actions->actions = aggregation; 4000c6a0: 00f42823 sw a5,16(s0) _Thread_Priority_do_perform_actions( 4000c6a4: 00040713 mv a4,s0 4000c6a8: 00000693 li a3,0 4000c6ac: 00048593 mv a1,s1 4000c6b0: cc5ff0ef jal ra,4000c374 <_Thread_Priority_do_perform_actions> if ( !_Priority_Actions_is_empty( &queue_context->Priority.Actions ) ) { 4000c6b4: 01042783 lw a5,16(s0) 4000c6b8: 02078c63 beqz a5,4000c6f0 <_Thread_Priority_add+0x80> <== ALWAYS TAKEN _Thread_Priority_perform_actions( queue->owner, queue_context ); 4000c6bc: 0044a503 lw a0,4(s1) <== NOT EXECUTED return queue_context->Priority.update_count; 4000c6c0: 01442903 lw s2,20(s0) <== NOT EXECUTED 4000c6c4: 00c0006f j 4000c6d0 <_Thread_Priority_add+0x60> <== NOT EXECUTED the_thread = queue->owner; 4000c6c8: 0044a503 lw a0,4(s1) <== NOT EXECUTED queue_context->Priority.update_count = update_count; 4000c6cc: 01242a23 sw s2,20(s0) <== NOT EXECUTED queue = the_thread->Wait.queue; 4000c6d0: 05452483 lw s1,84(a0) <== NOT EXECUTED _Thread_Priority_do_perform_actions( 4000c6d4: 05852603 lw a2,88(a0) <== NOT EXECUTED 4000c6d8: 00040713 mv a4,s0 <== NOT EXECUTED 4000c6dc: 00000693 li a3,0 <== NOT EXECUTED 4000c6e0: 00048593 mv a1,s1 <== NOT EXECUTED 4000c6e4: c91ff0ef jal ra,4000c374 <_Thread_Priority_do_perform_actions> <== NOT EXECUTED if ( _Priority_Actions_is_empty( &queue_context->Priority.Actions ) ) { 4000c6e8: 01042783 lw a5,16(s0) <== NOT EXECUTED 4000c6ec: fc079ee3 bnez a5,4000c6c8 <_Thread_Priority_add+0x58> <== NOT EXECUTED priority_node, queue_context, false, PRIORITY_ACTION_ADD ); } 4000c6f0: 00c12083 lw ra,12(sp) 4000c6f4: 00812403 lw s0,8(sp) 4000c6f8: 00412483 lw s1,4(sp) 4000c6fc: 00012903 lw s2,0(sp) 4000c700: 01010113 addi sp,sp,16 4000c704: 00008067 ret =============================================================================== 40010c60 <_Thread_Priority_perform_actions>: void _Thread_Priority_perform_actions( Thread_Control *start_of_path, Thread_queue_Context *queue_context ) { 40010c60: ff010113 addi sp,sp,-16 <== NOT EXECUTED 40010c64: 00812423 sw s0,8(sp) <== NOT EXECUTED 40010c68: 01212023 sw s2,0(sp) <== NOT EXECUTED 40010c6c: 00112623 sw ra,12(sp) <== NOT EXECUTED return queue_context->Priority.update_count; 40010c70: 0145a903 lw s2,20(a1) <== NOT EXECUTED 40010c74: 00912223 sw s1,4(sp) <== NOT EXECUTED 40010c78: 00058413 mv s0,a1 <== NOT EXECUTED 40010c7c: 00c0006f j 40010c88 <_Thread_Priority_perform_actions+0x28> <== NOT EXECUTED if ( _Priority_Actions_is_empty( &queue_context->Priority.Actions ) ) { return; } _Assert( queue != NULL ); the_thread = queue->owner; 40010c80: 0044a503 lw a0,4(s1) <== NOT EXECUTED queue_context->Priority.update_count = update_count; 40010c84: 01242a23 sw s2,20(s0) <== NOT EXECUTED queue = the_thread->Wait.queue; 40010c88: 05452483 lw s1,84(a0) <== NOT EXECUTED _Thread_Priority_do_perform_actions( 40010c8c: 05852603 lw a2,88(a0) <== NOT EXECUTED 40010c90: 00040713 mv a4,s0 <== NOT EXECUTED 40010c94: 00000693 li a3,0 <== NOT EXECUTED 40010c98: 00048593 mv a1,s1 <== NOT EXECUTED 40010c9c: d29ff0ef jal ra,400109c4 <_Thread_Priority_do_perform_actions> <== NOT EXECUTED if ( _Priority_Actions_is_empty( &queue_context->Priority.Actions ) ) { 40010ca0: 01042783 lw a5,16(s0) <== NOT EXECUTED 40010ca4: fc079ee3 bnez a5,40010c80 <_Thread_Priority_perform_actions+0x20><== NOT EXECUTED _Thread_queue_Context_restore_priority_updates( queue_context, update_count ); } } 40010ca8: 00c12083 lw ra,12(sp) <== NOT EXECUTED 40010cac: 00812403 lw s0,8(sp) <== NOT EXECUTED 40010cb0: 00412483 lw s1,4(sp) <== NOT EXECUTED 40010cb4: 00012903 lw s2,0(sp) <== NOT EXECUTED 40010cb8: 01010113 addi sp,sp,16 <== NOT EXECUTED 40010cbc: 00008067 ret <== NOT EXECUTED =============================================================================== 4000c708 <_Thread_Priority_remove>: 4000c708: 03852783 lw a5,56(a0) void _Thread_Priority_remove( Thread_Control *the_thread, Priority_Node *priority_node, Thread_queue_Context *queue_context ) { 4000c70c: ff010113 addi sp,sp,-16 4000c710: 00912223 sw s1,4(sp) queue = the_thread->Wait.queue; 4000c714: 05452483 lw s1,84(a0) { 4000c718: 00812423 sw s0,8(sp) 4000c71c: 00112623 sw ra,12(sp) 4000c720: 01212023 sw s2,0(sp) 4000c724: 00060413 mv s0,a2 aggregation->Action.type = type; 4000c728: 00200713 li a4,2 _Thread_Priority_do_perform_actions( 4000c72c: 05852603 lw a2,88(a0) _Priority_Actions_initialize_one( 4000c730: 00878793 addi a5,a5,8 aggregation->Action.node = node; 4000c734: 00b7ae23 sw a1,28(a5) aggregation->Action.type = type; 4000c738: 02e7a023 sw a4,32(a5) actions->actions = aggregation; 4000c73c: 00f42823 sw a5,16(s0) _Thread_Priority_do_perform_actions( 4000c740: 00040713 mv a4,s0 4000c744: 00100693 li a3,1 4000c748: 00048593 mv a1,s1 4000c74c: c29ff0ef jal ra,4000c374 <_Thread_Priority_do_perform_actions> if ( !_Priority_Actions_is_empty( &queue_context->Priority.Actions ) ) { 4000c750: 01042783 lw a5,16(s0) 4000c754: 02078c63 beqz a5,4000c78c <_Thread_Priority_remove+0x84> <== ALWAYS TAKEN _Thread_Priority_perform_actions( queue->owner, queue_context ); 4000c758: 0044a503 lw a0,4(s1) <== NOT EXECUTED return queue_context->Priority.update_count; 4000c75c: 01442903 lw s2,20(s0) <== NOT EXECUTED 4000c760: 00c0006f j 4000c76c <_Thread_Priority_remove+0x64> <== NOT EXECUTED the_thread = queue->owner; 4000c764: 0044a503 lw a0,4(s1) <== NOT EXECUTED queue_context->Priority.update_count = update_count; 4000c768: 01242a23 sw s2,20(s0) <== NOT EXECUTED queue = the_thread->Wait.queue; 4000c76c: 05452483 lw s1,84(a0) <== NOT EXECUTED _Thread_Priority_do_perform_actions( 4000c770: 05852603 lw a2,88(a0) <== NOT EXECUTED 4000c774: 00040713 mv a4,s0 <== NOT EXECUTED 4000c778: 00000693 li a3,0 <== NOT EXECUTED 4000c77c: 00048593 mv a1,s1 <== NOT EXECUTED 4000c780: bf5ff0ef jal ra,4000c374 <_Thread_Priority_do_perform_actions> <== NOT EXECUTED if ( _Priority_Actions_is_empty( &queue_context->Priority.Actions ) ) { 4000c784: 01042783 lw a5,16(s0) <== NOT EXECUTED 4000c788: fc079ee3 bnez a5,4000c764 <_Thread_Priority_remove+0x5c> <== NOT EXECUTED priority_node, queue_context, true, PRIORITY_ACTION_REMOVE ); } 4000c78c: 00c12083 lw ra,12(sp) 4000c790: 00812403 lw s0,8(sp) 4000c794: 00412483 lw s1,4(sp) 4000c798: 00012903 lw s2,0(sp) 4000c79c: 01010113 addi sp,sp,16 4000c7a0: 00008067 ret =============================================================================== 40005808 <_Thread_Restart_other>: Thread_Life_state previous; Per_CPU_Control *cpu_self; _Thread_State_acquire_critical( the_thread, lock_context ); if ( _States_Is_dormant( the_thread->current_state ) ) { 40005808: 01c52783 lw a5,28(a0) { 4000580c: fe010113 addi sp,sp,-32 40005810: 00912a23 sw s1,20(sp) 40005814: 00112e23 sw ra,28(sp) 40005818: 00812c23 sw s0,24(sp) 4000581c: 01212823 sw s2,16(sp) 40005820: 01412623 sw s4,12(sp) 40005824: 01512423 sw s5,8(sp) 40005828: 00060493 mv s1,a2 if ( _States_Is_dormant( the_thread->current_state ) ) { 4000582c: 1407c063 bltz a5,4000596c <_Thread_Restart_other+0x164> _Thread_State_release( the_thread, lock_context ); return false; } the_thread->Start.Entry = *entry; 40005830: 0005a703 lw a4,0(a1) previous = the_thread->Life.state; 40005834: 1ac52783 lw a5,428(a0) 40005838: 00050413 mv s0,a0 the_thread->Start.Entry = *entry; 4000583c: 0ae52023 sw a4,160(a0) 40005840: 0045a703 lw a4,4(a1) state |= set; 40005844: 0027e693 ori a3,a5,2 if ( 40005848: 0097f793 andi a5,a5,9 the_thread->Start.Entry = *entry; 4000584c: 0ae52223 sw a4,164(a0) 40005850: 0085a703 lw a4,8(a1) the_thread->Life.state = state; 40005854: 1ad52623 sw a3,428(a0) the_thread->Start.Entry = *entry; 40005858: 0ae52423 sw a4,168(a0) if ( 4000585c: 04078a63 beqz a5,400058b0 <_Thread_Restart_other+0xa8> <== ALWAYS TAKEN disable_level = cpu_self->thread_dispatch_disable_level; 40005860: 40013937 lui s2,0x40013 <== NOT EXECUTED 40005864: 2c090713 addi a4,s2,704 # 400132c0 <_Per_CPU_Information> <== NOT EXECUTED 40005868: 03072783 lw a5,48(a4) <== NOT EXECUTED _Thread_Finalize_life_change( the_thread, the_thread->Start.initial_priority ); } else { _Thread_Clear_state_locked( the_thread, STATES_SUSPENDED ); 4000586c: 000085b7 lui a1,0x8 <== NOT EXECUTED cpu_self->thread_dispatch_disable_level = disable_level + 1; 40005870: 00178793 addi a5,a5,1 # 4001 <== NOT EXECUTED 40005874: 02f72823 sw a5,48(a4) <== NOT EXECUTED 40005878: 091030ef jal ra,40009108 <_Thread_Clear_state_locked> <== NOT EXECUTED 4000587c: 0004a783 lw a5,0(s1) <== NOT EXECUTED 40005880: 3007a073 csrs mstatus,a5 <== NOT EXECUTED _Thread_State_release( the_thread, lock_context ); } _Thread_Dispatch_enable( cpu_self ); 40005884: 2c090513 addi a0,s2,704 40005888: f64ff0ef jal ra,40004fec <_Thread_Dispatch_enable> return true; } 4000588c: 01c12083 lw ra,28(sp) 40005890: 01812403 lw s0,24(sp) 40005894: 01412483 lw s1,20(sp) 40005898: 01012903 lw s2,16(sp) 4000589c: 00c12a03 lw s4,12(sp) 400058a0: 00812a83 lw s5,8(sp) return true; 400058a4: 00100513 li a0,1 } 400058a8: 02010113 addi sp,sp,32 400058ac: 00008067 ret the_thread->budget_callout = the_thread->Start.budget_callout; 400058b0: 0b452783 lw a5,180(a0) the_thread->budget_algorithm = the_thread->Start.budget_algorithm; 400058b4: 0b052683 lw a3,176(a0) the_thread->is_preemptible = the_thread->Start.is_preemptible; 400058b8: 0ac54603 lbu a2,172(a0) the_thread->budget_callout = the_thread->Start.budget_callout; 400058bc: 08f52a23 sw a5,148(a0) action->handler = handler; 400058c0: 400057b7 lui a5,0x40005 400058c4: 30078793 addi a5,a5,768 # 40005300 <_Thread_Life_action_handler> if ( _Chain_Is_node_off_chain( the_node ) ) { 400058c8: 1a052703 lw a4,416(a0) cpu_self->dispatch_necessary = true; 400058cc: 40013937 lui s2,0x40013 the_thread->budget_algorithm = the_thread->Start.budget_algorithm; 400058d0: 08d52823 sw a3,144(a0) 400058d4: 1af52423 sw a5,424(a0) the_thread->is_preemptible = the_thread->Start.is_preemptible; 400058d8: 08c504a3 sb a2,137(a0) 400058dc: 2c090793 addi a5,s2,704 # 400132c0 <_Per_CPU_Information> 400058e0: 00100693 li a3,1 400058e4: 02d78a23 sb a3,52(a5) 400058e8: 0c070c63 beqz a4,400059c0 <_Thread_Restart_other+0x1b8> <== ALWAYS TAKEN disable_level = cpu_self->thread_dispatch_disable_level; 400058ec: 0307a703 lw a4,48(a5) cpu_self->thread_dispatch_disable_level = disable_level + 1; 400058f0: 00170713 addi a4,a4,1 400058f4: 02e7a823 sw a4,48(a5) pending_requests = the_thread->Life.pending_life_change_requests; 400058f8: 1b042783 lw a5,432(s0) the_thread->Life.pending_life_change_requests = pending_requests + 1; 400058fc: 00178713 addi a4,a5,1 40005900: 1ae42823 sw a4,432(s0) if ( pending_requests == 0 ) { 40005904: 08078a63 beqz a5,40005998 <_Thread_Restart_other+0x190> <== ALWAYS TAKEN 40005908: 0004a783 lw a5,0(s1) 4000590c: 3007a073 csrs mstatus,a5 _Thread_queue_Extract_with_proxy( the_thread ); 40005910: 00040513 mv a0,s0 _Thread_Finalize_life_change( 40005914: 0c042a03 lw s4,192(s0) 40005918: 0c442a83 lw s5,196(s0) _Thread_queue_Extract_with_proxy( the_thread ); 4000591c: 09c040ef jal ra,400099b8 <_Thread_queue_Extract_with_proxy> __asm__ volatile ( 40005920: 300474f3 csrrci s1,mstatus,8 40005924: 06042503 lw a0,96(s0) 40005928: 06840593 addi a1,s0,104 4000592c: 119000ef jal ra,40006244 <_Watchdog_Remove> return mstatus & RISCV_MSTATUS_MIE; 40005930: 0084f493 andi s1,s1,8 __asm__ volatile ( "csrrs zero, mstatus, %0" : : "r" ( level ) ); 40005934: 3004a073 csrs mstatus,s1 _Thread_Raise_real_priority( the_thread, priority ); 40005938: 000a0593 mv a1,s4 4000593c: 000a8613 mv a2,s5 40005940: 00040513 mv a0,s0 40005944: 8b9ff0ef jal ra,400051fc <_Thread_Raise_real_priority> __asm__ volatile ( 40005948: 300474f3 csrrci s1,mstatus,8 return mstatus & RISCV_MSTATUS_MIE; 4000594c: 0084f493 andi s1,s1,8 pending_requests = the_thread->Life.pending_life_change_requests; 40005950: 1b042783 lw a5,432(s0) if ( pending_requests == 1 ) { 40005954: 00100713 li a4,1 the_thread->Life.pending_life_change_requests = pending_requests - 1; 40005958: fff78693 addi a3,a5,-1 4000595c: 1ad42823 sw a3,432(s0) if ( pending_requests == 1 ) { 40005960: 04e78463 beq a5,a4,400059a8 <_Thread_Restart_other+0x1a0> __asm__ volatile ( "csrrs zero, mstatus, %0" : : "r" ( level ) ); 40005964: 3004a073 csrs mstatus,s1 <== NOT EXECUTED } 40005968: f1dff06f j 40005884 <_Thread_Restart_other+0x7c> <== NOT EXECUTED 4000596c: 00062783 lw a5,0(a2) 40005970: 3007a073 csrs mstatus,a5 } 40005974: 01c12083 lw ra,28(sp) 40005978: 01812403 lw s0,24(sp) 4000597c: 01412483 lw s1,20(sp) 40005980: 01012903 lw s2,16(sp) 40005984: 00c12a03 lw s4,12(sp) 40005988: 00812a83 lw s5,8(sp) return false; 4000598c: 00000513 li a0,0 } 40005990: 02010113 addi sp,sp,32 40005994: 00008067 ret _Thread_Set_state_locked( the_thread, STATES_LIFE_IS_CHANGING ); 40005998: 000205b7 lui a1,0x20 4000599c: 00040513 mv a0,s0 400059a0: 1b0000ef jal ra,40005b50 <_Thread_Set_state_locked> 400059a4: f65ff06f j 40005908 <_Thread_Restart_other+0x100> _Thread_Clear_state_locked( 400059a8: 300285b7 lui a1,0x30028 400059ac: 30c58593 addi a1,a1,780 # 3002830c 400059b0: 00040513 mv a0,s0 400059b4: 754030ef jal ra,40009108 <_Thread_Clear_state_locked> 400059b8: 3004a073 csrs mstatus,s1 _ISR_lock_ISR_enable( lock_context ); 400059bc: ec9ff06f j 40005884 <_Thread_Restart_other+0x7c> old_last = tail->previous; 400059c0: 0e052683 lw a3,224(a0) _Chain_Append_if_is_off_chain_unprotected( 400059c4: 1a050713 addi a4,a0,416 return &the_chain->Tail.Node; 400059c8: 0dc50613 addi a2,a0,220 the_node->next = tail; 400059cc: 1ac52023 sw a2,416(a0) tail->previous = the_node; 400059d0: 0ee52023 sw a4,224(a0) old_last->next = the_node; 400059d4: 00e6a023 sw a4,0(a3) the_node->previous = old_last; 400059d8: 1ad52223 sw a3,420(a0) } 400059dc: f11ff06f j 400058ec <_Thread_Restart_other+0xe4> =============================================================================== 4000af64 <_Thread_Set_life_protection>: return previous; } Thread_Life_state _Thread_Set_life_protection( Thread_Life_state state ) { 4000af64: ff010113 addi sp,sp,-16 4000af68: 00112623 sw ra,12(sp) 4000af6c: 00812423 sw s0,8(sp) __asm__ volatile ( 4000af70: 30047673 csrrci a2,mstatus,8 return mstatus & RISCV_MSTATUS_MIE; 4000af74: 00867613 andi a2,a2,8 4000af78: 400235b7 lui a1,0x40023 4000af7c: f8058693 addi a3,a1,-128 # 40022f80 <_Per_CPU_Information> 4000af80: 0386a703 lw a4,56(a3) return _Thread_Change_life( THREAD_LIFE_PROTECTED, state & THREAD_LIFE_PROTECTED, 4000af84: 00157793 andi a5,a0,1 previous = the_thread->Life.state; 4000af88: 1ac72403 lw s0,428(a4) state &= ~clear; 4000af8c: ffe47513 andi a0,s0,-2 state |= set; 4000af90: 00a7e7b3 or a5,a5,a0 the_thread->Life.state = state; 4000af94: 1af72623 sw a5,428(a4) & ( THREAD_LIFE_PROTECTED | THREAD_LIFE_CHANGE_DEFERRED ) ) == 0; 4000af98: 0097f513 andi a0,a5,9 if ( 4000af9c: 04051063 bnez a0,4000afdc <_Thread_Set_life_protection+0x78> & ( THREAD_LIFE_RESTARTING | THREAD_LIFE_TERMINATING ) ) != 0; 4000afa0: 0067f793 andi a5,a5,6 && _Thread_Is_life_changing( state ) 4000afa4: 02078c63 beqz a5,4000afdc <_Thread_Set_life_protection+0x78> the_thread->budget_callout = the_thread->Start.budget_callout; 4000afa8: 0b472783 lw a5,180(a4) the_thread->is_preemptible = the_thread->Start.is_preemptible; 4000afac: 0ac74883 lbu a7,172(a4) the_thread->budget_algorithm = the_thread->Start.budget_algorithm; 4000afb0: 0b072803 lw a6,176(a4) the_thread->budget_callout = the_thread->Start.budget_callout; 4000afb4: 08f72a23 sw a5,148(a4) action->handler = handler; 4000afb8: 4000b7b7 lui a5,0x4000b 4000afbc: a5c78793 addi a5,a5,-1444 # 4000aa5c <_Thread_Life_action_handler> if ( _Chain_Is_node_off_chain( the_node ) ) { 4000afc0: 1a072503 lw a0,416(a4) 4000afc4: 1af72423 sw a5,424(a4) the_thread->is_preemptible = the_thread->Start.is_preemptible; 4000afc8: 091704a3 sb a7,137(a4) the_thread->budget_algorithm = the_thread->Start.budget_algorithm; 4000afcc: 09072823 sw a6,144(a4) 4000afd0: 00100793 li a5,1 4000afd4: 02f68a23 sb a5,52(a3) 4000afd8: 02050863 beqz a0,4000b008 <_Thread_Set_life_protection+0xa4> <== ALWAYS TAKEN disable_level = cpu_self->thread_dispatch_disable_level; 4000afdc: 0306a783 lw a5,48(a3) cpu_self->thread_dispatch_disable_level = disable_level + 1; 4000afe0: 00178793 addi a5,a5,1 4000afe4: 02f6a823 sw a5,48(a3) __asm__ volatile ( "csrrs zero, mstatus, %0" : : "r" ( level ) ); 4000afe8: 30062073 csrs mstatus,a2 _Thread_Dispatch_enable( cpu_self ); 4000afec: f8058513 addi a0,a1,-128 4000aff0: 93dfe0ef jal ra,4000992c <_Thread_Dispatch_enable> 0 ); } 4000aff4: 00c12083 lw ra,12(sp) 4000aff8: 00040513 mv a0,s0 4000affc: 00812403 lw s0,8(sp) 4000b000: 01010113 addi sp,sp,16 4000b004: 00008067 ret old_last = tail->previous; 4000b008: 0e072783 lw a5,224(a4) _Chain_Append_if_is_off_chain_unprotected( 4000b00c: 1a070513 addi a0,a4,416 return &the_chain->Tail.Node; 4000b010: 0dc70813 addi a6,a4,220 the_node->next = tail; 4000b014: 1b072023 sw a6,416(a4) tail->previous = the_node; 4000b018: 0ea72023 sw a0,224(a4) old_last->next = the_node; 4000b01c: 00a7a023 sw a0,0(a5) the_node->previous = old_last; 4000b020: 1af72223 sw a5,420(a4) } 4000b024: fb9ff06f j 4000afdc <_Thread_Set_life_protection+0x78> =============================================================================== 4000815c <_Thread_Wait_get_id>: if ( _States_Is_waiting_for_rpc_reply( the_thread->current_state ) ) { return the_thread->Wait.remote_id; } #endif queue = the_thread->Wait.queue; 4000815c: 05452783 lw a5,84(a0) if ( queue != NULL && queue->name == _Thread_queue_Object_name ) { 40008160: 00078c63 beqz a5,40008178 <_Thread_Wait_get_id+0x1c> 40008164: 0087a683 lw a3,8(a5) 40008168: 83418713 addi a4,gp,-1996 # 40012234 <_Thread_queue_Object_name> queue_object = THREAD_QUEUE_QUEUE_TO_OBJECT( queue ); return queue_object->Object.id; } return 0; 4000816c: 00000513 li a0,0 if ( queue != NULL && queue->name == _Thread_queue_Object_name ) { 40008170: 00e68863 beq a3,a4,40008180 <_Thread_Wait_get_id+0x24> } 40008174: 00008067 ret <== NOT EXECUTED return 0; 40008178: 00000513 li a0,0 } 4000817c: 00008067 ret return queue_object->Object.id; 40008180: ff87a503 lw a0,-8(a5) 40008184: 00008067 ret =============================================================================== 4000b28c <_Thread_Yield>: #include #include void _Thread_Yield( Thread_Control *executing ) { 4000b28c: ff010113 addi sp,sp,-16 4000b290: 00112623 sw ra,12(sp) 4000b294: 00812423 sw s0,8(sp) __asm__ volatile ( 4000b298: 30047473 csrrci s0,mstatus,8 return mstatus & RISCV_MSTATUS_MIE; 4000b29c: 00847413 andi s0,s0,8 ISR_lock_Context lock_context; _Thread_State_acquire( executing, &lock_context ); if ( _States_Is_ready( executing->current_state ) ) { 4000b2a0: 01c52783 lw a5,28(a0) 4000b2a4: 02079063 bnez a5,4000b2c4 <_Thread_Yield+0x38> <== NEVER TAKEN return the_thread->Scheduler.nodes; 4000b2a8: 00050593 mv a1,a0 ( *scheduler->Operations.yield )( 4000b2ac: 4001e537 lui a0,0x4001e 4000b2b0: 37050793 addi a5,a0,880 # 4001e370 <_Scheduler_Table> 4000b2b4: 00c7a783 lw a5,12(a5) 4000b2b8: 0385a603 lw a2,56(a1) 4000b2bc: 37050513 addi a0,a0,880 4000b2c0: 000780e7 jalr a5 __asm__ volatile ( "csrrs zero, mstatus, %0" : : "r" ( level ) ); 4000b2c4: 30042073 csrs mstatus,s0 _Scheduler_Yield( executing ); } _Thread_State_release( executing, &lock_context ); } 4000b2c8: 00c12083 lw ra,12(sp) 4000b2cc: 00812403 lw s0,8(sp) 4000b2d0: 01010113 addi sp,sp,16 4000b2d4: 00008067 ret =============================================================================== 40009afc <_Thread_queue_Enqueue>: { 40009afc: fe010113 addi sp,sp,-32 40009b00: 00812c23 sw s0,24(sp) 40009b04: 00912a23 sw s1,20(sp) 40009b08: 01212823 sw s2,16(sp) 40009b0c: 00112e23 sw ra,28(sp) 40009b10: 01312623 sw s3,12(sp) 40009b14: 01412423 sw s4,8(sp) 40009b18: 00050913 mv s2,a0 40009b1c: 00060413 mv s0,a2 40009b20: 00068493 mv s1,a3 the_thread->Wait.queue = queue; 40009b24: 04a62a23 sw a0,84(a2) } 40009b28: 00050793 mv a5,a0 40009b2c: 0100006f j 40009b3c <_Thread_queue_Enqueue+0x40> if ( owner == the_thread ) { 40009b30: 10f40463 beq s0,a5,40009c38 <_Thread_queue_Enqueue+0x13c> queue = owner->Wait.queue; 40009b34: 0547a783 lw a5,84(a5) } while ( queue != NULL ); 40009b38: 00078663 beqz a5,40009b44 <_Thread_queue_Enqueue+0x48> owner = queue->owner; 40009b3c: 0047a783 lw a5,4(a5) if ( owner == NULL ) { 40009b40: fe0798e3 bnez a5,40009b30 <_Thread_queue_Enqueue+0x34> ( *operations->enqueue )( queue, the_thread, queue_context ); 40009b44: 0045a783 lw a5,4(a1) */ RTEMS_INLINE_ROUTINE void _Thread_queue_Context_clear_priority_updates( Thread_queue_Context *queue_context ) { queue_context->Priority.update_count = 0; 40009b48: 0004aa23 sw zero,20(s1) the_thread->Wait.operations = operations; 40009b4c: 04b42c23 sw a1,88(s0) 40009b50: 00048613 mv a2,s1 40009b54: 00040593 mv a1,s0 40009b58: 00090513 mv a0,s2 40009b5c: 000780e7 jalr a5 the_thread->Wait.flags = flags; 40009b60: 40100a13 li s4,1025 disable_level = cpu_self->thread_dispatch_disable_level; 40009b64: 400239b7 lui s3,0x40023 the_thread->Wait.return_code = STATUS_SUCCESSFUL; 40009b68: 04042623 sw zero,76(s0) 40009b6c: 05442823 sw s4,80(s0) 40009b70: f8098713 addi a4,s3,-128 # 40022f80 <_Per_CPU_Information> 40009b74: 03072783 lw a5,48(a4) cpu_self->thread_dispatch_disable_level = disable_level + 1; 40009b78: 00178793 addi a5,a5,1 40009b7c: 02f72823 sw a5,48(a4) 40009b80: 0004a783 lw a5,0(s1) 40009b84: 3007a073 csrs mstatus,a5 ( *queue_context->enqueue_callout )( 40009b88: 0084a783 lw a5,8(s1) 40009b8c: 00048693 mv a3,s1 40009b90: f8098613 addi a2,s3,-128 40009b94: 00040593 mv a1,s0 40009b98: 00090513 mv a0,s2 40009b9c: 000780e7 jalr a5 _Thread_Set_state( the_thread, queue_context->thread_state ); 40009ba0: 0044a583 lw a1,4(s1) 40009ba4: 00040513 mv a0,s0 40009ba8: 4cc010ef jal ra,4000b074 <_Thread_Set_state> __asm__ volatile ( 40009bac: 300477f3 csrrci a5,mstatus,8 return mstatus & RISCV_MSTATUS_MIE; 40009bb0: 0087f793 andi a5,a5,8 bool success = ( the_thread->Wait.flags == expected_flags ); 40009bb4: 05042703 lw a4,80(s0) if ( success ) { 40009bb8: 07470463 beq a4,s4,40009c20 <_Thread_queue_Enqueue+0x124> __asm__ volatile ( "csrrs zero, mstatus, %0" : : "r" ( level ) ); 40009bbc: 3007a073 csrs mstatus,a5 if ( !success ) { 40009bc0: 40100793 li a5,1025 40009bc4: 02f71863 bne a4,a5,40009bf4 <_Thread_queue_Enqueue+0xf8> _Thread_Priority_update( queue_context ); 40009bc8: 00048513 mv a0,s1 40009bcc: 194070ef jal ra,40010d60 <_Thread_Priority_update> } 40009bd0: 01812403 lw s0,24(sp) 40009bd4: 01c12083 lw ra,28(sp) 40009bd8: 01412483 lw s1,20(sp) 40009bdc: 01012903 lw s2,16(sp) 40009be0: 00812a03 lw s4,8(sp) _Thread_Dispatch_direct( cpu_self ); 40009be4: f8098513 addi a0,s3,-128 } 40009be8: 00c12983 lw s3,12(sp) 40009bec: 02010113 addi sp,sp,32 _Thread_Dispatch_direct( cpu_self ); 40009bf0: d15ff06f j 40009904 <_Thread_Dispatch_direct> __asm__ volatile ( 40009bf4: 30047973 csrrci s2,mstatus,8 40009bf8: 06042503 lw a0,96(s0) 40009bfc: 06840593 addi a1,s0,104 40009c00: 211010ef jal ra,4000b610 <_Watchdog_Remove> return mstatus & RISCV_MSTATUS_MIE; 40009c04: 00897913 andi s2,s2,8 __asm__ volatile ( "csrrs zero, mstatus, %0" : : "r" ( level ) ); 40009c08: 30092073 csrs mstatus,s2 _Thread_Clear_state( the_thread, STATES_BLOCKED ); 40009c0c: 300165b7 lui a1,0x30016 40009c10: fff58593 addi a1,a1,-1 # 30015fff 40009c14: 00040513 mv a0,s0 40009c18: 228070ef jal ra,40010e40 <_Thread_Clear_state> } #else (void) queue; _Thread_Unblock( the_thread ); #endif } 40009c1c: fadff06f j 40009bc8 <_Thread_queue_Enqueue+0xcc> the_thread->Wait.flags = desired_flags; 40009c20: 40200693 li a3,1026 40009c24: 04d42823 sw a3,80(s0) 40009c28: 3007a073 csrs mstatus,a5 if ( !success ) { 40009c2c: 40100793 li a5,1025 40009c30: f8f70ce3 beq a4,a5,40009bc8 <_Thread_queue_Enqueue+0xcc> 40009c34: fc1ff06f j 40009bf4 <_Thread_queue_Enqueue+0xf8> <== NOT EXECUTED the_thread->Wait.operations = &_Thread_queue_Operations_default; 40009c38: 4001f7b7 lui a5,0x4001f 40009c3c: f1078793 addi a5,a5,-240 # 4001ef10 <_Thread_queue_Operations_default> the_thread->Wait.queue = NULL; 40009c40: 04042a23 sw zero,84(s0) the_thread->Wait.operations = &_Thread_queue_Operations_default; 40009c44: 04f42c23 sw a5,88(s0) 40009c48: 0004a783 lw a5,0(s1) 40009c4c: 3007a073 csrs mstatus,a5 ( *queue_context->deadlock_callout )( the_thread ); 40009c50: 00040513 mv a0,s0 } 40009c54: 01812403 lw s0,24(sp) ( *queue_context->deadlock_callout )( the_thread ); 40009c58: 0204a783 lw a5,32(s1) } 40009c5c: 01c12083 lw ra,28(sp) 40009c60: 01412483 lw s1,20(sp) 40009c64: 01012903 lw s2,16(sp) 40009c68: 00c12983 lw s3,12(sp) 40009c6c: 00812a03 lw s4,8(sp) 40009c70: 02010113 addi sp,sp,32 ( *queue_context->deadlock_callout )( the_thread ); 40009c74: 00078067 jr a5 =============================================================================== 40009ccc <_Thread_queue_Extract>: &queue_context->Lock_context.Lock_context ); } void _Thread_queue_Extract( Thread_Control *the_thread ) { 40009ccc: fc010113 addi sp,sp,-64 40009cd0: 02812c23 sw s0,56(sp) 40009cd4: 02112e23 sw ra,60(sp) 40009cd8: 00050413 mv s0,a0 40009cdc: 02012023 sw zero,32(sp) __asm__ volatile ( 40009ce0: 300477f3 csrrci a5,mstatus,8 return mstatus & RISCV_MSTATUS_MIE; 40009ce4: 0087f793 andi a5,a5,8 _ISR_lock_ISR_disable( &queue_context->Lock_context.Lock_context ); 40009ce8: 00f12623 sw a5,12(sp) _Thread_queue_Context_initialize( &queue_context ); _Thread_queue_Context_clear_priority_updates( &queue_context ); _Thread_Wait_acquire( the_thread, &queue_context ); queue = the_thread->Wait.queue; 40009cec: 05452503 lw a0,84(a0) if ( queue != NULL ) { 40009cf0: 08050463 beqz a0,40009d78 <_Thread_queue_Extract+0xac> ( *operations->extract )( queue, the_thread, queue_context ); 40009cf4: 05842783 lw a5,88(s0) 40009cf8: 00c10613 addi a2,sp,12 40009cfc: 00040593 mv a1,s0 40009d00: 0087a783 lw a5,8(a5) 40009d04: 000780e7 jalr a5 if ( success ) { 40009d08: 05042703 lw a4,80(s0) 40009d0c: 40100793 li a5,1025 40009d10: 02f70c63 beq a4,a5,40009d48 <_Thread_queue_Extract+0x7c> the_thread->Wait.flags = flags; 40009d14: 40400793 li a5,1028 40009d18: 04f42823 sw a5,80(s0) the_thread->Wait.operations = &_Thread_queue_Operations_default; 40009d1c: 4001f7b7 lui a5,0x4001f 40009d20: f1078793 addi a5,a5,-240 # 4001ef10 <_Thread_queue_Operations_default> the_thread->Wait.queue = NULL; 40009d24: 04042a23 sw zero,84(s0) the_thread->Wait.operations = &_Thread_queue_Operations_default; 40009d28: 04f42c23 sw a5,88(s0) if ( unblock ) { 40009d2c: 00c10593 addi a1,sp,12 40009d30: 00040513 mv a0,s0 40009d34: d3dff0ef jal ra,40009a70 <_Thread_queue_Unblock_critical.part.0> &queue_context.Lock_context.Lock_context ); } else { _Thread_Wait_release( the_thread, &queue_context ); } } 40009d38: 03c12083 lw ra,60(sp) 40009d3c: 03812403 lw s0,56(sp) 40009d40: 04010113 addi sp,sp,64 40009d44: 00008067 ret the_thread->Wait.flags = desired_flags; 40009d48: 40400793 li a5,1028 <== NOT EXECUTED 40009d4c: 04f42823 sw a5,80(s0) <== NOT EXECUTED the_thread->Wait.operations = &_Thread_queue_Operations_default; 40009d50: 4001f7b7 lui a5,0x4001f <== NOT EXECUTED 40009d54: f1078793 addi a5,a5,-240 # 4001ef10 <_Thread_queue_Operations_default><== NOT EXECUTED the_thread->Wait.queue = NULL; 40009d58: 04042a23 sw zero,84(s0) <== NOT EXECUTED the_thread->Wait.operations = &_Thread_queue_Operations_default; 40009d5c: 04f42c23 sw a5,88(s0) <== NOT EXECUTED __asm__ volatile ( "csrrs zero, mstatus, %0" : : "r" ( level ) ); 40009d60: 00c12783 lw a5,12(sp) <== NOT EXECUTED 40009d64: 3007a073 csrs mstatus,a5 <== NOT EXECUTED 40009d68: 03c12083 lw ra,60(sp) <== NOT EXECUTED 40009d6c: 03812403 lw s0,56(sp) <== NOT EXECUTED 40009d70: 04010113 addi sp,sp,64 <== NOT EXECUTED 40009d74: 00008067 ret <== NOT EXECUTED 40009d78: 00c12783 lw a5,12(sp) 40009d7c: 3007a073 csrs mstatus,a5 40009d80: 03c12083 lw ra,60(sp) 40009d84: 03812403 lw s0,56(sp) 40009d88: 04010113 addi sp,sp,64 40009d8c: 00008067 ret =============================================================================== 40007870 <_Thread_queue_Queue_get_name_and_id>: Objects_Id *id ) { const char *name; name = queue->name; 40007870: 00852783 lw a5,8(a0) <== NOT EXECUTED if ( name == _Thread_queue_Object_name ) { 40007874: 8a818893 addi a7,gp,-1880 # 400279d0 <_Thread_queue_Object_name><== NOT EXECUTED { 40007878: 00058713 mv a4,a1 <== NOT EXECUTED 4000787c: 00068593 mv a1,a3 <== NOT EXECUTED if ( name == _Thread_queue_Object_name ) { 40007880: 03178663 beq a5,a7,400078ac <_Thread_queue_Queue_get_name_and_id+0x3c><== NOT EXECUTED false, buffer, buffer_size ); } else { if ( name == NULL ) { 40007884: 00078a63 beqz a5,40007898 <_Thread_queue_Queue_get_name_and_id+0x28><== NOT EXECUTED name = _Thread_queue_Object_name; } *id = 0; 40007888: 0005a023 sw zero,0(a1) <== NOT EXECUTED return strlcpy( buffer, name, buffer_size ); 4000788c: 00070513 mv a0,a4 <== NOT EXECUTED 40007890: 00078593 mv a1,a5 <== NOT EXECUTED 40007894: 5011106f j 40019594 <== NOT EXECUTED name = _Thread_queue_Object_name; 40007898: 8a818793 addi a5,gp,-1880 # 400279d0 <_Thread_queue_Object_name><== NOT EXECUTED *id = 0; 4000789c: 0005a023 sw zero,0(a1) <== NOT EXECUTED return strlcpy( buffer, name, buffer_size ); 400078a0: 00070513 mv a0,a4 <== NOT EXECUTED 400078a4: 00078593 mv a1,a5 <== NOT EXECUTED 400078a8: 4ed1106f j 40019594 <== NOT EXECUTED *id = queue_object->Object.id; 400078ac: ff852803 lw a6,-8(a0) <== NOT EXECUTED queue_object = THREAD_QUEUE_QUEUE_TO_OBJECT( queue ); 400078b0: ff050793 addi a5,a0,-16 <== NOT EXECUTED return _Objects_Name_to_string( 400078b4: 00060693 mv a3,a2 <== NOT EXECUTED *id = queue_object->Object.id; 400078b8: 0105a023 sw a6,0(a1) <== NOT EXECUTED return _Objects_Name_to_string( 400078bc: 00c7a503 lw a0,12(a5) <== NOT EXECUTED 400078c0: 00070613 mv a2,a4 <== NOT EXECUTED 400078c4: 00000593 li a1,0 <== NOT EXECUTED 400078c8: 93cff06f j 40006a04 <_Objects_Name_to_string> <== NOT EXECUTED =============================================================================== 400087e8 <_Timecounter_Bintime>: { 400087e8: fe010113 addi sp,sp,-32 <== NOT EXECUTED 400087ec: 01312623 sw s3,12(sp) <== NOT EXECUTED 400087f0: 00912a23 sw s1,20(sp) <== NOT EXECUTED 400087f4: 00112e23 sw ra,28(sp) <== NOT EXECUTED 400087f8: 00812c23 sw s0,24(sp) <== NOT EXECUTED 400087fc: 01212823 sw s2,16(sp) <== NOT EXECUTED 40008800: 01412423 sw s4,8(sp) <== NOT EXECUTED 40008804: 01512223 sw s5,4(sp) <== NOT EXECUTED 40008808: 01612023 sw s6,0(sp) <== NOT EXECUTED 4000880c: 00050493 mv s1,a0 <== NOT EXECUTED 40008810: 8fc18993 addi s3,gp,-1796 # 40020d3c <== NOT EXECUTED th = timehands; 40008814: 0009a403 lw s0,0(s3) <== NOT EXECUTED 40008818: 07042b03 lw s6,112(s0) <== NOT EXECUTED tc = th->th_counter; 4000881c: 00042a03 lw s4,0(s0) <== NOT EXECUTED *bt = th->th_bintime; 40008820: 03442603 lw a2,52(s0) <== NOT EXECUTED 40008824: 03842683 lw a3,56(s0) <== NOT EXECUTED 40008828: 03c42703 lw a4,60(s0) <== NOT EXECUTED 4000882c: 03042583 lw a1,48(s0) <== NOT EXECUTED return ((tc->tc_get_timecount(tc) - th->th_offset_count) & 40008830: 000a2783 lw a5,0(s4) <== NOT EXECUTED 40008834: 000a0513 mv a0,s4 <== NOT EXECUTED *bt = th->th_bintime; 40008838: 00c4a223 sw a2,4(s1) <== NOT EXECUTED 4000883c: 00d4a423 sw a3,8(s1) <== NOT EXECUTED 40008840: 00e4a623 sw a4,12(s1) <== NOT EXECUTED 40008844: 00b4a023 sw a1,0(s1) <== NOT EXECUTED bintime_addx(bt, th->th_scale * tc_delta(th)); 40008848: 01042a83 lw s5,16(s0) <== NOT EXECUTED 4000884c: 01442903 lw s2,20(s0) <== NOT EXECUTED return ((tc->tc_get_timecount(tc) - th->th_offset_count) & 40008850: 000780e7 jalr a5 <== NOT EXECUTED 40008854: 01842703 lw a4,24(s0) <== NOT EXECUTED 40008858: 004a2783 lw a5,4(s4) <== NOT EXECUTED _u = _bt->frac; 4000885c: 0084a603 lw a2,8(s1) <== NOT EXECUTED 40008860: 40e50533 sub a0,a0,a4 <== NOT EXECUTED 40008864: 00f57533 and a0,a0,a5 <== NOT EXECUTED bintime_addx(bt, th->th_scale * tc_delta(th)); 40008868: 035507b3 mul a5,a0,s5 <== NOT EXECUTED 4000886c: 00c4a703 lw a4,12(s1) <== NOT EXECUTED 40008870: 02a90933 mul s2,s2,a0 <== NOT EXECUTED _bt->frac += _x; 40008874: 00c786b3 add a3,a5,a2 <== NOT EXECUTED 40008878: 00f6b7b3 sltu a5,a3,a5 <== NOT EXECUTED 4000887c: 00d4a423 sw a3,8(s1) <== NOT EXECUTED 40008880: 03553533 mulhu a0,a0,s5 <== NOT EXECUTED 40008884: 00a90533 add a0,s2,a0 <== NOT EXECUTED 40008888: 00e50533 add a0,a0,a4 <== NOT EXECUTED 4000888c: 00a78533 add a0,a5,a0 <== NOT EXECUTED 40008890: 00a4a623 sw a0,12(s1) <== NOT EXECUTED if (_u > _bt->frac) 40008894: 00e56663 bltu a0,a4,400088a0 <_Timecounter_Bintime+0xb8> <== NOT EXECUTED 40008898: 02a71263 bne a4,a0,400088bc <_Timecounter_Bintime+0xd4> <== NOT EXECUTED 4000889c: 02c6f063 bgeu a3,a2,400088bc <_Timecounter_Bintime+0xd4> <== NOT EXECUTED _bt->sec++; 400088a0: 0004a783 lw a5,0(s1) <== NOT EXECUTED 400088a4: 0044a683 lw a3,4(s1) <== NOT EXECUTED 400088a8: 00178713 addi a4,a5,1 <== NOT EXECUTED 400088ac: 00f737b3 sltu a5,a4,a5 <== NOT EXECUTED 400088b0: 00d787b3 add a5,a5,a3 <== NOT EXECUTED 400088b4: 00e4a023 sw a4,0(s1) <== NOT EXECUTED 400088b8: 00f4a223 sw a5,4(s1) <== NOT EXECUTED } while (gen == 0 || gen != th->th_generation); 400088bc: f40b0ce3 beqz s6,40008814 <_Timecounter_Bintime+0x2c> <== NOT EXECUTED 400088c0: 07042783 lw a5,112(s0) <== NOT EXECUTED 400088c4: f56798e3 bne a5,s6,40008814 <_Timecounter_Bintime+0x2c> <== NOT EXECUTED } 400088c8: 01c12083 lw ra,28(sp) <== NOT EXECUTED 400088cc: 01812403 lw s0,24(sp) <== NOT EXECUTED 400088d0: 01412483 lw s1,20(sp) <== NOT EXECUTED 400088d4: 01012903 lw s2,16(sp) <== NOT EXECUTED 400088d8: 00c12983 lw s3,12(sp) <== NOT EXECUTED 400088dc: 00812a03 lw s4,8(sp) <== NOT EXECUTED 400088e0: 00412a83 lw s5,4(sp) <== NOT EXECUTED 400088e4: 00012b03 lw s6,0(sp) <== NOT EXECUTED 400088e8: 02010113 addi sp,sp,32 <== NOT EXECUTED 400088ec: 00008067 ret <== NOT EXECUTED =============================================================================== 400067f4 <_Timecounter_Binuptime>: { 400067f4: fe010113 addi sp,sp,-32 400067f8: 01312623 sw s3,12(sp) 400067fc: 00912a23 sw s1,20(sp) 40006800: 00112e23 sw ra,28(sp) 40006804: 00812c23 sw s0,24(sp) 40006808: 01212823 sw s2,16(sp) 4000680c: 01412423 sw s4,8(sp) 40006810: 01512223 sw s5,4(sp) 40006814: 01612023 sw s6,0(sp) 40006818: 00050493 mv s1,a0 4000681c: 88418993 addi s3,gp,-1916 # 40012174 th = timehands; 40006820: 0009a403 lw s0,0(s3) val = *obj; 40006824: 07042b03 lw s6,112(s0) tc = th->th_counter; 40006828: 00042a03 lw s4,0(s0) *bt = th->th_offset; 4000682c: 02442603 lw a2,36(s0) 40006830: 02842683 lw a3,40(s0) 40006834: 02c42703 lw a4,44(s0) 40006838: 02042583 lw a1,32(s0) return ((tc->tc_get_timecount(tc) - th->th_offset_count) & 4000683c: 000a2783 lw a5,0(s4) 40006840: 000a0513 mv a0,s4 *bt = th->th_offset; 40006844: 00c4a223 sw a2,4(s1) 40006848: 00d4a423 sw a3,8(s1) 4000684c: 00e4a623 sw a4,12(s1) 40006850: 00b4a023 sw a1,0(s1) bintime_addx(bt, th->th_scale * tc_delta(th)); 40006854: 01042a83 lw s5,16(s0) 40006858: 01442903 lw s2,20(s0) return ((tc->tc_get_timecount(tc) - th->th_offset_count) & 4000685c: 000780e7 jalr a5 40006860: 01842703 lw a4,24(s0) 40006864: 004a2783 lw a5,4(s4) _u = _bt->frac; 40006868: 0084a603 lw a2,8(s1) 4000686c: 40e50533 sub a0,a0,a4 40006870: 00f57533 and a0,a0,a5 bintime_addx(bt, th->th_scale * tc_delta(th)); 40006874: 035507b3 mul a5,a0,s5 40006878: 00c4a703 lw a4,12(s1) 4000687c: 02a90933 mul s2,s2,a0 _bt->frac += _x; 40006880: 00c786b3 add a3,a5,a2 40006884: 00f6b7b3 sltu a5,a3,a5 40006888: 00d4a423 sw a3,8(s1) 4000688c: 03553533 mulhu a0,a0,s5 40006890: 00a90533 add a0,s2,a0 40006894: 00e50533 add a0,a0,a4 40006898: 00a78533 add a0,a5,a0 4000689c: 00a4a623 sw a0,12(s1) if (_u > _bt->frac) 400068a0: 00e56663 bltu a0,a4,400068ac <_Timecounter_Binuptime+0xb8> 400068a4: 02a71263 bne a4,a0,400068c8 <_Timecounter_Binuptime+0xd4> 400068a8: 02c6f063 bgeu a3,a2,400068c8 <_Timecounter_Binuptime+0xd4> _bt->sec++; 400068ac: 0004a783 lw a5,0(s1) 400068b0: 0044a683 lw a3,4(s1) 400068b4: 00178713 addi a4,a5,1 400068b8: 00f737b3 sltu a5,a4,a5 400068bc: 00d787b3 add a5,a5,a3 400068c0: 00e4a023 sw a4,0(s1) 400068c4: 00f4a223 sw a5,4(s1) } while (gen == 0 || gen != th->th_generation); 400068c8: f40b0ce3 beqz s6,40006820 <_Timecounter_Binuptime+0x2c> <== NEVER TAKEN 400068cc: 07042783 lw a5,112(s0) 400068d0: f56798e3 bne a5,s6,40006820 <_Timecounter_Binuptime+0x2c> } 400068d4: 01c12083 lw ra,28(sp) 400068d8: 01812403 lw s0,24(sp) 400068dc: 01412483 lw s1,20(sp) 400068e0: 01012903 lw s2,16(sp) 400068e4: 00c12983 lw s3,12(sp) 400068e8: 00812a03 lw s4,8(sp) 400068ec: 00412a83 lw s5,4(sp) 400068f0: 00012b03 lw s6,0(sp) 400068f4: 02010113 addi sp,sp,32 400068f8: 00008067 ret =============================================================================== 4000897c <_Timecounter_Getbintime>: { 4000897c: 8fc18893 addi a7,gp,-1796 # 40020d3c th = timehands; 40008980: 0008a783 lw a5,0(a7) 40008984: 0707a703 lw a4,112(a5) *bt = th->th_bintime; 40008988: 0307a803 lw a6,48(a5) 4000898c: 0347a583 lw a1,52(a5) 40008990: 0387a603 lw a2,56(a5) 40008994: 03c7a683 lw a3,60(a5) 40008998: 01052023 sw a6,0(a0) 4000899c: 00b52223 sw a1,4(a0) 400089a0: 00c52423 sw a2,8(a0) 400089a4: 00d52623 sw a3,12(a0) } while (gen == 0 || gen != th->th_generation); 400089a8: fc070ce3 beqz a4,40008980 <_Timecounter_Getbintime+0x4> 400089ac: 0707a783 lw a5,112(a5) 400089b0: fce798e3 bne a5,a4,40008980 <_Timecounter_Getbintime+0x4> } 400089b4: 00008067 ret =============================================================================== 40001e88 <_Timecounter_Getbinuptime>: { 40001e88: 84418893 addi a7,gp,-1980 # 4000b6a4 th = timehands; 40001e8c: 0008a783 lw a5,0(a7) 40001e90: 0707a703 lw a4,112(a5) *bt = th->th_offset; 40001e94: 0207a803 lw a6,32(a5) 40001e98: 0247a583 lw a1,36(a5) 40001e9c: 0287a603 lw a2,40(a5) 40001ea0: 02c7a683 lw a3,44(a5) 40001ea4: 01052023 sw a6,0(a0) 40001ea8: 00b52223 sw a1,4(a0) 40001eac: 00c52423 sw a2,8(a0) 40001eb0: 00d52623 sw a3,12(a0) } while (gen == 0 || gen != th->th_generation); 40001eb4: fc070ce3 beqz a4,40001e8c <_Timecounter_Getbinuptime+0x4> <== NEVER TAKEN 40001eb8: 0707a783 lw a5,112(a5) 40001ebc: fce798e3 bne a5,a4,40001e8c <_Timecounter_Getbinuptime+0x4> } 40001ec0: 00008067 ret =============================================================================== 40001fbc <_Timecounter_Getmicrotime>: { 40001fbc: 84418893 addi a7,gp,-1980 # 4000b6a4 th = timehands; 40001fc0: 0008a783 lw a5,0(a7) 40001fc4: 0707a703 lw a4,112(a5) *tvp = th->th_microtime; 40001fc8: 0407a803 lw a6,64(a5) 40001fcc: 0447a583 lw a1,68(a5) 40001fd0: 0487a603 lw a2,72(a5) 40001fd4: 04c7a683 lw a3,76(a5) 40001fd8: 01052023 sw a6,0(a0) 40001fdc: 00b52223 sw a1,4(a0) 40001fe0: 00c52423 sw a2,8(a0) 40001fe4: 00d52623 sw a3,12(a0) } while (gen == 0 || gen != th->th_generation); 40001fe8: fc070ce3 beqz a4,40001fc0 <_Timecounter_Getmicrotime+0x4> <== NEVER TAKEN 40001fec: 0707a783 lw a5,112(a5) 40001ff0: fce798e3 bne a5,a4,40001fc0 <_Timecounter_Getmicrotime+0x4> } 40001ff4: 00008067 ret =============================================================================== 40001f04 <_Timecounter_Getmicrouptime>: _tv->tv_usec = ((uint64_t)1000000 * (uint32_t)(_bt->frac >> 32)) >> 32; 40001f04: 000f4637 lui a2,0xf4 40001f08: 84418593 addi a1,gp,-1980 # 4000b6a4 40001f0c: 24060613 addi a2,a2,576 # f4240 th = timehands; 40001f10: 0005a783 lw a5,0(a1) 40001f14: 0707a683 lw a3,112(a5) 40001f18: 02c7a703 lw a4,44(a5) _tv->tv_sec = _bt->sec; 40001f1c: 0207a803 lw a6,32(a5) 40001f20: 0247a883 lw a7,36(a5) _tv->tv_usec = ((uint64_t)1000000 * (uint32_t)(_bt->frac >> 32)) >> 32; 40001f24: 02c73733 mulhu a4,a4,a2 _tv->tv_sec = _bt->sec; 40001f28: 01052023 sw a6,0(a0) 40001f2c: 01152223 sw a7,4(a0) _tv->tv_usec = ((uint64_t)1000000 * (uint32_t)(_bt->frac >> 32)) >> 32; 40001f30: 00e52423 sw a4,8(a0) } while (gen == 0 || gen != th->th_generation); 40001f34: fc068ee3 beqz a3,40001f10 <_Timecounter_Getmicrouptime+0xc> <== NEVER TAKEN 40001f38: 0707a783 lw a5,112(a5) 40001f3c: fcd79ae3 bne a5,a3,40001f10 <_Timecounter_Getmicrouptime+0xc> } 40001f40: 00008067 ret =============================================================================== 400089b8 <_Timecounter_Getnanotime>: { 400089b8: 8fc18893 addi a7,gp,-1796 # 40020d3c th = timehands; 400089bc: 0008a783 lw a5,0(a7) 400089c0: 0707a703 lw a4,112(a5) *tsp = th->th_nanotime; 400089c4: 0507a803 lw a6,80(a5) 400089c8: 0547a583 lw a1,84(a5) 400089cc: 0587a603 lw a2,88(a5) 400089d0: 05c7a683 lw a3,92(a5) 400089d4: 01052023 sw a6,0(a0) 400089d8: 00b52223 sw a1,4(a0) 400089dc: 00c52423 sw a2,8(a0) 400089e0: 00d52623 sw a3,12(a0) } while (gen == 0 || gen != th->th_generation); 400089e4: fc070ce3 beqz a4,400089bc <_Timecounter_Getnanotime+0x4> <== NEVER TAKEN 400089e8: 0707a783 lw a5,112(a5) 400089ec: fce798e3 bne a5,a4,400089bc <_Timecounter_Getnanotime+0x4> } 400089f0: 00008067 ret =============================================================================== 4000893c <_Timecounter_Getnanouptime>: _ts->tv_nsec = ((uint64_t)1000000000 * 4000893c: 3b9ad637 lui a2,0x3b9ad 40008940: 8fc18593 addi a1,gp,-1796 # 40020d3c 40008944: a0060613 addi a2,a2,-1536 # 3b9aca00 th = timehands; 40008948: 0005a783 lw a5,0(a1) # 80000000 4000894c: 0707a683 lw a3,112(a5) (uint32_t)(_bt->frac >> 32)) >> 32; 40008950: 02c7a703 lw a4,44(a5) _ts->tv_sec = _bt->sec; 40008954: 0207a803 lw a6,32(a5) 40008958: 0247a883 lw a7,36(a5) _ts->tv_nsec = ((uint64_t)1000000000 * 4000895c: 02c73733 mulhu a4,a4,a2 _ts->tv_sec = _bt->sec; 40008960: 01052023 sw a6,0(a0) 40008964: 01152223 sw a7,4(a0) _ts->tv_nsec = ((uint64_t)1000000000 * 40008968: 00e52423 sw a4,8(a0) } while (gen == 0 || gen != th->th_generation); 4000896c: fc068ee3 beqz a3,40008948 <_Timecounter_Getnanouptime+0xc> <== NEVER TAKEN 40008970: 0707a783 lw a5,112(a5) 40008974: fcd79ae3 bne a5,a3,40008948 <_Timecounter_Getnanouptime+0xc> } 40008978: 00008067 ret =============================================================================== 40008734 <_Timecounter_Sbinuptime>: { 40008734: fd010113 addi sp,sp,-48 40008738: 01712623 sw s7,12(sp) 4000873c: 02112623 sw ra,44(sp) 40008740: 02812423 sw s0,40(sp) 40008744: 02912223 sw s1,36(sp) 40008748: 03212023 sw s2,32(sp) 4000874c: 01312e23 sw s3,28(sp) 40008750: 01412c23 sw s4,24(sp) 40008754: 01512a23 sw s5,20(sp) 40008758: 01612823 sw s6,16(sp) 4000875c: 8fc18b93 addi s7,gp,-1796 # 40020d3c th = timehands; 40008760: 000ba403 lw s0,0(s7) val = *obj; 40008764: 07042903 lw s2,112(s0) tc = th->th_counter; 40008768: 00042483 lw s1,0(s0) 4000876c: 02042a03 lw s4,32(s0) 40008770: 02c42a83 lw s5,44(s0) return ((tc->tc_get_timecount(tc) - th->th_offset_count) & 40008774: 0004a783 lw a5,0(s1) 40008778: 00048513 mv a0,s1 sbt += (th->th_scale * tc_delta(th)) >> 32; 4000877c: 01042b03 lw s6,16(s0) 40008780: 01442983 lw s3,20(s0) return ((tc->tc_get_timecount(tc) - th->th_offset_count) & 40008784: 000780e7 jalr a5 40008788: 01842703 lw a4,24(s0) tc->tc_counter_mask); 4000878c: 0044a783 lw a5,4(s1) } while (gen == 0 || gen != th->th_generation); 40008790: fc0908e3 beqz s2,40008760 <_Timecounter_Sbinuptime+0x2c> 40008794: 07042683 lw a3,112(s0) 40008798: fd2694e3 bne a3,s2,40008760 <_Timecounter_Sbinuptime+0x2c> return ((tc->tc_get_timecount(tc) - th->th_offset_count) & 4000879c: 40e50533 sub a0,a0,a4 400087a0: 00f57533 and a0,a0,a5 sbt += (th->th_scale * tc_delta(th)) >> 32; 400087a4: 02a985b3 mul a1,s3,a0 } 400087a8: 02c12083 lw ra,44(sp) 400087ac: 02812403 lw s0,40(sp) 400087b0: 02412483 lw s1,36(sp) 400087b4: 02012903 lw s2,32(sp) 400087b8: 01c12983 lw s3,28(sp) 400087bc: 00c12b83 lw s7,12(sp) sbt += (th->th_scale * tc_delta(th)) >> 32; 400087c0: 03653533 mulhu a0,a0,s6 } 400087c4: 01012b03 lw s6,16(sp) sbt += (th->th_scale * tc_delta(th)) >> 32; 400087c8: 00a585b3 add a1,a1,a0 400087cc: 01558533 add a0,a1,s5 400087d0: 00b535b3 sltu a1,a0,a1 } 400087d4: 01412a83 lw s5,20(sp) 400087d8: 014585b3 add a1,a1,s4 400087dc: 01812a03 lw s4,24(sp) 400087e0: 03010113 addi sp,sp,48 400087e4: 00008067 ret =============================================================================== 40005f10 <_Timecounter_Tick_simple>: { struct bintime bt; struct timehands *th; uint32_t ogen; th = timehands; 40005f10: 88c1a783 lw a5,-1908(gp) # 400137bc ogen = th->th_generation; th->th_offset_count = offset; bintime_addx(&th->th_offset, th->th_scale * delta); 40005f14: 0107a883 lw a7,16(a5) 40005f18: 0147a683 lw a3,20(a5) _u = _bt->frac; 40005f1c: 0287ae83 lw t4,40(a5) 40005f20: 02a88733 mul a4,a7,a0 40005f24: 02c7ae03 lw t3,44(a5) th->th_offset_count = offset; 40005f28: 00b7ac23 sw a1,24(a5) ogen = th->th_generation; 40005f2c: 0707a303 lw t1,112(a5) bintime_addx(&th->th_offset, th->th_scale * delta); 40005f30: 02a686b3 mul a3,a3,a0 _bt->frac += _x; 40005f34: 01d70833 add a6,a4,t4 40005f38: 00e83733 sltu a4,a6,a4 40005f3c: 0307a423 sw a6,40(a5) 40005f40: 02a8b533 mulhu a0,a7,a0 40005f44: 00a686b3 add a3,a3,a0 40005f48: 01c686b3 add a3,a3,t3 40005f4c: 00d70733 add a4,a4,a3 40005f50: 02e7a623 sw a4,44(a5) if (_u > _bt->frac) 40005f54: 0dc76c63 bltu a4,t3,4000602c <_Timecounter_Tick_simple+0x11c> 40005f58: 0cee0863 beq t3,a4,40006028 <_Timecounter_Tick_simple+0x118> bt = th->th_offset; 40005f5c: 0207ae03 lw t3,32(a5) 40005f60: 0247a683 lw a3,36(a5) _bt->frac += _bt2->frac; 40005f64: 0687a883 lw a7,104(a5) 40005f68: 06c7a503 lw a0,108(a5) 40005f6c: 011808b3 add a7,a6,a7 40005f70: 0108b5b3 sltu a1,a7,a6 40005f74: 00a70533 add a0,a4,a0 40005f78: 00a585b3 add a1,a1,a0 if (_u > _bt->frac) 40005f7c: 08e5ee63 bltu a1,a4,40006018 <_Timecounter_Tick_simple+0x108> 40005f80: 08b70a63 beq a4,a1,40006014 <_Timecounter_Tick_simple+0x104> 40005f84: 000e0713 mv a4,t3 _bt->sec += _bt2->sec; 40005f88: 0607ae83 lw t4,96(a5) 40005f8c: 0647a803 lw a6,100(a5) _tv->tv_usec = ((uint64_t)1000000 * (uint32_t)(_bt->frac >> 32)) >> 32; 40005f90: 000f4537 lui a0,0xf4 _bt->sec += _bt2->sec; 40005f94: 01d70eb3 add t4,a4,t4 40005f98: 00eeb733 sltu a4,t4,a4 40005f9c: 010686b3 add a3,a3,a6 bintime_add(&bt, &th->th_boottime); /* Update the UTC timestamps used by the get*() functions. */ th->th_bintime = bt; 40005fa0: 0317ac23 sw a7,56(a5) 40005fa4: 00d708b3 add a7,a4,a3 _ts->tv_nsec = ((uint64_t)1000000000 * 40005fa8: 3b9ad737 lui a4,0x3b9ad _tv->tv_usec = ((uint64_t)1000000 * (uint32_t)(_bt->frac >> 32)) >> 32; 40005fac: 24050513 addi a0,a0,576 # f4240 _ts->tv_nsec = ((uint64_t)1000000000 * 40005fb0: a0070713 addi a4,a4,-1536 # 3b9aca00 _tv->tv_usec = ((uint64_t)1000000 * (uint32_t)(_bt->frac >> 32)) >> 32; 40005fb4: 02a5b533 mulhu a0,a1,a0 40005fb8: 03d7a823 sw t4,48(a5) 40005fbc: 0317aa23 sw a7,52(a5) 40005fc0: 02b7ae23 sw a1,60(a5) _tv->tv_sec = _bt->sec; 40005fc4: 05d7a023 sw t4,64(a5) 40005fc8: 0517a223 sw a7,68(a5) _ts->tv_sec = _bt->sec; 40005fcc: 05d7a823 sw t4,80(a5) 40005fd0: 0517aa23 sw a7,84(a5) /* * Now that the struct timehands is again consistent, set the new * generation number, making sure to not make it zero. */ if (++ogen == 0) 40005fd4: 00130313 addi t1,t1,1 _bt->sec += _bt2->sec; 40005fd8: 000e8813 mv a6,t4 _ts->tv_nsec = ((uint64_t)1000000000 * 40005fdc: 02e5b733 mulhu a4,a1,a4 _tv->tv_usec = ((uint64_t)1000000 * (uint32_t)(_bt->frac >> 32)) >> 32; 40005fe0: 04a7a423 sw a0,72(a5) _ts->tv_nsec = ((uint64_t)1000000000 * 40005fe4: 04e7ac23 sw a4,88(a5) ogen = 1; th->th_generation = ogen; 40005fe8: 00031463 bnez t1,40005ff0 <_Timecounter_Tick_simple+0xe0> <== ALWAYS TAKEN 40005fec: 00100313 li t1,1 <== NOT EXECUTED /* Go live with the new struct timehands. */ time_second = th->th_microtime.tv_sec; 40005ff0: 8901a023 sw a6,-1920(gp) # 400137b0 <_Timecounter_Time_second> 40005ff4: 8911a223 sw a7,-1916(gp) # 400137b4 <_Timecounter_Time_second+0x4> th->th_generation = ogen; 40005ff8: 0667a823 sw t1,112(a5) time_uptime = th->th_offset.sec; 40005ffc: 89c1a423 sw t3,-1912(gp) # 400137b8 <_Timecounter_Time_uptime> __asm__ volatile ( "csrrs zero, mstatus, %0" : : "r" ( level ) ); 40006000: 00062783 lw a5,0(a2) 40006004: 3007a073 csrs mstatus,a5 _Timecounter_Release(lock_context); _Watchdog_Tick(_Per_CPU_Get_snapshot()); 40006008: 40015537 lui a0,0x40015 4000600c: 3c050513 addi a0,a0,960 # 400153c0 <_Per_CPU_Information> 40006010: 3650206f j 40008b74 <_Watchdog_Tick> if (_u > _bt->frac) 40006014: f708f8e3 bgeu a7,a6,40005f84 <_Timecounter_Tick_simple+0x74> _bt->sec++; 40006018: 001e0713 addi a4,t3,1 4000601c: 01c73533 sltu a0,a4,t3 40006020: 00d506b3 add a3,a0,a3 40006024: f65ff06f j 40005f88 <_Timecounter_Tick_simple+0x78> if (_u > _bt->frac) 40006028: f3d87ae3 bgeu a6,t4,40005f5c <_Timecounter_Tick_simple+0x4c> <== NOT EXECUTED _bt->sec++; 4000602c: 0207a683 lw a3,32(a5) <== NOT EXECUTED 40006030: 0247a583 lw a1,36(a5) <== NOT EXECUTED 40006034: 00168e13 addi t3,a3,1 <== NOT EXECUTED 40006038: 00de36b3 sltu a3,t3,a3 <== NOT EXECUTED 4000603c: 00b686b3 add a3,a3,a1 <== NOT EXECUTED 40006040: 03c7a023 sw t3,32(a5) <== NOT EXECUTED 40006044: 02d7a223 sw a3,36(a5) <== NOT EXECUTED } 40006048: f1dff06f j 40005f64 <_Timecounter_Tick_simple+0x54> <== NOT EXECUTED =============================================================================== 4000b2d8 <_User_extensions_Handler_initialization>: size_t n; size_t i; initial_table = _User_extensions_Initial_extensions; initial_switch_controls = _User_extensions_Initial_switch_controls; n = _User_extensions_Initial_count; 4000b2d8: 8801a783 lw a5,-1920(gp) # 40020cc0 <_User_extensions_Initial_count> for ( i = 0 ; i < n ; ++i ) { 4000b2dc: 06078863 beqz a5,4000b34c <_User_extensions_Handler_initialization+0x74> 4000b2e0: 400218b7 lui a7,0x40021 4000b2e4: 00179593 slli a1,a5,0x1 4000b2e8: 8d888893 addi a7,a7,-1832 # 400208d8 <_User_extensions_Switches_list> 4000b2ec: 00f585b3 add a1,a1,a5 4000b2f0: 0088a603 lw a2,8(a7) 4000b2f4: 400237b7 lui a5,0x40023 4000b2f8: cb078793 addi a5,a5,-848 # 40022cb0 <_User_extensions_Initial_switch_controls> 4000b2fc: 00259593 slli a1,a1,0x2 4000b300: 4001e737 lui a4,0x4001e the_node->next = tail; 4000b304: 40021537 lui a0,0x40021 4000b308: 3f870713 addi a4,a4,1016 # 4001e3f8 <_User_extensions_Initial_extensions+0x10> 4000b30c: 00f585b3 add a1,a1,a5 4000b310: 00000813 li a6,0 4000b314: 8dc50513 addi a0,a0,-1828 # 400208dc <_User_extensions_Switches_list+0x4> User_extensions_thread_switch_extension callout; callout = initial_table[ i ].thread_switch; 4000b318: 00072683 lw a3,0(a4) for ( i = 0 ; i < n ; ++i ) { 4000b31c: 02470713 addi a4,a4,36 if ( callout != NULL ) { 4000b320: 00068e63 beqz a3,4000b33c <_User_extensions_Handler_initialization+0x64> User_extensions_Switch_control *c; c = &initial_switch_controls[ i ]; c->thread_switch = callout; 4000b324: 00d7a423 sw a3,8(a5) 4000b328: 00a7a023 sw a0,0(a5) <== NOT EXECUTED old_last->next = the_node; 4000b32c: 00f62023 sw a5,0(a2) <== NOT EXECUTED the_node->previous = old_last; 4000b330: 00c7a223 sw a2,4(a5) <== NOT EXECUTED } 4000b334: 00100813 li a6,1 <== NOT EXECUTED 4000b338: 00078613 mv a2,a5 <== NOT EXECUTED for ( i = 0 ; i < n ; ++i ) { 4000b33c: 00c78793 addi a5,a5,12 <== NOT EXECUTED 4000b340: fcb79ce3 bne a5,a1,4000b318 <_User_extensions_Handler_initialization+0x40> 4000b344: 00080463 beqz a6,4000b34c <_User_extensions_Handler_initialization+0x74> 4000b348: 00c8a423 sw a2,8(a7) _Chain_Initialize_node( &c->Node ); _Chain_Append_unprotected( &_User_extensions_Switches_list, &c->Node ); } } } 4000b34c: 00008067 ret <== NOT EXECUTED =============================================================================== 4000b410 <_User_extensions_Iterate>: ISR_lock_Context lock_context; executing = _Thread_Get_executing(); initial_begin = _User_extensions_Initial_extensions; initial_end = initial_begin + _User_extensions_Initial_count; 4000b410: 8801a783 lw a5,-1920(gp) # 40020cc0 <_User_extensions_Initial_count> { 4000b414: fc010113 addi sp,sp,-64 4000b418: 02812c23 sw s0,56(sp) initial_end = initial_begin + _User_extensions_Initial_count; 4000b41c: 00379413 slli s0,a5,0x3 4000b420: 00f40433 add s0,s0,a5 { 4000b424: 03212823 sw s2,48(sp) initial_end = initial_begin + _User_extensions_Initial_count; 4000b428: 4001e937 lui s2,0x4001e { 4000b42c: 02912a23 sw s1,52(sp) 4000b430: 03312623 sw s3,44(sp) 4000b434: 03412423 sw s4,40(sp) 4000b438: 03512223 sw s5,36(sp) 4000b43c: 03612023 sw s6,32(sp) initial_end = initial_begin + _User_extensions_Initial_count; 4000b440: 00241413 slli s0,s0,0x2 4000b444: 3e890a93 addi s5,s2,1000 # 4001e3e8 <_User_extensions_Initial_extensions> 4000b448: 400237b7 lui a5,0x40023 { 4000b44c: 02112e23 sw ra,60(sp) 4000b450: fb87a483 lw s1,-72(a5) # 40022fb8 <_Per_CPU_Information+0x38> 4000b454: 00060a13 mv s4,a2 4000b458: 00050b13 mv s6,a0 4000b45c: 00058993 mv s3,a1 initial_end = initial_begin + _User_extensions_Initial_count; 4000b460: 008a8433 add s0,s5,s0 if ( direction == CHAIN_ITERATOR_FORWARD ) { 4000b464: 12061663 bnez a2,4000b590 <_User_extensions_Iterate+0x180> initial_current = initial_begin; 4000b468: 3e890913 addi s2,s2,1000 while ( initial_current != initial_end ) { 4000b46c: 01540e63 beq s0,s5,4000b488 <_User_extensions_Iterate+0x78> (*visitor)( executing, arg, initial_current ); 4000b470: 00090613 mv a2,s2 4000b474: 000b0593 mv a1,s6 ++initial_current; 4000b478: 02490913 addi s2,s2,36 (*visitor)( executing, arg, initial_current ); 4000b47c: 00048513 mv a0,s1 4000b480: 000980e7 jalr s3 while ( initial_current != initial_end ) { 4000b484: ff2416e3 bne s0,s2,4000b470 <_User_extensions_Iterate+0x60> } end = _Chain_Immutable_tail( &_User_extensions_List.Active ); 4000b488: 40021937 lui s2,0x40021 4000b48c: 8f090693 addi a3,s2,-1808 # 400208f0 <_User_extensions_List> 4000b490: 00468913 addi s2,a3,4 __asm__ volatile ( 4000b494: 300477f3 csrrci a5,mstatus,8 return mstatus & RISCV_MSTATUS_MIE; 4000b498: 0087f793 andi a5,a5,8 old_last = tail->previous; 4000b49c: 0146a703 lw a4,20(a3) the_node->next = tail; 4000b4a0: 01068613 addi a2,a3,16 4000b4a4: 00c12623 sw a2,12(sp) tail->previous = the_node; 4000b4a8: 00c10613 addi a2,sp,12 4000b4ac: 00c6aa23 sw a2,20(a3) old_last->next = the_node; 4000b4b0: 00c72023 sw a2,0(a4) the_node->previous = old_last; 4000b4b4: 00e12823 sw a4,16(sp) _Chain_Append_unprotected( &the_registry->Iterators, &the_iterator->Registry_node ); the_iterator->direction = direction; 4000b4b8: 01412a23 sw s4,20(sp) if ( direction == CHAIN_ITERATOR_FORWARD ) { the_iterator->position = _Chain_Head( the_chain ); } else { the_iterator->position = _Chain_Tail( the_chain ); 4000b4bc: 00468713 addi a4,a3,4 if ( direction == CHAIN_ITERATOR_FORWARD ) { 4000b4c0: 000a1463 bnez s4,4000b4c8 <_User_extensions_Iterate+0xb8> the_iterator->position = _Chain_Head( the_chain ); 4000b4c4: 00068713 mv a4,a3 4000b4c8: 00e12c23 sw a4,24(sp) &_User_extensions_List.Iterators, &iter.Iterator, direction ); if ( executing != NULL ) { 4000b4cc: 00048a63 beqz s1,4000b4e0 <_User_extensions_Iterate+0xd0> iter.previous = executing->last_user_extensions_iterator; 4000b4d0: 1c84a683 lw a3,456(s1) executing->last_user_extensions_iterator = &iter; 4000b4d4: 00c10613 addi a2,sp,12 4000b4d8: 1cc4a423 sw a2,456(s1) iter.previous = executing->last_user_extensions_iterator; 4000b4dc: 00d12e23 sw a3,28(sp) 4000b4e0: 000a0693 mv a3,s4 */ RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Iterator_next( const Chain_Iterator *the_iterator ) { if ( the_iterator->direction == CHAIN_ITERATOR_FORWARD ) { 4000b4e4: 02069c63 bnez a3,4000b51c <_User_extensions_Iterate+0x10c> return the_node->next; 4000b4e8: 00072603 lw a2,0(a4) } while ( ( node = _Chain_Iterator_next( &iter.Iterator ) ) != end ) { 4000b4ec: 02c90c63 beq s2,a2,4000b524 <_User_extensions_Iterate+0x114> RTEMS_INLINE_ROUTINE void _Chain_Iterator_set_position( Chain_Iterator *the_iterator, Chain_Node *the_node ) { the_iterator->position = the_node; 4000b4f0: 00c12c23 sw a2,24(sp) __asm__ volatile ( "csrrs zero, mstatus, %0" : : "r" ( level ) ); 4000b4f4: 3007a073 csrs mstatus,a5 _Chain_Iterator_set_position( &iter.Iterator, node ); _User_extensions_Release( &lock_context ); extension = (const User_extensions_Control *) node; ( *visitor )( executing, arg, &extension->Callouts ); 4000b4f8: 01460613 addi a2,a2,20 4000b4fc: 000b0593 mv a1,s6 4000b500: 00048513 mv a0,s1 4000b504: 000980e7 jalr s3 __asm__ volatile ( 4000b508: 300477f3 csrrci a5,mstatus,8 return mstatus & RISCV_MSTATUS_MIE; 4000b50c: 0087f793 andi a5,a5,8 if ( the_iterator->direction == CHAIN_ITERATOR_FORWARD ) { 4000b510: 01412683 lw a3,20(sp) return _Chain_Next( the_iterator->position ); 4000b514: 01812703 lw a4,24(sp) if ( the_iterator->direction == CHAIN_ITERATOR_FORWARD ) { 4000b518: fc0688e3 beqz a3,4000b4e8 <_User_extensions_Iterate+0xd8> return the_node->previous; 4000b51c: 00472603 lw a2,4(a4) while ( ( node = _Chain_Iterator_next( &iter.Iterator ) ) != end ) { 4000b520: fcc918e3 bne s2,a2,4000b4f0 <_User_extensions_Iterate+0xe0> <== NOT EXECUTED _User_extensions_Acquire( &lock_context ); } if ( executing != NULL ) { 4000b524: 00048663 beqz s1,4000b530 <_User_extensions_Iterate+0x120> <== NOT EXECUTED executing->last_user_extensions_iterator = iter.previous; 4000b528: 01c12703 lw a4,28(sp) 4000b52c: 1ce4a423 sw a4,456(s1) next = the_node->next; 4000b530: 00c12683 lw a3,12(sp) previous = the_node->previous; 4000b534: 01012703 lw a4,16(sp) next->previous = previous; 4000b538: 00e6a223 sw a4,4(a3) previous->next = next; 4000b53c: 00d72023 sw a3,0(a4) __asm__ volatile ( "csrrs zero, mstatus, %0" : : "r" ( level ) ); 4000b540: 3007a073 csrs mstatus,a5 _Chain_Iterator_destroy( &iter.Iterator ); _User_extensions_Release( &lock_context ); if ( direction == CHAIN_ITERATOR_BACKWARD ) { 4000b544: 00100793 li a5,1 4000b548: 02fa0663 beq s4,a5,4000b574 <_User_extensions_Iterate+0x164> while ( initial_current != initial_begin ) { --initial_current; (*visitor)( executing, arg, initial_current ); } } } 4000b54c: 03c12083 lw ra,60(sp) 4000b550: 03812403 lw s0,56(sp) 4000b554: 03412483 lw s1,52(sp) 4000b558: 03012903 lw s2,48(sp) 4000b55c: 02c12983 lw s3,44(sp) 4000b560: 02812a03 lw s4,40(sp) 4000b564: 02412a83 lw s5,36(sp) 4000b568: 02012b03 lw s6,32(sp) 4000b56c: 04010113 addi sp,sp,64 4000b570: 00008067 ret while ( initial_current != initial_begin ) { 4000b574: fd540ce3 beq s0,s5,4000b54c <_User_extensions_Iterate+0x13c> --initial_current; 4000b578: fdc40413 addi s0,s0,-36 <== NOT EXECUTED (*visitor)( executing, arg, initial_current ); 4000b57c: 00040613 mv a2,s0 <== NOT EXECUTED 4000b580: 000b0593 mv a1,s6 <== NOT EXECUTED 4000b584: 00048513 mv a0,s1 <== NOT EXECUTED 4000b588: 000980e7 jalr s3 <== NOT EXECUTED 4000b58c: fe9ff06f j 4000b574 <_User_extensions_Iterate+0x164> <== NOT EXECUTED end = _Chain_Immutable_head( &_User_extensions_List.Active ); 4000b590: 40021937 lui s2,0x40021 <== NOT EXECUTED 4000b594: 8f090693 addi a3,s2,-1808 # 400208f0 <_User_extensions_List> <== NOT EXECUTED 4000b598: 8f090913 addi s2,s2,-1808 <== NOT EXECUTED 4000b59c: ef9ff06f j 4000b494 <_User_extensions_Iterate+0x84> <== NOT EXECUTED =============================================================================== 40013780 <_User_extensions_Remove_set>: __asm__ volatile ( 40013780: 30047873 csrrci a6,mstatus,8 return mstatus & RISCV_MSTATUS_MIE; 40013784: 00887813 andi a6,a6,8 return the_node->next; 40013788: 400177b7 lui a5,0x40017 4001378c: 1807a783 lw a5,384(a5) # 40017180 <_User_extensions_List+0xc> while ( ( iter_node = _Chain_Next( iter_node ) ) != iter_tail ) { 40013790: 400176b7 lui a3,0x40017 40013794: 18468693 addi a3,a3,388 # 40017184 <_User_extensions_List+0x10> 40013798: 00452603 lw a2,4(a0) 4001379c: 00052583 lw a1,0(a0) 400137a0: 00d79863 bne a5,a3,400137b0 <_User_extensions_Remove_set+0x30> 400137a4: 0280006f j 400137cc <_User_extensions_Remove_set+0x4c> return the_node->next; 400137a8: 0007a783 lw a5,0(a5) <== NOT EXECUTED while ( ( iter_node = _Chain_Next( iter_node ) ) != iter_tail ) { 400137ac: 02d78063 beq a5,a3,400137cc <_User_extensions_Remove_set+0x4c> <== NOT EXECUTED if ( iter->position == the_node_to_extract ) { 400137b0: 00c7a703 lw a4,12(a5) <== NOT EXECUTED 400137b4: fee51ae3 bne a0,a4,400137a8 <_User_extensions_Remove_set+0x28> <== NOT EXECUTED if ( iter->direction == CHAIN_ITERATOR_FORWARD ) { 400137b8: 0087a703 lw a4,8(a5) <== NOT EXECUTED 400137bc: 04071263 bnez a4,40013800 <_User_extensions_Remove_set+0x80> <== NOT EXECUTED iter->position = _Chain_Previous( the_node_to_extract ); 400137c0: 00c7a623 sw a2,12(a5) <== NOT EXECUTED return the_node->next; 400137c4: 0007a783 lw a5,0(a5) <== NOT EXECUTED while ( ( iter_node = _Chain_Next( iter_node ) ) != iter_tail ) { 400137c8: fed794e3 bne a5,a3,400137b0 <_User_extensions_Remove_set+0x30> <== NOT EXECUTED next->previous = previous; 400137cc: 00c5a223 sw a2,4(a1) previous->next = next; 400137d0: 00b62023 sw a1,0(a2) __asm__ volatile ( "csrrs zero, mstatus, %0" : : "r" ( level ) ); 400137d4: 30082073 csrs mstatus,a6 /* * If a switch handler is present, remove it. */ if ( the_extension->Callouts.thread_switch != NULL ) { 400137d8: 02452783 lw a5,36(a0) 400137dc: 02078063 beqz a5,400137fc <_User_extensions_Remove_set+0x7c> __asm__ volatile ( 400137e0: 300477f3 csrrci a5,mstatus,8 next = the_node->next; 400137e4: 00852683 lw a3,8(a0) previous = the_node->previous; 400137e8: 00c52703 lw a4,12(a0) next->previous = previous; 400137ec: 00e6a223 sw a4,4(a3) previous->next = next; 400137f0: 00d72023 sw a3,0(a4) return mstatus & RISCV_MSTATUS_MIE; 400137f4: 0087f793 andi a5,a5,8 __asm__ volatile ( "csrrs zero, mstatus, %0" : : "r" ( level ) ); 400137f8: 3007a073 csrs mstatus,a5 _Per_CPU_Acquire_all( &lock_context ); _Chain_Extract_unprotected( &the_extension->Switch.Node ); _Per_CPU_Release_all( &lock_context ); } } 400137fc: 00008067 ret iter->position = _Chain_Next( the_node_to_extract ); 40013800: 00b7a623 sw a1,12(a5) <== NOT EXECUTED 40013804: fa5ff06f j 400137a8 <_User_extensions_Remove_set+0x28> <== NOT EXECUTED =============================================================================== 4000b350 <_User_extensions_Thread_create_visitor>: Thread_Control *executing, void *arg, const User_extensions_Table *callouts ) { User_extensions_thread_create_extension callout = callouts->thread_create; 4000b350: 00062703 lw a4,0(a2) if ( callout != NULL ) { 4000b354: 02070e63 beqz a4,4000b390 <_User_extensions_Thread_create_visitor+0x40> User_extensions_Thread_create_context *ctx = arg; ctx->ok = ctx->ok && (*callout)( executing, ctx->created ); 4000b358: 0045c783 lbu a5,4(a1) { 4000b35c: ff010113 addi sp,sp,-16 4000b360: 00812423 sw s0,8(sp) 4000b364: 00112623 sw ra,12(sp) 4000b368: 00058413 mv s0,a1 ctx->ok = ctx->ok && (*callout)( executing, ctx->created ); 4000b36c: 00078863 beqz a5,4000b37c <_User_extensions_Thread_create_visitor+0x2c><== NEVER TAKEN 4000b370: 0005a583 lw a1,0(a1) 4000b374: 000700e7 jalr a4 4000b378: 00050793 mv a5,a0 } } 4000b37c: 00c12083 lw ra,12(sp) ctx->ok = ctx->ok && (*callout)( executing, ctx->created ); 4000b380: 00f40223 sb a5,4(s0) } 4000b384: 00812403 lw s0,8(sp) 4000b388: 01010113 addi sp,sp,16 4000b38c: 00008067 ret 4000b390: 00008067 ret =============================================================================== 4000b680 <_Watchdog_Do_tickle>: #ifdef RTEMS_SMP ISR_lock_Control *lock, #endif ISR_lock_Context *lock_context ) { 4000b680: fe010113 addi sp,sp,-32 4000b684: 00812c23 sw s0,24(sp) 4000b688: 00912a23 sw s1,20(sp) 4000b68c: 01212823 sw s2,16(sp) 4000b690: 01312623 sw s3,12(sp) 4000b694: 01412423 sw s4,8(sp) 4000b698: 01512223 sw s5,4(sp) 4000b69c: 00112e23 sw ra,28(sp) 4000b6a0: 00050493 mv s1,a0 4000b6a4: 00058413 mv s0,a1 4000b6a8: 00060a13 mv s4,a2 4000b6ac: 00068913 mv s2,a3 4000b6b0: 00070993 mv s3,a4 RB_COLOR( &the_watchdog->Node.RBTree, Node ) = state; 4000b6b4: 00200a93 li s5,2 do { if ( first->expire <= now ) { 4000b6b8: 01c42783 lw a5,28(s0) 4000b6bc: 04f96c63 bltu s2,a5,4000b714 <_Watchdog_Do_tickle+0x94> 4000b6c0: 09278263 beq a5,s2,4000b744 <_Watchdog_Do_tickle+0xc4> return RB_RIGHT( the_node, Node ); 4000b6c4: 00442783 lw a5,4(s0) if ( node != NULL ) { 4000b6c8: 06078863 beqz a5,4000b738 <_Watchdog_Do_tickle+0xb8> return RB_LEFT( the_node, Node ); 4000b6cc: 00078593 mv a1,a5 4000b6d0: 0007a783 lw a5,0(a5) while ( ( left = _RBTree_Left( node ) ) != NULL ) { 4000b6d4: fe079ce3 bnez a5,4000b6cc <_Watchdog_Do_tickle+0x4c> <== NEVER TAKEN header->first = node; 4000b6d8: 00b4a223 sw a1,4(s1) Watchdog_Service_routine_entry routine; _Watchdog_Next_first( header, first ); _RBTree_Extract( &header->Watchdogs, &first->Node.RBTree ); 4000b6dc: 00040593 mv a1,s0 4000b6e0: 00048513 mv a0,s1 4000b6e4: 439040ef jal ra,4001031c <_RBTree_Extract> _Watchdog_Set_state( first, WATCHDOG_INACTIVE ); routine = first->routine; 4000b6e8: 01042783 lw a5,16(s0) RB_COLOR( &the_watchdog->Node.RBTree, Node ) = state; 4000b6ec: 01542623 sw s5,12(s0) 4000b6f0: 0009a703 lw a4,0(s3) 4000b6f4: 30072073 csrs mstatus,a4 _ISR_lock_Release_and_ISR_enable( lock, lock_context ); ( *routine )( first ); 4000b6f8: 00040513 mv a0,s0 4000b6fc: 000780e7 jalr a5 __asm__ volatile ( 4000b700: 300477f3 csrrci a5,mstatus,8 return mstatus & RISCV_MSTATUS_MIE; 4000b704: 0087f793 andi a5,a5,8 _ISR_lock_ISR_disable_and_acquire( lock, lock_context ); 4000b708: 00f9a023 sw a5,0(s3) return (Watchdog_Control *) header->first; 4000b70c: 0044a403 lw s0,4(s1) } else { break; } first = _Watchdog_Header_first( header ); } while ( first != NULL ); 4000b710: fa0414e3 bnez s0,4000b6b8 <_Watchdog_Do_tickle+0x38> } 4000b714: 01c12083 lw ra,28(sp) 4000b718: 01812403 lw s0,24(sp) 4000b71c: 01412483 lw s1,20(sp) 4000b720: 01012903 lw s2,16(sp) 4000b724: 00c12983 lw s3,12(sp) 4000b728: 00812a03 lw s4,8(sp) 4000b72c: 00412a83 lw s5,4(sp) 4000b730: 02010113 addi sp,sp,32 4000b734: 00008067 ret header->first = _RBTree_Parent( &the_watchdog->Node.RBTree ); 4000b738: 00842783 lw a5,8(s0) 4000b73c: 00f4a223 sw a5,4(s1) 4000b740: f9dff06f j 4000b6dc <_Watchdog_Do_tickle+0x5c> if ( first->expire <= now ) { 4000b744: 01842783 lw a5,24(s0) 4000b748: f6fa7ee3 bgeu s4,a5,4000b6c4 <_Watchdog_Do_tickle+0x44> 4000b74c: fc9ff06f j 4000b714 <_Watchdog_Do_tickle+0x94> =============================================================================== 4000b610 <_Watchdog_Remove>: void _Watchdog_Remove( Watchdog_Header *header, Watchdog_Control *the_watchdog ) { if ( _Watchdog_Is_scheduled( the_watchdog ) ) { 4000b610: 00c5a703 lw a4,12(a1) 4000b614: 00100793 li a5,1 4000b618: 00e7f463 bgeu a5,a4,4000b620 <_Watchdog_Remove+0x10> 4000b61c: 00008067 ret if ( header->first == &the_watchdog->Node.RBTree ) { 4000b620: 00452783 lw a5,4(a0) { 4000b624: ff010113 addi sp,sp,-16 4000b628: 00812423 sw s0,8(sp) 4000b62c: 00112623 sw ra,12(sp) 4000b630: 00058413 mv s0,a1 if ( header->first == &the_watchdog->Node.RBTree ) { 4000b634: 02b78263 beq a5,a1,4000b658 <_Watchdog_Remove+0x48> _Watchdog_Next_first( header, the_watchdog ); } _RBTree_Extract( &header->Watchdogs, &the_watchdog->Node.RBTree ); 4000b638: 00040593 mv a1,s0 4000b63c: 4e1040ef jal ra,4001031c <_RBTree_Extract> RB_COLOR( &the_watchdog->Node.RBTree, Node ) = state; 4000b640: 00200793 li a5,2 _Watchdog_Set_state( the_watchdog, WATCHDOG_INACTIVE ); } } 4000b644: 00c12083 lw ra,12(sp) 4000b648: 00f42623 sw a5,12(s0) 4000b64c: 00812403 lw s0,8(sp) 4000b650: 01010113 addi sp,sp,16 4000b654: 00008067 ret return RB_RIGHT( the_node, Node ); 4000b658: 0045a783 lw a5,4(a1) if ( node != NULL ) { 4000b65c: 00078c63 beqz a5,4000b674 <_Watchdog_Remove+0x64> return RB_LEFT( the_node, Node ); 4000b660: 00078713 mv a4,a5 4000b664: 0007a783 lw a5,0(a5) while ( ( left = _RBTree_Left( node ) ) != NULL ) { 4000b668: fe079ce3 bnez a5,4000b660 <_Watchdog_Remove+0x50> <== NEVER TAKEN header->first = node; 4000b66c: 00e52223 sw a4,4(a0) 4000b670: fc9ff06f j 4000b638 <_Watchdog_Remove+0x28> header->first = _RBTree_Parent( &the_watchdog->Node.RBTree ); 4000b674: 0085a783 lw a5,8(a1) 4000b678: 00f52223 sw a5,4(a0) 4000b67c: fbdff06f j 4000b638 <_Watchdog_Remove+0x28> =============================================================================== 4000b750 <_Watchdog_Tick>: Watchdog_Control *first; uint64_t ticks; struct timespec now; if ( _Per_CPU_Is_boot_processor( cpu ) ) { ++_Watchdog_Ticks_since_boot; 4000b750: 93c1a783 lw a5,-1732(gp) # 40020d7c <_Watchdog_Ticks_since_boot> <== NOT EXECUTED { 4000b754: fd010113 addi sp,sp,-48 <== NOT EXECUTED 4000b758: 02812423 sw s0,40(sp) <== NOT EXECUTED ++_Watchdog_Ticks_since_boot; 4000b75c: 00178793 addi a5,a5,1 <== NOT EXECUTED { 4000b760: 02112623 sw ra,44(sp) <== NOT EXECUTED 4000b764: 02912223 sw s1,36(sp) <== NOT EXECUTED 4000b768: 00050413 mv s0,a0 <== NOT EXECUTED ++_Watchdog_Ticks_since_boot; 4000b76c: 92f1ae23 sw a5,-1732(gp) # 40020d7c <_Watchdog_Ticks_since_boot> <== NOT EXECUTED __asm__ volatile ( 4000b770: 300477f3 csrrci a5,mstatus,8 <== NOT EXECUTED return mstatus & RISCV_MSTATUS_MIE; 4000b774: 0087f793 andi a5,a5,8 <== NOT EXECUTED } _ISR_lock_ISR_disable_and_acquire( &cpu->Watchdog.Lock, &lock_context ); 4000b778: 00f12623 sw a5,12(sp) <== NOT EXECUTED ticks = cpu->Watchdog.ticks; 4000b77c: 04852783 lw a5,72(a0) <== NOT EXECUTED 4000b780: 04c52683 lw a3,76(a0) <== NOT EXECUTED return (Watchdog_Control *) header->first; 4000b784: 05452583 lw a1,84(a0) <== NOT EXECUTED _Assert( ticks < UINT64_MAX ); ++ticks; 4000b788: 00178613 addi a2,a5,1 <== NOT EXECUTED 4000b78c: 00f637b3 sltu a5,a2,a5 <== NOT EXECUTED 4000b790: 00d786b3 add a3,a5,a3 <== NOT EXECUTED cpu->Watchdog.ticks = ticks; 4000b794: 04c52423 sw a2,72(a0) <== NOT EXECUTED 4000b798: 04d52623 sw a3,76(a0) <== NOT EXECUTED header = &cpu->Watchdog.Header[ PER_CPU_WATCHDOG_TICKS ]; first = _Watchdog_Header_first( header ); if ( first != NULL ) { 4000b79c: 00058863 beqz a1,4000b7ac <_Watchdog_Tick+0x5c> <== NOT EXECUTED _Watchdog_Tickle( 4000b7a0: 00c10713 addi a4,sp,12 <== NOT EXECUTED 4000b7a4: 05050513 addi a0,a0,80 <== NOT EXECUTED 4000b7a8: ed9ff0ef jal ra,4000b680 <_Watchdog_Do_tickle> <== NOT EXECUTED 4000b7ac: 06442483 lw s1,100(s0) <== NOT EXECUTED } header = &cpu->Watchdog.Header[ PER_CPU_WATCHDOG_MONOTONIC ]; first = _Watchdog_Header_first( header ); if ( first != NULL ) { 4000b7b0: 02048e63 beqz s1,4000b7ec <_Watchdog_Tick+0x9c> <== NOT EXECUTED _Timecounter_Getnanouptime( &now ); 4000b7b4: 01010513 addi a0,sp,16 <== NOT EXECUTED 4000b7b8: 984fd0ef jal ra,4000893c <_Timecounter_Getnanouptime> <== NOT EXECUTED ticks = (uint64_t) ts->tv_sec; 4000b7bc: 01012603 lw a2,16(sp) <== NOT EXECUTED ticks <<= WATCHDOG_BITS_FOR_1E9_NANOSECONDS; 4000b7c0: 01412783 lw a5,20(sp) <== NOT EXECUTED _Watchdog_Tickle( 4000b7c4: 01812583 lw a1,24(sp) <== NOT EXECUTED 4000b7c8: 00265693 srli a3,a2,0x2 <== NOT EXECUTED 4000b7cc: 01e79793 slli a5,a5,0x1e <== NOT EXECUTED 4000b7d0: 01e61613 slli a2,a2,0x1e <== NOT EXECUTED 4000b7d4: 00c5e633 or a2,a1,a2 <== NOT EXECUTED 4000b7d8: 00c10713 addi a4,sp,12 <== NOT EXECUTED 4000b7dc: 00f6e6b3 or a3,a3,a5 <== NOT EXECUTED 4000b7e0: 00048593 mv a1,s1 <== NOT EXECUTED 4000b7e4: 06040513 addi a0,s0,96 <== NOT EXECUTED 4000b7e8: e99ff0ef jal ra,4000b680 <_Watchdog_Do_tickle> <== NOT EXECUTED return (Watchdog_Control *) header->first; 4000b7ec: 05c42483 lw s1,92(s0) <== NOT EXECUTED } header = &cpu->Watchdog.Header[ PER_CPU_WATCHDOG_REALTIME ]; first = _Watchdog_Header_first( header ); if ( first != NULL ) { 4000b7f0: 02048e63 beqz s1,4000b82c <_Watchdog_Tick+0xdc> <== NOT EXECUTED _Timecounter_Getnanotime( &now ); 4000b7f4: 01010513 addi a0,sp,16 <== NOT EXECUTED 4000b7f8: 9c0fd0ef jal ra,400089b8 <_Timecounter_Getnanotime> <== NOT EXECUTED ticks = (uint64_t) ts->tv_sec; 4000b7fc: 01012603 lw a2,16(sp) <== NOT EXECUTED ticks <<= WATCHDOG_BITS_FOR_1E9_NANOSECONDS; 4000b800: 01412783 lw a5,20(sp) <== NOT EXECUTED _Watchdog_Tickle( 4000b804: 01812583 lw a1,24(sp) <== NOT EXECUTED 4000b808: 00265693 srli a3,a2,0x2 <== NOT EXECUTED 4000b80c: 01e79793 slli a5,a5,0x1e <== NOT EXECUTED 4000b810: 01e61613 slli a2,a2,0x1e <== NOT EXECUTED 4000b814: 00c5e633 or a2,a1,a2 <== NOT EXECUTED 4000b818: 00c10713 addi a4,sp,12 <== NOT EXECUTED 4000b81c: 00f6e6b3 or a3,a3,a5 <== NOT EXECUTED 4000b820: 00048593 mv a1,s1 <== NOT EXECUTED 4000b824: 05840513 addi a0,s0,88 <== NOT EXECUTED 4000b828: e59ff0ef jal ra,4000b680 <_Watchdog_Do_tickle> <== NOT EXECUTED __asm__ volatile ( "csrrs zero, mstatus, %0" : : "r" ( level ) ); 4000b82c: 00c12783 lw a5,12(sp) <== NOT EXECUTED 4000b830: 3007a073 csrs mstatus,a5 <== NOT EXECUTED Thread_Control *executing = cpu->executing; 4000b834: 03842583 lw a1,56(s0) <== NOT EXECUTED if ( scheduler != NULL && executing != NULL ) { 4000b838: 00058c63 beqz a1,4000b850 <_Watchdog_Tick+0x100> <== NOT EXECUTED ( *scheduler->Operations.tick )( scheduler, executing ); 4000b83c: 4001e537 lui a0,0x4001e <== NOT EXECUTED 4000b840: 37050793 addi a5,a0,880 # 4001e370 <_Scheduler_Table> <== NOT EXECUTED 4000b844: 0347a783 lw a5,52(a5) <== NOT EXECUTED 4000b848: 37050513 addi a0,a0,880 <== NOT EXECUTED 4000b84c: 000780e7 jalr a5 <== NOT EXECUTED } _ISR_lock_Release_and_ISR_enable( &cpu->Watchdog.Lock, &lock_context ); _Scheduler_Tick( cpu ); } 4000b850: 02c12083 lw ra,44(sp) <== NOT EXECUTED 4000b854: 02812403 lw s0,40(sp) <== NOT EXECUTED 4000b858: 02412483 lw s1,36(sp) <== NOT EXECUTED 4000b85c: 03010113 addi sp,sp,48 <== NOT EXECUTED 4000b860: 00008067 ret <== NOT EXECUTED =============================================================================== 4000b864 <_Workspace_Handler_initialization>: uintptr_t page_size; uintptr_t overhead; size_t i; page_size = CPU_HEAP_ALIGNMENT; remaining = rtems_configuration_get_work_space_size(); 4000b864: 8c01c783 lbu a5,-1856(gp) # 40020d00 <_Stack_Allocator_avoids_workspace> { 4000b868: fd010113 addi sp,sp,-48 4000b86c: 01412c23 sw s4,24(sp) 4000b870: 01512a23 sw s5,20(sp) 4000b874: 01612823 sw s6,16(sp) 4000b878: 02112623 sw ra,44(sp) 4000b87c: 02812423 sw s0,40(sp) 4000b880: 02912223 sw s1,36(sp) 4000b884: 03212023 sw s2,32(sp) 4000b888: 01312e23 sw s3,28(sp) 4000b88c: 01712623 sw s7,12(sp) 4000b890: 01812423 sw s8,8(sp) 4000b894: 01912223 sw s9,4(sp) 4000b898: 00050a93 mv s5,a0 4000b89c: 00058b13 mv s6,a1 4000b8a0: 00000a13 li s4,0 remaining = rtems_configuration_get_work_space_size(); 4000b8a4: 10078063 beqz a5,4000b9a4 <_Workspace_Handler_initialization+0x140> 4000b8a8: 8881a503 lw a0,-1912(gp) # 40020cc8 <_Workspace_Size> init_or_extend = _Heap_Initialize; unified = rtems_configuration_get_unified_work_area(); overhead = _Heap_Area_overhead( page_size ); for ( i = 0; i < _Memory_Get_count( mem ); ++i ) { 4000b8ac: 000aa783 lw a5,0(s5) unified = rtems_configuration_get_unified_work_area(); 4000b8b0: 8b41cb83 lbu s7,-1868(gp) # 40020cf4 <_Workspace_Is_unified> remaining = rtems_configuration_get_work_space_size(); 4000b8b4: 00aa0a33 add s4,s4,a0 for ( i = 0; i < _Memory_Get_count( mem ); ++i ) { 4000b8b8: 08078c63 beqz a5,4000b950 <_Workspace_Handler_initialization+0xec> init_or_extend = _Heap_Initialize; 4000b8bc: 40007737 lui a4,0x40007 for ( i = 0; i < _Memory_Get_count( mem ); ++i ) { 4000b8c0: 00000993 li s3,0 4000b8c4: 00000913 li s2,0 init_or_extend = _Heap_Initialize; 4000b8c8: 56070713 addi a4,a4,1376 # 40007560 <_Heap_Initialize> uintptr_t free_size; area = _Memory_Get_area( mem, i ); free_size = _Memory_Get_free_size( area ); if ( free_size > overhead ) { 4000b8cc: 02600c93 li s9,38 } else { size = 0; } } space_available = ( *init_or_extend )( 4000b8d0: 40023c37 lui s8,0x40023 4000b8d4: 0180006f j 4000b8ec <_Workspace_Handler_initialization+0x88> ); _Memory_Consume( area, size ); if ( space_available < remaining ) { remaining -= space_available; 4000b8d8: 40aa0a33 sub s4,s4,a0 } else { remaining = 0; } init_or_extend = extend; 4000b8dc: 000b0713 mv a4,s6 for ( i = 0; i < _Memory_Get_count( mem ); ++i ) { 4000b8e0: 00190913 addi s2,s2,1 4000b8e4: 00c98993 addi s3,s3,12 <== NOT EXECUTED 4000b8e8: 06f97463 bgeu s2,a5,4000b950 <_Workspace_Handler_initialization+0xec><== NOT EXECUTED const Memory_Information *information, size_t index ) { _Assert( index < _Memory_Get_count( information ) ); return &information->areas[ index ]; 4000b8ec: 004aa403 lw s0,4(s5) <== NOT EXECUTED 4000b8f0: 01340433 add s0,s0,s3 <== NOT EXECUTED * * @return The free memory area size in bytes of the memory area. */ RTEMS_INLINE_ROUTINE uintptr_t _Memory_Get_free_size( const Memory_Area *area ) { return (uintptr_t) area->end - (uintptr_t) area->free; 4000b8f4: 00442583 lw a1,4(s0) <== NOT EXECUTED 4000b8f8: 00842483 lw s1,8(s0) 4000b8fc: 40b484b3 sub s1,s1,a1 if ( free_size > overhead ) { 4000b900: fe9cf0e3 bgeu s9,s1,4000b8e0 <_Workspace_Handler_initialization+0x7c> if ( unified ) { 4000b904: 000b9a63 bnez s7,4000b918 <_Workspace_Handler_initialization+0xb4> if ( remaining > 0 ) { 4000b908: 080a0063 beqz s4,4000b988 <_Workspace_Handler_initialization+0x124> size = remaining < free_size - overhead ? 4000b90c: fda48793 addi a5,s1,-38 remaining + overhead : free_size; 4000b910: 00fa7463 bgeu s4,a5,4000b918 <_Workspace_Handler_initialization+0xb4> 4000b914: 026a0493 addi s1,s4,38 space_available = ( *init_or_extend )( 4000b918: 01000693 li a3,16 4000b91c: 00048613 mv a2,s1 4000b920: ff0c0513 addi a0,s8,-16 # 40022ff0 <_Workspace_Area> 4000b924: 000700e7 jalr a4 RTEMS_INLINE_ROUTINE void _Memory_Consume( Memory_Area *area, uintptr_t consume ) { area->free = (char *) area->free + consume; 4000b928: 00442783 lw a5,4(s0) 4000b92c: 009787b3 add a5,a5,s1 4000b930: 00f42223 sw a5,4(s0) if ( space_available < remaining ) { 4000b934: 000aa783 lw a5,0(s5) 4000b938: fb4560e3 bltu a0,s4,4000b8d8 <_Workspace_Handler_initialization+0x74> for ( i = 0; i < _Memory_Get_count( mem ); ++i ) { 4000b93c: 00190913 addi s2,s2,1 init_or_extend = extend; 4000b940: 000b0713 mv a4,s6 remaining = 0; 4000b944: 00000a13 li s4,0 for ( i = 0; i < _Memory_Get_count( mem ); ++i ) { 4000b948: 00c98993 addi s3,s3,12 4000b94c: faf960e3 bltu s2,a5,4000b8ec <_Workspace_Handler_initialization+0x88> } } if ( remaining > 0 ) { 4000b950: 060a1063 bnez s4,4000b9b0 <_Workspace_Handler_initialization+0x14c> _Internal_error( INTERNAL_ERROR_TOO_LITTLE_WORKSPACE ); } _Heap_Protection_set_delayed_free_fraction( &_Workspace_Area, 1 ); } 4000b954: 02c12083 lw ra,44(sp) 4000b958: 02812403 lw s0,40(sp) 4000b95c: 02412483 lw s1,36(sp) 4000b960: 02012903 lw s2,32(sp) 4000b964: 01c12983 lw s3,28(sp) 4000b968: 01812a03 lw s4,24(sp) 4000b96c: 01412a83 lw s5,20(sp) 4000b970: 01012b03 lw s6,16(sp) 4000b974: 00c12b83 lw s7,12(sp) 4000b978: 00812c03 lw s8,8(sp) 4000b97c: 00412c83 lw s9,4(sp) 4000b980: 03010113 addi sp,sp,48 4000b984: 00008067 ret space_available = ( *init_or_extend )( 4000b988: 01000693 li a3,16 4000b98c: 00000613 li a2,0 4000b990: ff0c0513 addi a0,s8,-16 4000b994: 000700e7 jalr a4 <== NOT EXECUTED if ( space_available < remaining ) { 4000b998: 000aa783 lw a5,0(s5) <== NOT EXECUTED init_or_extend = extend; 4000b99c: 000b0713 mv a4,s6 <== NOT EXECUTED 4000b9a0: f41ff06f j 4000b8e0 <_Workspace_Handler_initialization+0x7c> <== NOT EXECUTED remaining = rtems_configuration_get_work_space_size(); 4000b9a4: 264040ef jal ra,4000fc08 <== NOT EXECUTED 4000b9a8: 00050a13 mv s4,a0 <== NOT EXECUTED 4000b9ac: efdff06f j 4000b8a8 <_Workspace_Handler_initialization+0x44> <== NOT EXECUTED _Internal_error( INTERNAL_ERROR_TOO_LITTLE_WORKSPACE ); 4000b9b0: 00200513 li a0,2 4000b9b4: 804fc0ef jal ra,400079b8 <_Internal_error> =============================================================================== 4000fc08 : #include #include #include uintptr_t rtems_configuration_get_stack_space_size( void ) { 4000fc08: ff010113 addi sp,sp,-16 4000fc0c: 00812423 sw s0,8(sp) 4000fc10: 00112623 sw ra,12(sp) uintptr_t space_size; space_size = _Stack_Space_size; 4000fc14: 86c1a403 lw s0,-1940(gp) # 40020cac <_Stack_Space_size> * space. Ensure that the stack space is large enough to fulfill all requests * known at configuration time (so excluding the unlimited option). It is not * possible to estimate the TLS size in the configuration at compile-time. * The TLS size is determined at application link-time. */ space_size += _Thread_Initial_thread_count * _TLS_Get_allocation_size(); 4000fc18: 031010ef jal ra,40011448 <_TLS_Get_allocation_size> 4000fc1c: 8781a783 lw a5,-1928(gp) # 40020cb8 <_Thread_Initial_thread_count> return space_size; } 4000fc20: 00c12083 lw ra,12(sp) space_size += _Thread_Initial_thread_count * _TLS_Get_allocation_size(); 4000fc24: 02f50533 mul a0,a0,a5 } 4000fc28: 00850533 add a0,a0,s0 4000fc2c: 00812403 lw s0,8(sp) 4000fc30: 01010113 addi sp,sp,16 4000fc34: 00008067 ret