RTEMS-6
Annotated Report
score
Sun Feb 28 12:22:01 2021
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 <memcpy>
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 <bsp_section_bss_size+0x2c04>
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 <RamEnd+0x3effffff>
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 <memcpy>
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 <bsp_section_data_size+0x57d>
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 <memcpy>
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 <bsp_section_rodata_size+0x5668>
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 <bsp_section_data_size+0x575>
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 <bsp_section_data_size+0x57d>
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 <RamEnd+0x3f000000>
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 <memset>
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 <base64>
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 <base64>
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 <RamEnd+0x3f000000>
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 <base64>
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 <IMFS_node_control_sym_link+0x94>
40007a24: 4001fb37 lui s6,0x4001f
40007a28: 00f12823 sw a5,16(sp)
40007a2c: ed4b0793 addi a5,s6,-300 # 4001eed4 <hex2ascii_data>
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 <IMFS_node_control_sym_link+0x8c>
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 <IMFS_node_control_sym_link+0x80><== 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 <strlen>
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 <string.h> /* 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 <RamEnd+0xbeff0000>
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 <memcpy>
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 <memset>
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>
memcpy(
40008638: 024a2583 lw a1,36(s4)
4000863c: 001b1613 slli a2,s6,0x1
40008640: 000d8513 mv a0,s11
40008644: 124130ef jal ra,4001b768 <memcpy>
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 <strnlen>
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 <RamSize+0x1f202020>
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 <rtems/score/rbtreeimpl.h>
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 <rtems/score/rbtreeimpl.h>
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 <rtems/score/schedulercbsimpl.h>
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 <rtems/score/schedulercbs.h>
#include <rtems/score/wkspace.h>
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 <RamEnd+0x3f000014>
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 <rtems/score/stackimpl.h>
#include <rtems/config.h>
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 <rtems/score/stackimpl.h>
#include <rtems/config.h>
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 <RamSize+0x3a9ac9ff>
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 <RamEnd+0x9d251b00>
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 <RamEnd+0xa82fa09>
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 <RamSize+0x2f02830c>
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 <RamEnd+0x8444c45>
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 <strlcpy>
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 <memset>
);
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 <bsp_section_bss_size+0xca5b>
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 <bsp_section_bss_size+0x1b1d> <== 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 <RamSize+0x2f02830c>
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 <rtems/score/threadimpl.h>
#include <rtems/score/schedulerimpl.h>
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 <RamSize+0x2f015fff>
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 <strlcpy> <== 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 <strlcpy> <== 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 <timehands> <== 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 <timehands>
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 <timehands>
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 <timehands>
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 <timehands>
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 <timehands>
40001f0c: 24060613 addi a2,a2,576 # f4240 <bsp_section_text_size+0xea67c>
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 <timehands>
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 <timehands>
40008944: a0060613 addi a2,a2,-1536 # 3b9aca00 <RamSize+0x3a9aca00>
th = timehands;
40008948: 0005a783 lw a5,0(a1) # 80000000 <RamEnd+0x3f000000>
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 <timehands>
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 <timehands>
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 <bsp_section_text_size+0xe3590>
_ts->tv_nsec = ((uint64_t)1000000000 *
40005fb0: a0070713 addi a4,a4,-1536 # 3b9aca00 <RamSize+0x3a9aca00>
_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 <rtems_configuration_get_stack_space_size><== 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 <rtems_configuration_get_stack_space_size>:
#include <rtems/score/stack.h>
#include <rtems/score/tls.h>
#include <rtems/score/thread.h>
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